OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 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 "base/message_loop.h" | |
6 #include "base/strings/string16.h" | |
7 #include "base/strings/utf_string_conversions.h" | |
8 #include "components/autofill/browser/phone_number_i18n.h" | |
9 #include "content/public/test/test_browser_thread.h" | |
10 #include "testing/gtest/include/gtest/gtest.h" | |
11 #include "third_party/libphonenumber/src/phonenumber_api.h" | |
12 | |
13 using content::BrowserThread; | |
14 | |
15 namespace autofill { | |
16 | |
17 using i18n::NormalizePhoneNumber; | |
18 using i18n::ParsePhoneNumber; | |
19 using i18n::ConstructPhoneNumber; | |
20 using i18n::PhoneNumbersMatch; | |
21 | |
22 TEST(PhoneNumberI18NTest, NormalizePhoneNumber) { | |
23 // "Large" digits. | |
24 base::string16 phone1(UTF8ToUTF16( | |
25 "\xEF\xBC\x91\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90" | |
26 "\xEF\xBC\x97\xEF\xBC\x94\xEF\xBC\x99\xEF\xBC\x98" | |
27 "\xEF\xBC\x93\xEF\xBC\x92\xEF\xBC\x93")); | |
28 EXPECT_EQ(NormalizePhoneNumber(phone1, "US"), ASCIIToUTF16("16507498323")); | |
29 | |
30 // Devanagari script digits. | |
31 base::string16 phone2(UTF8ToUTF16( | |
32 "\xD9\xA1\xD9\xA6\xD9\xA5\xD9\xA0\xD9\xA8\xD9\xA3" | |
33 "\xD9\xA2\xD9\xA3\xD9\xA7\xD9\xA4\xD9\xA9")); | |
34 EXPECT_EQ(NormalizePhoneNumber(phone2, "US"), ASCIIToUTF16("16508323749")); | |
35 | |
36 base::string16 phone3(UTF8ToUTF16("16503334\xef\xbc\x92\x35\xd9\xa5")); | |
37 EXPECT_EQ(NormalizePhoneNumber(phone3, "US"), ASCIIToUTF16("16503334255")); | |
38 | |
39 base::string16 phone4(UTF8ToUTF16("+1(650)2346789")); | |
40 EXPECT_EQ(NormalizePhoneNumber(phone4, "US"), ASCIIToUTF16("16502346789")); | |
41 | |
42 base::string16 phone5(UTF8ToUTF16("6502346789")); | |
43 EXPECT_EQ(NormalizePhoneNumber(phone5, "US"), ASCIIToUTF16("6502346789")); | |
44 } | |
45 | |
46 TEST(PhoneNumberI18NTest, ParsePhoneNumber) { | |
47 base::string16 number; | |
48 base::string16 city_code; | |
49 base::string16 country_code; | |
50 ::i18n::phonenumbers::PhoneNumber unused_i18n_number; | |
51 | |
52 // Test for empty string. Should give back empty strings. | |
53 base::string16 phone0; | |
54 EXPECT_FALSE(ParsePhoneNumber(phone0, "US", | |
55 &country_code, | |
56 &city_code, | |
57 &number, | |
58 &unused_i18n_number)); | |
59 EXPECT_EQ(base::string16(), number); | |
60 EXPECT_EQ(base::string16(), city_code); | |
61 EXPECT_EQ(base::string16(), country_code); | |
62 | |
63 // Test for string with less than 7 digits. Should give back empty strings. | |
64 base::string16 phone1(ASCIIToUTF16("1234")); | |
65 EXPECT_FALSE(ParsePhoneNumber(phone1, "US", | |
66 &country_code, | |
67 &city_code, | |
68 &number, | |
69 &unused_i18n_number)); | |
70 EXPECT_EQ(base::string16(), number); | |
71 EXPECT_EQ(base::string16(), city_code); | |
72 EXPECT_EQ(base::string16(), country_code); | |
73 | |
74 // Test for string with exactly 7 digits. | |
75 // Not a valid number - starts with 1 | |
76 base::string16 phone2(ASCIIToUTF16("1234567")); | |
77 EXPECT_FALSE(ParsePhoneNumber(phone2, "US", | |
78 &country_code, | |
79 &city_code, | |
80 &number, | |
81 &unused_i18n_number)); | |
82 EXPECT_EQ(base::string16(), number); | |
83 EXPECT_EQ(base::string16(), city_code); | |
84 EXPECT_EQ(base::string16(), country_code); | |
85 | |
86 // Not a valid number - does not have area code. | |
87 base::string16 phone3(ASCIIToUTF16("2234567")); | |
88 EXPECT_FALSE(ParsePhoneNumber(phone3, "US", | |
89 &country_code, | |
90 &city_code, | |
91 &number, | |
92 &unused_i18n_number)); | |
93 EXPECT_EQ(base::string16(), number); | |
94 EXPECT_EQ(base::string16(), city_code); | |
95 EXPECT_EQ(base::string16(), country_code); | |
96 | |
97 // Test for string with greater than 7 digits but less than 10 digits. | |
98 // Should fail parsing in US. | |
99 base::string16 phone4(ASCIIToUTF16("123456789")); | |
100 EXPECT_FALSE(ParsePhoneNumber(phone4, "US", | |
101 &country_code, | |
102 &city_code, | |
103 &number, | |
104 &unused_i18n_number)); | |
105 EXPECT_EQ(base::string16(), number); | |
106 EXPECT_EQ(base::string16(), city_code); | |
107 EXPECT_EQ(base::string16(), country_code); | |
108 | |
109 // Test for string with greater than 7 digits but less than 10 digits and | |
110 // separators. | |
111 // Should fail parsing in US. | |
112 base::string16 phone_separator4(ASCIIToUTF16("12.345-6789")); | |
113 EXPECT_FALSE(ParsePhoneNumber(phone_separator4, "US", | |
114 &country_code, | |
115 &city_code, | |
116 &number, | |
117 &unused_i18n_number)); | |
118 EXPECT_EQ(base::string16(), number); | |
119 EXPECT_EQ(base::string16(), city_code); | |
120 EXPECT_EQ(base::string16(), country_code); | |
121 | |
122 // Test for string with exactly 10 digits. | |
123 // Should give back phone number and city code. | |
124 // This one going to fail because of the incorrect area code. | |
125 base::string16 phone5(ASCIIToUTF16("1234567890")); | |
126 EXPECT_FALSE(ParsePhoneNumber(phone5, "US", | |
127 &country_code, | |
128 &city_code, | |
129 &number, | |
130 &unused_i18n_number)); | |
131 EXPECT_EQ(base::string16(), number); | |
132 EXPECT_EQ(base::string16(), city_code); | |
133 EXPECT_EQ(base::string16(), country_code); | |
134 | |
135 base::string16 phone6(ASCIIToUTF16("6501567890")); | |
136 // This one going to fail because of the incorrect number (starts with 1). | |
137 EXPECT_FALSE(ParsePhoneNumber(phone6, "US", | |
138 &country_code, | |
139 &city_code, | |
140 &number, | |
141 &unused_i18n_number)); | |
142 EXPECT_EQ(base::string16(), number); | |
143 EXPECT_EQ(base::string16(), city_code); | |
144 EXPECT_EQ(base::string16(), country_code); | |
145 | |
146 base::string16 phone7(ASCIIToUTF16("6504567890")); | |
147 EXPECT_TRUE(ParsePhoneNumber(phone7, "US", | |
148 &country_code, | |
149 &city_code, | |
150 &number, | |
151 &unused_i18n_number)); | |
152 EXPECT_EQ(ASCIIToUTF16("4567890"), number); | |
153 EXPECT_EQ(ASCIIToUTF16("650"), city_code); | |
154 EXPECT_EQ(base::string16(), country_code); | |
155 | |
156 // Test for string with exactly 10 digits and separators. | |
157 // Should give back phone number and city code. | |
158 base::string16 phone_separator7(ASCIIToUTF16("(650) 456-7890")); | |
159 EXPECT_TRUE(ParsePhoneNumber(phone_separator7, "US", | |
160 &country_code, | |
161 &city_code, | |
162 &number, | |
163 &unused_i18n_number)); | |
164 EXPECT_EQ(ASCIIToUTF16("4567890"), number); | |
165 EXPECT_EQ(ASCIIToUTF16("650"), city_code); | |
166 EXPECT_EQ(base::string16(), country_code); | |
167 | |
168 // Tests for string with over 10 digits. | |
169 // 01 is incorrect prefix in the USA, and if we interpret 011 as prefix, the | |
170 // rest is too short for international number - the parsing should fail. | |
171 base::string16 phone8(ASCIIToUTF16("0116504567890")); | |
172 EXPECT_FALSE(ParsePhoneNumber(phone8, "US", | |
173 &country_code, | |
174 &city_code, | |
175 &number, | |
176 &unused_i18n_number)); | |
177 EXPECT_EQ(base::string16(), number); | |
178 EXPECT_EQ(base::string16(), city_code); | |
179 EXPECT_EQ(base::string16(), country_code); | |
180 | |
181 // 011 is a correct "dial out" prefix in the USA - the parsing should succeed. | |
182 base::string16 phone9(ASCIIToUTF16("01116504567890")); | |
183 EXPECT_TRUE(ParsePhoneNumber(phone9, "US", | |
184 &country_code, | |
185 &city_code, | |
186 &number, | |
187 &unused_i18n_number)); | |
188 EXPECT_EQ(ASCIIToUTF16("4567890"), number); | |
189 EXPECT_EQ(ASCIIToUTF16("650"), city_code); | |
190 EXPECT_EQ(ASCIIToUTF16("1"), country_code); | |
191 | |
192 // 011 is a correct "dial out" prefix in the USA - the parsing should succeed. | |
193 base::string16 phone10(ASCIIToUTF16("01178124567890")); | |
194 EXPECT_TRUE(ParsePhoneNumber(phone10, "US", | |
195 &country_code, | |
196 &city_code, | |
197 &number, | |
198 &unused_i18n_number)); | |
199 EXPECT_EQ(ASCIIToUTF16("4567890"), number); | |
200 EXPECT_EQ(ASCIIToUTF16("812"), city_code); | |
201 EXPECT_EQ(ASCIIToUTF16("7"), country_code); | |
202 | |
203 // Test for string with over 10 digits with separator characters. | |
204 // Should give back phone number, city code, and country code. "011" is | |
205 // US "dial out" code, which is discarded. | |
206 base::string16 phone11(ASCIIToUTF16("(0111) 650-456.7890")); | |
207 EXPECT_TRUE(ParsePhoneNumber(phone11, "US", | |
208 &country_code, | |
209 &city_code, | |
210 &number, | |
211 &unused_i18n_number)); | |
212 EXPECT_EQ(ASCIIToUTF16("4567890"), number); | |
213 EXPECT_EQ(ASCIIToUTF16("650"), city_code); | |
214 EXPECT_EQ(ASCIIToUTF16("1"), country_code); | |
215 | |
216 // Now try phone from Chech republic - it has 00 dial out code, 420 country | |
217 // code and variable length area codes. | |
218 base::string16 phone12(ASCIIToUTF16("+420 27-89.10.112")); | |
219 EXPECT_TRUE(ParsePhoneNumber(phone12, "US", | |
220 &country_code, | |
221 &city_code, | |
222 &number, | |
223 &unused_i18n_number)); | |
224 EXPECT_EQ(ASCIIToUTF16("910112"), number); | |
225 EXPECT_EQ(ASCIIToUTF16("278"), city_code); | |
226 EXPECT_EQ(ASCIIToUTF16("420"), country_code); | |
227 | |
228 EXPECT_TRUE(ParsePhoneNumber(phone12, "CZ", | |
229 &country_code, | |
230 &city_code, | |
231 &number, | |
232 &unused_i18n_number)); | |
233 EXPECT_EQ(ASCIIToUTF16("910112"), number); | |
234 EXPECT_EQ(ASCIIToUTF16("278"), city_code); | |
235 EXPECT_EQ(ASCIIToUTF16("420"), country_code); | |
236 | |
237 base::string16 phone13(ASCIIToUTF16("420 57-89.10.112")); | |
238 EXPECT_FALSE(ParsePhoneNumber(phone13, "US", | |
239 &country_code, | |
240 &city_code, | |
241 &number, | |
242 &unused_i18n_number)); | |
243 EXPECT_TRUE(ParsePhoneNumber(phone13, "CZ", | |
244 &country_code, | |
245 &city_code, | |
246 &number, | |
247 &unused_i18n_number)); | |
248 EXPECT_EQ(ASCIIToUTF16("910112"), number); | |
249 EXPECT_EQ(ASCIIToUTF16("578"), city_code); | |
250 EXPECT_EQ(ASCIIToUTF16("420"), country_code); | |
251 | |
252 base::string16 phone14(ASCIIToUTF16("1-650-FLOWERS")); | |
253 EXPECT_TRUE(ParsePhoneNumber(phone14, "US", | |
254 &country_code, | |
255 &city_code, | |
256 &number, | |
257 &unused_i18n_number)); | |
258 EXPECT_EQ(ASCIIToUTF16("3569377"), number); | |
259 EXPECT_EQ(ASCIIToUTF16("650"), city_code); | |
260 EXPECT_EQ(ASCIIToUTF16("1"), country_code); | |
261 | |
262 // 800 is not an area code, but the destination code. In our library these | |
263 // codes should be treated the same as area codes. | |
264 base::string16 phone15(ASCIIToUTF16("1-800-FLOWERS")); | |
265 EXPECT_TRUE(ParsePhoneNumber(phone15, "US", | |
266 &country_code, | |
267 &city_code, | |
268 &number, | |
269 &unused_i18n_number)); | |
270 EXPECT_EQ(ASCIIToUTF16("3569377"), number); | |
271 EXPECT_EQ(ASCIIToUTF16("800"), city_code); | |
272 EXPECT_EQ(ASCIIToUTF16("1"), country_code); | |
273 } | |
274 | |
275 TEST(PhoneNumberI18NTest, ConstructPhoneNumber) { | |
276 base::string16 number; | |
277 EXPECT_TRUE(ConstructPhoneNumber(ASCIIToUTF16("1"), | |
278 ASCIIToUTF16("650"), | |
279 ASCIIToUTF16("2345678"), | |
280 "US", | |
281 &number)); | |
282 EXPECT_EQ(number, ASCIIToUTF16("+1 650-234-5678")); | |
283 EXPECT_TRUE(ConstructPhoneNumber(base::string16(), | |
284 ASCIIToUTF16("650"), | |
285 ASCIIToUTF16("2345678"), | |
286 "US", | |
287 &number)); | |
288 EXPECT_EQ(number, ASCIIToUTF16("(650) 234-5678")); | |
289 EXPECT_TRUE(ConstructPhoneNumber(ASCIIToUTF16("1"), | |
290 base::string16(), | |
291 ASCIIToUTF16("6502345678"), | |
292 "US", | |
293 &number)); | |
294 EXPECT_EQ(number, ASCIIToUTF16("+1 650-234-5678")); | |
295 EXPECT_TRUE(ConstructPhoneNumber(base::string16(), | |
296 base::string16(), | |
297 ASCIIToUTF16("6502345678"), | |
298 "US", | |
299 &number)); | |
300 EXPECT_EQ(number, ASCIIToUTF16("(650) 234-5678")); | |
301 | |
302 EXPECT_FALSE(ConstructPhoneNumber(base::string16(), | |
303 ASCIIToUTF16("650"), | |
304 ASCIIToUTF16("234567890"), | |
305 "US", | |
306 &number)); | |
307 EXPECT_EQ(number, base::string16()); | |
308 // Italian number | |
309 EXPECT_TRUE(ConstructPhoneNumber(ASCIIToUTF16("39"), | |
310 ASCIIToUTF16("347"), | |
311 ASCIIToUTF16("2345678"), | |
312 "IT", | |
313 &number)); | |
314 EXPECT_EQ(number, ASCIIToUTF16("+39 347 234 5678")); | |
315 EXPECT_TRUE(ConstructPhoneNumber(base::string16(), | |
316 ASCIIToUTF16("347"), | |
317 ASCIIToUTF16("2345678"), | |
318 "IT", | |
319 &number)); | |
320 EXPECT_EQ(number, ASCIIToUTF16("347 234 5678")); | |
321 // German number. | |
322 EXPECT_TRUE(ConstructPhoneNumber(ASCIIToUTF16("49"), | |
323 ASCIIToUTF16("024"), | |
324 ASCIIToUTF16("2345678901"), | |
325 "DE", | |
326 &number)); | |
327 EXPECT_EQ(number, ASCIIToUTF16("+49 2423/45678901")); | |
328 EXPECT_TRUE(ConstructPhoneNumber(base::string16(), | |
329 ASCIIToUTF16("024"), | |
330 ASCIIToUTF16("2345678901"), | |
331 "DE", | |
332 &number)); | |
333 EXPECT_EQ(number, ASCIIToUTF16("02423/45678901")); | |
334 } | |
335 | |
336 TEST(PhoneNumberI18NTest, PhoneNumbersMatch) { | |
337 // Same numbers, defined country code. | |
338 EXPECT_TRUE(PhoneNumbersMatch(ASCIIToUTF16("4158889999"), | |
339 ASCIIToUTF16("4158889999"), | |
340 "US", | |
341 "en-US")); | |
342 // Same numbers, undefined country code. | |
343 EXPECT_TRUE(PhoneNumbersMatch(ASCIIToUTF16("4158889999"), | |
344 ASCIIToUTF16("4158889999"), | |
345 std::string(), | |
346 "en-US")); | |
347 | |
348 // Numbers differ by country code only. | |
349 EXPECT_TRUE(PhoneNumbersMatch(ASCIIToUTF16("14158889999"), | |
350 ASCIIToUTF16("4158889999"), | |
351 "US", | |
352 "en-US")); | |
353 | |
354 // Same numbers, different formats. | |
355 EXPECT_TRUE(PhoneNumbersMatch(ASCIIToUTF16("4158889999"), | |
356 ASCIIToUTF16("415-888-9999"), | |
357 "US", | |
358 "en-US")); | |
359 EXPECT_TRUE(PhoneNumbersMatch(ASCIIToUTF16("4158889999"), | |
360 ASCIIToUTF16("(415)888-9999"), | |
361 "US", | |
362 "en-US")); | |
363 EXPECT_TRUE(PhoneNumbersMatch(ASCIIToUTF16("4158889999"), | |
364 ASCIIToUTF16("415 888 9999"), | |
365 "US", | |
366 "en-US")); | |
367 EXPECT_TRUE(PhoneNumbersMatch(ASCIIToUTF16("4158889999"), | |
368 ASCIIToUTF16("415 TUV WXYZ"), | |
369 "US", | |
370 "en-US")); | |
371 EXPECT_TRUE(PhoneNumbersMatch(ASCIIToUTF16("1(415)888-99-99"), | |
372 ASCIIToUTF16("+14158889999"), | |
373 "US", | |
374 "en-US")); | |
375 | |
376 // Partial matches don't count. | |
377 EXPECT_FALSE(PhoneNumbersMatch(ASCIIToUTF16("14158889999"), | |
378 ASCIIToUTF16("8889999"), | |
379 "US", | |
380 "en-US")); | |
381 | |
382 // Different numbers don't match. | |
383 EXPECT_FALSE(PhoneNumbersMatch(ASCIIToUTF16("14158889999"), | |
384 ASCIIToUTF16("1415888"), | |
385 "US", | |
386 "en-US")); | |
387 } | |
388 | |
389 } // namespace autofill | |
OLD | NEW |