Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(236)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/libphonenumber/cpp/src/phonenumberutil_test.cc

Issue 8736001: Pull the phone library directly. Delete old version. (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: '' Created 9 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « third_party/libphonenumber/cpp/src/phonenumberutil.cc ('k') | third_party/libphonenumber/cpp/src/regexp_adapter.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (C) 2009 Google Inc.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // Author: Shaopeng Jia
16 // Author: Lara Rennie
17 // Open-sourced by: Philippe Liard
18
19 #include <iostream>
20 #include <set>
21 #include <string>
22
23 #include <gtest/gtest.h>
24
25 #include "phonemetadata.pb.h"
26 #include "phonenumber.h"
27 #include "phonenumber.pb.h"
28 #include "phonenumberutil.h"
29
30 namespace i18n {
31 namespace phonenumbers {
32
33 using std::endl;
34 using std::make_pair;
35 using std::ostream;
36
37 using google::protobuf::RepeatedPtrField;
38
39 namespace {
40
41 // Class containing string constants of region codes for easier testing. This is
42 // intended to replace region_code.h for testing in this file, with more
43 // constants defined.
44 class RegionCode {
45 public:
46 static const string& AD() {
47 static const string s = "AD";
48 return s;
49 }
50
51 static const string& AO() {
52 static const string s = "AO";
53 return s;
54 }
55
56 static const string& AR() {
57 static const string s = "AR";
58 return s;
59 }
60
61 static const string& AU() {
62 static const string s = "AU";
63 return s;
64 }
65
66 static const string& BS() {
67 static const string s = "BS";
68 return s;
69 }
70
71 static const string& CN() {
72 static const string s = "CN";
73 return s;
74 }
75
76 static const string& CS() {
77 static const string s = "CS";
78 return s;
79 }
80
81 static const string& DE() {
82 static const string s = "DE";
83 return s;
84 }
85
86 static const string& GB() {
87 static const string s = "GB";
88 return s;
89 }
90
91 static const string& IT() {
92 static const string s = "IT";
93 return s;
94 }
95
96 static const string& KR() {
97 static const string s = "KR";
98 return s;
99 }
100
101 static const string& MX() {
102 static const string s = "MX";
103 return s;
104 }
105
106 static const string& NZ() {
107 static const string s = "NZ";
108 return s;
109 }
110
111 static const string& PL() {
112 static const string s = "PL";
113 return s;
114 }
115
116 static const string& RE() {
117 static const string s = "RE";
118 return s;
119 }
120
121 static const string& SG() {
122 static const string s = "SG";
123 return s;
124 }
125
126 static const string& US() {
127 static const string s = "US";
128 return s;
129 }
130
131 static const string& YT() {
132 static const string s = "YT";
133 return s;
134 }
135
136 // Returns a region code string representing the "unknown" region.
137 static const string& GetUnknown() {
138 static const string s = "ZZ";
139 return s;
140 }
141 };
142
143 } // namespace
144
145 class PhoneNumberUtilTest : public testing::Test {
146 protected:
147 PhoneNumberUtilTest() : phone_util_(*PhoneNumberUtil::GetInstance()) {
148 }
149
150 // Wrapper functions for private functions that we want to test.
151 const PhoneMetadata* GetPhoneMetadata(const string& region_code) const {
152 return phone_util_.GetMetadataForRegion(region_code);
153 }
154
155 void GetSupportedRegions(set<string>* regions) {
156 phone_util_.GetSupportedRegions(regions);
157 }
158
159 void ExtractPossibleNumber(const string& number,
160 string* extracted_number) const {
161 phone_util_.ExtractPossibleNumber(number, extracted_number);
162 }
163
164 bool IsViablePhoneNumber(const string& number) const {
165 return phone_util_.IsViablePhoneNumber(number);
166 }
167
168 void Normalize(string* number) const {
169 phone_util_.Normalize(number);
170 }
171
172 bool IsLeadingZeroPossible(int country_calling_code) const {
173 return phone_util_.IsLeadingZeroPossible(country_calling_code);
174 }
175
176 PhoneNumber::CountryCodeSource MaybeStripInternationalPrefixAndNormalize(
177 const string& possible_idd_prefix,
178 string* number) const {
179 return phone_util_.MaybeStripInternationalPrefixAndNormalize(
180 possible_idd_prefix,
181 number);
182 }
183
184 void MaybeStripNationalPrefixAndCarrierCode(const PhoneMetadata& metadata,
185 string* number,
186 string* carrier_code) const {
187 phone_util_.MaybeStripNationalPrefixAndCarrierCode(metadata, number,
188 carrier_code);
189 }
190
191 bool MaybeStripExtension(string* number, string* extension) const {
192 return phone_util_.MaybeStripExtension(number, extension);
193 }
194
195 PhoneNumberUtil::ErrorType MaybeExtractCountryCode(
196 const PhoneMetadata* default_region_metadata,
197 bool keep_raw_input,
198 string* national_number,
199 PhoneNumber* phone_number) const {
200 return phone_util_.MaybeExtractCountryCode(default_region_metadata,
201 keep_raw_input,
202 national_number,
203 phone_number);
204 }
205
206 void GetNddPrefixForRegion(const string& region,
207 bool strip_non_digits,
208 string* ndd_prefix) const {
209 // For testing purposes, we check this is empty first.
210 ndd_prefix->clear();
211 phone_util_.GetNddPrefixForRegion(region, strip_non_digits, ndd_prefix);
212 }
213
214 static bool Equals(const PhoneNumberDesc& expected_number,
215 const PhoneNumberDesc& actual_number) {
216 return ExactlySameAs(expected_number, actual_number);
217 }
218
219 const PhoneNumberUtil& phone_util_;
220 };
221
222 // Provides PhoneNumber comparison operators to support the use of EXPECT_EQ and
223 // EXPECT_NE in the unittests.
224 bool operator==(const PhoneNumber& number1, const PhoneNumber& number2) {
225 return ExactlySameAs(number1, number2);
226 }
227
228 bool operator!=(const PhoneNumber& number1, const PhoneNumber& number2) {
229 return !(number1 == number2);
230 }
231
232 // Needed by Google Test to display errors.
233 ostream& operator<<(ostream& os, const PhoneNumber& number) {
234 os << endl
235 << "country_code: " << number.country_code() << endl
236 << "national_number: " << number.national_number() << endl;
237 if (number.has_extension()) {
238 os << "extension: " << number.extension() << endl;
239 }
240 if (number.has_italian_leading_zero()) {
241 os << "italian_leading_zero: " << number.italian_leading_zero() << endl;
242 }
243 if (number.has_raw_input()) {
244 os << "raw_input: " << number.raw_input() << endl;
245 }
246 if (number.has_country_code_source()) {
247 os << "country_code_source: " << number.country_code_source() << endl;
248 }
249 if (number.has_preferred_domestic_carrier_code()) {
250 os << "preferred_domestic_carrier_code: "
251 << number.preferred_domestic_carrier_code() << endl;
252 }
253 return os;
254 }
255
256 TEST_F(PhoneNumberUtilTest, GetSupportedRegions) {
257 set<string> regions;
258
259 GetSupportedRegions(&regions);
260 EXPECT_GT(regions.size(), 0U);
261 }
262
263 TEST_F(PhoneNumberUtilTest, GetInstanceLoadUSMetadata) {
264 const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::US());
265 EXPECT_EQ("US", metadata->id());
266 EXPECT_EQ(1, metadata->country_code());
267 EXPECT_EQ("011", metadata->international_prefix());
268 EXPECT_TRUE(metadata->has_national_prefix());
269 ASSERT_EQ(2, metadata->number_format_size());
270 EXPECT_EQ("(\\d{3})(\\d{3})(\\d{4})",
271 metadata->number_format(1).pattern());
272 EXPECT_EQ("$1 $2 $3", metadata->number_format(1).format());
273 EXPECT_EQ("[13-9]\\d{9}|2[0-35-9]\\d{8}",
274 metadata->general_desc().national_number_pattern());
275 EXPECT_EQ("\\d{7}(?:\\d{3})?",
276 metadata->general_desc().possible_number_pattern());
277 EXPECT_TRUE(Equals(metadata->general_desc(), metadata->fixed_line()));
278 EXPECT_EQ("\\d{10}", metadata->toll_free().possible_number_pattern());
279 EXPECT_EQ("900\\d{7}", metadata->premium_rate().national_number_pattern());
280 // No shared-cost data is available, so it should be initialised to "NA".
281 EXPECT_EQ("NA", metadata->shared_cost().national_number_pattern());
282 EXPECT_EQ("NA", metadata->shared_cost().possible_number_pattern());
283 }
284
285 TEST_F(PhoneNumberUtilTest, GetInstanceLoadDEMetadata) {
286 const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::DE());
287 EXPECT_EQ("DE", metadata->id());
288 EXPECT_EQ(49, metadata->country_code());
289 EXPECT_EQ("00", metadata->international_prefix());
290 EXPECT_EQ("0", metadata->national_prefix());
291 ASSERT_EQ(6, metadata->number_format_size());
292 EXPECT_EQ(1, metadata->number_format(5).leading_digits_pattern_size());
293 EXPECT_EQ("900", metadata->number_format(5).leading_digits_pattern(0));
294 EXPECT_EQ("(\\d{3})(\\d{3,4})(\\d{4})",
295 metadata->number_format(5).pattern());
296 EXPECT_EQ("$1 $2 $3", metadata->number_format(5).format());
297 EXPECT_EQ("(?:[24-6]\\d{2}|3[03-9]\\d|[789](?:[1-9]\\d|0[2-9]))\\d{3,8}",
298 metadata->fixed_line().national_number_pattern());
299 EXPECT_EQ("\\d{2,14}", metadata->fixed_line().possible_number_pattern());
300 EXPECT_EQ("30123456", metadata->fixed_line().example_number());
301 EXPECT_EQ("\\d{10}", metadata->toll_free().possible_number_pattern());
302 EXPECT_EQ("900([135]\\d{6}|9\\d{7})",
303 metadata->premium_rate().national_number_pattern());
304 }
305
306 TEST_F(PhoneNumberUtilTest, GetInstanceLoadARMetadata) {
307 const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::AR());
308 EXPECT_EQ("AR", metadata->id());
309 EXPECT_EQ(54, metadata->country_code());
310 EXPECT_EQ("00", metadata->international_prefix());
311 EXPECT_EQ("0", metadata->national_prefix());
312 EXPECT_EQ("0(?:(11|343|3715)15)?", metadata->national_prefix_for_parsing());
313 EXPECT_EQ("9$1", metadata->national_prefix_transform_rule());
314 ASSERT_EQ(5, metadata->number_format_size());
315 EXPECT_EQ("$2 15 $3-$4", metadata->number_format(2).format());
316 EXPECT_EQ("(9)(\\d{4})(\\d{2})(\\d{4})",
317 metadata->number_format(3).pattern());
318 EXPECT_EQ("(9)(\\d{4})(\\d{2})(\\d{4})",
319 metadata->intl_number_format(3).pattern());
320 EXPECT_EQ("$1 $2 $3 $4", metadata->intl_number_format(3).format());
321 }
322
323 TEST_F(PhoneNumberUtilTest, GetNationalSignificantNumber) {
324 PhoneNumber number;
325 number.set_country_code(1);
326 number.set_national_number(6502530000ULL);
327 string national_significant_number;
328 phone_util_.GetNationalSignificantNumber(number,
329 &national_significant_number);
330 EXPECT_EQ("6502530000", national_significant_number);
331
332 // An Italian mobile number.
333 national_significant_number.clear();
334 number.set_country_code(39);
335 number.set_national_number(312345678ULL);
336 phone_util_.GetNationalSignificantNumber(number,
337 &national_significant_number);
338 EXPECT_EQ("312345678", national_significant_number);
339
340 // An Italian fixed line number.
341 national_significant_number.clear();
342 number.set_country_code(39);
343 number.set_national_number(236618300ULL);
344 number.set_italian_leading_zero(true);
345 phone_util_.GetNationalSignificantNumber(number,
346 &national_significant_number);
347 EXPECT_EQ("0236618300", national_significant_number);
348 }
349
350 TEST_F(PhoneNumberUtilTest, GetExampleNumber) {
351 PhoneNumber de_number;
352 de_number.set_country_code(49);
353 de_number.set_national_number(30123456ULL);
354 PhoneNumber test_number;
355 bool success = phone_util_.GetExampleNumber(RegionCode::DE(), &test_number);
356 EXPECT_TRUE(success);
357 EXPECT_EQ(de_number, test_number);
358 success = phone_util_.GetExampleNumberForType(RegionCode::DE(),
359 PhoneNumberUtil::FIXED_LINE,
360 &test_number);
361 EXPECT_TRUE(success);
362 EXPECT_EQ(de_number, test_number);
363 test_number.Clear();
364 success = phone_util_.GetExampleNumberForType(RegionCode::DE(),
365 PhoneNumberUtil::MOBILE,
366 &test_number);
367 // Here we test that an example number was not returned, and that the number
368 // passed in was not modified.
369 EXPECT_FALSE(success);
370 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
371 // For the US, the example number is placed under general description, and
372 // hence should be used for both fixed line and mobile, so neither of these
373 // should return null.
374 test_number.Clear();
375 success = phone_util_.GetExampleNumberForType(RegionCode::US(),
376 PhoneNumberUtil::FIXED_LINE,
377 &test_number);
378 // Here we test that the call to get an example number succeeded, and that the
379 // number passed in was modified.
380 EXPECT_TRUE(success);
381 EXPECT_NE(PhoneNumber::default_instance(), test_number);
382 test_number.Clear();
383 success = phone_util_.GetExampleNumberForType(RegionCode::US(),
384 PhoneNumberUtil::MOBILE,
385 &test_number);
386 EXPECT_TRUE(success);
387 EXPECT_NE(PhoneNumber::default_instance(), test_number);
388
389 test_number.Clear();
390 // CS is an invalid region, so we have no data for it. We should return false.
391 EXPECT_FALSE(phone_util_.GetExampleNumberForType(RegionCode::CS(),
392 PhoneNumberUtil::MOBILE,
393 &test_number));
394 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
395 }
396
397 TEST_F(PhoneNumberUtilTest, FormatUSNumber) {
398 PhoneNumber test_number;
399 string formatted_number;
400 test_number.set_country_code(1);
401 test_number.set_national_number(6502530000ULL);
402 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
403 EXPECT_EQ("650 253 0000", formatted_number);
404 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
405 &formatted_number);
406 EXPECT_EQ("+1 650 253 0000", formatted_number);
407
408 test_number.set_national_number(8002530000ULL);
409 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
410 EXPECT_EQ("800 253 0000", formatted_number);
411 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
412 &formatted_number);
413 EXPECT_EQ("+1 800 253 0000", formatted_number);
414
415 test_number.set_national_number(9002530000ULL);
416 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
417 EXPECT_EQ("900 253 0000", formatted_number);
418 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
419 &formatted_number);
420 EXPECT_EQ("+1 900 253 0000", formatted_number);
421 phone_util_.Format(test_number, PhoneNumberUtil::RFC3966, &formatted_number);
422 EXPECT_EQ("+1-900-253-0000", formatted_number);
423 }
424
425 TEST_F(PhoneNumberUtilTest, FormatBSNumber) {
426 PhoneNumber test_number;
427 string formatted_number;
428 test_number.set_country_code(1);
429 test_number.set_national_number(2421234567ULL);
430 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
431 EXPECT_EQ("242 123 4567", formatted_number);
432 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
433 &formatted_number);
434 EXPECT_EQ("+1 242 123 4567", formatted_number);
435
436 test_number.set_national_number(8002530000ULL);
437 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
438 EXPECT_EQ("800 253 0000", formatted_number);
439 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
440 &formatted_number);
441 EXPECT_EQ("+1 800 253 0000", formatted_number);
442
443 test_number.set_national_number(9002530000ULL);
444 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
445 EXPECT_EQ("900 253 0000", formatted_number);
446 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
447 &formatted_number);
448 EXPECT_EQ("+1 900 253 0000", formatted_number);
449 }
450
451 TEST_F(PhoneNumberUtilTest, FormatGBNumber) {
452 PhoneNumber test_number;
453 string formatted_number;
454 test_number.set_country_code(44);
455 test_number.set_national_number(2087389353ULL);
456 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
457 EXPECT_EQ("(020) 8738 9353", formatted_number);
458 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
459 &formatted_number);
460 EXPECT_EQ("+44 20 8738 9353", formatted_number);
461
462 test_number.set_national_number(7912345678ULL);
463 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
464 EXPECT_EQ("(07912) 345 678", formatted_number);
465 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
466 &formatted_number);
467 EXPECT_EQ("+44 7912 345 678", formatted_number);
468 }
469
470 TEST_F(PhoneNumberUtilTest, FormatDENumber) {
471 PhoneNumber test_number;
472 string formatted_number;
473 test_number.set_country_code(49);
474 test_number.set_national_number(301234ULL);
475 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
476 EXPECT_EQ("030/1234", formatted_number);
477 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
478 &formatted_number);
479 EXPECT_EQ("+49 30/1234", formatted_number);
480 phone_util_.Format(test_number, PhoneNumberUtil::RFC3966, &formatted_number);
481 EXPECT_EQ("+49-30-1234", formatted_number);
482
483 test_number.set_national_number(291123ULL);
484 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
485 EXPECT_EQ("0291 123", formatted_number);
486 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
487 &formatted_number);
488 EXPECT_EQ("+49 291 123", formatted_number);
489
490 test_number.set_national_number(29112345678ULL);
491 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
492 EXPECT_EQ("0291 12345678", formatted_number);
493 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
494 &formatted_number);
495 EXPECT_EQ("+49 291 12345678", formatted_number);
496
497 test_number.set_national_number(9123123ULL);
498 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
499 EXPECT_EQ("09123 123", formatted_number);
500 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
501 &formatted_number);
502 EXPECT_EQ("+49 9123 123", formatted_number);
503
504 test_number.set_national_number(80212345ULL);
505 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
506 EXPECT_EQ("08021 2345", formatted_number);
507 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
508 &formatted_number);
509 EXPECT_EQ("+49 8021 2345", formatted_number);
510
511 test_number.set_national_number(1234ULL);
512 // Note this number is correctly formatted without national prefix. Most of
513 // the numbers that are treated as invalid numbers by the library are short
514 // numbers, and they are usually not dialed with national prefix.
515 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
516 EXPECT_EQ("1234", formatted_number);
517 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
518 &formatted_number);
519 EXPECT_EQ("+49 1234", formatted_number);
520 }
521
522 TEST_F(PhoneNumberUtilTest, FormatITNumber) {
523 PhoneNumber test_number;
524 string formatted_number;
525 test_number.set_country_code(39);
526 test_number.set_national_number(236618300ULL);
527 test_number.set_italian_leading_zero(true);
528 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
529 EXPECT_EQ("02 3661 8300", formatted_number);
530 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
531 &formatted_number);
532 EXPECT_EQ("+39 02 3661 8300", formatted_number);
533 phone_util_.Format(test_number, PhoneNumberUtil::E164,
534 &formatted_number);
535 EXPECT_EQ("+390236618300", formatted_number);
536
537 test_number.set_national_number(345678901ULL);
538 test_number.set_italian_leading_zero(false);
539 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
540 EXPECT_EQ("345 678 901", formatted_number);
541 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
542 &formatted_number);
543 EXPECT_EQ("+39 345 678 901", formatted_number);
544 phone_util_.Format(test_number, PhoneNumberUtil::E164,
545 &formatted_number);
546 EXPECT_EQ("+39345678901", formatted_number);
547 }
548
549 TEST_F(PhoneNumberUtilTest, FormatAUNumber) {
550 PhoneNumber test_number;
551 string formatted_number;
552 test_number.set_country_code(61);
553 test_number.set_national_number(236618300ULL);
554 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
555 EXPECT_EQ("02 3661 8300", formatted_number);
556 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
557 &formatted_number);
558 EXPECT_EQ("+61 2 3661 8300", formatted_number);
559 phone_util_.Format(test_number, PhoneNumberUtil::E164,
560 &formatted_number);
561 EXPECT_EQ("+61236618300", formatted_number);
562
563 test_number.set_national_number(1800123456ULL);
564 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
565 EXPECT_EQ("1800 123 456", formatted_number);
566 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
567 &formatted_number);
568 EXPECT_EQ("+61 1800 123 456", formatted_number);
569 phone_util_.Format(test_number, PhoneNumberUtil::E164,
570 &formatted_number);
571 EXPECT_EQ("+611800123456", formatted_number);
572 }
573
574 TEST_F(PhoneNumberUtilTest, FormatARNumber) {
575 PhoneNumber test_number;
576 string formatted_number;
577 test_number.set_country_code(54);
578 test_number.set_national_number(1187654321ULL);
579 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
580 EXPECT_EQ("011 8765-4321", formatted_number);
581 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
582 &formatted_number);
583 EXPECT_EQ("+54 11 8765-4321", formatted_number);
584 phone_util_.Format(test_number, PhoneNumberUtil::E164,
585 &formatted_number);
586 EXPECT_EQ("+541187654321", formatted_number);
587
588 test_number.set_national_number(91187654321ULL);
589 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
590 EXPECT_EQ("011 15 8765-4321", formatted_number);
591 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
592 &formatted_number);
593 EXPECT_EQ("+54 9 11 8765 4321", formatted_number);
594 phone_util_.Format(test_number, PhoneNumberUtil::E164,
595 &formatted_number);
596 EXPECT_EQ("+5491187654321", formatted_number);
597 }
598
599 TEST_F(PhoneNumberUtilTest, FormatMXNumber) {
600 PhoneNumber test_number;
601 string formatted_number;
602 test_number.set_country_code(52);
603 test_number.set_national_number(12345678900ULL);
604 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
605 EXPECT_EQ("045 234 567 8900", formatted_number);
606 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
607 &formatted_number);
608 EXPECT_EQ("+52 1 234 567 8900", formatted_number);
609 phone_util_.Format(test_number, PhoneNumberUtil::E164,
610 &formatted_number);
611 EXPECT_EQ("+5212345678900", formatted_number);
612
613 test_number.set_national_number(15512345678ULL);
614 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
615 EXPECT_EQ("045 55 1234 5678", formatted_number);
616 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
617 &formatted_number);
618 EXPECT_EQ("+52 1 55 1234 5678", formatted_number);
619 phone_util_.Format(test_number, PhoneNumberUtil::E164,
620 &formatted_number);
621 EXPECT_EQ("+5215512345678", formatted_number);
622
623 test_number.set_national_number(3312345678LL);
624 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
625 EXPECT_EQ("01 33 1234 5678", formatted_number);
626 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
627 &formatted_number);
628 EXPECT_EQ("+52 33 1234 5678", formatted_number);
629 phone_util_.Format(test_number, PhoneNumberUtil::E164,
630 &formatted_number);
631 EXPECT_EQ("+523312345678", formatted_number);
632
633 test_number.set_national_number(8211234567LL);
634 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
635 EXPECT_EQ("01 821 123 4567", formatted_number);
636 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
637 &formatted_number);
638 EXPECT_EQ("+52 821 123 4567", formatted_number);
639 phone_util_.Format(test_number, PhoneNumberUtil::E164,
640 &formatted_number);
641 EXPECT_EQ("+528211234567", formatted_number);
642 }
643
644 TEST_F(PhoneNumberUtilTest, FormatOutOfCountryCallingNumber) {
645 PhoneNumber test_number;
646 string formatted_number;
647 test_number.set_country_code(1);
648 test_number.set_national_number(9002530000ULL);
649 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::DE(),
650 &formatted_number);
651 EXPECT_EQ("00 1 900 253 0000", formatted_number);
652
653 test_number.set_national_number(6502530000ULL);
654 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::BS(),
655 &formatted_number);
656 EXPECT_EQ("1 650 253 0000", formatted_number);
657 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::PL(),
658 &formatted_number);
659 EXPECT_EQ("0~0 1 650 253 0000", formatted_number);
660
661 test_number.set_country_code(44);
662 test_number.set_national_number(7912345678ULL);
663 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
664 &formatted_number);
665 EXPECT_EQ("011 44 7912 345 678", formatted_number);
666
667 test_number.set_country_code(49);
668 test_number.set_national_number(1234ULL);
669 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::GB(),
670 &formatted_number);
671 EXPECT_EQ("00 49 1234", formatted_number);
672 // Note this number is correctly formatted without national prefix. Most of
673 // the numbers that are treated as invalid numbers by the library are short
674 // numbers, and they are usually not dialed with national prefix.
675 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::DE(),
676 &formatted_number);
677 EXPECT_EQ("1234", formatted_number);
678
679 test_number.set_country_code(39);
680 test_number.set_national_number(236618300ULL);
681 test_number.set_italian_leading_zero(true);
682 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
683 &formatted_number);
684 EXPECT_EQ("011 39 02 3661 8300", formatted_number);
685 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::IT(),
686 &formatted_number);
687 EXPECT_EQ("02 3661 8300", formatted_number);
688 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::SG(),
689 &formatted_number);
690 EXPECT_EQ("+39 02 3661 8300", formatted_number);
691
692 test_number.set_country_code(65);
693 test_number.set_national_number(94777892ULL);
694 test_number.set_italian_leading_zero(false);
695 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::SG(),
696 &formatted_number);
697 EXPECT_EQ("9477 7892", formatted_number);
698
699 test_number.set_country_code(54);
700 test_number.set_national_number(91187654321ULL);
701 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
702 &formatted_number);
703 EXPECT_EQ("011 54 9 11 8765 4321", formatted_number);
704
705 test_number.set_extension("1234");
706 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
707 &formatted_number);
708 EXPECT_EQ("011 54 9 11 8765 4321 ext. 1234", formatted_number);
709 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AU(),
710 &formatted_number);
711 EXPECT_EQ("0011 54 9 11 8765 4321 ext. 1234", formatted_number);
712 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AR(),
713 &formatted_number);
714 EXPECT_EQ("011 15 8765-4321 ext. 1234", formatted_number);
715 }
716
717 TEST_F(PhoneNumberUtilTest, FormatOutOfCountryWithPreferredIntlPrefix) {
718 PhoneNumber test_number;
719 string formatted_number;
720 test_number.set_country_code(39);
721 test_number.set_national_number(236618300ULL);
722 test_number.set_italian_leading_zero(true);
723 // This should use 0011, since that is the preferred international prefix
724 // (both 0011 and 0012 are accepted as possible international prefixes in our
725 // test metadta.)
726 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AU(),
727 &formatted_number);
728 EXPECT_EQ("0011 39 02 3661 8300", formatted_number);
729 }
730
731 TEST_F(PhoneNumberUtilTest, FormatOutOfCountryKeepingAlphaChars) {
732 PhoneNumber alpha_numeric_number;
733 string formatted_number;
734 alpha_numeric_number.set_country_code(1);
735 alpha_numeric_number.set_national_number(8007493524ULL);
736 alpha_numeric_number.set_raw_input("1800 six-flag");
737 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
738 RegionCode::AU(),
739 &formatted_number);
740 EXPECT_EQ("0011 1 800 SIX-FLAG", formatted_number);
741
742 formatted_number.clear();
743 alpha_numeric_number.set_raw_input("1-800-SIX-flag");
744 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
745 RegionCode::AU(),
746 &formatted_number);
747 EXPECT_EQ("0011 1 800-SIX-FLAG", formatted_number);
748
749 formatted_number.clear();
750 alpha_numeric_number.set_raw_input("Call us from UK: 00 1 800 SIX-flag");
751 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
752 RegionCode::AU(),
753 &formatted_number);
754 EXPECT_EQ("0011 1 800 SIX-FLAG", formatted_number);
755
756 formatted_number.clear();
757 alpha_numeric_number.set_raw_input("800 SIX-flag");
758 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
759 RegionCode::AU(),
760 &formatted_number);
761 EXPECT_EQ("0011 1 800 SIX-FLAG", formatted_number);
762
763 // Formatting from within the NANPA region.
764 formatted_number.clear();
765 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
766 RegionCode::US(),
767 &formatted_number);
768 EXPECT_EQ("1 800 SIX-FLAG", formatted_number);
769 formatted_number.clear();
770 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
771 RegionCode::BS(),
772 &formatted_number);
773 EXPECT_EQ("1 800 SIX-FLAG", formatted_number);
774
775 // Testing that if the raw input doesn't exist, it is formatted using
776 // FormatOutOfCountryCallingNumber.
777 alpha_numeric_number.clear_raw_input();
778 formatted_number.clear();
779 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
780 RegionCode::DE(),
781 &formatted_number);
782 EXPECT_EQ("00 1 800 749 3524", formatted_number);
783
784 // Testing AU alpha number formatted from Australia.
785 alpha_numeric_number.set_country_code(61);
786 alpha_numeric_number.set_national_number(827493524ULL);
787 alpha_numeric_number.set_raw_input("+61 82749-FLAG");
788 formatted_number.clear();
789 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
790 RegionCode::AU(),
791 &formatted_number);
792 // This number should have the national prefix prefixed.
793 EXPECT_EQ("082749-FLAG", formatted_number);
794
795 alpha_numeric_number.set_raw_input("082749-FLAG");
796 formatted_number.clear();
797 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
798 RegionCode::AU(),
799 &formatted_number);
800 EXPECT_EQ("082749-FLAG", formatted_number);
801
802 alpha_numeric_number.set_national_number(18007493524ULL);
803 alpha_numeric_number.set_raw_input("1-800-SIX-flag");
804 formatted_number.clear();
805 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
806 RegionCode::AU(),
807 &formatted_number);
808 // This number should not have the national prefix prefixed, in accordance
809 // with the override for this specific formatting rule.
810 EXPECT_EQ("1-800-SIX-FLAG", formatted_number);
811 // The metadata should not be permanently changed, since we copied it before
812 // modifying patterns. Here we check this.
813 formatted_number.clear();
814 alpha_numeric_number.set_national_number(1800749352ULL);
815 phone_util_.FormatOutOfCountryCallingNumber(alpha_numeric_number,
816 RegionCode::AU(),
817 &formatted_number);
818 EXPECT_EQ("1800 749 352", formatted_number);
819
820 // Testing a country with multiple international prefixes.
821 formatted_number.clear();
822 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
823 RegionCode::SG(),
824 &formatted_number);
825 EXPECT_EQ("+61 1-800-SIX-FLAG", formatted_number);
826
827 // Testing the case with an invalid country code.
828 formatted_number.clear();
829 alpha_numeric_number.set_country_code(0);
830 alpha_numeric_number.set_national_number(18007493524ULL);
831 alpha_numeric_number.set_raw_input("1-800-SIX-flag");
832 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
833 RegionCode::DE(),
834 &formatted_number);
835 // Uses the raw input only.
836 EXPECT_EQ("1-800-SIX-flag", formatted_number);
837
838 // Testing the case of an invalid alpha number.
839 formatted_number.clear();
840 alpha_numeric_number.set_country_code(1);
841 alpha_numeric_number.set_national_number(80749ULL);
842 alpha_numeric_number.set_raw_input("180-SIX");
843 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
844 RegionCode::DE(),
845 &formatted_number);
846 // No country-code stripping can be done.
847 EXPECT_EQ("00 1 180-SIX", formatted_number);
848 }
849
850 TEST_F(PhoneNumberUtilTest, FormatWithCarrierCode) {
851 // We only support this for AR in our test metadata.
852 PhoneNumber ar_number;
853 string formatted_number;
854 ar_number.set_country_code(54);
855 ar_number.set_national_number(91234125678ULL);
856 phone_util_.Format(ar_number, PhoneNumberUtil::NATIONAL, &formatted_number);
857 EXPECT_EQ("01234 12-5678", formatted_number);
858 // Test formatting with a carrier code.
859 phone_util_.FormatNationalNumberWithCarrierCode(ar_number, "15",
860 &formatted_number);
861 EXPECT_EQ("01234 15 12-5678", formatted_number);
862 phone_util_.FormatNationalNumberWithCarrierCode(ar_number, "",
863 &formatted_number);
864 EXPECT_EQ("01234 12-5678", formatted_number);
865 // Here the international rule is used, so no carrier code should be present.
866 phone_util_.Format(ar_number, PhoneNumberUtil::E164, &formatted_number);
867 EXPECT_EQ("+5491234125678", formatted_number);
868 // We don't support this for the US so there should be no change.
869 PhoneNumber us_number;
870 us_number.set_country_code(1);
871 us_number.set_national_number(4241231234ULL);
872 phone_util_.Format(us_number, PhoneNumberUtil::NATIONAL, &formatted_number);
873 EXPECT_EQ("424 123 1234", formatted_number);
874 phone_util_.FormatNationalNumberWithCarrierCode(us_number, "15",
875 &formatted_number);
876 EXPECT_EQ("424 123 1234", formatted_number);
877 }
878
879 TEST_F(PhoneNumberUtilTest, FormatWithPreferredCarrierCode) {
880 // We only support this for AR in our test metadata.
881 PhoneNumber ar_number;
882 string formatted_number;
883 ar_number.set_country_code(54);
884 ar_number.set_national_number(91234125678ULL);
885 // Test formatting with no preferred carrier code stored in the number itself.
886 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "15",
887 &formatted_number);
888 EXPECT_EQ("01234 15 12-5678", formatted_number);
889 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "",
890 &formatted_number);
891 EXPECT_EQ("01234 12-5678", formatted_number);
892 // Test formatting with preferred carrier code present.
893 ar_number.set_preferred_domestic_carrier_code("19");
894 phone_util_.Format(ar_number, PhoneNumberUtil::NATIONAL, &formatted_number);
895 EXPECT_EQ("01234 12-5678", formatted_number);
896 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "15",
897 &formatted_number);
898 EXPECT_EQ("01234 19 12-5678", formatted_number);
899 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "",
900 &formatted_number);
901 EXPECT_EQ("01234 19 12-5678", formatted_number);
902 // When the preferred_domestic_carrier_code is present (even when it contains
903 // an empty string), use it instead of the default carrier code passed in.
904 ar_number.set_preferred_domestic_carrier_code("");
905 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "15",
906 &formatted_number);
907 EXPECT_EQ("01234 12-5678", formatted_number);
908 // We don't support this for the US so there should be no change.
909 PhoneNumber us_number;
910 us_number.set_country_code(1);
911 us_number.set_national_number(4241231234ULL);
912 us_number.set_preferred_domestic_carrier_code("99");
913 phone_util_.Format(us_number, PhoneNumberUtil::NATIONAL, &formatted_number);
914 EXPECT_EQ("424 123 1234", formatted_number);
915 phone_util_.FormatNationalNumberWithPreferredCarrierCode(us_number, "15",
916 &formatted_number);
917 EXPECT_EQ("424 123 1234", formatted_number);
918 }
919
920 TEST_F(PhoneNumberUtilTest, FormatByPattern) {
921 PhoneNumber test_number;
922 string formatted_number;
923 test_number.set_country_code(1);
924 test_number.set_national_number(6502530000ULL);
925
926 RepeatedPtrField<NumberFormat> number_formats;
927 NumberFormat* number_format = number_formats.Add();
928 number_format->set_pattern("(\\d{3})(\\d{3})(\\d{4})");
929 number_format->set_format("($1) $2-$3");
930 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
931 number_formats,
932 &formatted_number);
933 EXPECT_EQ("(650) 253-0000", formatted_number);
934 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
935 number_formats,
936 &formatted_number);
937 EXPECT_EQ("+1 (650) 253-0000", formatted_number);
938
939 // $NP is set to '1' for the US. Here we check that for other NANPA countries
940 // the US rules are followed.
941 number_format->set_national_prefix_formatting_rule("$NP ($FG)");
942 number_format->set_format("$1 $2-$3");
943 test_number.set_country_code(1);
944 test_number.set_national_number(4168819999ULL);
945 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
946 number_formats,
947 &formatted_number);
948 EXPECT_EQ("1 (416) 881-9999", formatted_number);
949 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
950 number_formats,
951 &formatted_number);
952 EXPECT_EQ("+1 416 881-9999", formatted_number);
953
954 test_number.set_country_code(39);
955 test_number.set_national_number(236618300ULL);
956 test_number.set_italian_leading_zero(true);
957 number_format->set_pattern("(\\d{2})(\\d{5})(\\d{3})");
958 number_format->set_format("$1-$2 $3");
959 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
960 number_formats,
961 &formatted_number);
962 EXPECT_EQ("02-36618 300", formatted_number);
963 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
964 number_formats,
965 &formatted_number);
966 EXPECT_EQ("+39 02-36618 300", formatted_number);
967
968 test_number.set_country_code(44);
969 test_number.set_national_number(2012345678ULL);
970 test_number.set_italian_leading_zero(false);
971 number_format->set_national_prefix_formatting_rule("$NP$FG");
972 number_format->set_pattern("(\\d{2})(\\d{4})(\\d{4})");
973 number_format->set_format("$1 $2 $3");
974 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
975 number_formats,
976 &formatted_number);
977 EXPECT_EQ("020 1234 5678", formatted_number);
978
979 number_format->set_national_prefix_formatting_rule("($NP$FG)");
980 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
981 number_formats,
982 &formatted_number);
983 EXPECT_EQ("(020) 1234 5678", formatted_number);
984 number_format->set_national_prefix_formatting_rule("");
985 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
986 number_formats,
987 &formatted_number);
988 EXPECT_EQ("20 1234 5678", formatted_number);
989 number_format->set_national_prefix_formatting_rule("");
990 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
991 number_formats,
992 &formatted_number);
993 EXPECT_EQ("+44 20 1234 5678", formatted_number);
994 }
995
996 TEST_F(PhoneNumberUtilTest, FormatE164Number) {
997 PhoneNumber test_number;
998 string formatted_number;
999 test_number.set_country_code(1);
1000 test_number.set_national_number(6502530000ULL);
1001 phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
1002 EXPECT_EQ("+16502530000", formatted_number);
1003
1004 test_number.set_country_code(49);
1005 test_number.set_national_number(301234ULL);
1006 phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
1007 EXPECT_EQ("+49301234", formatted_number);
1008 }
1009
1010 TEST_F(PhoneNumberUtilTest, FormatNumberWithExtension) {
1011 PhoneNumber nz_number;
1012 nz_number.set_country_code(64);
1013 nz_number.set_national_number(33316005ULL);
1014 nz_number.set_extension("1234");
1015 string formatted_number;
1016 // Uses default extension prefix:
1017 phone_util_.Format(nz_number, PhoneNumberUtil::NATIONAL, &formatted_number);
1018 EXPECT_EQ("03-331 6005 ext. 1234", formatted_number);
1019 // Uses RFC 3966 syntax.
1020 phone_util_.Format(nz_number, PhoneNumberUtil::RFC3966, &formatted_number);
1021 EXPECT_EQ("+64-3-331-6005;ext=1234", formatted_number);
1022 // Extension prefix overridden in the territory information for the US:
1023 PhoneNumber us_number_with_extension;
1024 us_number_with_extension.set_country_code(1);
1025 us_number_with_extension.set_national_number(6502530000ULL);
1026 us_number_with_extension.set_extension("4567");
1027 phone_util_.Format(us_number_with_extension,
1028 PhoneNumberUtil::NATIONAL, &formatted_number);
1029 EXPECT_EQ("650 253 0000 extn. 4567", formatted_number);
1030 }
1031
1032 TEST_F(PhoneNumberUtilTest, GetLengthOfGeographicalAreaCode) {
1033 PhoneNumber number;
1034 // Google MTV, which has area code "650".
1035 number.set_country_code(1);
1036 number.set_national_number(6502530000ULL);
1037 EXPECT_EQ(3, phone_util_.GetLengthOfGeographicalAreaCode(number));
1038
1039 // A North America toll-free number, which has no area code.
1040 number.set_country_code(1);
1041 number.set_national_number(8002530000ULL);
1042 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1043
1044 // An invalid US number (1 digit shorter), which has no area code.
1045 number.set_country_code(1);
1046 number.set_national_number(650253000ULL);
1047 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1048
1049 // Google London, which has area code "20".
1050 number.set_country_code(44);
1051 number.set_national_number(2070313000ULL);
1052 EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
1053
1054 // A UK mobile phone, which has no area code.
1055 number.set_country_code(44);
1056 number.set_national_number(7123456789ULL);
1057 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1058
1059 // Google Buenos Aires, which has area code "11".
1060 number.set_country_code(54);
1061 number.set_national_number(1155303000ULL);
1062 EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
1063
1064 // Google Sydney, which has area code "2".
1065 number.set_country_code(61);
1066 number.set_national_number(293744000ULL);
1067 EXPECT_EQ(1, phone_util_.GetLengthOfGeographicalAreaCode(number));
1068
1069 // Google Singapore. Singapore has no area code and no national prefix.
1070 number.set_country_code(65);
1071 number.set_national_number(65218000ULL);
1072 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1073 }
1074
1075 TEST_F(PhoneNumberUtilTest, GetLengthOfNationalDestinationCode) {
1076 PhoneNumber number;
1077 // Google MTV, which has national destination code (NDC) "650".
1078 number.set_country_code(1);
1079 number.set_national_number(6502530000ULL);
1080 EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));
1081
1082 // A North America toll-free number, which has NDC "800".
1083 number.set_country_code(1);
1084 number.set_national_number(8002530000ULL);
1085 EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));
1086
1087 // Google London, which has NDC "20".
1088 number.set_country_code(44);
1089 number.set_national_number(2070313000ULL);
1090 EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));
1091
1092 // A UK mobile phone, which has NDC "7123"
1093 number.set_country_code(44);
1094 number.set_national_number(7123456789ULL);
1095 EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
1096
1097 // Google Buenos Aires, which has NDC "11".
1098 number.set_country_code(54);
1099 number.set_national_number(1155303000ULL);
1100 EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));
1101
1102 // Google Sydney, which has NDC "2".
1103 number.set_country_code(61);
1104 number.set_national_number(293744000ULL);
1105 EXPECT_EQ(1, phone_util_.GetLengthOfNationalDestinationCode(number));
1106
1107 // Google Singapore. Singapore has NDC "6521".
1108 number.set_country_code(65);
1109 number.set_national_number(65218000ULL);
1110 EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
1111
1112 // An invalid US number (1 digit shorter), which has no NDC.
1113 number.set_country_code(1);
1114 number.set_national_number(650253000ULL);
1115 EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1116
1117 // A number containing an invalid country code, which shouldn't have any NDC.
1118 number.set_country_code(123);
1119 number.set_national_number(650253000ULL);
1120 EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1121
1122 // A number that has only one group of digits after country code when
1123 // formatted in the international format.
1124 number.set_country_code(376);
1125 number.set_national_number(12345ULL);
1126 EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1127
1128 // The same number above, but with an extension.
1129 number.set_country_code(376);
1130 number.set_national_number(12345ULL);
1131 number.set_extension("321");
1132 EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1133 }
1134
1135 TEST_F(PhoneNumberUtilTest, ExtractPossibleNumber) {
1136 // Removes preceding funky punctuation and letters but leaves the rest
1137 // untouched.
1138 string extracted_number;
1139 ExtractPossibleNumber("Tel:0800-345-600", &extracted_number);
1140 EXPECT_EQ("0800-345-600", extracted_number);
1141 ExtractPossibleNumber("Tel:0800 FOR PIZZA", &extracted_number);
1142 EXPECT_EQ("0800 FOR PIZZA", extracted_number);
1143
1144 // Should not remove plus sign.
1145 ExtractPossibleNumber("Tel:+800-345-600", &extracted_number);
1146 EXPECT_EQ("+800-345-600", extracted_number);
1147 // Should recognise wide digits as possible start values.
1148 ExtractPossibleNumber("\xEF\xBC\x90\xEF\xBC\x92\xEF\xBC\x93", &extracted_numbe r);
1149 EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x92\xEF\xBC\x93", extracted_number);
1150 // Dashes are not possible start values and should be removed.
1151 ExtractPossibleNumber("Num-\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93", &extracted_n umber);
1152 EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93", extracted_number);
1153 // If not possible number present, return empty string.
1154 ExtractPossibleNumber("Num-....", &extracted_number);
1155 EXPECT_EQ("", extracted_number);
1156 // Leading brackets are stripped - these are not used when parsing.
1157 ExtractPossibleNumber("(650) 253-0000", &extracted_number);
1158 EXPECT_EQ("650) 253-0000", extracted_number);
1159
1160 // Trailing non-alpha-numeric characters should be removed.
1161 ExtractPossibleNumber("(650) 253-0000..- ..", &extracted_number);
1162 EXPECT_EQ("650) 253-0000", extracted_number);
1163 ExtractPossibleNumber("(650) 253-0000.", &extracted_number);
1164 EXPECT_EQ("650) 253-0000", extracted_number);
1165 // This case has a trailing RTL char.
1166 ExtractPossibleNumber("(650) 253-0000\xE2\x80\x8F", &extracted_number);
1167 EXPECT_EQ("650) 253-0000", extracted_number);
1168 }
1169
1170 TEST_F(PhoneNumberUtilTest, IsNANPACountry) {
1171 EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::US()));
1172 EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::BS()));
1173 }
1174
1175 TEST_F(PhoneNumberUtilTest, IsValidNumber) {
1176 PhoneNumber us_number;
1177 us_number.set_country_code(1);
1178 us_number.set_national_number(6502530000ULL);
1179 EXPECT_TRUE(phone_util_.IsValidNumber(us_number));
1180
1181 PhoneNumber it_number;
1182 it_number.set_country_code(39);
1183 it_number.set_national_number(236618300ULL);
1184 it_number.set_italian_leading_zero(true);
1185 EXPECT_TRUE(phone_util_.IsValidNumber(it_number));
1186
1187 PhoneNumber gb_number;
1188 gb_number.set_country_code(44);
1189 gb_number.set_national_number(7912345678ULL);
1190 EXPECT_TRUE(phone_util_.IsValidNumber(gb_number));
1191
1192 PhoneNumber nz_number;
1193 nz_number.set_country_code(64);
1194 nz_number.set_national_number(21387835ULL);
1195 EXPECT_TRUE(phone_util_.IsValidNumber(nz_number));
1196 }
1197
1198 TEST_F(PhoneNumberUtilTest, IsValidForRegion) {
1199 // This number is valid for the Bahamas, but is not a valid US number.
1200 PhoneNumber bs_number;
1201 bs_number.set_country_code(1);
1202 bs_number.set_national_number(2423232345ULL);
1203 EXPECT_TRUE(phone_util_.IsValidNumber(bs_number));
1204 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(bs_number, RegionCode::BS()));
1205 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(bs_number, RegionCode::US()));
1206 bs_number.set_national_number(2421232345ULL);
1207 // This number is no longer valid.
1208 EXPECT_FALSE(phone_util_.IsValidNumber(bs_number));
1209
1210 // La Mayotte and R\xC3\xA9union use 'leadingDigits' to differentiate them.
1211 PhoneNumber re_number;
1212 re_number.set_country_code(262);
1213 re_number.set_national_number(262123456ULL);
1214 EXPECT_TRUE(phone_util_.IsValidNumber(re_number));
1215 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1216 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1217 // Now change the number to be a number for La Mayotte.
1218 re_number.set_national_number(269601234ULL);
1219 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1220 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1221 // This number is no longer valid.
1222 re_number.set_national_number(269123456ULL);
1223 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1224 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1225 EXPECT_FALSE(phone_util_.IsValidNumber(re_number));
1226 // However, it should be recognised as from La Mayotte.
1227 string region_code;
1228 phone_util_.GetRegionCodeForNumber(re_number, &region_code);
1229 EXPECT_EQ(RegionCode::YT(), region_code);
1230 // This number is valid in both places.
1231 re_number.set_national_number(800123456ULL);
1232 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1233 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1234 }
1235
1236 TEST_F(PhoneNumberUtilTest, IsNotValidNumber) {
1237 PhoneNumber us_number;
1238 us_number.set_country_code(1);
1239 us_number.set_national_number(2530000ULL);
1240 EXPECT_FALSE(phone_util_.IsValidNumber(us_number));
1241
1242 PhoneNumber it_number;
1243 it_number.set_country_code(39);
1244 it_number.set_national_number(23661830000ULL);
1245 it_number.set_italian_leading_zero(true);
1246 EXPECT_FALSE(phone_util_.IsValidNumber(it_number));
1247
1248 PhoneNumber gb_number;
1249 gb_number.set_country_code(44);
1250 gb_number.set_national_number(791234567ULL);
1251 EXPECT_FALSE(phone_util_.IsValidNumber(gb_number));
1252
1253 PhoneNumber de_number;
1254 de_number.set_country_code(49);
1255 de_number.set_national_number(1234ULL);
1256 EXPECT_FALSE(phone_util_.IsValidNumber(de_number));
1257
1258 PhoneNumber nz_number;
1259 nz_number.set_country_code(64);
1260 nz_number.set_national_number(3316005ULL);
1261 EXPECT_FALSE(phone_util_.IsValidNumber(nz_number));
1262 }
1263
1264 TEST_F(PhoneNumberUtilTest, IsPossibleNumber) {
1265 PhoneNumber number;
1266 number.set_country_code(1);
1267 number.set_national_number(6502530000ULL);
1268 EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1269
1270 number.set_country_code(1);
1271 number.set_national_number(2530000ULL);
1272 EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1273
1274 number.set_country_code(44);
1275 number.set_national_number(2070313000ULL);
1276 EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1277
1278 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 253 0000",
1279 RegionCode::US()));
1280 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 GOO OGLE",
1281 RegionCode::US()));
1282 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("(650) 253-0000",
1283 RegionCode::US()));
1284 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("253-0000",
1285 RegionCode::US()));
1286 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 253 0000",
1287 RegionCode::GB()));
1288 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+44 20 7031 3000",
1289 RegionCode::GB()));
1290 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("(020) 7031 3000",
1291 RegionCode::GB()));
1292 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("7031 3000",
1293 RegionCode::GB()));
1294 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("3331 6005",
1295 RegionCode::NZ()));
1296 }
1297
1298 TEST_F(PhoneNumberUtilTest, IsPossibleNumberWithReason) {
1299 // FYI, national numbers for country code +1 that are within 7 to 10 digits
1300 // are possible.
1301 PhoneNumber number;
1302 number.set_country_code(1);
1303 number.set_national_number(6502530000ULL);
1304 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1305 phone_util_.IsPossibleNumberWithReason(number));
1306
1307 number.set_country_code(1);
1308 number.set_national_number(2530000ULL);
1309 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1310 phone_util_.IsPossibleNumberWithReason(number));
1311
1312 number.set_country_code(0);
1313 number.set_national_number(2530000ULL);
1314 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE,
1315 phone_util_.IsPossibleNumberWithReason(number));
1316
1317 number.set_country_code(1);
1318 number.set_national_number(253000ULL);
1319 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
1320 phone_util_.IsPossibleNumberWithReason(number));
1321
1322 number.set_country_code(1);
1323 number.set_national_number(65025300000ULL);
1324 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
1325 phone_util_.IsPossibleNumberWithReason(number));
1326
1327 number.set_country_code(44);
1328 number.set_national_number(2070310000ULL);
1329 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1330 phone_util_.IsPossibleNumberWithReason(number));
1331
1332 number.set_country_code(49);
1333 number.set_national_number(30123456ULL);
1334 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1335 phone_util_.IsPossibleNumberWithReason(number));
1336
1337 number.set_country_code(65);
1338 number.set_national_number(1234567890ULL);
1339 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1340 phone_util_.IsPossibleNumberWithReason(number));
1341
1342 // Try with number that we don't have metadata for.
1343 PhoneNumber ad_number;
1344 ad_number.set_country_code(376);
1345 ad_number.set_national_number(12345ULL);
1346 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1347 phone_util_.IsPossibleNumberWithReason(ad_number));
1348 ad_number.set_country_code(376);
1349 ad_number.set_national_number(13ULL);
1350 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
1351 phone_util_.IsPossibleNumberWithReason(ad_number));
1352 ad_number.set_country_code(376);
1353 ad_number.set_national_number(1234567890123456ULL);
1354 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
1355 phone_util_.IsPossibleNumberWithReason(ad_number));
1356 }
1357
1358 TEST_F(PhoneNumberUtilTest, IsNotPossibleNumber) {
1359 PhoneNumber number;
1360 number.set_country_code(1);
1361 number.set_national_number(65025300000ULL);
1362 EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
1363
1364 number.set_country_code(1);
1365 number.set_national_number(253000ULL);
1366 EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
1367
1368 number.set_country_code(44);
1369 number.set_national_number(300ULL);
1370 EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
1371
1372 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+1 650 253 00000",
1373 RegionCode::US()));
1374 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("(650) 253-00000",
1375 RegionCode::US()));
1376 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("I want a Pizza",
1377 RegionCode::US()));
1378 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("253-000",
1379 RegionCode::US()));
1380 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("1 3000",
1381 RegionCode::GB()));
1382 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+44 300",
1383 RegionCode::GB()));
1384 }
1385
1386 TEST_F(PhoneNumberUtilTest, TruncateTooLongNumber) {
1387 // US number 650-253-0000, but entered with one additional digit at the end.
1388 PhoneNumber too_long_number;
1389 too_long_number.set_country_code(1);
1390 too_long_number.set_national_number(65025300001ULL);
1391 PhoneNumber valid_number;
1392 valid_number.set_country_code(1);
1393 valid_number.set_national_number(6502530000ULL);
1394 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
1395 EXPECT_EQ(valid_number, too_long_number);
1396
1397 // GB number 080 1234 5678, but entered with 4 extra digits at the end.
1398 too_long_number.set_country_code(44);
1399 too_long_number.set_national_number(80123456780123ULL);
1400 valid_number.set_country_code(44);
1401 valid_number.set_national_number(8012345678ULL);
1402 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
1403 EXPECT_EQ(valid_number, too_long_number);
1404
1405 // IT number 022 3456 7890, but entered with 3 extra digits at the end.
1406 too_long_number.set_country_code(39);
1407 too_long_number.set_national_number(2234567890123ULL);
1408 too_long_number.set_italian_leading_zero(true);
1409 valid_number.set_country_code(39);
1410 valid_number.set_national_number(2234567890ULL);
1411 valid_number.set_italian_leading_zero(true);
1412 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
1413 EXPECT_EQ(valid_number, too_long_number);
1414
1415 // Tests what happens when a valid number is passed in.
1416 PhoneNumber valid_number_copy(valid_number);
1417 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&valid_number));
1418 // Tests the number is not modified.
1419 EXPECT_EQ(valid_number_copy, valid_number);
1420
1421 // Tests what happens when a number with invalid prefix is passed in.
1422 PhoneNumber number_with_invalid_prefix;
1423 number_with_invalid_prefix.set_country_code(1);
1424 // The test metadata says US numbers cannot have prefix 240.
1425 number_with_invalid_prefix.set_national_number(2401234567ULL);
1426 PhoneNumber invalid_number_copy(number_with_invalid_prefix);
1427 EXPECT_FALSE(phone_util_.TruncateTooLongNumber(&number_with_invalid_prefix));
1428 // Tests the number is not modified.
1429 EXPECT_EQ(invalid_number_copy, number_with_invalid_prefix);
1430
1431 // Tests what happens when a too short number is passed in.
1432 PhoneNumber too_short_number;
1433 too_short_number.set_country_code(1);
1434 too_short_number.set_national_number(1234ULL);
1435 PhoneNumber too_short_number_copy(too_short_number);
1436 EXPECT_FALSE(phone_util_.TruncateTooLongNumber(&too_short_number));
1437 // Tests the number is not modified.
1438 EXPECT_EQ(too_short_number_copy, too_short_number);
1439 }
1440
1441 TEST_F(PhoneNumberUtilTest, IsLeadingZeroPossible) {
1442 EXPECT_TRUE(IsLeadingZeroPossible(39)); // Italy
1443 EXPECT_FALSE(IsLeadingZeroPossible(1)); // USA
1444 EXPECT_FALSE(IsLeadingZeroPossible(800)); // Not in metadata file, should
1445 // return default value of false.
1446 }
1447
1448 TEST_F(PhoneNumberUtilTest, FormatUsingOriginalNumberFormat) {
1449 PhoneNumber phone_number;
1450 string formatted_number;
1451
1452 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1453 phone_util_.ParseAndKeepRawInput("+442087654321", RegionCode::GB(),
1454 &phone_number));
1455 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1456 &formatted_number);
1457 EXPECT_EQ("+44 20 8765 4321", formatted_number);
1458
1459 phone_number.Clear();
1460 formatted_number.clear();
1461 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1462 phone_util_.ParseAndKeepRawInput("02087654321", RegionCode::GB(),
1463 &phone_number));
1464 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1465 &formatted_number);
1466 EXPECT_EQ("(020) 8765 4321", formatted_number);
1467
1468 phone_number.Clear();
1469 formatted_number.clear();
1470 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1471 phone_util_.ParseAndKeepRawInput("011442087654321",
1472 RegionCode::US(), &phone_number));
1473 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
1474 &formatted_number);
1475 EXPECT_EQ("011 44 20 8765 4321", formatted_number);
1476
1477 phone_number.Clear();
1478 formatted_number.clear();
1479 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1480 phone_util_.ParseAndKeepRawInput("442087654321", RegionCode::GB(),
1481 &phone_number));
1482 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1483 &formatted_number);
1484 EXPECT_EQ("44 20 8765 4321", formatted_number);
1485
1486 phone_number.Clear();
1487 formatted_number.clear();
1488 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1489 phone_util_.Parse("+442087654321", RegionCode::GB(),
1490 &phone_number));
1491 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1492 &formatted_number);
1493 EXPECT_EQ("(020) 8765 4321", formatted_number);
1494 }
1495
1496 TEST_F(PhoneNumberUtilTest, IsPremiumRate) {
1497 PhoneNumber number;
1498 number.set_country_code(1);
1499 number.set_national_number(9004433030ULL);
1500 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
1501
1502 number.set_country_code(39);
1503 number.set_national_number(892123ULL);
1504 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
1505
1506 number.set_country_code(44);
1507 number.set_national_number(9187654321ULL);
1508 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
1509
1510 number.set_country_code(49);
1511 number.set_national_number(9001654321ULL);
1512 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
1513
1514 number.set_country_code(49);
1515 number.set_national_number(90091234567ULL);
1516 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
1517 }
1518
1519 TEST_F(PhoneNumberUtilTest, IsTollFree) {
1520 PhoneNumber number;
1521 number.set_country_code(1);
1522 number.set_national_number(8881234567ULL);
1523 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
1524
1525 number.set_country_code(39);
1526 number.set_national_number(803123ULL);
1527 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
1528
1529 number.set_country_code(44);
1530 number.set_national_number(8012345678ULL);
1531 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
1532
1533 number.set_country_code(49);
1534 number.set_national_number(8001234567ULL);
1535 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
1536 }
1537
1538 TEST_F(PhoneNumberUtilTest, IsMobile) {
1539 PhoneNumber number;
1540 // A Bahama mobile number
1541 number.set_country_code(1);
1542 number.set_national_number(2423570000ULL);
1543 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
1544
1545 number.set_country_code(39);
1546 number.set_national_number(312345678ULL);
1547 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
1548
1549 number.set_country_code(44);
1550 number.set_national_number(7912345678ULL);
1551 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
1552
1553 number.set_country_code(49);
1554 number.set_national_number(15123456789ULL);
1555 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
1556
1557 number.set_country_code(54);
1558 number.set_national_number(91187654321ULL);
1559 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
1560 }
1561
1562 TEST_F(PhoneNumberUtilTest, IsFixedLine) {
1563 PhoneNumber number;
1564 // A Bahama fixed-line number
1565 number.set_country_code(1);
1566 number.set_national_number(2423651234ULL);
1567 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
1568
1569 // An Italian fixed-line number
1570 number.Clear();
1571 number.set_country_code(39);
1572 number.set_national_number(236618300ULL);
1573 number.set_italian_leading_zero(true);
1574 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
1575
1576 number.Clear();
1577 number.set_country_code(44);
1578 number.set_national_number(2012345678ULL);
1579 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
1580
1581 number.set_country_code(49);
1582 number.set_national_number(301234ULL);
1583 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
1584 }
1585
1586 TEST_F(PhoneNumberUtilTest, IsFixedLineAndMobile) {
1587 PhoneNumber number;
1588 number.set_country_code(1);
1589 number.set_national_number(6502531111ULL);
1590 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE_OR_MOBILE,
1591 phone_util_.GetNumberType(number));
1592
1593 number.set_country_code(54);
1594 number.set_national_number(1987654321ULL);
1595 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE_OR_MOBILE,
1596 phone_util_.GetNumberType(number));
1597 }
1598
1599 TEST_F(PhoneNumberUtilTest, IsSharedCost) {
1600 PhoneNumber number;
1601 number.set_country_code(44);
1602 number.set_national_number(8431231234ULL);
1603 EXPECT_EQ(PhoneNumberUtil::SHARED_COST, phone_util_.GetNumberType(number));
1604 }
1605
1606 TEST_F(PhoneNumberUtilTest, IsVoip) {
1607 PhoneNumber number;
1608 number.set_country_code(44);
1609 number.set_national_number(5631231234ULL);
1610 EXPECT_EQ(PhoneNumberUtil::VOIP, phone_util_.GetNumberType(number));
1611 }
1612
1613 TEST_F(PhoneNumberUtilTest, IsPersonalNumber) {
1614 PhoneNumber number;
1615 number.set_country_code(44);
1616 number.set_national_number(7031231234ULL);
1617 EXPECT_EQ(PhoneNumberUtil::PERSONAL_NUMBER,
1618 phone_util_.GetNumberType(number));
1619 }
1620
1621 TEST_F(PhoneNumberUtilTest, IsUnknown) {
1622 PhoneNumber number;
1623 number.set_country_code(1);
1624 number.set_national_number(65025311111ULL);
1625 EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(number));
1626 }
1627
1628 TEST_F(PhoneNumberUtilTest, GetCountryCodeForRegion) {
1629 EXPECT_EQ(1, phone_util_.GetCountryCodeForRegion(RegionCode::US()));
1630 EXPECT_EQ(64, phone_util_.GetCountryCodeForRegion(RegionCode::NZ()));
1631 EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::GetUnknown()));
1632 // CS is already deprecated so the library doesn't support it.
1633 EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::CS()));
1634 }
1635
1636 TEST_F(PhoneNumberUtilTest, GetNationalDiallingPrefixForRegion) {
1637 string ndd_prefix;
1638 GetNddPrefixForRegion(RegionCode::US(), false, &ndd_prefix);
1639 EXPECT_EQ("1", ndd_prefix);
1640
1641 // Test non-main country to see it gets the national dialling prefix for the
1642 // main country with that country calling code.
1643 GetNddPrefixForRegion(RegionCode::BS(), false, &ndd_prefix);
1644 EXPECT_EQ("1", ndd_prefix);
1645
1646 GetNddPrefixForRegion(RegionCode::NZ(), false, &ndd_prefix);
1647 EXPECT_EQ("0", ndd_prefix);
1648
1649 // Test case with non digit in the national prefix.
1650 GetNddPrefixForRegion(RegionCode::AO(), false, &ndd_prefix);
1651 EXPECT_EQ("0~0", ndd_prefix);
1652
1653 GetNddPrefixForRegion(RegionCode::AO(), true, &ndd_prefix);
1654 EXPECT_EQ("00", ndd_prefix);
1655
1656 // Test cases with invalid regions.
1657 GetNddPrefixForRegion(RegionCode::GetUnknown(), false, &ndd_prefix);
1658 EXPECT_EQ("", ndd_prefix);
1659
1660 // CS is already deprecated so the library doesn't support it.
1661 GetNddPrefixForRegion(RegionCode::CS(), false, &ndd_prefix);
1662 EXPECT_EQ("", ndd_prefix);
1663 }
1664
1665 TEST_F(PhoneNumberUtilTest, IsViablePhoneNumber) {
1666 // Only one or two digits before strange non-possible punctuation.
1667 EXPECT_FALSE(IsViablePhoneNumber("12. March"));
1668 EXPECT_FALSE(IsViablePhoneNumber("1+1+1"));
1669 EXPECT_FALSE(IsViablePhoneNumber("80+0"));
1670 EXPECT_FALSE(IsViablePhoneNumber("00"));
1671 // Three digits is viable.
1672 EXPECT_TRUE(IsViablePhoneNumber("111"));
1673 // Alpha numbers.
1674 EXPECT_TRUE(IsViablePhoneNumber("0800-4-pizza"));
1675 EXPECT_TRUE(IsViablePhoneNumber("0800-4-PIZZA"));
1676 // Only one or two digits before possible punctuation followed by more digits.
1677 // The punctuation used here is the unicode character u+3000.
1678 EXPECT_TRUE(IsViablePhoneNumber("1\xE3\x80\x80" "34"));
1679 EXPECT_FALSE(IsViablePhoneNumber("1\xE3\x80\x80" "3+4"));
1680 // Unicode variants of possible starting character and other allowed
1681 // punctuation/digits.
1682 EXPECT_TRUE(IsViablePhoneNumber("\xEF\xBC\x88" "1\xEF\xBC\x89\xE3\x80\x80" "34 56789"));
1683 // Testing a leading + is okay.
1684 EXPECT_TRUE(IsViablePhoneNumber("+1\xEF\xBC\x89\xE3\x80\x80" "3456789"));
1685 }
1686
1687 TEST_F(PhoneNumberUtilTest, ConvertAlphaCharactersInNumber) {
1688 string input("1800-ABC-DEF");
1689 phone_util_.ConvertAlphaCharactersInNumber(&input);
1690 // Alpha chars are converted to digits; everything else is left untouched.
1691 static const string kExpectedOutput = "1800-222-333";
1692 EXPECT_EQ(kExpectedOutput, input);
1693
1694 // Try with some non-ASCII characters.
1695 input.assign("1\xE3\x80\x80\xEF\xBC\x88" "800) ABC-DEF");
1696 static const string kExpectedFullwidthOutput = "1\xE3\x80\x80\xEF\xBC\x88" "80 0) 222-333";
1697 phone_util_.ConvertAlphaCharactersInNumber(&input);
1698 EXPECT_EQ(kExpectedFullwidthOutput, input);
1699 }
1700
1701 TEST_F(PhoneNumberUtilTest, NormaliseRemovePunctuation) {
1702 string input_number("034-56&+#234");
1703 Normalize(&input_number);
1704 static const string kExpectedOutput("03456234");
1705 EXPECT_EQ(kExpectedOutput, input_number)
1706 << "Conversion did not correctly remove punctuation";
1707 }
1708
1709 TEST_F(PhoneNumberUtilTest, NormaliseReplaceAlphaCharacters) {
1710 string input_number("034-I-am-HUNGRY");
1711 Normalize(&input_number);
1712 static const string kExpectedOutput("034426486479");
1713 EXPECT_EQ(kExpectedOutput, input_number)
1714 << "Conversion did not correctly replace alpha characters";
1715 }
1716
1717 TEST_F(PhoneNumberUtilTest, NormaliseOtherDigits) {
1718 // The first digit is a full-width 2, the last digit is an Arabic-indic digit
1719 // 5.
1720 string input_number("\xEF\xBC\x92" "5\xD9\xA5");
1721 Normalize(&input_number);
1722 static const string kExpectedOutput("255");
1723 EXPECT_EQ(kExpectedOutput, input_number)
1724 << "Conversion did not correctly replace non-latin digits";
1725 // The first digit is an Eastern-Arabic 5, the latter an Eastern-Arabic 0.
1726 string eastern_arabic_input_number("\xDB\xB5" "2\xDB\xB0");
1727 Normalize(&eastern_arabic_input_number);
1728 static const string kExpectedOutput2("520");
1729 EXPECT_EQ(kExpectedOutput2, eastern_arabic_input_number)
1730 << "Conversion did not correctly replace non-latin digits";
1731 }
1732
1733 TEST_F(PhoneNumberUtilTest, NormaliseStripAlphaCharacters) {
1734 string input_number("034-56&+a#234");
1735 phone_util_.NormalizeDigitsOnly(&input_number);
1736 static const string kExpectedOutput("03456234");
1737 EXPECT_EQ(kExpectedOutput, input_number)
1738 << "Conversion did not correctly remove alpha characters";
1739 }
1740
1741 TEST_F(PhoneNumberUtilTest, MaybeStripInternationalPrefix) {
1742 string international_prefix("00[39]");
1743 string number_to_strip("0034567700-3898003");
1744 // Note the dash is removed as part of the normalization.
1745 string stripped_number("45677003898003");
1746 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
1747 MaybeStripInternationalPrefixAndNormalize(international_prefix,
1748 &number_to_strip));
1749 EXPECT_EQ(stripped_number, number_to_strip)
1750 << "The number was not stripped of its international prefix.";
1751
1752 // Now the number no longer starts with an IDD prefix, so it should now report
1753 // FROM_DEFAULT_COUNTRY.
1754 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
1755 MaybeStripInternationalPrefixAndNormalize(international_prefix,
1756 &number_to_strip));
1757
1758 number_to_strip.assign("00945677003898003");
1759 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
1760 MaybeStripInternationalPrefixAndNormalize(international_prefix,
1761 &number_to_strip));
1762 EXPECT_EQ(stripped_number, number_to_strip)
1763 << "The number was not stripped of its international prefix.";
1764
1765 // Test it works when the international prefix is broken up by spaces.
1766 number_to_strip.assign("00 9 45677003898003");
1767 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
1768 MaybeStripInternationalPrefixAndNormalize(international_prefix,
1769 &number_to_strip));
1770 EXPECT_EQ(stripped_number, number_to_strip)
1771 << "The number was not stripped of its international prefix.";
1772 // Now the number no longer starts with an IDD prefix, so it should now report
1773 // FROM_DEFAULT_COUNTRY.
1774 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
1775 MaybeStripInternationalPrefixAndNormalize(international_prefix,
1776 &number_to_strip));
1777
1778 // Test the + symbol is also recognised and stripped.
1779 number_to_strip.assign("+45677003898003");
1780 stripped_number.assign("45677003898003");
1781 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
1782 MaybeStripInternationalPrefixAndNormalize(international_prefix,
1783 &number_to_strip));
1784 EXPECT_EQ(stripped_number, number_to_strip)
1785 << "The number supplied was not stripped of the plus symbol.";
1786
1787 // If the number afterwards is a zero, we should not strip this - no country
1788 // code begins with 0.
1789 number_to_strip.assign("0090112-3123");
1790 stripped_number.assign("00901123123");
1791 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
1792 MaybeStripInternationalPrefixAndNormalize(international_prefix,
1793 &number_to_strip));
1794 EXPECT_EQ(stripped_number, number_to_strip)
1795 << "The number had a 0 after the match so shouldn't be stripped.";
1796 // Here the 0 is separated by a space from the IDD.
1797 number_to_strip.assign("009 0-112-3123");
1798 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
1799 MaybeStripInternationalPrefixAndNormalize(international_prefix,
1800 &number_to_strip));
1801 }
1802
1803 TEST_F(PhoneNumberUtilTest, MaybeStripNationalPrefixAndCarrierCode) {
1804 PhoneMetadata metadata;
1805 metadata.set_national_prefix_for_parsing("34");
1806 metadata.mutable_general_desc()->set_national_number_pattern("\\d{4,8}");
1807 string number_to_strip("34356778");
1808 string stripped_number("356778");
1809 string carrier_code;
1810 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
1811 &carrier_code);
1812 EXPECT_EQ(stripped_number, number_to_strip)
1813 << "Should have had national prefix stripped.";
1814 EXPECT_EQ("", carrier_code) << "Should have had no carrier code stripped.";
1815 // Retry stripping - now the number should not start with the national prefix,
1816 // so no more stripping should occur.
1817 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
1818 &carrier_code);
1819 EXPECT_EQ(stripped_number, number_to_strip)
1820 << "Should have had no change - no national prefix present.";
1821 // Some countries have no national prefix. Repeat test with none specified.
1822 metadata.clear_national_prefix_for_parsing();
1823 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
1824 &carrier_code);
1825 EXPECT_EQ(stripped_number, number_to_strip)
1826 << "Should have had no change - empty national prefix.";
1827 // If the resultant number doesn't match the national rule, it shouldn't be
1828 // stripped.
1829 metadata.set_national_prefix_for_parsing("3");
1830 number_to_strip.assign("3123");
1831 stripped_number.assign("3123");
1832 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
1833 &carrier_code);
1834 EXPECT_EQ(stripped_number, number_to_strip)
1835 << "Should have had no change - after stripping, it wouldn't have "
1836 << "matched the national rule.";
1837 // Test extracting carrier selection code.
1838 metadata.set_national_prefix_for_parsing("0(81)?");
1839 number_to_strip.assign("08122123456");
1840 stripped_number.assign("22123456");
1841 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
1842 &carrier_code);
1843 EXPECT_EQ("81", carrier_code) << "Should have had carrier code stripped.";
1844 EXPECT_EQ(stripped_number, number_to_strip)
1845 << "Should have had national prefix and carrier code stripped.";
1846 // If there was a transform rule, check it was applied.
1847 metadata.set_national_prefix_transform_rule("5$15");
1848 // Note that a capturing group is present here.
1849 metadata.set_national_prefix_for_parsing("0(\\d{2})");
1850 number_to_strip.assign("031123");
1851 string transformed_number("5315123");
1852 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
1853 &carrier_code);
1854 EXPECT_EQ(transformed_number, number_to_strip)
1855 << "Was not successfully transformed.";
1856 }
1857
1858 TEST_F(PhoneNumberUtilTest, MaybeStripExtension) {
1859 // One with extension.
1860 string number("1234576 ext. 1234");
1861 string extension;
1862 string expected_extension("1234");
1863 string stripped_number("1234576");
1864 EXPECT_TRUE(MaybeStripExtension(&number, &extension));
1865 EXPECT_EQ(stripped_number, number);
1866 EXPECT_EQ(expected_extension, extension);
1867
1868 // One without extension.
1869 number.assign("1234-576");
1870 extension.clear();
1871 stripped_number.assign("1234-576");
1872 EXPECT_FALSE(MaybeStripExtension(&number, &extension));
1873 EXPECT_EQ(stripped_number, number);
1874 EXPECT_TRUE(extension.empty());
1875
1876 // One with an extension caught by the second capturing group in
1877 // kKnownExtnPatterns.
1878 number.assign("1234576-123#");
1879 extension.clear();
1880 expected_extension.assign("123");
1881 stripped_number.assign("1234576");
1882 EXPECT_TRUE(MaybeStripExtension(&number, &extension));
1883 EXPECT_EQ(stripped_number, number);
1884 EXPECT_EQ(expected_extension, extension);
1885
1886 number.assign("1234576 ext.123#");
1887 extension.clear();
1888 EXPECT_TRUE(MaybeStripExtension(&number, &extension));
1889 EXPECT_EQ(stripped_number, number);
1890 EXPECT_EQ(expected_extension, extension);
1891 }
1892
1893 TEST_F(PhoneNumberUtilTest, MaybeExtractCountryCode) {
1894 PhoneNumber number;
1895 const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::US());
1896 // Note that for the US, the IDD is 011.
1897 string phone_number("011112-3456789");
1898 string stripped_number("123456789");
1899 int expected_country_code = 1;
1900 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1901 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
1902 EXPECT_EQ(expected_country_code, number.country_code());
1903 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD, number.country_code_source());
1904 EXPECT_EQ(stripped_number, phone_number);
1905
1906 number.Clear();
1907 phone_number.assign("+6423456789");
1908 stripped_number.assign("23456789");
1909 expected_country_code = 64;
1910 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1911 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
1912 EXPECT_EQ(expected_country_code, number.country_code());
1913 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
1914 number.country_code_source());
1915 EXPECT_EQ(stripped_number, phone_number);
1916
1917 // Should not have extracted a country code - no international prefix present.
1918 number.Clear();
1919 expected_country_code = 0;
1920 phone_number.assign("2345-6789");
1921 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1922 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
1923 EXPECT_EQ(expected_country_code, number.country_code());
1924 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY, number.country_code_source());
1925 EXPECT_EQ(stripped_number, phone_number);
1926
1927 expected_country_code = 0;
1928 phone_number.assign("0119991123456789");
1929 stripped_number.assign(phone_number);
1930 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
1931 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
1932
1933 number.Clear();
1934 phone_number.assign("(1 610) 619 4466");
1935 stripped_number.assign("6106194466");
1936 expected_country_code = 1;
1937 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1938 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
1939 EXPECT_EQ(expected_country_code, number.country_code());
1940 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN,
1941 number.country_code_source());
1942 EXPECT_EQ(stripped_number, phone_number);
1943
1944 number.Clear();
1945 phone_number.assign("(1 610) 619 4466");
1946 stripped_number.assign("6106194466");
1947 expected_country_code = 1;
1948 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1949 MaybeExtractCountryCode(metadata, false, &phone_number, &number));
1950 EXPECT_EQ(expected_country_code, number.country_code());
1951 EXPECT_FALSE(number.has_country_code_source());
1952 EXPECT_EQ(stripped_number, phone_number);
1953
1954 // Should not have extracted a country code - invalid number after extraction
1955 // of uncertain country code.
1956 number.Clear();
1957 phone_number.assign("(1 610) 619 446");
1958 stripped_number.assign("1610619446");
1959 expected_country_code = 0;
1960 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1961 MaybeExtractCountryCode(metadata, false, &phone_number, &number));
1962 EXPECT_EQ(expected_country_code, number.country_code());
1963 EXPECT_FALSE(number.has_country_code_source());
1964 EXPECT_EQ(stripped_number, phone_number);
1965
1966 number.Clear();
1967 phone_number.assign("(1 610) 619");
1968 stripped_number.assign("1610619");
1969 expected_country_code = 0;
1970 // Should not have extracted a country code - invalid number both before and
1971 // after extraction of uncertain country code.
1972 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1973 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
1974 EXPECT_EQ(expected_country_code, number.country_code());
1975 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY, number.country_code_source());
1976 EXPECT_EQ(stripped_number, phone_number);
1977 }
1978
1979 TEST_F(PhoneNumberUtilTest, CountryWithNoNumberDesc) {
1980 string formatted_number;
1981 // Andorra is a country where we don't have PhoneNumberDesc info in the
1982 // metadata.
1983 PhoneNumber ad_number;
1984 ad_number.set_country_code(376);
1985 ad_number.set_national_number(12345ULL);
1986 phone_util_.Format(ad_number, PhoneNumberUtil::INTERNATIONAL,
1987 &formatted_number);
1988 EXPECT_EQ("+376 12345", formatted_number);
1989 phone_util_.Format(ad_number, PhoneNumberUtil::E164, &formatted_number);
1990 EXPECT_EQ("+37612345", formatted_number);
1991 phone_util_.Format(ad_number, PhoneNumberUtil::NATIONAL, &formatted_number);
1992 EXPECT_EQ("12345", formatted_number);
1993 EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(ad_number));
1994 EXPECT_TRUE(phone_util_.IsValidNumber(ad_number));
1995
1996 // Test dialing a US number from within Andorra.
1997 PhoneNumber us_number;
1998 us_number.set_country_code(1);
1999 us_number.set_national_number(6502530000ULL);
2000 phone_util_.FormatOutOfCountryCallingNumber(us_number, RegionCode::AD(),
2001 &formatted_number);
2002 EXPECT_EQ("00 1 650 253 0000", formatted_number);
2003 }
2004
2005 TEST_F(PhoneNumberUtilTest, UnknownCountryCallingCodeForValidation) {
2006 PhoneNumber invalid_number;
2007 invalid_number.set_country_code(0);
2008 invalid_number.set_national_number(1234ULL);
2009 EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
2010 }
2011
2012 TEST_F(PhoneNumberUtilTest, IsNumberMatchMatches) {
2013 // Test simple matches where formatting is different, or leading zeroes, or
2014 // country code has been specified.
2015 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2016 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331 6005",
2017 "+64 03 331 6005"));
2018 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2019 phone_util_.IsNumberMatchWithTwoStrings("+64 03 331-6005",
2020 "+64 03331 6005"));
2021 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2022 phone_util_.IsNumberMatchWithTwoStrings("+643 331-6005",
2023 "+64033316005"));
2024 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2025 phone_util_.IsNumberMatchWithTwoStrings("+643 331-6005",
2026 "+6433316005"));
2027 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2028 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2029 "+6433316005"));
2030 // Test alpha numbers.
2031 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2032 phone_util_.IsNumberMatchWithTwoStrings("+1800 siX-Flags",
2033 "+1 800 7493 5247"));
2034 // Test numbers with extensions.
2035 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2036 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 extn 1234",
2037 "+6433316005#1234"));
2038 // Test proto buffers.
2039 PhoneNumber nz_number;
2040 nz_number.set_country_code(64);
2041 nz_number.set_national_number(33316005ULL);
2042 nz_number.set_extension("3456");
2043 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2044 phone_util_.IsNumberMatchWithOneString(nz_number,
2045 "+643 331 6005 ext 3456"));
2046 nz_number.clear_extension();
2047 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2048 phone_util_.IsNumberMatchWithOneString(nz_number,
2049 "+643 331 6005"));
2050 // Check empty extensions are ignored.
2051 nz_number.set_extension("");
2052 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2053 phone_util_.IsNumberMatchWithOneString(nz_number,
2054 "+643 331 6005"));
2055 // Check variant with two proto buffers.
2056 PhoneNumber nz_number_2;
2057 nz_number_2.set_country_code(64);
2058 nz_number_2.set_national_number(33316005ULL);
2059 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2060 phone_util_.IsNumberMatch(nz_number, nz_number_2));
2061
2062 // Check raw_input, country_code_source and preferred_domestic_carrier_code
2063 // are ignored.
2064 PhoneNumber br_number_1;
2065 PhoneNumber br_number_2;
2066 br_number_1.set_country_code(55);
2067 br_number_1.set_national_number(3121286979ULL);
2068 br_number_1.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
2069 br_number_1.set_preferred_domestic_carrier_code("12");
2070 br_number_1.set_raw_input("012 3121286979");
2071 br_number_2.set_country_code(55);
2072 br_number_2.set_national_number(3121286979ULL);
2073 br_number_2.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
2074 br_number_2.set_preferred_domestic_carrier_code("14");
2075 br_number_2.set_raw_input("143121286979");
2076 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2077 phone_util_.IsNumberMatch(br_number_1, br_number_2));
2078 }
2079
2080 TEST_F(PhoneNumberUtilTest, IsNumberMatchNonMetches) {
2081 // NSN matches.
2082 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2083 phone_util_.IsNumberMatchWithTwoStrings("03 331 6005",
2084 "03 331 6006"));
2085 // Different country code, partial number match.
2086 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2087 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2088 "+16433316005"));
2089 // Different country code, same number.
2090 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2091 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2092 "+6133316005"));
2093 // Extension different, all else the same.
2094 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2095 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 extn 1234",
2096 "+0116433316005#1235"));
2097 // NSN matches, but extension is different - not the same number.
2098 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2099 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 ext.1235",
2100 "3 331 6005#1234"));
2101 // Invalid numbers that can't be parsed.
2102 EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
2103 phone_util_.IsNumberMatchWithTwoStrings("43", "3 331 6043"));
2104 // Invalid numbers that can't be parsed.
2105 EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
2106 phone_util_.IsNumberMatchWithTwoStrings("+43", "+64 3 331 6005"));
2107 EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
2108 phone_util_.IsNumberMatchWithTwoStrings("+43", "64 3 331 6005"));
2109 EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
2110 phone_util_.IsNumberMatchWithTwoStrings("Dog", "64 3 331 6005"));
2111 }
2112
2113 TEST_F(PhoneNumberUtilTest, IsNumberMatchNsnMatches) {
2114 // NSN matches.
2115 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2116 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2117 "03 331 6005"));
2118
2119 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2120 phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
2121 "03 331 6005"));
2122
2123 PhoneNumber nz_number;
2124 nz_number.set_country_code(64);
2125 nz_number.set_national_number(33316005ULL);
2126 nz_number.set_extension("");
2127 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2128 phone_util_.IsNumberMatchWithOneString(nz_number, "03 331 6005"));
2129 // Here the second number possibly starts with the country code for New
2130 // Zealand, although we are unsure.
2131 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2132 phone_util_.IsNumberMatchWithOneString(nz_number,
2133 "(64-3) 331 6005"));
2134
2135 // Here, the 1 might be a national prefix, if we compare it to the US number,
2136 // so the resultant match is an NSN match.
2137 PhoneNumber us_number;
2138 us_number.set_country_code(1);
2139 us_number.set_national_number(2345678901ULL);
2140 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2141 phone_util_.IsNumberMatchWithOneString(us_number,
2142 "1-234-567-8901"));
2143 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2144 phone_util_.IsNumberMatchWithOneString(us_number, "2345678901"));
2145 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2146 phone_util_.IsNumberMatchWithTwoStrings("+1 234-567 8901",
2147 "1 234 567 8901"));
2148 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2149 phone_util_.IsNumberMatchWithTwoStrings("1 234-567 8901",
2150 "1 234 567 8901"));
2151 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2152 phone_util_.IsNumberMatchWithTwoStrings("1 234-567 8901",
2153 "+1 234 567 8901"));
2154 // For this case, the match will be a short NSN match, because we cannot
2155 // assume that the 1 might be a national prefix, so don't remove it when
2156 // parsing.
2157 PhoneNumber random_number;
2158 random_number.set_country_code(41);
2159 random_number.set_national_number(2345678901ULL);
2160 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2161 phone_util_.IsNumberMatchWithOneString(random_number,
2162 "1-234-567-8901"));
2163 }
2164
2165 TEST_F(PhoneNumberUtilTest, IsNumberMatchShortNsnMatches) {
2166 // Short NSN matches with the country not specified for either one or both
2167 // numbers.
2168 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2169 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2170 "331 6005"));
2171
2172 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2173 phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
2174 "331 6005"));
2175
2176 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2177 phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
2178 "+64 331 6005"));
2179
2180 // Short NSN match with the country specified.
2181 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2182 phone_util_.IsNumberMatchWithTwoStrings("03 331-6005",
2183 "331 6005"));
2184
2185 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2186 phone_util_.IsNumberMatchWithTwoStrings("1 234 345 6789",
2187 "345 6789"));
2188
2189 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2190 phone_util_.IsNumberMatchWithTwoStrings("+1 (234) 345 6789",
2191 "345 6789"));
2192
2193 // NSN matches, country code omitted for one number, extension missing for
2194 // one.
2195 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2196 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2197 "3 331 6005#1234"));
2198
2199 // One has Italian leading zero, one does not.
2200 PhoneNumber it_number_1, it_number_2;
2201 it_number_1.set_country_code(39);
2202 it_number_1.set_national_number(1234ULL);
2203 it_number_1.set_italian_leading_zero(true);
2204 it_number_2.set_country_code(39);
2205 it_number_2.set_national_number(1234ULL);
2206 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2207 phone_util_.IsNumberMatch(it_number_1, it_number_2));
2208
2209 // One has an extension, the other has an extension of "".
2210 it_number_1.set_extension("1234");
2211 it_number_1.clear_italian_leading_zero();
2212 it_number_2.set_extension("");
2213 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2214 phone_util_.IsNumberMatch(it_number_1, it_number_2));
2215 }
2216
2217 TEST_F(PhoneNumberUtilTest, ParseNationalNumber) {
2218 PhoneNumber nz_number;
2219 nz_number.set_country_code(64);
2220 nz_number.set_national_number(33316005ULL);
2221 PhoneNumber test_number;
2222 // National prefix attached.
2223 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2224 phone_util_.Parse("033316005", RegionCode::NZ(), &test_number));
2225 EXPECT_EQ(nz_number, test_number);
2226 // National prefix missing.
2227 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2228 phone_util_.Parse("33316005", RegionCode::NZ(), &test_number));
2229 EXPECT_EQ(nz_number, test_number);
2230 // National prefix attached and some formatting present.
2231 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2232 phone_util_.Parse("03-331 6005", RegionCode::NZ(), &test_number));
2233 EXPECT_EQ(nz_number, test_number);
2234 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2235 phone_util_.Parse("03 331 6005", RegionCode::NZ(), &test_number));
2236 EXPECT_EQ(nz_number, test_number);
2237
2238 // Testing international prefixes.
2239 // Should strip country code.
2240 test_number.Clear();
2241 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2242 phone_util_.Parse("0064 3 331 6005",
2243 RegionCode::NZ(), &test_number));
2244 EXPECT_EQ(nz_number, test_number);
2245 // Try again, but this time we have an international number with Region Code
2246 // US. It should recognise the country code and parse accordingly.
2247 test_number.Clear();
2248 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2249 phone_util_.Parse("01164 3 331 6005",
2250 RegionCode::US(), &test_number));
2251 EXPECT_EQ(nz_number, test_number);
2252 test_number.Clear();
2253 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2254 phone_util_.Parse("+64 3 331 6005",
2255 RegionCode::US(), &test_number));
2256 EXPECT_EQ(nz_number, test_number);
2257
2258 // Test for http://b/issue?id=2247493
2259 nz_number.Clear();
2260 nz_number.set_country_code(64);
2261 nz_number.set_national_number(64123456ULL);
2262 test_number.Clear();
2263 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2264 phone_util_.Parse("+64(0)64123456",
2265 RegionCode::US(), &test_number));
2266 EXPECT_EQ(nz_number, test_number);
2267
2268 // Check that using a "/" is fine in a phone number.
2269 PhoneNumber de_number;
2270 de_number.set_country_code(49);
2271 de_number.set_national_number(12345678ULL);
2272 test_number.Clear();
2273 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2274 phone_util_.Parse("123/45678", RegionCode::DE(), &test_number));
2275 EXPECT_EQ(de_number, test_number);
2276
2277 PhoneNumber us_number;
2278 us_number.set_country_code(1);
2279 // Check it doesn't use the '1' as a country code when parsing if the phone
2280 // number was already possible.
2281 us_number.set_national_number(1234567890ULL);
2282 test_number.Clear();
2283 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2284 phone_util_.Parse("123-456-7890", RegionCode::US(), &test_number));
2285 EXPECT_EQ(us_number, test_number);
2286 }
2287
2288 TEST_F(PhoneNumberUtilTest, ParseNumberWithAlphaCharacters) {
2289 // Test case with alpha characters.
2290 PhoneNumber test_number;
2291 PhoneNumber tollfree_number;
2292 tollfree_number.set_country_code(64);
2293 tollfree_number.set_national_number(800332005ULL);
2294 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2295 phone_util_.Parse("0800 DDA 005", RegionCode::NZ(), &test_number));
2296 EXPECT_EQ(tollfree_number, test_number);
2297
2298 test_number.Clear();
2299 PhoneNumber premium_number;
2300 premium_number.set_country_code(64);
2301 premium_number.set_national_number(9003326005ULL);
2302 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2303 phone_util_.Parse("0900 DDA 6005", RegionCode::NZ(), &test_number));
2304 EXPECT_EQ(premium_number, test_number);
2305
2306 // Not enough alpha characters for them to be considered intentional, so they
2307 // are stripped.
2308 test_number.Clear();
2309 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2310 phone_util_.Parse("0900 332 6005a",
2311 RegionCode::NZ(), &test_number));
2312 EXPECT_EQ(premium_number, test_number);
2313 test_number.Clear();
2314 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2315 phone_util_.Parse("0900 332 600a5",
2316 RegionCode::NZ(), &test_number));
2317 EXPECT_EQ(premium_number, test_number);
2318
2319 test_number.Clear();
2320 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2321 phone_util_.Parse("0900 332 600A5",
2322 RegionCode::NZ(), &test_number));
2323 EXPECT_EQ(premium_number, test_number);
2324
2325 test_number.Clear();
2326 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2327 phone_util_.Parse("0900 a332 600A5",
2328 RegionCode::NZ(), &test_number));
2329 EXPECT_EQ(premium_number, test_number);
2330 }
2331
2332 TEST_F(PhoneNumberUtilTest, ParseWithInternationalPrefixes) {
2333 PhoneNumber us_number;
2334 us_number.set_country_code(1);
2335 us_number.set_national_number(6503336000ULL);
2336 PhoneNumber test_number;
2337 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2338 phone_util_.Parse("+1 (650) 333-6000",
2339 RegionCode::US(), &test_number));
2340 EXPECT_EQ(us_number, test_number);
2341 test_number.Clear();
2342 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2343 phone_util_.Parse("+1-650-333-6000",
2344 RegionCode::US(), &test_number));
2345 EXPECT_EQ(us_number, test_number);
2346
2347 // Calling the US number from Singapore by using different service providers
2348 // 1st test: calling using SingTel IDD service (IDD is 001)
2349 test_number.Clear();
2350 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2351 phone_util_.Parse("0011-650-333-6000",
2352 RegionCode::SG(), &test_number));
2353 EXPECT_EQ(us_number, test_number);
2354 // 2nd test: calling using StarHub IDD service (IDD is 008)
2355 test_number.Clear();
2356 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2357 phone_util_.Parse("0081-650-333-6000",
2358 RegionCode::SG(), &test_number));
2359 EXPECT_EQ(us_number, test_number);
2360 // 3rd test: calling using SingTel V019 service (IDD is 019)
2361 test_number.Clear();
2362 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2363 phone_util_.Parse("0191-650-333-6000",
2364 RegionCode::SG(), &test_number));
2365 EXPECT_EQ(us_number, test_number);
2366 // Calling the US number from Poland
2367 test_number.Clear();
2368 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2369 phone_util_.Parse("0~01-650-333-6000",
2370 RegionCode::PL(), &test_number));
2371 EXPECT_EQ(us_number, test_number);
2372
2373 // Using "++" at the start.
2374 test_number.Clear();
2375 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2376 phone_util_.Parse("++1 (650) 333-6000",
2377 RegionCode::PL(), &test_number));
2378 EXPECT_EQ(us_number, test_number);
2379 // Using a full-width plus sign.
2380 test_number.Clear();
2381 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2382 phone_util_.Parse("\xEF\xBC\x8B" "1 (650) 333-6000",
2383 RegionCode::SG(), &test_number));
2384 EXPECT_EQ(us_number, test_number);
2385 // The whole number, including punctuation, is here represented in full-width
2386 // form.
2387 test_number.Clear();
2388 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2389 phone_util_.Parse("\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88\ xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89\xE3\x80\x80\xEF\xBC\x93\xEF\xBC\ x93\xEF\xBC\x93\xEF\xBC\x8D\xEF\xBC\x96\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x90",
2390 RegionCode::SG(), &test_number));
2391 EXPECT_EQ(us_number, test_number);
2392
2393 // Using the U+30FC dash.
2394 test_number.Clear();
2395 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2396 phone_util_.Parse("\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88\ xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89\xE3\x80\x80\xEF\xBC\x93\xEF\xBC\ x93\xEF\xBC\x93\xE3\x83\xBC\xEF\xBC\x96\xEF\xBC\x90\xEF\xBC\x90\xEF\xBC\x90",
2397 RegionCode::SG(), &test_number));
2398 EXPECT_EQ(us_number, test_number);
2399 }
2400
2401 TEST_F(PhoneNumberUtilTest, ParseWithLeadingZero) {
2402 PhoneNumber it_number;
2403 it_number.set_country_code(39);
2404 it_number.set_national_number(236618300ULL);
2405 it_number.set_italian_leading_zero(true);
2406 PhoneNumber test_number;
2407 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2408 phone_util_.Parse("+39 02-36618 300",
2409 RegionCode::NZ(), &test_number));
2410 EXPECT_EQ(it_number, test_number);
2411 test_number.Clear();
2412 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2413 phone_util_.Parse("02-36618 300", RegionCode::IT(), &test_number));
2414 EXPECT_EQ(it_number, test_number);
2415
2416 it_number.Clear();
2417 it_number.set_country_code(39);
2418 it_number.set_national_number(312345678ULL);
2419 test_number.Clear();
2420 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2421 phone_util_.Parse("312 345 678", RegionCode::IT(), &test_number));
2422 EXPECT_EQ(it_number, test_number);
2423 }
2424
2425 TEST_F(PhoneNumberUtilTest, ParseNationalNumberArgentina) {
2426 // Test parsing mobile numbers of Argentina.
2427 PhoneNumber ar_number;
2428 ar_number.set_country_code(54);
2429 ar_number.set_national_number(93435551212ULL);
2430 PhoneNumber test_number;
2431 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2432 phone_util_.Parse("+54 9 343 555 1212", RegionCode::AR(),
2433 &test_number));
2434 EXPECT_EQ(ar_number, test_number);
2435 test_number.Clear();
2436 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2437 phone_util_.Parse("0343 15 555 1212", RegionCode::AR(),
2438 &test_number));
2439 EXPECT_EQ(ar_number, test_number);
2440
2441 ar_number.set_national_number(93715654320ULL);
2442 test_number.Clear();
2443 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2444 phone_util_.Parse("+54 9 3715 65 4320", RegionCode::AR(),
2445 &test_number));
2446 EXPECT_EQ(ar_number, test_number);
2447 test_number.Clear();
2448 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2449 phone_util_.Parse("03715 15 65 4320", RegionCode::AR(),
2450 &test_number));
2451 EXPECT_EQ(ar_number, test_number);
2452
2453 // Test parsing fixed-line numbers of Argentina.
2454 ar_number.set_national_number(1137970000ULL);
2455 test_number.Clear();
2456 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2457 phone_util_.Parse("+54 11 3797 0000", RegionCode::AR(),
2458 &test_number));
2459 EXPECT_EQ(ar_number, test_number);
2460 test_number.Clear();
2461 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2462 phone_util_.Parse("011 3797 0000", RegionCode::AR(), &test_number));
2463 EXPECT_EQ(ar_number, test_number);
2464
2465 ar_number.set_national_number(3715654321ULL);
2466 test_number.Clear();
2467 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2468 phone_util_.Parse("+54 3715 65 4321", RegionCode::AR(),
2469 &test_number));
2470 EXPECT_EQ(ar_number, test_number);
2471 test_number.Clear();
2472 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2473 phone_util_.Parse("03715 65 4321", RegionCode::AR(), &test_number));
2474 EXPECT_EQ(ar_number, test_number);
2475
2476 ar_number.set_national_number(2312340000ULL);
2477 test_number.Clear();
2478 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2479 phone_util_.Parse("+54 23 1234 0000", RegionCode::AR(),
2480 &test_number));
2481 EXPECT_EQ(ar_number, test_number);
2482 test_number.Clear();
2483 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2484 phone_util_.Parse("023 1234 0000", RegionCode::AR(), &test_number));
2485 EXPECT_EQ(ar_number, test_number);
2486 }
2487
2488 TEST_F(PhoneNumberUtilTest, ParseWithXInNumber) {
2489 // Test that having an 'x' in the phone number at the start is ok and that it
2490 // just gets removed.
2491 PhoneNumber ar_number;
2492 ar_number.set_country_code(54);
2493 ar_number.set_national_number(123456789ULL);
2494 PhoneNumber test_number;
2495 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2496 phone_util_.Parse("0123456789", RegionCode::AR(), &test_number));
2497 EXPECT_EQ(ar_number, test_number);
2498 test_number.Clear();
2499 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2500 phone_util_.Parse("(0) 123456789", RegionCode::AR(), &test_number));
2501 EXPECT_EQ(ar_number, test_number);
2502 test_number.Clear();
2503 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2504 phone_util_.Parse("0 123456789", RegionCode::AR(), &test_number));
2505 EXPECT_EQ(ar_number, test_number);
2506 test_number.Clear();
2507 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2508 phone_util_.Parse("(0xx) 123456789", RegionCode::AR(),
2509 &test_number));
2510 EXPECT_EQ(ar_number, test_number);
2511
2512 PhoneNumber ar_from_us;
2513 ar_from_us.set_country_code(54);
2514 ar_from_us.set_national_number(81429712ULL);
2515 // This test is intentionally constructed such that the number of digit after
2516 // xx is larger than 7, so that the number won't be mistakenly treated as an
2517 // extension, as we allow extensions up to 7 digits. This assumption is okay
2518 // for now as all the countries where a carrier selection code is written in
2519 // the form of xx have a national significant number of length larger than 7.
2520 test_number.Clear();
2521 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2522 phone_util_.Parse("011xx5481429712", RegionCode::US(),
2523 &test_number));
2524 EXPECT_EQ(ar_from_us, test_number);
2525 }
2526
2527 TEST_F(PhoneNumberUtilTest, ParseNumbersMexico) {
2528 // Test parsing fixed-line numbers of Mexico.
2529 PhoneNumber mx_number;
2530
2531 mx_number.set_country_code(52);
2532 mx_number.set_national_number(4499780001ULL);
2533 PhoneNumber test_number;
2534 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2535 phone_util_.Parse("+52 (449)978-0001", RegionCode::MX(),
2536 &test_number));
2537 EXPECT_EQ(mx_number, test_number);
2538 test_number.Clear();
2539 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2540 phone_util_.Parse("01 (449)978-0001", RegionCode::MX(),
2541 &test_number));
2542 EXPECT_EQ(mx_number, test_number);
2543 test_number.Clear();
2544 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2545 phone_util_.Parse("(449)978-0001", RegionCode::MX(),
2546 &test_number));
2547 EXPECT_EQ(mx_number, test_number);
2548
2549 // Test parsing mobile numbers of Mexico.
2550 mx_number.Clear();
2551 mx_number.set_country_code(52);
2552 mx_number.set_national_number(13312345678ULL);
2553 test_number.Clear();
2554 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2555 phone_util_.Parse("+52 1 33 1234-5678", RegionCode::MX(),
2556 &test_number));
2557 EXPECT_EQ(mx_number, test_number);
2558 test_number.Clear();
2559 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2560 phone_util_.Parse("044 (33) 1234-5678", RegionCode::MX(),
2561 &test_number));
2562 EXPECT_EQ(mx_number, test_number);
2563 test_number.Clear();
2564 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2565 phone_util_.Parse("045 33 1234-5678", RegionCode::MX(),
2566 &test_number));
2567 EXPECT_EQ(mx_number, test_number);
2568 }
2569
2570 TEST_F(PhoneNumberUtilTest, FailedParseOnInvalidNumbers) {
2571 PhoneNumber test_number;
2572 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
2573 phone_util_.Parse("This is not a phone number", RegionCode::NZ(),
2574 &test_number));
2575 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2576
2577 EXPECT_EQ(PhoneNumberUtil::TOO_LONG_NSN,
2578 phone_util_.Parse("01495 72553301873 810104", RegionCode::GB(),
2579 &test_number));
2580 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2581
2582 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_NSN,
2583 phone_util_.Parse("+49 0", RegionCode::DE(),
2584 &test_number));
2585 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2586
2587 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
2588 phone_util_.Parse("+210 3456 56789", RegionCode::NZ(),
2589 &test_number));
2590 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2591
2592 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
2593 phone_util_.Parse("123 456 7890", RegionCode::GetUnknown(),
2594 &test_number));
2595 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2596
2597 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
2598 phone_util_.Parse("123 456 7890", RegionCode::CS(),
2599 &test_number));
2600 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2601
2602 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
2603 phone_util_.Parse("0044-----", RegionCode::GB(),
2604 &test_number));
2605 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2606 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
2607 phone_util_.Parse("0044", RegionCode::GB(),
2608 &test_number));
2609 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2610
2611 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
2612 phone_util_.Parse("011", RegionCode::US(),
2613 &test_number));
2614 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2615 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
2616 phone_util_.Parse("0119", RegionCode::US(),
2617 &test_number));
2618 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2619 }
2620
2621 TEST_F(PhoneNumberUtilTest, ParseNumbersWithPlusWithNoRegion) {
2622 PhoneNumber nz_number;
2623 nz_number.set_country_code(64);
2624 nz_number.set_national_number(33316005ULL);
2625 // "ZZ" is allowed only if the number starts with a '+' - then the country
2626 // code can be calculated.
2627 PhoneNumber result_proto;
2628 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2629 phone_util_.Parse("+64 3 331 6005", RegionCode::GetUnknown(),
2630 &result_proto));
2631 EXPECT_EQ(nz_number, result_proto);
2632
2633 // Test with full-width plus.
2634 result_proto.Clear();
2635 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2636 phone_util_.Parse("\xEF\xBC\x8B" "64 3 331 6005", RegionCode::GetUnk nown(),
2637 &result_proto));
2638 EXPECT_EQ(nz_number, result_proto);
2639 // Test with normal plus but leading characters that need to be stripped.
2640 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2641 phone_util_.Parse(" +64 3 331 6005", RegionCode::GetUnknown(),
2642 &result_proto));
2643 EXPECT_EQ(nz_number, result_proto);
2644
2645 nz_number.set_raw_input("+64 3 331 6005");
2646 nz_number.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
2647 // It is important that we set this to an empty string, since we used
2648 // ParseAndKeepRawInput and no carrrier code was found.
2649 nz_number.set_preferred_domestic_carrier_code("");
2650 result_proto.Clear();
2651 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2652 phone_util_.ParseAndKeepRawInput("+64 3 331 6005",
2653 RegionCode::GetUnknown(),
2654 &result_proto));
2655 EXPECT_EQ(nz_number, result_proto);
2656 }
2657
2658 TEST_F(PhoneNumberUtilTest, ParseExtensions) {
2659 PhoneNumber nz_number;
2660 nz_number.set_country_code(64);
2661 nz_number.set_national_number(33316005ULL);
2662 nz_number.set_extension("3456");
2663 PhoneNumber test_number;
2664 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2665 phone_util_.Parse("03 331 6005 ext 3456", RegionCode::NZ(),
2666 &test_number));
2667 EXPECT_EQ(nz_number, test_number);
2668 test_number.Clear();
2669 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2670 phone_util_.Parse("03 331 6005x3456", RegionCode::NZ(),
2671 &test_number));
2672 EXPECT_EQ(nz_number, test_number);
2673 test_number.Clear();
2674 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2675 phone_util_.Parse("03-331 6005 int.3456", RegionCode::NZ(),
2676 &test_number));
2677 EXPECT_EQ(nz_number, test_number);
2678 test_number.Clear();
2679 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2680 phone_util_.Parse("03 331 6005 #3456", RegionCode::NZ(),
2681 &test_number));
2682 EXPECT_EQ(nz_number, test_number);
2683
2684 // Test the following do not extract extensions:
2685 PhoneNumber non_extn_number;
2686 non_extn_number.set_country_code(1);
2687 non_extn_number.set_national_number(80074935247ULL);
2688 test_number.Clear();
2689 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2690 phone_util_.Parse("1800 six-flags", RegionCode::US(),
2691 &test_number));
2692 EXPECT_EQ(non_extn_number, test_number);
2693 test_number.Clear();
2694 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2695 phone_util_.Parse("1800 SIX-FLAGS", RegionCode::US(),
2696 &test_number));
2697 EXPECT_EQ(non_extn_number, test_number);
2698 test_number.Clear();
2699 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2700 phone_util_.Parse("0~0 1800 7493 5247", RegionCode::PL(),
2701 &test_number));
2702 EXPECT_EQ(non_extn_number, test_number);
2703 test_number.Clear();
2704 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2705 phone_util_.Parse("(1800) 7493.5247", RegionCode::US(),
2706 &test_number));
2707 EXPECT_EQ(non_extn_number, test_number);
2708
2709 // Check that the last instance of an extension token is matched.
2710 PhoneNumber extn_number;
2711 extn_number.set_country_code(1);
2712 extn_number.set_national_number(80074935247ULL);
2713 extn_number.set_extension("1234");
2714 test_number.Clear();
2715 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2716 phone_util_.Parse("0~0 1800 7493 5247 ~1234", RegionCode::PL(),
2717 &test_number));
2718 EXPECT_EQ(extn_number, test_number);
2719
2720 // Verifying bug-fix where the last digit of a number was previously omitted
2721 // if it was a 0 when extracting the extension. Also verifying a few different
2722 // cases of extensions.
2723 PhoneNumber uk_number;
2724 uk_number.set_country_code(44);
2725 uk_number.set_national_number(2034567890ULL);
2726 uk_number.set_extension("456");
2727 test_number.Clear();
2728 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2729 phone_util_.Parse("+44 2034567890x456", RegionCode::NZ(),
2730 &test_number));
2731 EXPECT_EQ(uk_number, test_number);
2732 test_number.Clear();
2733 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2734 phone_util_.Parse("+44 2034567890x456", RegionCode::GB(),
2735 &test_number));
2736 EXPECT_EQ(uk_number, test_number);
2737 test_number.Clear();
2738 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2739 phone_util_.Parse("+44 2034567890 x456", RegionCode::GB(),
2740 &test_number));
2741 EXPECT_EQ(uk_number, test_number);
2742 test_number.Clear();
2743 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2744 phone_util_.Parse("+44 2034567890 X456", RegionCode::GB(),
2745 &test_number));
2746 EXPECT_EQ(uk_number, test_number);
2747 test_number.Clear();
2748 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2749 phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
2750 &test_number));
2751 EXPECT_EQ(uk_number, test_number);
2752 test_number.Clear();
2753 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2754 phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
2755 &test_number));
2756 EXPECT_EQ(uk_number, test_number);
2757 test_number.Clear();
2758 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2759 phone_util_.Parse("+44 2034567890 x 456 ", RegionCode::GB(),
2760 &test_number));
2761 EXPECT_EQ(uk_number, test_number);
2762 test_number.Clear();
2763 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2764 phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
2765 &test_number));
2766 EXPECT_EQ(uk_number, test_number);
2767 test_number.Clear();
2768 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2769 phone_util_.Parse("+44-2034567890;ext=456", RegionCode::GB(),
2770 &test_number));
2771 EXPECT_EQ(uk_number, test_number);
2772
2773 PhoneNumber us_with_extension;
2774 us_with_extension.set_country_code(1);
2775 us_with_extension.set_national_number(8009013355ULL);
2776 us_with_extension.set_extension("7246433");
2777 test_number.Clear();
2778 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2779 phone_util_.Parse("(800) 901-3355 x 7246433", RegionCode::US(),
2780 &test_number));
2781 EXPECT_EQ(us_with_extension, test_number);
2782 test_number.Clear();
2783 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2784 phone_util_.Parse("(800) 901-3355 , ext 7246433", RegionCode::US(),
2785 &test_number));
2786 EXPECT_EQ(us_with_extension, test_number);
2787 test_number.Clear();
2788 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2789 phone_util_.Parse("(800) 901-3355 ,extension 7246433",
2790 RegionCode::US(),
2791 &test_number));
2792 EXPECT_EQ(us_with_extension, test_number);
2793 test_number.Clear();
2794 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2795 phone_util_.Parse("(800) 901-3355 ,extensi\xC3\xB3n 7246433",
2796 RegionCode::US(),
2797 &test_number));
2798 EXPECT_EQ(us_with_extension, test_number);
2799 test_number.Clear();
2800 // Repeat with the small letter o with acute accent created by combining
2801 // characters.
2802 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2803 phone_util_.Parse("(800) 901-3355 ,extensio\xCC\x81n 7246433",
2804 RegionCode::US(),
2805 &test_number));
2806 EXPECT_EQ(us_with_extension, test_number);
2807 test_number.Clear();
2808 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2809 phone_util_.Parse("(800) 901-3355 , 7246433", RegionCode::US(),
2810 &test_number));
2811 EXPECT_EQ(us_with_extension, test_number);
2812 test_number.Clear();
2813 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2814 phone_util_.Parse("(800) 901-3355 ext: 7246433", RegionCode::US(),
2815 &test_number));
2816 EXPECT_EQ(us_with_extension, test_number);
2817
2818 // Test that if a number has two extensions specified, we ignore the second.
2819 PhoneNumber us_with_two_extensions_number;
2820 us_with_two_extensions_number.set_country_code(1);
2821 us_with_two_extensions_number.set_national_number(2121231234ULL);
2822 us_with_two_extensions_number.set_extension("508");
2823 test_number.Clear();
2824 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2825 phone_util_.Parse("(212)123-1234 x508/x1234", RegionCode::US(),
2826 &test_number));
2827 EXPECT_EQ(us_with_two_extensions_number, test_number);
2828 test_number.Clear();
2829 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2830 phone_util_.Parse("(212)123-1234 x508/ x1234", RegionCode::US(),
2831 &test_number));
2832 EXPECT_EQ(us_with_two_extensions_number, test_number);
2833 test_number.Clear();
2834 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2835 phone_util_.Parse("(212)123-1234 x508\\x1234", RegionCode::US(),
2836 &test_number));
2837 EXPECT_EQ(us_with_two_extensions_number, test_number);
2838
2839 // Test parsing numbers in the form (645) 123-1234-910# works, where the last
2840 // 3 digits before the # are an extension.
2841 us_with_extension.Clear();
2842 us_with_extension.set_country_code(1);
2843 us_with_extension.set_national_number(6451231234ULL);
2844 us_with_extension.set_extension("910");
2845 test_number.Clear();
2846 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2847 phone_util_.Parse("+1 (645) 123 1234-910#", RegionCode::US(),
2848 &test_number));
2849 EXPECT_EQ(us_with_extension, test_number);
2850 }
2851
2852 TEST_F(PhoneNumberUtilTest, ParseAndKeepRaw) {
2853 PhoneNumber alpha_numeric_number;
2854 alpha_numeric_number.set_country_code(1);
2855 alpha_numeric_number.set_national_number(80074935247ULL);
2856 alpha_numeric_number.set_raw_input("800 six-flags");
2857 alpha_numeric_number.set_country_code_source(
2858 PhoneNumber::FROM_DEFAULT_COUNTRY);
2859 alpha_numeric_number.set_preferred_domestic_carrier_code("");
2860
2861 PhoneNumber test_number;
2862 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2863 phone_util_.ParseAndKeepRawInput("800 six-flags", RegionCode::US(),
2864 &test_number));
2865 EXPECT_EQ(alpha_numeric_number, test_number);
2866
2867 alpha_numeric_number.set_national_number(8007493524ULL);
2868 alpha_numeric_number.set_raw_input("1800 six-flag");
2869 alpha_numeric_number.set_country_code_source(
2870 PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN);
2871 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2872 phone_util_.ParseAndKeepRawInput("1800 six-flag", RegionCode::US(),
2873 &test_number));
2874 EXPECT_EQ(alpha_numeric_number, test_number);
2875
2876 alpha_numeric_number.set_raw_input("+1800 six-flag");
2877 alpha_numeric_number.set_country_code_source(
2878 PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
2879 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2880 phone_util_.ParseAndKeepRawInput("+1800 six-flag", RegionCode::CN(),
2881 &test_number));
2882 EXPECT_EQ(alpha_numeric_number, test_number);
2883
2884 alpha_numeric_number.set_raw_input("001800 six-flag");
2885 alpha_numeric_number.set_country_code_source(
2886 PhoneNumber::FROM_NUMBER_WITH_IDD);
2887 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2888 phone_util_.ParseAndKeepRawInput("001800 six-flag",
2889 RegionCode::NZ(),
2890 &test_number));
2891 EXPECT_EQ(alpha_numeric_number, test_number);
2892
2893 // Try with invalid region - expect failure.
2894 test_number.Clear();
2895 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
2896 phone_util_.Parse("123 456 7890", RegionCode::CS(), &test_number));
2897 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
2898
2899 PhoneNumber korean_number;
2900 korean_number.set_country_code(82);
2901 korean_number.set_national_number(22123456);
2902 korean_number.set_raw_input("08122123456");
2903 korean_number.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
2904 korean_number.set_preferred_domestic_carrier_code("81");
2905 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2906 phone_util_.ParseAndKeepRawInput("08122123456",
2907 RegionCode::KR(),
2908 &test_number));
2909 EXPECT_EQ(korean_number, test_number);
2910 }
2911
2912 TEST_F(PhoneNumberUtilTest, IsAlphaNumber) {
2913 static const string kAlphaNumber("1800 six-flags");
2914 EXPECT_TRUE(phone_util_.IsAlphaNumber(kAlphaNumber));
2915 static const string kAlphaNumberWithExtension = "1800 six-flags ext. 1234";
2916 EXPECT_TRUE(phone_util_.IsAlphaNumber(kAlphaNumberWithExtension));
2917 static const string kNonAlphaNumber("1800 123-1234");
2918 EXPECT_FALSE(phone_util_.IsAlphaNumber(kNonAlphaNumber));
2919 static const string kNonAlphaNumberWithExtension(
2920 "1800 123-1234 extension: 1234");
2921 EXPECT_FALSE(phone_util_.IsAlphaNumber(kNonAlphaNumberWithExtension));
2922 }
2923
2924 } // namespace phonenumbers
2925 } // namespace i18n
OLDNEW
« no previous file with comments | « third_party/libphonenumber/cpp/src/phonenumberutil.cc ('k') | third_party/libphonenumber/cpp/src/regexp_adapter.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698