1 // Copyright (C) 2009 The Libphonenumber Authors
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 // Note that these tests use the metadata contained in the test metadata file,
20 // not the normal metadata file, so should not be used for regression test
21 // purposes - these tests are illustrative only and test functionality.
22
23 #include "phonenumbers/phonenumberutil.h"
24
25 #include <algorithm>
26 #include <iostream>
27 #include <list>
28 #include <set>
29 #include <string>
30
31 #include <gtest/gtest.h>
32
33 #include "phonenumbers/default_logger.h"
34 #include "phonenumbers/phonemetadata.pb.h"
35 #include "phonenumbers/phonenumber.h"
36 #include "phonenumbers/phonenumber.pb.h"
37 #include "phonenumbers/test_util.h"
38
39 namespace i18n {
40 namespace phonenumbers {
41
42 using std::find;
43 using std::ostream;
44
45 using google::protobuf::RepeatedPtrField;
46
47 static const int kInvalidCountryCode = 2;
48
49 class PhoneNumberUtilTest : public testing::Test {
50 protected:
PhoneNumberUtilTest()51 PhoneNumberUtilTest() : phone_util_(*PhoneNumberUtil::GetInstance()) {
52 PhoneNumberUtil::GetInstance()->SetLogger(new StdoutLogger());
53 }
54
55 // Wrapper functions for private functions that we want to test.
GetPhoneMetadata(const string & region_code) const56 const PhoneMetadata* GetPhoneMetadata(const string& region_code) const {
57 return phone_util_.GetMetadataForRegion(region_code);
58 }
59
GetMetadataForNonGeographicalRegion(int country_code) const60 const PhoneMetadata* GetMetadataForNonGeographicalRegion(
61 int country_code) const {
62 return phone_util_.GetMetadataForNonGeographicalRegion(country_code);
63 }
64
ExtractPossibleNumber(const string & number,string * extracted_number) const65 void ExtractPossibleNumber(const string& number,
66 string* extracted_number) const {
67 phone_util_.ExtractPossibleNumber(number, extracted_number);
68 }
69
IsViablePhoneNumber(const string & number) const70 bool IsViablePhoneNumber(const string& number) const {
71 return phone_util_.IsViablePhoneNumber(number);
72 }
73
Normalize(string * number) const74 void Normalize(string* number) const {
75 phone_util_.Normalize(number);
76 }
77
MaybeStripInternationalPrefixAndNormalize(const string & possible_idd_prefix,string * number) const78 PhoneNumber::CountryCodeSource MaybeStripInternationalPrefixAndNormalize(
79 const string& possible_idd_prefix,
80 string* number) const {
81 return phone_util_.MaybeStripInternationalPrefixAndNormalize(
82 possible_idd_prefix,
83 number);
84 }
85
MaybeStripNationalPrefixAndCarrierCode(const PhoneMetadata & metadata,string * number,string * carrier_code) const86 void MaybeStripNationalPrefixAndCarrierCode(const PhoneMetadata& metadata,
87 string* number,
88 string* carrier_code) const {
89 phone_util_.MaybeStripNationalPrefixAndCarrierCode(metadata, number,
90 carrier_code);
91 }
92
MaybeStripExtension(string * number,string * extension) const93 bool MaybeStripExtension(string* number, string* extension) const {
94 return phone_util_.MaybeStripExtension(number, extension);
95 }
96
MaybeExtractCountryCode(const PhoneMetadata * default_region_metadata,bool keep_raw_input,string * national_number,PhoneNumber * phone_number) const97 PhoneNumberUtil::ErrorType MaybeExtractCountryCode(
98 const PhoneMetadata* default_region_metadata,
99 bool keep_raw_input,
100 string* national_number,
101 PhoneNumber* phone_number) const {
102 return phone_util_.MaybeExtractCountryCode(default_region_metadata,
103 keep_raw_input,
104 national_number,
105 phone_number);
106 }
107
ContainsOnlyValidDigits(const string & s) const108 bool ContainsOnlyValidDigits(const string& s) const {
109 return phone_util_.ContainsOnlyValidDigits(s);
110 }
111
112 const PhoneNumberUtil& phone_util_;
113
114 private:
115 DISALLOW_COPY_AND_ASSIGN(PhoneNumberUtilTest);
116 };
117
TEST_F(PhoneNumberUtilTest,ContainsOnlyValidDigits)118 TEST_F(PhoneNumberUtilTest, ContainsOnlyValidDigits) {
119 EXPECT_TRUE(ContainsOnlyValidDigits(""));
120 EXPECT_TRUE(ContainsOnlyValidDigits("2"));
121 EXPECT_TRUE(ContainsOnlyValidDigits("25"));
122 EXPECT_TRUE(ContainsOnlyValidDigits("\xEF\xBC\x96" /* "6" */));
123 EXPECT_FALSE(ContainsOnlyValidDigits("a"));
124 EXPECT_FALSE(ContainsOnlyValidDigits("2a"));
125 }
126
TEST_F(PhoneNumberUtilTest,GetSupportedRegions)127 TEST_F(PhoneNumberUtilTest, GetSupportedRegions) {
128 std::set<string> regions;
129
130 phone_util_.GetSupportedRegions(®ions);
131 EXPECT_GT(regions.size(), 0U);
132 }
133
TEST_F(PhoneNumberUtilTest,GetSupportedGlobalNetworkCallingCodes)134 TEST_F(PhoneNumberUtilTest, GetSupportedGlobalNetworkCallingCodes) {
135 std::set<int> calling_codes;
136
137 phone_util_.GetSupportedGlobalNetworkCallingCodes(&calling_codes);
138 EXPECT_GT(calling_codes.size(), 0U);
139 for (std::set<int>::const_iterator it = calling_codes.begin();
140 it != calling_codes.end(); ++it) {
141 EXPECT_GT(*it, 0);
142 string region_code;
143 phone_util_.GetRegionCodeForCountryCode(*it, ®ion_code);
144 EXPECT_EQ(RegionCode::UN001(), region_code);
145 }
146 }
147
TEST_F(PhoneNumberUtilTest,GetSupportedCallingCodes)148 TEST_F(PhoneNumberUtilTest, GetSupportedCallingCodes) {
149 std::set<int> calling_codes;
150
151 phone_util_.GetSupportedCallingCodes(&calling_codes);
152 EXPECT_GT(calling_codes.size(), 0U);
153 for (std::set<int>::const_iterator it = calling_codes.begin();
154 it != calling_codes.end(); ++it) {
155 EXPECT_GT(*it, 0);
156 string region_code;
157 phone_util_.GetRegionCodeForCountryCode(*it, ®ion_code);
158 EXPECT_NE(RegionCode::ZZ(), region_code);
159 }
160 std::set<int> supported_global_network_calling_codes;
161 phone_util_.GetSupportedGlobalNetworkCallingCodes(
162 &supported_global_network_calling_codes);
163 // There should be more than just the global network calling codes in this
164 // set.
165 EXPECT_GT(calling_codes.size(),
166 supported_global_network_calling_codes.size());
167 // But they should be included. Testing one of them.
168 EXPECT_NE(calling_codes.find(979), calling_codes.end());
169 }
170
TEST_F(PhoneNumberUtilTest,GetSupportedTypesForRegion)171 TEST_F(PhoneNumberUtilTest, GetSupportedTypesForRegion) {
172 std::set<PhoneNumberUtil::PhoneNumberType> types;
173 phone_util_.GetSupportedTypesForRegion(RegionCode::BR(), &types);
174 EXPECT_NE(types.find(PhoneNumberUtil::FIXED_LINE), types.end());
175 // Our test data has no mobile numbers for Brazil.
176 EXPECT_EQ(types.find(PhoneNumberUtil::MOBILE), types.end());
177 // UNKNOWN should never be returned.
178 EXPECT_EQ(types.find(PhoneNumberUtil::UNKNOWN), types.end());
179
180 types.clear();
181 // In the US, many numbers are classified as FIXED_LINE_OR_MOBILE; but we
182 // don't want to expose this as a supported type, instead we say FIXED_LINE
183 // and MOBILE are both present.
184 phone_util_.GetSupportedTypesForRegion(RegionCode::US(), &types);
185 EXPECT_NE(types.find(PhoneNumberUtil::FIXED_LINE), types.end());
186 EXPECT_NE(types.find(PhoneNumberUtil::MOBILE), types.end());
187 EXPECT_EQ(types.find(PhoneNumberUtil::FIXED_LINE_OR_MOBILE), types.end());
188 types.clear();
189 phone_util_.GetSupportedTypesForRegion(RegionCode::ZZ(), &types);
190 // Test the invalid region code.
191 EXPECT_EQ(0u, types.size());
192 }
193
TEST_F(PhoneNumberUtilTest,GetSupportedTypesForNonGeoEntity)194 TEST_F(PhoneNumberUtilTest, GetSupportedTypesForNonGeoEntity) {
195 std::set<PhoneNumberUtil::PhoneNumberType> types;
196 // No data exists for 999 at all, no types should be returned.
197 phone_util_.GetSupportedTypesForNonGeoEntity(999, &types);
198 EXPECT_EQ(0u, types.size());
199
200 types.clear();
201 phone_util_.GetSupportedTypesForNonGeoEntity(979, &types);
202 EXPECT_NE(types.find(PhoneNumberUtil::PREMIUM_RATE), types.end());
203 EXPECT_EQ(types.find(PhoneNumberUtil::MOBILE), types.end());
204 EXPECT_EQ(types.find(PhoneNumberUtil::UNKNOWN), types.end());
205 }
206
TEST_F(PhoneNumberUtilTest,GetRegionCodesForCountryCallingCode)207 TEST_F(PhoneNumberUtilTest, GetRegionCodesForCountryCallingCode) {
208 std::list<string> regions;
209
210 phone_util_.GetRegionCodesForCountryCallingCode(1, ®ions);
211 EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::US())
212 != regions.end());
213 EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::BS())
214 != regions.end());
215
216 regions.clear();
217 phone_util_.GetRegionCodesForCountryCallingCode(44, ®ions);
218 EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::GB())
219 != regions.end());
220
221 regions.clear();
222 phone_util_.GetRegionCodesForCountryCallingCode(49, ®ions);
223 EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::DE())
224 != regions.end());
225
226 regions.clear();
227 phone_util_.GetRegionCodesForCountryCallingCode(800, ®ions);
228 EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::UN001())
229 != regions.end());
230
231 regions.clear();
232 phone_util_.GetRegionCodesForCountryCallingCode(
233 kInvalidCountryCode, ®ions);
234 EXPECT_TRUE(regions.empty());
235 }
236
TEST_F(PhoneNumberUtilTest,GetInstanceLoadUSMetadata)237 TEST_F(PhoneNumberUtilTest, GetInstanceLoadUSMetadata) {
238 const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::US());
239 EXPECT_EQ("US", metadata->id());
240 EXPECT_EQ(1, metadata->country_code());
241 EXPECT_EQ("011", metadata->international_prefix());
242 EXPECT_TRUE(metadata->has_national_prefix());
243 ASSERT_EQ(2, metadata->number_format_size());
244 EXPECT_EQ("(\\d{3})(\\d{3})(\\d{4})",
245 metadata->number_format(1).pattern());
246 EXPECT_EQ("$1 $2 $3", metadata->number_format(1).format());
247 EXPECT_EQ("[13-689]\\d{9}|2[0-35-9]\\d{8}",
248 metadata->general_desc().national_number_pattern());
249 EXPECT_EQ("[13-689]\\d{9}|2[0-35-9]\\d{8}",
250 metadata->fixed_line().national_number_pattern());
251 EXPECT_EQ(1, metadata->general_desc().possible_length_size());
252 EXPECT_EQ(10, metadata->general_desc().possible_length(0));
253 // Possible lengths are the same as the general description, so aren't stored
254 // separately in the toll free element as well.
255 EXPECT_EQ(0, metadata->toll_free().possible_length_size());
256 EXPECT_EQ("900\\d{7}", metadata->premium_rate().national_number_pattern());
257 // No shared-cost data is available, so its national number data should not be
258 // set.
259 EXPECT_FALSE(metadata->shared_cost().has_national_number_pattern());
260 }
261
TEST_F(PhoneNumberUtilTest,GetInstanceLoadDEMetadata)262 TEST_F(PhoneNumberUtilTest, GetInstanceLoadDEMetadata) {
263 const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::DE());
264 EXPECT_EQ("DE", metadata->id());
265 EXPECT_EQ(49, metadata->country_code());
266 EXPECT_EQ("00", metadata->international_prefix());
267 EXPECT_EQ("0", metadata->national_prefix());
268 ASSERT_EQ(6, metadata->number_format_size());
269 EXPECT_EQ(1, metadata->number_format(5).leading_digits_pattern_size());
270 EXPECT_EQ("900", metadata->number_format(5).leading_digits_pattern(0));
271 EXPECT_EQ("(\\d{3})(\\d{3,4})(\\d{4})",
272 metadata->number_format(5).pattern());
273 EXPECT_EQ(2, metadata->general_desc().possible_length_local_only_size());
274 EXPECT_EQ(8, metadata->general_desc().possible_length_size());
275 // Nothing is present for fixed-line, since it is the same as the general
276 // desc, so for efficiency reasons we don't store an extra value.
277 EXPECT_EQ(0, metadata->fixed_line().possible_length_size());
278 EXPECT_EQ(2, metadata->mobile().possible_length_size());
279 EXPECT_EQ("$1 $2 $3", metadata->number_format(5).format());
280 EXPECT_EQ("(?:[24-6]\\d{2}|3[03-9]\\d|[789](?:0[2-9]|[1-9]\\d))\\d{1,8}",
281 metadata->fixed_line().national_number_pattern());
282 EXPECT_EQ("30123456", metadata->fixed_line().example_number());
283 EXPECT_EQ(10, metadata->toll_free().possible_length(0));
284 EXPECT_EQ("900([135]\\d{6}|9\\d{7})",
285 metadata->premium_rate().national_number_pattern());
286 }
287
TEST_F(PhoneNumberUtilTest,GetInstanceLoadARMetadata)288 TEST_F(PhoneNumberUtilTest, GetInstanceLoadARMetadata) {
289 const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::AR());
290 EXPECT_EQ("AR", metadata->id());
291 EXPECT_EQ(54, metadata->country_code());
292 EXPECT_EQ("00", metadata->international_prefix());
293 EXPECT_EQ("0", metadata->national_prefix());
294 EXPECT_EQ("0(?:(11|343|3715)15)?", metadata->national_prefix_for_parsing());
295 EXPECT_EQ("9$1", metadata->national_prefix_transform_rule());
296 ASSERT_EQ(5, metadata->number_format_size());
297 EXPECT_EQ("$2 15 $3-$4", metadata->number_format(2).format());
298 EXPECT_EQ("(\\d)(\\d{4})(\\d{2})(\\d{4})",
299 metadata->number_format(3).pattern());
300 EXPECT_EQ("(\\d)(\\d{4})(\\d{2})(\\d{4})",
301 metadata->intl_number_format(3).pattern());
302 EXPECT_EQ("$1 $2 $3 $4", metadata->intl_number_format(3).format());
303 }
304
TEST_F(PhoneNumberUtilTest,GetInstanceLoadInternationalTollFreeMetadata)305 TEST_F(PhoneNumberUtilTest, GetInstanceLoadInternationalTollFreeMetadata) {
306 const PhoneMetadata* metadata = GetMetadataForNonGeographicalRegion(800);
307 EXPECT_FALSE(metadata == NULL);
308 EXPECT_EQ("001", metadata->id());
309 EXPECT_EQ(800, metadata->country_code());
310 EXPECT_EQ("$1 $2", metadata->number_format(0).format());
311 EXPECT_EQ("(\\d{4})(\\d{4})", metadata->number_format(0).pattern());
312 EXPECT_EQ(0, metadata->general_desc().possible_length_local_only_size());
313 EXPECT_EQ(1, metadata->general_desc().possible_length_size());
314 EXPECT_EQ("12345678", metadata->toll_free().example_number());
315 }
316
TEST_F(PhoneNumberUtilTest,GetNationalSignificantNumber)317 TEST_F(PhoneNumberUtilTest, GetNationalSignificantNumber) {
318 PhoneNumber number;
319 number.set_country_code(1);
320 number.set_national_number(uint64{6502530000});
321 string national_significant_number;
322 phone_util_.GetNationalSignificantNumber(number,
323 &national_significant_number);
324 EXPECT_EQ("6502530000", national_significant_number);
325
326 // An Italian mobile number.
327 national_significant_number.clear();
328 number.set_country_code(39);
329 number.set_national_number(uint64{312345678});
330 phone_util_.GetNationalSignificantNumber(number,
331 &national_significant_number);
332 EXPECT_EQ("312345678", national_significant_number);
333
334 // An Italian fixed line number.
335 national_significant_number.clear();
336 number.set_country_code(39);
337 number.set_national_number(uint64{236618300});
338 number.set_italian_leading_zero(true);
339 phone_util_.GetNationalSignificantNumber(number,
340 &national_significant_number);
341 EXPECT_EQ("0236618300", national_significant_number);
342
343 national_significant_number.clear();
344 number.Clear();
345 number.set_country_code(800);
346 number.set_national_number(uint64{12345678});
347 phone_util_.GetNationalSignificantNumber(number,
348 &national_significant_number);
349 EXPECT_EQ("12345678", national_significant_number);
350 }
351
TEST_F(PhoneNumberUtilTest,GetNationalSignificantNumber_ManyLeadingZeros)352 TEST_F(PhoneNumberUtilTest, GetNationalSignificantNumber_ManyLeadingZeros) {
353 PhoneNumber number;
354 number.set_country_code(1);
355 number.set_national_number(uint64{650});
356 number.set_italian_leading_zero(true);
357 number.set_number_of_leading_zeros(2);
358 string national_significant_number;
359 phone_util_.GetNationalSignificantNumber(number,
360 &national_significant_number);
361 EXPECT_EQ("00650", national_significant_number);
362
363 // Set a bad value; we shouldn't crash, we shouldn't output any leading zeros
364 // at all.
365 number.set_number_of_leading_zeros(-3);
366 national_significant_number.clear();
367 phone_util_.GetNationalSignificantNumber(number,
368 &national_significant_number);
369 EXPECT_EQ("650", national_significant_number);
370 }
371
TEST_F(PhoneNumberUtilTest,GetExampleNumber)372 TEST_F(PhoneNumberUtilTest, GetExampleNumber) {
373 PhoneNumber de_number;
374 de_number.set_country_code(49);
375 de_number.set_national_number(uint64{30123456});
376 PhoneNumber test_number;
377 bool success = phone_util_.GetExampleNumber(RegionCode::DE(), &test_number);
378 EXPECT_TRUE(success);
379 EXPECT_EQ(de_number, test_number);
380
381 success = phone_util_.GetExampleNumberForType(
382 RegionCode::DE(), PhoneNumberUtil::FIXED_LINE, &test_number);
383 EXPECT_TRUE(success);
384 EXPECT_EQ(de_number, test_number);
385
386 // Should return the same response if asked for FIXED_LINE_OR_MOBILE too.
387 success = phone_util_.GetExampleNumberForType(
388 RegionCode::DE(), PhoneNumberUtil::FIXED_LINE_OR_MOBILE, &test_number);
389 EXPECT_EQ(de_number, test_number);
390
391 success = phone_util_.GetExampleNumberForType(
392 RegionCode::DE(), PhoneNumberUtil::MOBILE, &test_number);
393 // We have data for the US, but no data for VOICEMAIL, so the number passed in
394 // should be left empty.
395 success = phone_util_.GetExampleNumberForType(
396 RegionCode::US(), PhoneNumberUtil::VOICEMAIL, &test_number);
397 test_number.Clear();
398 EXPECT_FALSE(success);
399 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
400
401 success = phone_util_.GetExampleNumberForType(
402 RegionCode::US(), PhoneNumberUtil::FIXED_LINE, &test_number);
403 // Here we test that the call to get an example number succeeded, and that the
404 // number passed in was modified.
405 EXPECT_TRUE(success);
406 EXPECT_NE(PhoneNumber::default_instance(), test_number);
407 success = phone_util_.GetExampleNumberForType(
408 RegionCode::US(), PhoneNumberUtil::MOBILE, &test_number);
409 EXPECT_TRUE(success);
410 EXPECT_NE(PhoneNumber::default_instance(), test_number);
411
412 // CS is an invalid region, so we have no data for it. We should return false.
413 test_number.Clear();
414 EXPECT_FALSE(phone_util_.GetExampleNumberForType(
415 RegionCode::CS(), PhoneNumberUtil::MOBILE, &test_number));
416 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
417
418 // RegionCode 001 is reserved for supporting non-geographical country calling
419 // code. We don't support getting an example number for it with this method.
420 EXPECT_FALSE(phone_util_.GetExampleNumber(RegionCode::UN001(), &test_number));
421 }
422
TEST_F(PhoneNumberUtilTest,GetInvalidExampleNumber)423 TEST_F(PhoneNumberUtilTest, GetInvalidExampleNumber) {
424 // RegionCode 001 is reserved for supporting non-geographical country calling
425 // codes. We don't support getting an invalid example number for it with
426 // GetInvalidExampleNumber.
427 PhoneNumber test_number;
428 EXPECT_FALSE(phone_util_.GetInvalidExampleNumber(RegionCode::UN001(),
429 &test_number));
430 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
431 EXPECT_FALSE(phone_util_.GetInvalidExampleNumber(RegionCode::CS(),
432 &test_number));
433 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
434
435 EXPECT_TRUE(phone_util_.GetInvalidExampleNumber(RegionCode::US(),
436 &test_number));
437 // At least the country calling code should be set correctly.
438 EXPECT_EQ(1, test_number.country_code());
439 EXPECT_NE(0u, test_number.national_number());
440 }
441
TEST_F(PhoneNumberUtilTest,GetExampleNumberForNonGeoEntity)442 TEST_F(PhoneNumberUtilTest, GetExampleNumberForNonGeoEntity) {
443 PhoneNumber toll_free_number;
444 toll_free_number.set_country_code(800);
445 toll_free_number.set_national_number(uint64{12345678});
446 PhoneNumber test_number;
447 bool success =
448 phone_util_.GetExampleNumberForNonGeoEntity(800 , &test_number);
449 EXPECT_TRUE(success);
450 EXPECT_EQ(toll_free_number, test_number);
451
452 PhoneNumber universal_premium_rate;
453 universal_premium_rate.set_country_code(979);
454 universal_premium_rate.set_national_number(uint64{123456789});
455 success = phone_util_.GetExampleNumberForNonGeoEntity(979 , &test_number);
456 EXPECT_TRUE(success);
457 EXPECT_EQ(universal_premium_rate, test_number);
458 }
459
TEST_F(PhoneNumberUtilTest,GetExampleNumberWithoutRegion)460 TEST_F(PhoneNumberUtilTest, GetExampleNumberWithoutRegion) {
461 // In our test metadata we don't cover all types: in our real metadata, we do.
462 PhoneNumber test_number;
463 bool success = phone_util_.GetExampleNumberForType(
464 PhoneNumberUtil::FIXED_LINE,
465 &test_number);
466 // We test that the call to get an example number succeeded, and that the
467 // number passed in was modified.
468 EXPECT_TRUE(success);
469 EXPECT_NE(PhoneNumber::default_instance(), test_number);
470 test_number.Clear();
471
472 success = phone_util_.GetExampleNumberForType(PhoneNumberUtil::MOBILE,
473 &test_number);
474 EXPECT_TRUE(success);
475 EXPECT_NE(PhoneNumber::default_instance(), test_number);
476 test_number.Clear();
477
478 success = phone_util_.GetExampleNumberForType(PhoneNumberUtil::PREMIUM_RATE,
479 &test_number);
480 EXPECT_TRUE(success);
481 EXPECT_NE(PhoneNumber::default_instance(), test_number);
482 }
483
TEST_F(PhoneNumberUtilTest,FormatUSNumber)484 TEST_F(PhoneNumberUtilTest, FormatUSNumber) {
485 PhoneNumber test_number;
486 string formatted_number;
487 test_number.set_country_code(1);
488 test_number.set_national_number(uint64{6502530000});
489 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
490 EXPECT_EQ("650 253 0000", formatted_number);
491 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
492 &formatted_number);
493 EXPECT_EQ("+1 650 253 0000", formatted_number);
494
495 test_number.set_national_number(uint64{8002530000});
496 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
497 EXPECT_EQ("800 253 0000", formatted_number);
498 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
499 &formatted_number);
500 EXPECT_EQ("+1 800 253 0000", formatted_number);
501
502 test_number.set_national_number(uint64{9002530000});
503 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
504 EXPECT_EQ("900 253 0000", formatted_number);
505 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
506 &formatted_number);
507 EXPECT_EQ("+1 900 253 0000", formatted_number);
508 phone_util_.Format(test_number, PhoneNumberUtil::RFC3966, &formatted_number);
509 EXPECT_EQ("tel:+1-900-253-0000", formatted_number);
510 test_number.set_national_number(uint64{0});
511 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
512 EXPECT_EQ("0", formatted_number);
513 // Numbers with all zeros in the national number part will be formatted by
514 // using the raw_input if that is available no matter which format is
515 // specified.
516 test_number.set_raw_input("000-000-0000");
517 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
518 EXPECT_EQ("000-000-0000", formatted_number);
519 }
520
TEST_F(PhoneNumberUtilTest,FormatBSNumber)521 TEST_F(PhoneNumberUtilTest, FormatBSNumber) {
522 PhoneNumber test_number;
523 string formatted_number;
524 test_number.set_country_code(1);
525 test_number.set_national_number(uint64{2421234567});
526 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
527 EXPECT_EQ("242 123 4567", formatted_number);
528 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
529 &formatted_number);
530 EXPECT_EQ("+1 242 123 4567", formatted_number);
531
532 test_number.set_national_number(uint64{8002530000});
533 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
534 EXPECT_EQ("800 253 0000", formatted_number);
535 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
536 &formatted_number);
537 EXPECT_EQ("+1 800 253 0000", formatted_number);
538
539 test_number.set_national_number(uint64{9002530000});
540 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
541 EXPECT_EQ("900 253 0000", formatted_number);
542 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
543 &formatted_number);
544 EXPECT_EQ("+1 900 253 0000", formatted_number);
545 }
546
TEST_F(PhoneNumberUtilTest,FormatGBNumber)547 TEST_F(PhoneNumberUtilTest, FormatGBNumber) {
548 PhoneNumber test_number;
549 string formatted_number;
550 test_number.set_country_code(44);
551 test_number.set_national_number(uint64{2087389353});
552 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
553 EXPECT_EQ("(020) 8738 9353", formatted_number);
554 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
555 &formatted_number);
556 EXPECT_EQ("+44 20 8738 9353", formatted_number);
557
558 test_number.set_national_number(uint64{7912345678});
559 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
560 EXPECT_EQ("(07912) 345 678", formatted_number);
561 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
562 &formatted_number);
563 EXPECT_EQ("+44 7912 345 678", formatted_number);
564 }
565
TEST_F(PhoneNumberUtilTest,FormatDENumber)566 TEST_F(PhoneNumberUtilTest, FormatDENumber) {
567 PhoneNumber test_number;
568 string formatted_number;
569 test_number.set_country_code(49);
570 test_number.set_national_number(uint64{301234});
571 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
572 EXPECT_EQ("030/1234", formatted_number);
573 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
574 &formatted_number);
575 EXPECT_EQ("+49 30/1234", formatted_number);
576 phone_util_.Format(test_number, PhoneNumberUtil::RFC3966, &formatted_number);
577 EXPECT_EQ("tel:+49-30-1234", formatted_number);
578
579 test_number.set_national_number(uint64{291123});
580 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
581 EXPECT_EQ("0291 123", formatted_number);
582 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
583 &formatted_number);
584 EXPECT_EQ("+49 291 123", formatted_number);
585
586 test_number.set_national_number(uint64{29112345678});
587 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
588 EXPECT_EQ("0291 12345678", formatted_number);
589 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
590 &formatted_number);
591 EXPECT_EQ("+49 291 12345678", formatted_number);
592
593 test_number.set_national_number(uint64{9123123});
594 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
595 EXPECT_EQ("09123 123", formatted_number);
596 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
597 &formatted_number);
598 EXPECT_EQ("+49 9123 123", formatted_number);
599
600 test_number.set_national_number(uint64{80212345});
601 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
602 EXPECT_EQ("08021 2345", formatted_number);
603 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
604 &formatted_number);
605 EXPECT_EQ("+49 8021 2345", formatted_number);
606
607 test_number.set_national_number(uint64{1234});
608 // Note this number is correctly formatted without national prefix. Most of
609 // the numbers that are treated as invalid numbers by the library are short
610 // numbers, and they are usually not dialed with national prefix.
611 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
612 EXPECT_EQ("1234", formatted_number);
613 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
614 &formatted_number);
615 EXPECT_EQ("+49 1234", formatted_number);
616 }
617
TEST_F(PhoneNumberUtilTest,FormatITNumber)618 TEST_F(PhoneNumberUtilTest, FormatITNumber) {
619 PhoneNumber test_number;
620 string formatted_number;
621 test_number.set_country_code(39);
622 test_number.set_national_number(uint64{236618300});
623 test_number.set_italian_leading_zero(true);
624 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
625 EXPECT_EQ("02 3661 8300", formatted_number);
626 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
627 &formatted_number);
628 EXPECT_EQ("+39 02 3661 8300", formatted_number);
629 phone_util_.Format(test_number, PhoneNumberUtil::E164,
630 &formatted_number);
631 EXPECT_EQ("+390236618300", formatted_number);
632
633 test_number.set_national_number(uint64{345678901});
634 test_number.set_italian_leading_zero(false);
635 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
636 EXPECT_EQ("345 678 901", formatted_number);
637 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
638 &formatted_number);
639 EXPECT_EQ("+39 345 678 901", formatted_number);
640 phone_util_.Format(test_number, PhoneNumberUtil::E164,
641 &formatted_number);
642 EXPECT_EQ("+39345678901", formatted_number);
643 }
644
TEST_F(PhoneNumberUtilTest,FormatAUNumber)645 TEST_F(PhoneNumberUtilTest, FormatAUNumber) {
646 PhoneNumber test_number;
647 string formatted_number;
648 test_number.set_country_code(61);
649 test_number.set_national_number(uint64{236618300});
650 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
651 EXPECT_EQ("02 3661 8300", formatted_number);
652 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
653 &formatted_number);
654 EXPECT_EQ("+61 2 3661 8300", formatted_number);
655 phone_util_.Format(test_number, PhoneNumberUtil::E164,
656 &formatted_number);
657 EXPECT_EQ("+61236618300", formatted_number);
658
659 test_number.set_national_number(uint64{1800123456});
660 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
661 EXPECT_EQ("1800 123 456", formatted_number);
662 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
663 &formatted_number);
664 EXPECT_EQ("+61 1800 123 456", formatted_number);
665 phone_util_.Format(test_number, PhoneNumberUtil::E164,
666 &formatted_number);
667 EXPECT_EQ("+611800123456", formatted_number);
668 }
669
TEST_F(PhoneNumberUtilTest,FormatARNumber)670 TEST_F(PhoneNumberUtilTest, FormatARNumber) {
671 PhoneNumber test_number;
672 string formatted_number;
673 test_number.set_country_code(54);
674 test_number.set_national_number(uint64{1187654321});
675 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
676 EXPECT_EQ("011 8765-4321", formatted_number);
677 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
678 &formatted_number);
679 EXPECT_EQ("+54 11 8765-4321", formatted_number);
680 phone_util_.Format(test_number, PhoneNumberUtil::E164,
681 &formatted_number);
682 EXPECT_EQ("+541187654321", formatted_number);
683
684 test_number.set_national_number(uint64{91187654321});
685 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
686 EXPECT_EQ("011 15 8765-4321", formatted_number);
687 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
688 &formatted_number);
689 EXPECT_EQ("+54 9 11 8765 4321", formatted_number);
690 phone_util_.Format(test_number, PhoneNumberUtil::E164,
691 &formatted_number);
692 EXPECT_EQ("+5491187654321", formatted_number);
693 }
694
TEST_F(PhoneNumberUtilTest,FormatMXNumber)695 TEST_F(PhoneNumberUtilTest, FormatMXNumber) {
696 PhoneNumber test_number;
697 string formatted_number;
698 test_number.set_country_code(52);
699 test_number.set_national_number(uint64{12345678900});
700 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
701 EXPECT_EQ("045 234 567 8900", formatted_number);
702 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
703 &formatted_number);
704 EXPECT_EQ("+52 1 234 567 8900", formatted_number);
705 phone_util_.Format(test_number, PhoneNumberUtil::E164,
706 &formatted_number);
707 EXPECT_EQ("+5212345678900", formatted_number);
708
709 test_number.set_national_number(uint64{15512345678});
710 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
711 EXPECT_EQ("045 55 1234 5678", formatted_number);
712 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
713 &formatted_number);
714 EXPECT_EQ("+52 1 55 1234 5678", formatted_number);
715 phone_util_.Format(test_number, PhoneNumberUtil::E164,
716 &formatted_number);
717 EXPECT_EQ("+5215512345678", formatted_number);
718
719 test_number.set_national_number(3312345678LL);
720 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
721 EXPECT_EQ("01 33 1234 5678", formatted_number);
722 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
723 &formatted_number);
724 EXPECT_EQ("+52 33 1234 5678", formatted_number);
725 phone_util_.Format(test_number, PhoneNumberUtil::E164,
726 &formatted_number);
727 EXPECT_EQ("+523312345678", formatted_number);
728
729 test_number.set_national_number(8211234567LL);
730 phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
731 EXPECT_EQ("01 821 123 4567", formatted_number);
732 phone_util_.Format(test_number, PhoneNumberUtil::INTERNATIONAL,
733 &formatted_number);
734 EXPECT_EQ("+52 821 123 4567", formatted_number);
735 phone_util_.Format(test_number, PhoneNumberUtil::E164,
736 &formatted_number);
737 EXPECT_EQ("+528211234567", formatted_number);
738 }
739
TEST_F(PhoneNumberUtilTest,FormatOutOfCountryCallingNumber)740 TEST_F(PhoneNumberUtilTest, FormatOutOfCountryCallingNumber) {
741 PhoneNumber test_number;
742 string formatted_number;
743 test_number.set_country_code(1);
744 test_number.set_national_number(uint64{9002530000});
745 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::DE(),
746 &formatted_number);
747 EXPECT_EQ("00 1 900 253 0000", formatted_number);
748
749 test_number.set_national_number(uint64{6502530000});
750 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::BS(),
751 &formatted_number);
752 EXPECT_EQ("1 650 253 0000", formatted_number);
753 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::PL(),
754 &formatted_number);
755 EXPECT_EQ("00 1 650 253 0000", formatted_number);
756
757 test_number.set_country_code(44);
758 test_number.set_national_number(uint64{7912345678});
759 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
760 &formatted_number);
761 EXPECT_EQ("011 44 7912 345 678", formatted_number);
762
763 test_number.set_country_code(49);
764 test_number.set_national_number(uint64{1234});
765 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::GB(),
766 &formatted_number);
767 EXPECT_EQ("00 49 1234", formatted_number);
768 // Note this number is correctly formatted without national prefix. Most of
769 // the numbers that are treated as invalid numbers by the library are short
770 // numbers, and they are usually not dialed with national prefix.
771 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::DE(),
772 &formatted_number);
773 EXPECT_EQ("1234", formatted_number);
774
775 test_number.set_country_code(39);
776 test_number.set_national_number(uint64{236618300});
777 test_number.set_italian_leading_zero(true);
778 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
779 &formatted_number);
780 EXPECT_EQ("011 39 02 3661 8300", formatted_number);
781 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::IT(),
782 &formatted_number);
783 EXPECT_EQ("02 3661 8300", formatted_number);
784 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::SG(),
785 &formatted_number);
786 EXPECT_EQ("+39 02 3661 8300", formatted_number);
787
788 test_number.set_country_code(65);
789 test_number.set_national_number(uint64{94777892});
790 test_number.set_italian_leading_zero(false);
791 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::SG(),
792 &formatted_number);
793 EXPECT_EQ("9477 7892", formatted_number);
794
795 test_number.set_country_code(800);
796 test_number.set_national_number(uint64{12345678});
797 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
798 &formatted_number);
799 EXPECT_EQ("011 800 1234 5678", formatted_number);
800
801 test_number.set_country_code(54);
802 test_number.set_national_number(uint64{91187654321});
803 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
804 &formatted_number);
805 EXPECT_EQ("011 54 9 11 8765 4321", formatted_number);
806
807 test_number.set_extension("1234");
808 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
809 &formatted_number);
810 EXPECT_EQ("011 54 9 11 8765 4321 ext. 1234", formatted_number);
811 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AU(),
812 &formatted_number);
813 EXPECT_EQ("0011 54 9 11 8765 4321 ext. 1234", formatted_number);
814 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AR(),
815 &formatted_number);
816 EXPECT_EQ("011 15 8765-4321 ext. 1234", formatted_number);
817 }
818
TEST_F(PhoneNumberUtilTest,FormatOutOfCountryWithInvalidRegion)819 TEST_F(PhoneNumberUtilTest, FormatOutOfCountryWithInvalidRegion) {
820 PhoneNumber test_number;
821 string formatted_number;
822 test_number.set_country_code(1);
823 test_number.set_national_number(uint64{6502530000});
824 // AQ/Antarctica isn't a valid region code for phone number formatting,
825 // so this falls back to intl formatting.
826 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AQ(),
827 &formatted_number);
828 EXPECT_EQ("+1 650 253 0000", formatted_number);
829 // For region code 001, the out-of-country format always turns into the
830 // international format.
831 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::UN001(),
832 &formatted_number);
833 EXPECT_EQ("+1 650 253 0000", formatted_number);
834 }
835
TEST_F(PhoneNumberUtilTest,FormatOutOfCountryWithPreferredIntlPrefix)836 TEST_F(PhoneNumberUtilTest, FormatOutOfCountryWithPreferredIntlPrefix) {
837 PhoneNumber test_number;
838 string formatted_number;
839 test_number.set_country_code(39);
840 test_number.set_national_number(uint64{236618300});
841 test_number.set_italian_leading_zero(true);
842 // This should use 0011, since that is the preferred international prefix
843 // (both 0011 and 0012 are accepted as possible international prefixes in our
844 // test metadta.)
845 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AU(),
846 &formatted_number);
847 EXPECT_EQ("0011 39 02 3661 8300", formatted_number);
848
849 // Testing preferred international prefixes with ~ are supported (designates
850 // waiting).
851 phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::UZ(),
852 &formatted_number);
853 EXPECT_EQ("8~10 39 02 3661 8300", formatted_number);
854 }
855
TEST_F(PhoneNumberUtilTest,FormatOutOfCountryKeepingAlphaChars)856 TEST_F(PhoneNumberUtilTest, FormatOutOfCountryKeepingAlphaChars) {
857 PhoneNumber alpha_numeric_number;
858 string formatted_number;
859 alpha_numeric_number.set_country_code(1);
860 alpha_numeric_number.set_national_number(uint64{8007493524});
861 alpha_numeric_number.set_raw_input("1800 six-flag");
862 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
863 RegionCode::AU(),
864 &formatted_number);
865 EXPECT_EQ("0011 1 800 SIX-FLAG", formatted_number);
866
867 formatted_number.clear();
868 alpha_numeric_number.set_raw_input("1-800-SIX-flag");
869 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
870 RegionCode::AU(),
871 &formatted_number);
872 EXPECT_EQ("0011 1 800-SIX-FLAG", formatted_number);
873
874 formatted_number.clear();
875 alpha_numeric_number.set_raw_input("Call us from UK: 00 1 800 SIX-flag");
876 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
877 RegionCode::AU(),
878 &formatted_number);
879 EXPECT_EQ("0011 1 800 SIX-FLAG", formatted_number);
880
881 formatted_number.clear();
882 alpha_numeric_number.set_raw_input("800 SIX-flag");
883 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
884 RegionCode::AU(),
885 &formatted_number);
886 EXPECT_EQ("0011 1 800 SIX-FLAG", formatted_number);
887
888 // Formatting from within the NANPA region.
889 formatted_number.clear();
890 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
891 RegionCode::US(),
892 &formatted_number);
893 EXPECT_EQ("1 800 SIX-FLAG", formatted_number);
894 formatted_number.clear();
895 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
896 RegionCode::BS(),
897 &formatted_number);
898 EXPECT_EQ("1 800 SIX-FLAG", formatted_number);
899
900 // Testing that if the raw input doesn't exist, it is formatted using
901 // FormatOutOfCountryCallingNumber.
902 alpha_numeric_number.clear_raw_input();
903 formatted_number.clear();
904 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
905 RegionCode::DE(),
906 &formatted_number);
907 EXPECT_EQ("00 1 800 749 3524", formatted_number);
908
909 // Testing AU alpha number formatted from Australia.
910 alpha_numeric_number.set_country_code(61);
911 alpha_numeric_number.set_national_number(uint64{827493524});
912 alpha_numeric_number.set_raw_input("+61 82749-FLAG");
913 formatted_number.clear();
914 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
915 RegionCode::AU(),
916 &formatted_number);
917 // This number should have the national prefix prefixed.
918 EXPECT_EQ("082749-FLAG", formatted_number);
919
920 alpha_numeric_number.set_raw_input("082749-FLAG");
921 formatted_number.clear();
922 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
923 RegionCode::AU(),
924 &formatted_number);
925 EXPECT_EQ("082749-FLAG", formatted_number);
926
927 alpha_numeric_number.set_national_number(uint64{18007493524});
928 alpha_numeric_number.set_raw_input("1-800-SIX-flag");
929 formatted_number.clear();
930 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
931 RegionCode::AU(),
932 &formatted_number);
933 // This number should not have the national prefix prefixed, in accordance
934 // with the override for this specific formatting rule.
935 EXPECT_EQ("1-800-SIX-FLAG", formatted_number);
936 // The metadata should not be permanently changed, since we copied it before
937 // modifying patterns. Here we check this.
938 formatted_number.clear();
939 alpha_numeric_number.set_national_number(uint64{1800749352});
940 phone_util_.FormatOutOfCountryCallingNumber(alpha_numeric_number,
941 RegionCode::AU(),
942 &formatted_number);
943 EXPECT_EQ("1800 749 352", formatted_number);
944
945 // Testing a country with multiple international prefixes.
946 formatted_number.clear();
947 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
948 RegionCode::SG(),
949 &formatted_number);
950 EXPECT_EQ("+61 1-800-SIX-FLAG", formatted_number);
951 // Testing the case of calling from a non-supported region.
952 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
953 RegionCode::AQ(),
954 &formatted_number);
955 EXPECT_EQ("+61 1-800-SIX-FLAG", formatted_number);
956
957 // Testing the case with an invalid country code.
958 formatted_number.clear();
959 alpha_numeric_number.set_country_code(0);
960 alpha_numeric_number.set_national_number(uint64{18007493524});
961 alpha_numeric_number.set_raw_input("1-800-SIX-flag");
962 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
963 RegionCode::DE(),
964 &formatted_number);
965 // Uses the raw input only.
966 EXPECT_EQ("1-800-SIX-flag", formatted_number);
967
968 // Testing the case of an invalid alpha number.
969 formatted_number.clear();
970 alpha_numeric_number.set_country_code(1);
971 alpha_numeric_number.set_national_number(uint64{80749});
972 alpha_numeric_number.set_raw_input("180-SIX");
973 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
974 RegionCode::DE(),
975 &formatted_number);
976 // No country-code stripping can be done.
977 EXPECT_EQ("00 1 180-SIX", formatted_number);
978 // Testing the case of calling from a non-supported region.
979 phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
980 RegionCode::AQ(),
981 &formatted_number);
982 // No country-code stripping can be done since the number is invalid.
983 EXPECT_EQ("+1 180-SIX", formatted_number);
984 }
985
TEST_F(PhoneNumberUtilTest,FormatWithCarrierCode)986 TEST_F(PhoneNumberUtilTest, FormatWithCarrierCode) {
987 // We only support this for AR in our test metadata.
988 PhoneNumber ar_number;
989 string formatted_number;
990 ar_number.set_country_code(54);
991 ar_number.set_national_number(uint64{91234125678});
992 phone_util_.Format(ar_number, PhoneNumberUtil::NATIONAL, &formatted_number);
993 EXPECT_EQ("01234 12-5678", formatted_number);
994 // Test formatting with a carrier code.
995 phone_util_.FormatNationalNumberWithCarrierCode(ar_number, "15",
996 &formatted_number);
997 EXPECT_EQ("01234 15 12-5678", formatted_number);
998 phone_util_.FormatNationalNumberWithCarrierCode(ar_number, "",
999 &formatted_number);
1000 EXPECT_EQ("01234 12-5678", formatted_number);
1001 // Here the international rule is used, so no carrier code should be present.
1002 phone_util_.Format(ar_number, PhoneNumberUtil::E164, &formatted_number);
1003 EXPECT_EQ("+5491234125678", formatted_number);
1004
1005 // We don't support this for the US so there should be no change.
1006 PhoneNumber us_number;
1007 us_number.set_country_code(1);
1008 us_number.set_national_number(uint64{4241231234});
1009 phone_util_.Format(us_number, PhoneNumberUtil::NATIONAL, &formatted_number);
1010 EXPECT_EQ("424 123 1234", formatted_number);
1011 phone_util_.FormatNationalNumberWithCarrierCode(us_number, "15",
1012 &formatted_number);
1013 EXPECT_EQ("424 123 1234", formatted_number);
1014
1015 // Invalid country code should just get the NSN.
1016 PhoneNumber invalid_number;
1017 invalid_number.set_country_code(kInvalidCountryCode);
1018 invalid_number.set_national_number(uint64{12345});
1019 phone_util_.FormatNationalNumberWithCarrierCode(invalid_number, "89",
1020 &formatted_number);
1021 EXPECT_EQ("12345", formatted_number);
1022 }
1023
TEST_F(PhoneNumberUtilTest,FormatWithPreferredCarrierCode)1024 TEST_F(PhoneNumberUtilTest, FormatWithPreferredCarrierCode) {
1025 // We only support this for AR in our test metadata.
1026 PhoneNumber ar_number;
1027 string formatted_number;
1028 ar_number.set_country_code(54);
1029 ar_number.set_national_number(uint64{91234125678});
1030 // Test formatting with no preferred carrier code stored in the number itself.
1031 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "15",
1032 &formatted_number);
1033 EXPECT_EQ("01234 15 12-5678", formatted_number);
1034 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "",
1035 &formatted_number);
1036 EXPECT_EQ("01234 12-5678", formatted_number);
1037 // Test formatting with preferred carrier code present.
1038 ar_number.set_preferred_domestic_carrier_code("19");
1039 phone_util_.Format(ar_number, PhoneNumberUtil::NATIONAL, &formatted_number);
1040 EXPECT_EQ("01234 12-5678", formatted_number);
1041 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "15",
1042 &formatted_number);
1043 EXPECT_EQ("01234 19 12-5678", formatted_number);
1044 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "",
1045 &formatted_number);
1046 EXPECT_EQ("01234 19 12-5678", formatted_number);
1047 // When the preferred_domestic_carrier_code is present (even when it is just a
1048 // space), use it instead of the default carrier code passed in.
1049 ar_number.set_preferred_domestic_carrier_code(" ");
1050 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "15",
1051 &formatted_number);
1052 EXPECT_EQ("01234 12-5678", formatted_number);
1053 // When the preferred_domestic_carrier_code is present but empty, treat it as
1054 // unset and use instead the default carrier code passed in.
1055 ar_number.set_preferred_domestic_carrier_code("");
1056 phone_util_.FormatNationalNumberWithPreferredCarrierCode(ar_number, "15",
1057 &formatted_number);
1058 EXPECT_EQ("01234 15 12-5678", formatted_number);
1059 // We don't support this for the US so there should be no change.
1060 PhoneNumber us_number;
1061 us_number.set_country_code(1);
1062 us_number.set_national_number(uint64{4241231234});
1063 us_number.set_preferred_domestic_carrier_code("99");
1064 phone_util_.Format(us_number, PhoneNumberUtil::NATIONAL, &formatted_number);
1065 EXPECT_EQ("424 123 1234", formatted_number);
1066 phone_util_.FormatNationalNumberWithPreferredCarrierCode(us_number, "15",
1067 &formatted_number);
1068 EXPECT_EQ("424 123 1234", formatted_number);
1069 }
1070
TEST_F(PhoneNumberUtilTest,FormatNumberForMobileDialing)1071 TEST_F(PhoneNumberUtilTest, FormatNumberForMobileDialing) {
1072 PhoneNumber test_number;
1073 string formatted_number;
1074
1075 // Numbers are normally dialed in national format in-country, and
1076 // international format from outside the country.
1077 test_number.set_country_code(49);
1078 test_number.set_national_number(uint64{30123456});
1079 phone_util_.FormatNumberForMobileDialing(
1080 test_number, RegionCode::DE(), false, /* remove formatting */
1081 &formatted_number);
1082 EXPECT_EQ("030123456", formatted_number);
1083 phone_util_.FormatNumberForMobileDialing(
1084 test_number, RegionCode::CH(), false, /* remove formatting */
1085 &formatted_number);
1086 EXPECT_EQ("+4930123456", formatted_number);
1087
1088 test_number.set_extension("1234");
1089 phone_util_.FormatNumberForMobileDialing(
1090 test_number, RegionCode::DE(), false, /* remove formatting */
1091 &formatted_number);
1092 EXPECT_EQ("030123456", formatted_number);
1093 phone_util_.FormatNumberForMobileDialing(
1094 test_number, RegionCode::CH(), false, /* remove formatting */
1095 &formatted_number);
1096 EXPECT_EQ("+4930123456", formatted_number);
1097
1098 test_number.set_country_code(1);
1099 test_number.clear_extension();
1100 // US toll free numbers are marked as noInternationalDialling in the test
1101 // metadata for testing purposes. For such numbers, we expect nothing to be
1102 // returned when the region code is not the same one.
1103 test_number.set_national_number(uint64{8002530000});
1104 phone_util_.FormatNumberForMobileDialing(
1105 test_number, RegionCode::US(), true, /* keep formatting */
1106 &formatted_number);
1107 EXPECT_EQ("800 253 0000", formatted_number);
1108 phone_util_.FormatNumberForMobileDialing(
1109 test_number, RegionCode::CN(), true, &formatted_number);
1110 EXPECT_EQ("", formatted_number);
1111 phone_util_.FormatNumberForMobileDialing(
1112 test_number, RegionCode::US(), false, /* remove formatting */
1113 &formatted_number);
1114 EXPECT_EQ("8002530000", formatted_number);
1115 phone_util_.FormatNumberForMobileDialing(
1116 test_number, RegionCode::CN(), false, &formatted_number);
1117 EXPECT_EQ("", formatted_number);
1118
1119 test_number.set_national_number(uint64{6502530000});
1120 phone_util_.FormatNumberForMobileDialing(
1121 test_number, RegionCode::US(), true, &formatted_number);
1122 EXPECT_EQ("+1 650 253 0000", formatted_number);
1123 phone_util_.FormatNumberForMobileDialing(
1124 test_number, RegionCode::US(), false, &formatted_number);
1125 EXPECT_EQ("+16502530000", formatted_number);
1126
1127 test_number.set_extension("1234");
1128 phone_util_.FormatNumberForMobileDialing(
1129 test_number, RegionCode::US(), true, &formatted_number);
1130 EXPECT_EQ("+1 650 253 0000", formatted_number);
1131 phone_util_.FormatNumberForMobileDialing(
1132 test_number, RegionCode::US(), false, &formatted_number);
1133 EXPECT_EQ("+16502530000", formatted_number);
1134
1135 // An invalid US number, which is one digit too long.
1136 test_number.set_national_number(uint64{65025300001});
1137 phone_util_.FormatNumberForMobileDialing(
1138 test_number, RegionCode::US(), true, &formatted_number);
1139 EXPECT_EQ("+1 65025300001", formatted_number);
1140 phone_util_.FormatNumberForMobileDialing(
1141 test_number, RegionCode::US(), false, &formatted_number);
1142 EXPECT_EQ("+165025300001", formatted_number);
1143
1144 // Star numbers. In real life they appear in Israel, but we have them in JP
1145 // in our test metadata.
1146 test_number.set_country_code(81);
1147 test_number.set_national_number(uint64{2345});
1148 phone_util_.FormatNumberForMobileDialing(
1149 test_number, RegionCode::JP(), true, &formatted_number);
1150 EXPECT_EQ("*2345", formatted_number);
1151 phone_util_.FormatNumberForMobileDialing(
1152 test_number, RegionCode::JP(), false, &formatted_number);
1153 EXPECT_EQ("*2345", formatted_number);
1154
1155 test_number.set_country_code(800);
1156 test_number.set_national_number(uint64{12345678});
1157 phone_util_.FormatNumberForMobileDialing(
1158 test_number, RegionCode::JP(), false, &formatted_number);
1159 EXPECT_EQ("+80012345678", formatted_number);
1160 phone_util_.FormatNumberForMobileDialing(
1161 test_number, RegionCode::JP(), true, &formatted_number);
1162 EXPECT_EQ("+800 1234 5678", formatted_number);
1163
1164 // UAE numbers beginning with 600 (classified as UAN) need to be dialled
1165 // without +971 locally.
1166 test_number.set_country_code(971);
1167 test_number.set_national_number(uint64{600123456});
1168 phone_util_.FormatNumberForMobileDialing(
1169 test_number, RegionCode::JP(), false, &formatted_number);
1170 EXPECT_EQ("+971600123456", formatted_number);
1171 phone_util_.FormatNumberForMobileDialing(
1172 test_number, RegionCode::AE(), true, &formatted_number);
1173 EXPECT_EQ("600123456", formatted_number);
1174
1175 test_number.set_country_code(52);
1176 test_number.set_national_number(uint64{3312345678});
1177 phone_util_.FormatNumberForMobileDialing(
1178 test_number, RegionCode::MX(), false, &formatted_number);
1179 EXPECT_EQ("+523312345678", formatted_number);
1180 phone_util_.FormatNumberForMobileDialing(
1181 test_number, RegionCode::US(), false, &formatted_number);
1182 EXPECT_EQ("+523312345678", formatted_number);
1183
1184 // Test whether Uzbek phone numbers are returned in international format even
1185 // when dialled from same region or other regions.
1186 // Fixed-line number
1187 test_number.set_country_code(998);
1188 test_number.set_national_number(uint64{612201234});
1189 phone_util_.FormatNumberForMobileDialing(
1190 test_number, RegionCode::UZ(), false, &formatted_number);
1191 EXPECT_EQ("+998612201234", formatted_number);
1192 // Mobile number
1193 test_number.set_country_code(998);
1194 test_number.set_national_number(uint64{950123456});
1195 phone_util_.FormatNumberForMobileDialing(
1196 test_number, RegionCode::UZ(), false, &formatted_number);
1197 EXPECT_EQ("+998950123456", formatted_number);
1198 phone_util_.FormatNumberForMobileDialing(
1199 test_number, RegionCode::US(), false, &formatted_number);
1200 EXPECT_EQ("+998950123456", formatted_number);
1201
1202 // Non-geographical numbers should always be dialed in international format.
1203 test_number.set_country_code(800);
1204 test_number.set_national_number(uint64{12345678});
1205 phone_util_.FormatNumberForMobileDialing(
1206 test_number, RegionCode::US(), false, &formatted_number);
1207 EXPECT_EQ("+80012345678", formatted_number);
1208 phone_util_.FormatNumberForMobileDialing(
1209 test_number, RegionCode::UN001(), false, &formatted_number);
1210 EXPECT_EQ("+80012345678", formatted_number);
1211
1212 // Test that a short number is formatted correctly for mobile dialing within
1213 // the region, and is not diallable from outside the region.
1214 test_number.set_country_code(49);
1215 test_number.set_national_number(123L);
1216 phone_util_.FormatNumberForMobileDialing(
1217 test_number, RegionCode::DE(), false, &formatted_number);
1218 EXPECT_EQ("123", formatted_number);
1219 phone_util_.FormatNumberForMobileDialing(
1220 test_number, RegionCode::IT(), false, &formatted_number);
1221 EXPECT_EQ("", formatted_number);
1222
1223 // Test the special logic for NANPA countries, for which regular length phone
1224 // numbers are always output in international format, but short numbers are
1225 // in national format.
1226 test_number.set_country_code(1);
1227 test_number.set_national_number(uint64{6502530000});
1228 phone_util_.FormatNumberForMobileDialing(
1229 test_number, RegionCode::US(), false, &formatted_number);
1230 EXPECT_EQ("+16502530000", formatted_number);
1231 phone_util_.FormatNumberForMobileDialing(
1232 test_number, RegionCode::CA(), false, &formatted_number);
1233 EXPECT_EQ("+16502530000", formatted_number);
1234 phone_util_.FormatNumberForMobileDialing(
1235 test_number, RegionCode::BR(), false, &formatted_number);
1236 EXPECT_EQ("+16502530000", formatted_number);
1237 test_number.set_national_number(911L);
1238 phone_util_.FormatNumberForMobileDialing(
1239 test_number, RegionCode::US(), false, &formatted_number);
1240 EXPECT_EQ("911", formatted_number);
1241 phone_util_.FormatNumberForMobileDialing(
1242 test_number, RegionCode::CA(), false, &formatted_number);
1243 EXPECT_EQ("", formatted_number);
1244 phone_util_.FormatNumberForMobileDialing(
1245 test_number, RegionCode::BR(), false, &formatted_number);
1246 EXPECT_EQ("", formatted_number);
1247 // Test that the Australian emergency number 000 is formatted correctly.
1248 test_number.set_country_code(61);
1249 test_number.set_national_number(0L);
1250 test_number.set_italian_leading_zero(true);
1251 test_number.set_number_of_leading_zeros(2);
1252 phone_util_.FormatNumberForMobileDialing(
1253 test_number, RegionCode::AU(), false, &formatted_number);
1254 EXPECT_EQ("000", formatted_number);
1255 phone_util_.FormatNumberForMobileDialing(
1256 test_number, RegionCode::NZ(), false, &formatted_number);
1257 EXPECT_EQ("", formatted_number);
1258 }
1259
TEST_F(PhoneNumberUtilTest,FormatByPattern)1260 TEST_F(PhoneNumberUtilTest, FormatByPattern) {
1261 PhoneNumber test_number;
1262 string formatted_number;
1263 test_number.set_country_code(1);
1264 test_number.set_national_number(uint64{6502530000});
1265
1266 RepeatedPtrField<NumberFormat> number_formats;
1267 NumberFormat* number_format = number_formats.Add();
1268 number_format->set_pattern("(\\d{3})(\\d{3})(\\d{4})");
1269 number_format->set_format("($1) $2-$3");
1270 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1271 number_formats,
1272 &formatted_number);
1273 EXPECT_EQ("(650) 253-0000", formatted_number);
1274 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
1275 number_formats,
1276 &formatted_number);
1277 EXPECT_EQ("+1 (650) 253-0000", formatted_number);
1278 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::RFC3966,
1279 number_formats,
1280 &formatted_number);
1281 EXPECT_EQ("tel:+1-650-253-0000", formatted_number);
1282
1283 // $NP is set to '1' for the US. Here we check that for other NANPA countries
1284 // the US rules are followed.
1285 number_format->set_national_prefix_formatting_rule("$NP ($FG)");
1286 number_format->set_format("$1 $2-$3");
1287 test_number.set_country_code(1);
1288 test_number.set_national_number(uint64{4168819999});
1289 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1290 number_formats,
1291 &formatted_number);
1292 EXPECT_EQ("1 (416) 881-9999", formatted_number);
1293 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
1294 number_formats,
1295 &formatted_number);
1296 EXPECT_EQ("+1 416 881-9999", formatted_number);
1297
1298 test_number.set_country_code(39);
1299 test_number.set_national_number(uint64{236618300});
1300 test_number.set_italian_leading_zero(true);
1301 number_format->set_pattern("(\\d{2})(\\d{5})(\\d{3})");
1302 number_format->set_format("$1-$2 $3");
1303 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1304 number_formats,
1305 &formatted_number);
1306 EXPECT_EQ("02-36618 300", formatted_number);
1307 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
1308 number_formats,
1309 &formatted_number);
1310 EXPECT_EQ("+39 02-36618 300", formatted_number);
1311
1312 test_number.set_country_code(44);
1313 test_number.set_national_number(uint64{2012345678});
1314 test_number.set_italian_leading_zero(false);
1315 number_format->set_national_prefix_formatting_rule("$NP$FG");
1316 number_format->set_pattern("(\\d{2})(\\d{4})(\\d{4})");
1317 number_format->set_format("$1 $2 $3");
1318 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1319 number_formats,
1320 &formatted_number);
1321 EXPECT_EQ("020 1234 5678", formatted_number);
1322
1323 number_format->set_national_prefix_formatting_rule("($NP$FG)");
1324 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1325 number_formats,
1326 &formatted_number);
1327 EXPECT_EQ("(020) 1234 5678", formatted_number);
1328 number_format->set_national_prefix_formatting_rule("");
1329 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1330 number_formats,
1331 &formatted_number);
1332 EXPECT_EQ("20 1234 5678", formatted_number);
1333 number_format->set_national_prefix_formatting_rule("");
1334 phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
1335 number_formats,
1336 &formatted_number);
1337 EXPECT_EQ("+44 20 1234 5678", formatted_number);
1338 }
1339
TEST_F(PhoneNumberUtilTest,FormatE164Number)1340 TEST_F(PhoneNumberUtilTest, FormatE164Number) {
1341 PhoneNumber test_number;
1342 string formatted_number;
1343 test_number.set_country_code(1);
1344 test_number.set_national_number(uint64{6502530000});
1345 phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
1346 EXPECT_EQ("+16502530000", formatted_number);
1347
1348 test_number.set_country_code(49);
1349 test_number.set_national_number(uint64{301234});
1350 phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
1351 EXPECT_EQ("+49301234", formatted_number);
1352
1353 test_number.set_country_code(800);
1354 test_number.set_national_number(uint64{12345678});
1355 phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
1356 EXPECT_EQ("+80012345678", formatted_number);
1357 }
1358
TEST_F(PhoneNumberUtilTest,FormatNumberWithExtension)1359 TEST_F(PhoneNumberUtilTest, FormatNumberWithExtension) {
1360 PhoneNumber nz_number;
1361 nz_number.set_country_code(64);
1362 nz_number.set_national_number(uint64{33316005});
1363 nz_number.set_extension("1234");
1364 string formatted_number;
1365 // Uses default extension prefix:
1366 phone_util_.Format(nz_number, PhoneNumberUtil::NATIONAL, &formatted_number);
1367 EXPECT_EQ("03-331 6005 ext. 1234", formatted_number);
1368 // Uses RFC 3966 syntax.
1369 phone_util_.Format(nz_number, PhoneNumberUtil::RFC3966, &formatted_number);
1370 EXPECT_EQ("tel:+64-3-331-6005;ext=1234", formatted_number);
1371 // Extension prefix overridden in the territory information for the US:
1372 PhoneNumber us_number_with_extension;
1373 us_number_with_extension.set_country_code(1);
1374 us_number_with_extension.set_national_number(uint64{6502530000});
1375 us_number_with_extension.set_extension("4567");
1376 phone_util_.Format(us_number_with_extension,
1377 PhoneNumberUtil::NATIONAL, &formatted_number);
1378 EXPECT_EQ("650 253 0000 extn. 4567", formatted_number);
1379 }
1380
TEST_F(PhoneNumberUtilTest,GetLengthOfGeographicalAreaCode)1381 TEST_F(PhoneNumberUtilTest, GetLengthOfGeographicalAreaCode) {
1382 PhoneNumber number;
1383 // Google MTV, which has area code "650".
1384 number.set_country_code(1);
1385 number.set_national_number(uint64{6502530000});
1386 EXPECT_EQ(3, phone_util_.GetLengthOfGeographicalAreaCode(number));
1387
1388 // A North America toll-free number, which has no area code.
1389 number.set_country_code(1);
1390 number.set_national_number(uint64{8002530000});
1391 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1392
1393 // An invalid US number (1 digit shorter), which has no area code.
1394 number.set_country_code(1);
1395 number.set_national_number(uint64{650253000});
1396 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1397
1398 // Google London, which has area code "20".
1399 number.set_country_code(44);
1400 number.set_national_number(uint64{2070313000});
1401 EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
1402
1403 // A mobile number in the UK does not have an area code (by default, mobile
1404 // numbers do not, unless they have been added to our list of exceptions).
1405 number.set_country_code(44);
1406 number.set_national_number(uint64{7912345678});
1407 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1408
1409 // Google Buenos Aires, which has area code "11".
1410 number.set_country_code(54);
1411 number.set_national_number(uint64{1155303000});
1412 EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
1413
1414 // A mobile number in Argentina also has an area code.
1415 number.set_country_code(54);
1416 number.set_national_number(uint64{91187654321});
1417 EXPECT_EQ(3, phone_util_.GetLengthOfGeographicalAreaCode(number));
1418
1419 // Google Sydney, which has area code "2".
1420 number.set_country_code(61);
1421 number.set_national_number(uint64{293744000});
1422 EXPECT_EQ(1, phone_util_.GetLengthOfGeographicalAreaCode(number));
1423
1424 // Italian numbers - there is no national prefix, but it still has an area
1425 // code.
1426 number.set_country_code(39);
1427 number.set_national_number(uint64{236618300});
1428 number.set_italian_leading_zero(true);
1429 EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
1430
1431 // Google Singapore. Singapore has no area code and no national prefix.
1432 number.set_country_code(65);
1433 number.set_national_number(uint64{65218000});
1434 number.set_italian_leading_zero(false);
1435 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1436
1437 // An international toll free number, which has no area code.
1438 number.set_country_code(800);
1439 number.set_national_number(uint64{12345678});
1440 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1441
1442 // A mobile number from China is geographical, but does not have an area code.
1443 PhoneNumber cn_mobile;
1444 cn_mobile.set_country_code(86);
1445 cn_mobile.set_national_number(uint64{18912341234});
1446 EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(cn_mobile));
1447 }
1448
TEST_F(PhoneNumberUtilTest,GetLengthOfNationalDestinationCode)1449 TEST_F(PhoneNumberUtilTest, GetLengthOfNationalDestinationCode) {
1450 PhoneNumber number;
1451 // Google MTV, which has national destination code (NDC) "650".
1452 number.set_country_code(1);
1453 number.set_national_number(uint64{6502530000});
1454 EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));
1455
1456 // A North America toll-free number, which has NDC "800".
1457 number.set_country_code(1);
1458 number.set_national_number(uint64{8002530000});
1459 EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));
1460
1461 // Google London, which has NDC "20".
1462 number.set_country_code(44);
1463 number.set_national_number(uint64{2070313000});
1464 EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));
1465
1466 // A UK mobile phone, which has NDC "7912"
1467 number.set_country_code(44);
1468 number.set_national_number(uint64{7912345678});
1469 EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
1470
1471 // Google Buenos Aires, which has NDC "11".
1472 number.set_country_code(54);
1473 number.set_national_number(uint64{1155303000});
1474 EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));
1475
1476 // An Argentinian mobile which has NDC "911".
1477 number.set_country_code(54);
1478 number.set_national_number(uint64{91187654321});
1479 EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));
1480
1481 // Google Sydney, which has NDC "2".
1482 number.set_country_code(61);
1483 number.set_national_number(uint64{293744000});
1484 EXPECT_EQ(1, phone_util_.GetLengthOfNationalDestinationCode(number));
1485
1486 // Google Singapore. Singapore has NDC "6521".
1487 number.set_country_code(65);
1488 number.set_national_number(uint64{65218000});
1489 EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
1490
1491 // An invalid US number (1 digit shorter), which has no NDC.
1492 number.set_country_code(1);
1493 number.set_national_number(uint64{650253000});
1494 EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1495
1496 // A number containing an invalid country code, which shouldn't have any NDC.
1497 number.set_country_code(123);
1498 number.set_national_number(uint64{650253000});
1499 EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1500
1501 // A number that has only one group of digits after country code when
1502 // formatted in the international format.
1503 number.set_country_code(376);
1504 number.set_national_number(uint64{12345});
1505 EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1506
1507 // The same number above, but with an extension.
1508 number.set_country_code(376);
1509 number.set_national_number(uint64{12345});
1510 number.set_extension("321");
1511 EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1512
1513 // An international toll free number, which has NDC "1234".
1514 number.Clear();
1515 number.set_country_code(800);
1516 number.set_national_number(uint64{12345678});
1517 EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
1518
1519 // A mobile number from China is geographical, but does not have an area code:
1520 // however it still can be considered to have a national destination code.
1521 PhoneNumber cn_mobile;
1522 cn_mobile.set_country_code(86);
1523 cn_mobile.set_national_number(uint64{18912341234});
1524 EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(cn_mobile));
1525 }
1526
TEST_F(PhoneNumberUtilTest,GetCountryMobileToken)1527 TEST_F(PhoneNumberUtilTest, GetCountryMobileToken) {
1528 int country_calling_code;
1529 string mobile_token;
1530
1531 country_calling_code = phone_util_.GetCountryCodeForRegion(RegionCode::AR());
1532 phone_util_.GetCountryMobileToken(country_calling_code, &mobile_token);
1533 EXPECT_EQ("9", mobile_token);
1534
1535 // Country calling code for Sweden, which has no mobile token.
1536 country_calling_code = phone_util_.GetCountryCodeForRegion(RegionCode::SE());
1537 phone_util_.GetCountryMobileToken(country_calling_code, &mobile_token);
1538 EXPECT_EQ("", mobile_token);
1539 }
1540
TEST_F(PhoneNumberUtilTest,ExtractPossibleNumber)1541 TEST_F(PhoneNumberUtilTest, ExtractPossibleNumber) {
1542 // Removes preceding funky punctuation and letters but leaves the rest
1543 // untouched.
1544 string extracted_number;
1545 ExtractPossibleNumber("Tel:0800-345-600", &extracted_number);
1546 EXPECT_EQ("0800-345-600", extracted_number);
1547 ExtractPossibleNumber("Tel:0800 FOR PIZZA", &extracted_number);
1548 EXPECT_EQ("0800 FOR PIZZA", extracted_number);
1549
1550 // Should not remove plus sign.
1551 ExtractPossibleNumber("Tel:+800-345-600", &extracted_number);
1552 EXPECT_EQ("+800-345-600", extracted_number);
1553 // Should recognise wide digits as possible start values.
1554 ExtractPossibleNumber("\xEF\xBC\x90\xEF\xBC\x92\xEF\xBC\x93" /* "023" */,
1555 &extracted_number);
1556 EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x92\xEF\xBC\x93" /* "023" */,
1557 extracted_number);
1558 // Dashes are not possible start values and should be removed.
1559 ExtractPossibleNumber("Num-\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93"
1560 /* "Num-123" */, &extracted_number);
1561 EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93" /* "123" */,
1562 extracted_number);
1563 // If not possible number present, return empty string.
1564 ExtractPossibleNumber("Num-....", &extracted_number);
1565 EXPECT_EQ("", extracted_number);
1566 // Leading brackets are stripped - these are not used when parsing.
1567 ExtractPossibleNumber("(650) 253-0000", &extracted_number);
1568 EXPECT_EQ("650) 253-0000", extracted_number);
1569
1570 // Trailing non-alpha-numeric characters should be removed.
1571 ExtractPossibleNumber("(650) 253-0000..- ..", &extracted_number);
1572 EXPECT_EQ("650) 253-0000", extracted_number);
1573 ExtractPossibleNumber("(650) 253-0000.", &extracted_number);
1574 EXPECT_EQ("650) 253-0000", extracted_number);
1575 // This case has a trailing RTL char.
1576 ExtractPossibleNumber("(650) 253-0000\xE2\x80\x8F"
1577 /* "(650) 253-0000" */, &extracted_number);
1578 EXPECT_EQ("650) 253-0000", extracted_number);
1579 }
1580
TEST_F(PhoneNumberUtilTest,IsNANPACountry)1581 TEST_F(PhoneNumberUtilTest, IsNANPACountry) {
1582 EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::US()));
1583 EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::BS()));
1584 EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::DE()));
1585 EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::GetUnknown()));
1586 EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::UN001()));
1587 }
1588
TEST_F(PhoneNumberUtilTest,IsValidNumber)1589 TEST_F(PhoneNumberUtilTest, IsValidNumber) {
1590 PhoneNumber us_number;
1591 us_number.set_country_code(1);
1592 us_number.set_national_number(uint64{6502530000});
1593 EXPECT_TRUE(phone_util_.IsValidNumber(us_number));
1594
1595 PhoneNumber it_number;
1596 it_number.set_country_code(39);
1597 it_number.set_national_number(uint64{236618300});
1598 it_number.set_italian_leading_zero(true);
1599 EXPECT_TRUE(phone_util_.IsValidNumber(it_number));
1600
1601 PhoneNumber gb_number;
1602 gb_number.set_country_code(44);
1603 gb_number.set_national_number(uint64{7912345678});
1604 EXPECT_TRUE(phone_util_.IsValidNumber(gb_number));
1605
1606 PhoneNumber nz_number;
1607 nz_number.set_country_code(64);
1608 nz_number.set_national_number(uint64{21387835});
1609 EXPECT_TRUE(phone_util_.IsValidNumber(nz_number));
1610
1611 PhoneNumber intl_toll_free_number;
1612 intl_toll_free_number.set_country_code(800);
1613 intl_toll_free_number.set_national_number(uint64{12345678});
1614 EXPECT_TRUE(phone_util_.IsValidNumber(intl_toll_free_number));
1615
1616 PhoneNumber universal_premium_rate;
1617 universal_premium_rate.set_country_code(979);
1618 universal_premium_rate.set_national_number(uint64{123456789});
1619 EXPECT_TRUE(phone_util_.IsValidNumber(universal_premium_rate));
1620 }
1621
TEST_F(PhoneNumberUtilTest,IsValidForRegion)1622 TEST_F(PhoneNumberUtilTest, IsValidForRegion) {
1623 // This number is valid for the Bahamas, but is not a valid US number.
1624 PhoneNumber bs_number;
1625 bs_number.set_country_code(1);
1626 bs_number.set_national_number(uint64{2423232345});
1627 EXPECT_TRUE(phone_util_.IsValidNumber(bs_number));
1628 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(bs_number, RegionCode::BS()));
1629 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(bs_number, RegionCode::US()));
1630 bs_number.set_national_number(uint64{2421232345});
1631 // This number is no longer valid.
1632 EXPECT_FALSE(phone_util_.IsValidNumber(bs_number));
1633
1634 // La Mayotte and Réunion use 'leadingDigits' to differentiate them.
1635 PhoneNumber re_number;
1636 re_number.set_country_code(262);
1637 re_number.set_national_number(uint64{262123456});
1638 EXPECT_TRUE(phone_util_.IsValidNumber(re_number));
1639 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1640 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1641 // Now change the number to be a number for La Mayotte.
1642 re_number.set_national_number(uint64{269601234});
1643 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1644 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1645 // This number is no longer valid.
1646 re_number.set_national_number(uint64{269123456});
1647 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1648 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1649 EXPECT_FALSE(phone_util_.IsValidNumber(re_number));
1650 // However, it should be recognised as from La Mayotte.
1651 string region_code;
1652 phone_util_.GetRegionCodeForNumber(re_number, ®ion_code);
1653 EXPECT_EQ(RegionCode::YT(), region_code);
1654 // This number is valid in both places.
1655 re_number.set_national_number(uint64{800123456});
1656 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1657 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1658
1659 PhoneNumber intl_toll_free_number;
1660 intl_toll_free_number.set_country_code(800);
1661 intl_toll_free_number.set_national_number(uint64{12345678});
1662 EXPECT_TRUE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
1663 RegionCode::UN001()));
1664 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
1665 RegionCode::US()));
1666 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
1667 RegionCode::ZZ()));
1668
1669 PhoneNumber invalid_number;
1670 // Invalid country calling codes.
1671 invalid_number.set_country_code(3923);
1672 invalid_number.set_national_number(uint64{2366});
1673 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
1674 RegionCode::ZZ()));
1675 invalid_number.set_country_code(3923);
1676 invalid_number.set_national_number(uint64{2366});
1677 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
1678 RegionCode::UN001()));
1679 invalid_number.set_country_code(0);
1680 invalid_number.set_national_number(uint64{2366});
1681 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
1682 RegionCode::UN001()));
1683 invalid_number.set_country_code(0);
1684 EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
1685 RegionCode::ZZ()));
1686 }
1687
TEST_F(PhoneNumberUtilTest,IsNotValidNumber)1688 TEST_F(PhoneNumberUtilTest, IsNotValidNumber) {
1689 PhoneNumber us_number;
1690 us_number.set_country_code(1);
1691 us_number.set_national_number(uint64{2530000});
1692 EXPECT_FALSE(phone_util_.IsValidNumber(us_number));
1693
1694 PhoneNumber it_number;
1695 it_number.set_country_code(39);
1696 it_number.set_national_number(uint64{23661830000});
1697 it_number.set_italian_leading_zero(true);
1698 EXPECT_FALSE(phone_util_.IsValidNumber(it_number));
1699
1700 PhoneNumber gb_number;
1701 gb_number.set_country_code(44);
1702 gb_number.set_national_number(uint64{791234567});
1703 EXPECT_FALSE(phone_util_.IsValidNumber(gb_number));
1704
1705 PhoneNumber de_number;
1706 de_number.set_country_code(49);
1707 de_number.set_national_number(uint64{1234});
1708 EXPECT_FALSE(phone_util_.IsValidNumber(de_number));
1709
1710 PhoneNumber nz_number;
1711 nz_number.set_country_code(64);
1712 nz_number.set_national_number(uint64{3316005});
1713 EXPECT_FALSE(phone_util_.IsValidNumber(nz_number));
1714
1715 PhoneNumber invalid_number;
1716 // Invalid country calling codes.
1717 invalid_number.set_country_code(3923);
1718 invalid_number.set_national_number(uint64{2366});
1719 EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
1720 invalid_number.set_country_code(0);
1721 EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
1722
1723 PhoneNumber intl_toll_free_number_too_long;
1724 intl_toll_free_number_too_long.set_country_code(800);
1725 intl_toll_free_number_too_long.set_national_number(uint64{123456789});
1726 EXPECT_FALSE(phone_util_.IsValidNumber(intl_toll_free_number_too_long));
1727 }
1728
TEST_F(PhoneNumberUtilTest,GetRegionCodeForCountryCode)1729 TEST_F(PhoneNumberUtilTest, GetRegionCodeForCountryCode) {
1730 string region_code;
1731 phone_util_.GetRegionCodeForCountryCode(1, ®ion_code);
1732 EXPECT_EQ(RegionCode::US(), region_code);
1733 phone_util_.GetRegionCodeForCountryCode(44, ®ion_code);
1734 EXPECT_EQ(RegionCode::GB(), region_code);
1735 phone_util_.GetRegionCodeForCountryCode(49, ®ion_code);
1736 EXPECT_EQ(RegionCode::DE(), region_code);
1737 phone_util_.GetRegionCodeForCountryCode(800, ®ion_code);
1738 EXPECT_EQ(RegionCode::UN001(), region_code);
1739 phone_util_.GetRegionCodeForCountryCode(979, ®ion_code);
1740 EXPECT_EQ(RegionCode::UN001(), region_code);
1741 }
1742
TEST_F(PhoneNumberUtilTest,GetRegionCodeForNumber)1743 TEST_F(PhoneNumberUtilTest, GetRegionCodeForNumber) {
1744 string region_code;
1745 PhoneNumber bs_number;
1746 bs_number.set_country_code(1);
1747 bs_number.set_national_number(uint64{2423232345});
1748 phone_util_.GetRegionCodeForNumber(bs_number, ®ion_code);
1749 EXPECT_EQ(RegionCode::BS(), region_code);
1750
1751 PhoneNumber us_number;
1752 us_number.set_country_code(1);
1753 us_number.set_national_number(uint64{4241231234});
1754 phone_util_.GetRegionCodeForNumber(us_number, ®ion_code);
1755 EXPECT_EQ(RegionCode::US(), region_code);
1756
1757 PhoneNumber gb_mobile;
1758 gb_mobile.set_country_code(44);
1759 gb_mobile.set_national_number(uint64{7912345678});
1760 phone_util_.GetRegionCodeForNumber(gb_mobile, ®ion_code);
1761 EXPECT_EQ(RegionCode::GB(), region_code);
1762
1763 PhoneNumber intl_toll_free_number;
1764 intl_toll_free_number.set_country_code(800);
1765 intl_toll_free_number.set_national_number(uint64{12345678});
1766 phone_util_.GetRegionCodeForNumber(intl_toll_free_number, ®ion_code);
1767 EXPECT_EQ(RegionCode::UN001(), region_code);
1768
1769 PhoneNumber universal_premium_rate;
1770 universal_premium_rate.set_country_code(979);
1771 universal_premium_rate.set_national_number(uint64{123456789});
1772 phone_util_.GetRegionCodeForNumber(universal_premium_rate, ®ion_code);
1773 EXPECT_EQ(RegionCode::UN001(), region_code);
1774 }
1775
TEST_F(PhoneNumberUtilTest,IsPossibleNumber)1776 TEST_F(PhoneNumberUtilTest, IsPossibleNumber) {
1777 PhoneNumber number;
1778 number.set_country_code(1);
1779 number.set_national_number(uint64{6502530000});
1780 EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1781
1782 number.set_country_code(1);
1783 number.set_national_number(uint64{2530000});
1784 EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1785
1786 number.set_country_code(44);
1787 number.set_national_number(uint64{2070313000});
1788 EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1789
1790 number.set_country_code(800);
1791 number.set_national_number(uint64{12345678});
1792 EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1793
1794 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 253 0000",
1795 RegionCode::US()));
1796 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 GOO OGLE",
1797 RegionCode::US()));
1798 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("(650) 253-0000",
1799 RegionCode::US()));
1800 EXPECT_TRUE(
1801 phone_util_.IsPossibleNumberForString("253-0000", RegionCode::US()));
1802 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 253 0000",
1803 RegionCode::GB()));
1804 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+44 20 7031 3000",
1805 RegionCode::GB()));
1806 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("(020) 7031 300",
1807 RegionCode::GB()));
1808 EXPECT_TRUE(
1809 phone_util_.IsPossibleNumberForString("7031 3000", RegionCode::GB()));
1810 EXPECT_TRUE(
1811 phone_util_.IsPossibleNumberForString("3331 6005", RegionCode::NZ()));
1812 EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+800 1234 5678",
1813 RegionCode::UN001()));
1814 }
1815
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForType_DifferentTypeLengths)1816 TEST_F(PhoneNumberUtilTest, IsPossibleNumberForType_DifferentTypeLengths) {
1817 // We use Argentinian numbers since they have different possible lengths for
1818 // different types.
1819 PhoneNumber number;
1820 number.set_country_code(54);
1821 number.set_national_number(uint64{12345});
1822 // Too short for any Argentinian number, including fixed-line.
1823 EXPECT_FALSE(
1824 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1825 EXPECT_FALSE(
1826 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::UNKNOWN));
1827
1828 // 6-digit numbers are okay for fixed-line.
1829 number.set_national_number(uint64{123456});
1830 EXPECT_TRUE(
1831 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::UNKNOWN));
1832 EXPECT_TRUE(
1833 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1834 // But too short for mobile.
1835 EXPECT_FALSE(
1836 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::MOBILE));
1837 // And too short for toll-free.
1838 EXPECT_FALSE(
1839 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::TOLL_FREE));
1840
1841 // The same applies to 9-digit numbers.
1842 number.set_national_number(uint64{123456789});
1843 EXPECT_TRUE(
1844 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::UNKNOWN));
1845 EXPECT_TRUE(
1846 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1847 EXPECT_FALSE(
1848 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::MOBILE));
1849 EXPECT_FALSE(
1850 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::TOLL_FREE));
1851
1852 // 10-digit numbers are universally possible.
1853 number.set_national_number(uint64{1234567890});
1854 EXPECT_TRUE(
1855 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::UNKNOWN));
1856 EXPECT_TRUE(
1857 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1858 EXPECT_TRUE(
1859 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::MOBILE));
1860 EXPECT_TRUE(
1861 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::TOLL_FREE));
1862
1863 // 11-digit numbers are only possible for mobile numbers. Note we don't
1864 // require the leading 9, which all mobile numbers start with, and would be
1865 // required for a valid mobile number.
1866 number.set_national_number(uint64{12345678901});
1867 EXPECT_TRUE(
1868 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::UNKNOWN));
1869 EXPECT_FALSE(
1870 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1871 EXPECT_TRUE(
1872 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::MOBILE));
1873 EXPECT_FALSE(
1874 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::TOLL_FREE));
1875 }
1876
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForType_LocalOnly)1877 TEST_F(PhoneNumberUtilTest, IsPossibleNumberForType_LocalOnly) {
1878 PhoneNumber number;
1879 // Here we test a number length which matches a local-only length.
1880 number.set_country_code(49);
1881 number.set_national_number(uint64{12});
1882 EXPECT_TRUE(
1883 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::UNKNOWN));
1884 EXPECT_TRUE(
1885 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1886 // Mobile numbers must be 10 or 11 digits, and there are no local-only
1887 // lengths.
1888 EXPECT_FALSE(
1889 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::MOBILE));
1890 }
1891
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForType_DataMissingForSizeReasons)1892 TEST_F(PhoneNumberUtilTest, IsPossibleNumberForType_DataMissingForSizeReasons) {
1893 PhoneNumber number;
1894 // Here we test something where the possible lengths match the possible
1895 // lengths of the country as a whole, and hence aren't present in the binary
1896 // for size reasons - this should still work.
1897 // Local-only number.
1898 number.set_country_code(55);
1899 number.set_national_number(uint64{12345678});
1900 EXPECT_TRUE(
1901 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::UNKNOWN));
1902 EXPECT_TRUE(
1903 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1904 number.set_national_number(uint64{1234567890});
1905 EXPECT_TRUE(
1906 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::UNKNOWN));
1907 EXPECT_TRUE(
1908 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1909 }
1910
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForType_NumberTypeNotSupportedForRegion)1911 TEST_F(PhoneNumberUtilTest,
1912 IsPossibleNumberForType_NumberTypeNotSupportedForRegion) {
1913 PhoneNumber number;
1914 // There are *no* mobile numbers for this region at all, so we return false.
1915 number.set_country_code(55);
1916 number.set_national_number(12345678L);
1917 EXPECT_FALSE(
1918 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::MOBILE));
1919 // This matches a fixed-line length though.
1920 EXPECT_TRUE(
1921 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1922 EXPECT_TRUE(phone_util_.IsPossibleNumberForType(
1923 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
1924
1925 // There are *no* fixed-line OR mobile numbers for this country calling code
1926 // at all, so we return false for these.
1927 number.set_country_code(979);
1928 number.set_national_number(123456789L);
1929 EXPECT_FALSE(
1930 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::MOBILE));
1931 EXPECT_FALSE(
1932 phone_util_.IsPossibleNumberForType(number, PhoneNumberUtil::FIXED_LINE));
1933 EXPECT_FALSE(phone_util_.IsPossibleNumberForType(
1934 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
1935 EXPECT_TRUE(phone_util_.IsPossibleNumberForType(
1936 number, PhoneNumberUtil::PREMIUM_RATE));
1937 }
1938
TEST_F(PhoneNumberUtilTest,IsPossibleNumberWithReason)1939 TEST_F(PhoneNumberUtilTest, IsPossibleNumberWithReason) {
1940 // FYI, national numbers for country code +1 that are within 7 to 10 digits
1941 // are possible.
1942 PhoneNumber number;
1943 number.set_country_code(1);
1944 number.set_national_number(uint64{6502530000});
1945 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1946 phone_util_.IsPossibleNumberWithReason(number));
1947
1948 number.set_country_code(1);
1949 number.set_national_number(uint64{2530000});
1950 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE_LOCAL_ONLY,
1951 phone_util_.IsPossibleNumberWithReason(number));
1952
1953 number.set_country_code(0);
1954 number.set_national_number(uint64{2530000});
1955 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE,
1956 phone_util_.IsPossibleNumberWithReason(number));
1957
1958 number.set_country_code(1);
1959 number.set_national_number(uint64{253000});
1960 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
1961 phone_util_.IsPossibleNumberWithReason(number));
1962
1963 number.set_country_code(1);
1964 number.set_national_number(uint64{65025300000});
1965 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
1966 phone_util_.IsPossibleNumberWithReason(number));
1967
1968 number.set_country_code(44);
1969 number.set_national_number(uint64{2070310000});
1970 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1971 phone_util_.IsPossibleNumberWithReason(number));
1972
1973 number.set_country_code(49);
1974 number.set_national_number(uint64{30123456});
1975 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1976 phone_util_.IsPossibleNumberWithReason(number));
1977
1978 number.set_country_code(65);
1979 number.set_national_number(uint64{1234567890});
1980 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1981 phone_util_.IsPossibleNumberWithReason(number));
1982
1983 number.set_country_code(800);
1984 number.set_national_number(uint64{123456789});
1985 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
1986 phone_util_.IsPossibleNumberWithReason(number));
1987 }
1988
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForTypeWithReason_DifferentTypeLengths)1989 TEST_F(PhoneNumberUtilTest,
1990 IsPossibleNumberForTypeWithReason_DifferentTypeLengths) {
1991 // We use Argentinian numbers since they have different possible lengths for
1992 // different types.
1993 PhoneNumber number;
1994 number.set_country_code(54);
1995 number.set_national_number(uint64{12345});
1996 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
1997 phone_util_.IsPossibleNumberForTypeWithReason(
1998 number, PhoneNumberUtil::UNKNOWN));
1999 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2000 phone_util_.IsPossibleNumberForTypeWithReason(
2001 number, PhoneNumberUtil::FIXED_LINE));
2002
2003 // 6-digit numbers are okay for fixed-line.
2004 number.set_national_number(uint64{123456});
2005 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2006 phone_util_.IsPossibleNumberForTypeWithReason(
2007 number, PhoneNumberUtil::UNKNOWN));
2008 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2009 phone_util_.IsPossibleNumberForTypeWithReason(
2010 number, PhoneNumberUtil::FIXED_LINE));
2011 // But too short for mobile.
2012 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2013 phone_util_.IsPossibleNumberForTypeWithReason(
2014 number, PhoneNumberUtil::MOBILE));
2015 // And too short for toll-free.
2016 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2017 phone_util_.IsPossibleNumberForTypeWithReason(
2018 number, PhoneNumberUtil::TOLL_FREE));
2019 // The same applies to 9-digit numbers.
2020 number.set_national_number(uint64{123456789});
2021 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2022 phone_util_.IsPossibleNumberForTypeWithReason(
2023 number, PhoneNumberUtil::UNKNOWN));
2024 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2025 phone_util_.IsPossibleNumberForTypeWithReason(
2026 number, PhoneNumberUtil::FIXED_LINE));
2027 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2028 phone_util_.IsPossibleNumberForTypeWithReason(
2029 number, PhoneNumberUtil::MOBILE));
2030 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2031 phone_util_.IsPossibleNumberForTypeWithReason(
2032 number, PhoneNumberUtil::TOLL_FREE));
2033 // 10-digit numbers are universally possible.
2034 number.set_national_number(uint64{1234567890});
2035 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2036 phone_util_.IsPossibleNumberForTypeWithReason(
2037 number, PhoneNumberUtil::UNKNOWN));
2038 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2039 phone_util_.IsPossibleNumberForTypeWithReason(
2040 number, PhoneNumberUtil::FIXED_LINE));
2041 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2042 phone_util_.IsPossibleNumberForTypeWithReason(
2043 number, PhoneNumberUtil::MOBILE));
2044 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2045 phone_util_.IsPossibleNumberForTypeWithReason(
2046 number, PhoneNumberUtil::TOLL_FREE));
2047 // 11-digit numbers are possible for mobile numbers. Note we don't require the
2048 // leading 9, which all mobile numbers start with, and would be required for a
2049 // valid mobile number.
2050 number.set_national_number(uint64{12345678901});
2051 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2052 phone_util_.IsPossibleNumberForTypeWithReason(
2053 number, PhoneNumberUtil::UNKNOWN));
2054 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
2055 phone_util_.IsPossibleNumberForTypeWithReason(
2056 number, PhoneNumberUtil::FIXED_LINE));
2057 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2058 phone_util_.IsPossibleNumberForTypeWithReason(
2059 number, PhoneNumberUtil::MOBILE));
2060 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
2061 phone_util_.IsPossibleNumberForTypeWithReason(
2062 number, PhoneNumberUtil::TOLL_FREE));
2063 }
2064
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForTypeWithReason_LocalOnly)2065 TEST_F(PhoneNumberUtilTest, IsPossibleNumberForTypeWithReason_LocalOnly) {
2066 PhoneNumber number;
2067 // Here we test a number length which matches a local-only length.
2068 number.set_country_code(49);
2069 number.set_national_number(uint64{12});
2070 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE_LOCAL_ONLY,
2071 phone_util_.IsPossibleNumberForTypeWithReason(
2072 number, PhoneNumberUtil::UNKNOWN));
2073 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE_LOCAL_ONLY,
2074 phone_util_.IsPossibleNumberForTypeWithReason(
2075 number, PhoneNumberUtil::FIXED_LINE));
2076 // Mobile numbers must be 10 or 11 digits, and there are no local-only
2077 // lengths.
2078 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2079 phone_util_.IsPossibleNumberForTypeWithReason(
2080 number, PhoneNumberUtil::MOBILE));
2081 }
2082
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForTypeWithReason_DataMissingForSizeReasons)2083 TEST_F(PhoneNumberUtilTest,
2084 IsPossibleNumberForTypeWithReason_DataMissingForSizeReasons) {
2085 PhoneNumber number;
2086 // Here we test something where the possible lengths match the possible
2087 // lengths of the country as a whole, and hence aren't present in the binary
2088 // for size reasons - this should still work.
2089 // Local-only number.
2090 number.set_country_code(55);
2091 number.set_national_number(uint64{12345678});
2092 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE_LOCAL_ONLY,
2093 phone_util_.IsPossibleNumberForTypeWithReason(
2094 number, PhoneNumberUtil::UNKNOWN));
2095 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE_LOCAL_ONLY,
2096 phone_util_.IsPossibleNumberForTypeWithReason(
2097 number, PhoneNumberUtil::FIXED_LINE));
2098 // Normal-length number.
2099 number.set_national_number(uint64{1234567890});
2100 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2101 phone_util_.IsPossibleNumberForTypeWithReason(
2102 number, PhoneNumberUtil::UNKNOWN));
2103 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2104 phone_util_.IsPossibleNumberForTypeWithReason(
2105 number, PhoneNumberUtil::FIXED_LINE));
2106 }
2107
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForTypeWithReason_NumberTypeNotSupportedForRegion)2108 TEST_F(PhoneNumberUtilTest,
2109 IsPossibleNumberForTypeWithReason_NumberTypeNotSupportedForRegion) {
2110 PhoneNumber number;
2111 // There are *no* mobile numbers for this region at all, so we return
2112 // INVALID_LENGTH.
2113 number.set_country_code(55);
2114 number.set_national_number(uint64{12345678});
2115 EXPECT_EQ(PhoneNumberUtil::INVALID_LENGTH,
2116 phone_util_.IsPossibleNumberForTypeWithReason(
2117 number, PhoneNumberUtil::MOBILE));
2118 // This matches a fixed-line length though.
2119 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE_LOCAL_ONLY,
2120 phone_util_.IsPossibleNumberForTypeWithReason(
2121 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2122 // This is too short for fixed-line, and no mobile numbers exist.
2123 number.set_national_number(uint64{1234567});
2124 EXPECT_EQ(PhoneNumberUtil::INVALID_LENGTH,
2125 phone_util_.IsPossibleNumberForTypeWithReason(
2126 number, PhoneNumberUtil::MOBILE));
2127 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2128 phone_util_.IsPossibleNumberForTypeWithReason(
2129 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2130 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2131 phone_util_.IsPossibleNumberForTypeWithReason(
2132 number, PhoneNumberUtil::FIXED_LINE));
2133 // This is too short for mobile, and no fixed-line number exist.
2134 number.set_country_code(882);
2135 number.set_national_number(uint64{1234567});
2136 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2137 phone_util_.IsPossibleNumberForTypeWithReason(
2138 number, PhoneNumberUtil::MOBILE));
2139 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2140 phone_util_.IsPossibleNumberForTypeWithReason(
2141 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2142 EXPECT_EQ(PhoneNumberUtil::INVALID_LENGTH,
2143 phone_util_.IsPossibleNumberForTypeWithReason(
2144 number, PhoneNumberUtil::FIXED_LINE));
2145
2146 // There are *no* fixed-line OR mobile numbers for this country calling code
2147 // at all, so we return INVALID_LENGTH.
2148 number.set_country_code(979);
2149 number.set_national_number(uint64{123456789});
2150 EXPECT_EQ(PhoneNumberUtil::INVALID_LENGTH,
2151 phone_util_.IsPossibleNumberForTypeWithReason(
2152 number, PhoneNumberUtil::MOBILE));
2153 EXPECT_EQ(PhoneNumberUtil::INVALID_LENGTH,
2154 phone_util_.IsPossibleNumberForTypeWithReason(
2155 number, PhoneNumberUtil::FIXED_LINE));
2156 EXPECT_EQ(PhoneNumberUtil::INVALID_LENGTH,
2157 phone_util_.IsPossibleNumberForTypeWithReason(
2158 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2159 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2160 phone_util_.IsPossibleNumberForTypeWithReason(
2161 number, PhoneNumberUtil::PREMIUM_RATE));
2162 }
2163
TEST_F(PhoneNumberUtilTest,IsPossibleNumberForTypeWithReason_FixedLineOrMobile)2164 TEST_F(PhoneNumberUtilTest,
2165 IsPossibleNumberForTypeWithReason_FixedLineOrMobile) {
2166 PhoneNumber number;
2167 // For FIXED_LINE_OR_MOBILE, a number should be considered valid if it matches
2168 // the possible lengths for mobile *or* fixed-line numbers.
2169 number.set_country_code(290);
2170 number.set_national_number(uint64{1234});
2171 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2172 phone_util_.IsPossibleNumberForTypeWithReason(
2173 number, PhoneNumberUtil::FIXED_LINE));
2174 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2175 phone_util_.IsPossibleNumberForTypeWithReason(
2176 number, PhoneNumberUtil::MOBILE));
2177 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2178 phone_util_.IsPossibleNumberForTypeWithReason(
2179 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2180
2181 number.set_national_number(uint64{12345});
2182 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
2183 phone_util_.IsPossibleNumberForTypeWithReason(
2184 number, PhoneNumberUtil::FIXED_LINE));
2185 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
2186 phone_util_.IsPossibleNumberForTypeWithReason(
2187 number, PhoneNumberUtil::MOBILE));
2188 EXPECT_EQ(PhoneNumberUtil::INVALID_LENGTH,
2189 phone_util_.IsPossibleNumberForTypeWithReason(
2190 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2191
2192 number.set_national_number(uint64{123456});
2193 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2194 phone_util_.IsPossibleNumberForTypeWithReason(
2195 number, PhoneNumberUtil::FIXED_LINE));
2196 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
2197 phone_util_.IsPossibleNumberForTypeWithReason(
2198 number, PhoneNumberUtil::MOBILE));
2199 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2200 phone_util_.IsPossibleNumberForTypeWithReason(
2201 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2202
2203 number.set_national_number(uint64{1234567});
2204 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
2205 phone_util_.IsPossibleNumberForTypeWithReason(
2206 number, PhoneNumberUtil::FIXED_LINE));
2207 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
2208 phone_util_.IsPossibleNumberForTypeWithReason(
2209 number, PhoneNumberUtil::MOBILE));
2210 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
2211 phone_util_.IsPossibleNumberForTypeWithReason(
2212 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2213
2214 number.set_national_number(uint64{12345678});
2215 EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
2216 phone_util_.IsPossibleNumberForTypeWithReason(
2217 number, PhoneNumberUtil::TOLL_FREE));
2218 EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
2219 phone_util_.IsPossibleNumberForTypeWithReason(
2220 number, PhoneNumberUtil::FIXED_LINE_OR_MOBILE));
2221 }
2222
TEST_F(PhoneNumberUtilTest,IsNotPossibleNumber)2223 TEST_F(PhoneNumberUtilTest, IsNotPossibleNumber) {
2224 PhoneNumber number;
2225 number.set_country_code(1);
2226 number.set_national_number(uint64{65025300000});
2227 EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
2228
2229 number.set_country_code(800);
2230 number.set_national_number(uint64{123456789});
2231 EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
2232
2233 number.set_country_code(1);
2234 number.set_national_number(uint64{253000});
2235 EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
2236
2237 number.set_country_code(44);
2238 number.set_national_number(uint64{300});
2239 EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
2240
2241 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+1 650 253 00000",
2242 RegionCode::US()));
2243 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("(650) 253-00000",
2244 RegionCode::US()));
2245 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("I want a Pizza",
2246 RegionCode::US()));
2247 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("253-000",
2248 RegionCode::US()));
2249 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("1 3000",
2250 RegionCode::GB()));
2251 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+44 300",
2252 RegionCode::GB()));
2253 EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+800 1234 5678 9",
2254 RegionCode::UN001()));
2255 }
2256
TEST_F(PhoneNumberUtilTest,TruncateTooLongNumber)2257 TEST_F(PhoneNumberUtilTest, TruncateTooLongNumber) {
2258 // US number 650-253-0000, but entered with one additional digit at the end.
2259 PhoneNumber too_long_number;
2260 too_long_number.set_country_code(1);
2261 too_long_number.set_national_number(uint64{65025300001});
2262 PhoneNumber valid_number;
2263 valid_number.set_country_code(1);
2264 valid_number.set_national_number(uint64{6502530000});
2265 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
2266 EXPECT_EQ(valid_number, too_long_number);
2267
2268 too_long_number.set_country_code(800);
2269 too_long_number.set_national_number(uint64{123456789});
2270 valid_number.set_country_code(800);
2271 valid_number.set_national_number(uint64{12345678});
2272 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
2273 EXPECT_EQ(valid_number, too_long_number);
2274
2275 // GB number 080 1234 5678, but entered with 4 extra digits at the end.
2276 too_long_number.set_country_code(44);
2277 too_long_number.set_national_number(uint64{80123456780123});
2278 valid_number.set_country_code(44);
2279 valid_number.set_national_number(uint64{8012345678});
2280 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
2281 EXPECT_EQ(valid_number, too_long_number);
2282
2283 // IT number 022 3456 7890, but entered with 3 extra digits at the end.
2284 too_long_number.set_country_code(39);
2285 too_long_number.set_national_number(uint64{2234567890123});
2286 too_long_number.set_italian_leading_zero(true);
2287 valid_number.set_country_code(39);
2288 valid_number.set_national_number(uint64{2234567890});
2289 valid_number.set_italian_leading_zero(true);
2290 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
2291 EXPECT_EQ(valid_number, too_long_number);
2292
2293 // Tests what happens when a valid number is passed in.
2294 PhoneNumber valid_number_copy(valid_number);
2295 EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&valid_number));
2296 // Tests the number is not modified.
2297 EXPECT_EQ(valid_number_copy, valid_number);
2298
2299 // Tests what happens when a number with invalid prefix is passed in.
2300 PhoneNumber number_with_invalid_prefix;
2301 number_with_invalid_prefix.set_country_code(1);
2302 // The test metadata says US numbers cannot have prefix 240.
2303 number_with_invalid_prefix.set_national_number(uint64{2401234567});
2304 PhoneNumber invalid_number_copy(number_with_invalid_prefix);
2305 EXPECT_FALSE(phone_util_.TruncateTooLongNumber(&number_with_invalid_prefix));
2306 // Tests the number is not modified.
2307 EXPECT_EQ(invalid_number_copy, number_with_invalid_prefix);
2308
2309 // Tests what happens when a too short number is passed in.
2310 PhoneNumber too_short_number;
2311 too_short_number.set_country_code(1);
2312 too_short_number.set_national_number(uint64{1234});
2313 PhoneNumber too_short_number_copy(too_short_number);
2314 EXPECT_FALSE(phone_util_.TruncateTooLongNumber(&too_short_number));
2315 // Tests the number is not modified.
2316 EXPECT_EQ(too_short_number_copy, too_short_number);
2317 }
2318
TEST_F(PhoneNumberUtilTest,IsNumberGeographical)2319 TEST_F(PhoneNumberUtilTest, IsNumberGeographical) {
2320 PhoneNumber number;
2321
2322 // Bahamas, mobile phone number.
2323 number.set_country_code(1);
2324 number.set_national_number(uint64{2423570000});
2325 EXPECT_FALSE(phone_util_.IsNumberGeographical(number));
2326
2327 // Australian fixed line number.
2328 number.set_country_code(61);
2329 number.set_national_number(uint64{236618300});
2330 EXPECT_TRUE(phone_util_.IsNumberGeographical(number));
2331
2332 // International toll free number.
2333 number.set_country_code(800);
2334 number.set_national_number(uint64{12345678});
2335 EXPECT_FALSE(phone_util_.IsNumberGeographical(number));
2336
2337 // We test that mobile phone numbers in relevant regions are indeed considered
2338 // geographical.
2339
2340 // Argentina, mobile phone number.
2341 number.set_country_code(54);
2342 number.set_national_number(uint64{91187654321});
2343 EXPECT_TRUE(phone_util_.IsNumberGeographical(number));
2344
2345 // Mexico, mobile phone number.
2346 number.set_country_code(52);
2347 number.set_national_number(uint64{12345678900});
2348 EXPECT_TRUE(phone_util_.IsNumberGeographical(number));
2349
2350 // Mexico, another mobile phone number.
2351 number.set_country_code(52);
2352 number.set_national_number(uint64{15512345678});
2353 EXPECT_TRUE(phone_util_.IsNumberGeographical(number));
2354 }
2355
TEST_F(PhoneNumberUtilTest,FormatInOriginalFormat)2356 TEST_F(PhoneNumberUtilTest, FormatInOriginalFormat) {
2357 PhoneNumber phone_number;
2358 string formatted_number;
2359
2360 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2361 phone_util_.ParseAndKeepRawInput("+442087654321", RegionCode::GB(),
2362 &phone_number));
2363 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
2364 &formatted_number);
2365 EXPECT_EQ("+44 20 8765 4321", formatted_number);
2366
2367 phone_number.Clear();
2368 formatted_number.clear();
2369 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2370 phone_util_.ParseAndKeepRawInput("02087654321", RegionCode::GB(),
2371 &phone_number));
2372 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
2373 &formatted_number);
2374 EXPECT_EQ("(020) 8765 4321", formatted_number);
2375
2376 phone_number.Clear();
2377 formatted_number.clear();
2378 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2379 phone_util_.ParseAndKeepRawInput("011442087654321",
2380 RegionCode::US(), &phone_number));
2381 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
2382 &formatted_number);
2383 EXPECT_EQ("011 44 20 8765 4321", formatted_number);
2384
2385 phone_number.Clear();
2386 formatted_number.clear();
2387 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2388 phone_util_.ParseAndKeepRawInput("442087654321", RegionCode::GB(),
2389 &phone_number));
2390 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
2391 &formatted_number);
2392 EXPECT_EQ("44 20 8765 4321", formatted_number);
2393
2394 phone_number.Clear();
2395 formatted_number.clear();
2396 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2397 phone_util_.Parse("+442087654321", RegionCode::GB(),
2398 &phone_number));
2399 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
2400 &formatted_number);
2401 EXPECT_EQ("(020) 8765 4321", formatted_number);
2402
2403 // Invalid numbers that we have a formatting pattern for should be formatted
2404 // properly. Note area codes starting with 7 are intentionally excluded in
2405 // the test metadata for testing purposes.
2406 phone_number.Clear();
2407 formatted_number.clear();
2408 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2409 phone_util_.ParseAndKeepRawInput("7345678901", RegionCode::US(),
2410 &phone_number));
2411 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
2412 &formatted_number);
2413 EXPECT_EQ("734 567 8901", formatted_number);
2414
2415 // US is not a leading zero country, and the presence of the leading zero
2416 // leads us to format the number using raw_input.
2417 phone_number.Clear();
2418 formatted_number.clear();
2419 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2420 phone_util_.ParseAndKeepRawInput("0734567 8901", RegionCode::US(),
2421 &phone_number));
2422 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
2423 &formatted_number);
2424 EXPECT_EQ("0734567 8901", formatted_number);
2425
2426 // This number is valid, but we don't have a formatting pattern for it. Fall
2427 // back to the raw input.
2428 phone_number.Clear();
2429 formatted_number.clear();
2430 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2431 phone_util_.ParseAndKeepRawInput("02-4567-8900", RegionCode::KR(),
2432 &phone_number));
2433 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::KR(),
2434 &formatted_number);
2435 EXPECT_EQ("02-4567-8900", formatted_number);
2436
2437 phone_number.Clear();
2438 formatted_number.clear();
2439 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2440 phone_util_.ParseAndKeepRawInput("01180012345678",
2441 RegionCode::US(), &phone_number));
2442 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
2443 &formatted_number);
2444 EXPECT_EQ("011 800 1234 5678", formatted_number);
2445
2446 phone_number.Clear();
2447 formatted_number.clear();
2448 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2449 phone_util_.ParseAndKeepRawInput("+80012345678", RegionCode::KR(),
2450 &phone_number));
2451 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::KR(),
2452 &formatted_number);
2453 EXPECT_EQ("+800 1234 5678", formatted_number);
2454
2455 // US local numbers are formatted correctly, as we have formatting patterns
2456 // for them.
2457 phone_number.Clear();
2458 formatted_number.clear();
2459 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2460 phone_util_.ParseAndKeepRawInput("2530000", RegionCode::US(),
2461 &phone_number));
2462 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
2463 &formatted_number);
2464 EXPECT_EQ("253 0000", formatted_number);
2465
2466 phone_number.Clear();
2467 formatted_number.clear();
2468 // Number with national prefix in the US.
2469 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2470 phone_util_.ParseAndKeepRawInput("18003456789", RegionCode::US(),
2471 &phone_number));
2472 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
2473 &formatted_number);
2474 EXPECT_EQ("1 800 345 6789", formatted_number);
2475
2476 phone_number.Clear();
2477 formatted_number.clear();
2478 // Number without national prefix in the UK.
2479 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2480 phone_util_.ParseAndKeepRawInput("2087654321", RegionCode::GB(),
2481 &phone_number));
2482 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
2483 &formatted_number);
2484 EXPECT_EQ("20 8765 4321", formatted_number);
2485 // Make sure no metadata is modified as a result of the previous function
2486 // call.
2487 phone_number.Clear();
2488 formatted_number.clear();
2489 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2490 phone_util_.Parse("+442087654321", RegionCode::GB(),
2491 &phone_number));
2492 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
2493 &formatted_number);
2494 EXPECT_EQ("(020) 8765 4321", formatted_number);
2495
2496 phone_number.Clear();
2497 formatted_number.clear();
2498 // Number with national prefix in Mexico.
2499 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2500 phone_util_.ParseAndKeepRawInput("013312345678", RegionCode::MX(),
2501 &phone_number));
2502 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
2503 &formatted_number);
2504 EXPECT_EQ("01 33 1234 5678", formatted_number);
2505
2506 phone_number.Clear();
2507 formatted_number.clear();
2508 // Number without national prefix in Mexico.
2509 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2510 phone_util_.ParseAndKeepRawInput("3312345678", RegionCode::MX(),
2511 &phone_number));
2512 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
2513 &formatted_number);
2514 EXPECT_EQ("33 1234 5678", formatted_number);
2515
2516 phone_number.Clear();
2517 formatted_number.clear();
2518 // Italian fixed-line number.
2519 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2520 phone_util_.ParseAndKeepRawInput("0212345678", RegionCode::IT(),
2521 &phone_number));
2522 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::IT(),
2523 &formatted_number);
2524 EXPECT_EQ("02 1234 5678", formatted_number);
2525
2526 phone_number.Clear();
2527 formatted_number.clear();
2528 // Number with national prefix in Japan.
2529 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2530 phone_util_.ParseAndKeepRawInput("00777012", RegionCode::JP(),
2531 &phone_number));
2532 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
2533 &formatted_number);
2534 EXPECT_EQ("0077-7012", formatted_number);
2535
2536 phone_number.Clear();
2537 formatted_number.clear();
2538 // Number without national prefix in Japan.
2539 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2540 phone_util_.ParseAndKeepRawInput("0777012", RegionCode::JP(),
2541 &phone_number));
2542 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
2543 &formatted_number);
2544 EXPECT_EQ("0777012", formatted_number);
2545
2546 phone_number.Clear();
2547 formatted_number.clear();
2548 // Number with carrier code in Brazil.
2549 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2550 phone_util_.ParseAndKeepRawInput("012 3121286979", RegionCode::BR(),
2551 &phone_number));
2552 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::BR(),
2553 &formatted_number);
2554 EXPECT_EQ("012 3121286979", formatted_number);
2555
2556 phone_number.Clear();
2557 formatted_number.clear();
2558 // The default national prefix used in this case is 045. When a number with
2559 // national prefix 044 is entered, we return the raw input as we don't want to
2560 // change the number entered.
2561 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2562 phone_util_.ParseAndKeepRawInput("044(33)1234-5678",
2563 RegionCode::MX(),
2564 &phone_number));
2565 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
2566 &formatted_number);
2567 EXPECT_EQ("044(33)1234-5678", formatted_number);
2568
2569 phone_number.Clear();
2570 formatted_number.clear();
2571 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2572 phone_util_.ParseAndKeepRawInput("045(33)1234-5678",
2573 RegionCode::MX(),
2574 &phone_number));
2575 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
2576 &formatted_number);
2577 EXPECT_EQ("045 33 1234 5678", formatted_number);
2578
2579 // The default international prefix used in this case is 0011. When a number
2580 // with international prefix 0012 is entered, we return the raw input as we
2581 // don't want to change the number entered.
2582 phone_number.Clear();
2583 formatted_number.clear();
2584 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2585 phone_util_.ParseAndKeepRawInput("0012 16502530000",
2586 RegionCode::AU(),
2587 &phone_number));
2588 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::AU(),
2589 &formatted_number);
2590 EXPECT_EQ("0012 16502530000", formatted_number);
2591
2592 phone_number.Clear();
2593 formatted_number.clear();
2594 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2595 phone_util_.ParseAndKeepRawInput("0011 16502530000",
2596 RegionCode::AU(),
2597 &phone_number));
2598 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::AU(),
2599 &formatted_number);
2600 EXPECT_EQ("0011 1 650 253 0000", formatted_number);
2601
2602 // Test the star sign is not removed from or added to the original input by
2603 // this method.
2604 phone_number.Clear();
2605 formatted_number.clear();
2606 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2607 phone_util_.ParseAndKeepRawInput("*1234",
2608 RegionCode::JP(),
2609 &phone_number));
2610 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
2611 &formatted_number);
2612 EXPECT_EQ("*1234", formatted_number);
2613 phone_number.Clear();
2614 formatted_number.clear();
2615 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2616 phone_util_.ParseAndKeepRawInput("1234",
2617 RegionCode::JP(),
2618 &phone_number));
2619 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
2620 &formatted_number);
2621 EXPECT_EQ("1234", formatted_number);
2622
2623 // Test that an invalid national number without raw input is just formatted
2624 // as the national number.
2625 phone_number.Clear();
2626 formatted_number.clear();
2627 phone_number.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
2628 phone_number.set_country_code(1);
2629 phone_number.set_national_number(uint64{650253000});
2630 phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
2631 &formatted_number);
2632 EXPECT_EQ("650253000", formatted_number);
2633 }
2634
TEST_F(PhoneNumberUtilTest,IsPremiumRate)2635 TEST_F(PhoneNumberUtilTest, IsPremiumRate) {
2636 PhoneNumber number;
2637 number.set_country_code(1);
2638 number.set_national_number(uint64{9004433030});
2639 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2640
2641 number.set_country_code(39);
2642 number.set_national_number(uint64{892123});
2643 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2644
2645 number.set_country_code(44);
2646 number.set_national_number(uint64{9187654321});
2647 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2648
2649 number.set_country_code(49);
2650 number.set_national_number(uint64{9001654321});
2651 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2652
2653 number.set_country_code(49);
2654 number.set_national_number(uint64{90091234567});
2655 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2656
2657 number.set_country_code(979);
2658 number.set_national_number(uint64{123456789});
2659 EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2660 }
2661
TEST_F(PhoneNumberUtilTest,IsTollFree)2662 TEST_F(PhoneNumberUtilTest, IsTollFree) {
2663 PhoneNumber number;
2664 number.set_country_code(1);
2665 number.set_national_number(uint64{8881234567});
2666 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2667
2668 number.set_country_code(39);
2669 number.set_national_number(uint64{803123});
2670 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2671
2672 number.set_country_code(44);
2673 number.set_national_number(uint64{8012345678});
2674 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2675
2676 number.set_country_code(49);
2677 number.set_national_number(uint64{8001234567});
2678 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2679
2680 number.set_country_code(800);
2681 number.set_national_number(uint64{12345678});
2682 EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2683 }
2684
TEST_F(PhoneNumberUtilTest,IsMobile)2685 TEST_F(PhoneNumberUtilTest, IsMobile) {
2686 PhoneNumber number;
2687 // A Bahama mobile number
2688 number.set_country_code(1);
2689 number.set_national_number(uint64{2423570000});
2690 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2691
2692 number.set_country_code(39);
2693 number.set_national_number(uint64{312345678});
2694 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2695
2696 number.set_country_code(44);
2697 number.set_national_number(uint64{7912345678});
2698 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2699
2700 number.set_country_code(49);
2701 number.set_national_number(uint64{15123456789});
2702 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2703
2704 number.set_country_code(54);
2705 number.set_national_number(uint64{91187654321});
2706 EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2707 }
2708
TEST_F(PhoneNumberUtilTest,IsFixedLine)2709 TEST_F(PhoneNumberUtilTest, IsFixedLine) {
2710 PhoneNumber number;
2711 // A Bahama fixed-line number
2712 number.set_country_code(1);
2713 number.set_national_number(uint64{2423651234});
2714 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
2715
2716 // An Italian fixed-line number
2717 number.Clear();
2718 number.set_country_code(39);
2719 number.set_national_number(uint64{236618300});
2720 number.set_italian_leading_zero(true);
2721 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
2722
2723 number.Clear();
2724 number.set_country_code(44);
2725 number.set_national_number(uint64{2012345678});
2726 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
2727
2728 number.set_country_code(49);
2729 number.set_national_number(uint64{301234});
2730 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
2731 }
2732
TEST_F(PhoneNumberUtilTest,IsFixedLineAndMobile)2733 TEST_F(PhoneNumberUtilTest, IsFixedLineAndMobile) {
2734 PhoneNumber number;
2735 number.set_country_code(1);
2736 number.set_national_number(uint64{6502531111});
2737 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE_OR_MOBILE,
2738 phone_util_.GetNumberType(number));
2739
2740 number.set_country_code(54);
2741 number.set_national_number(uint64{1987654321});
2742 EXPECT_EQ(PhoneNumberUtil::FIXED_LINE_OR_MOBILE,
2743 phone_util_.GetNumberType(number));
2744 }
2745
TEST_F(PhoneNumberUtilTest,IsSharedCost)2746 TEST_F(PhoneNumberUtilTest, IsSharedCost) {
2747 PhoneNumber number;
2748 number.set_country_code(44);
2749 number.set_national_number(uint64{8431231234});
2750 EXPECT_EQ(PhoneNumberUtil::SHARED_COST, phone_util_.GetNumberType(number));
2751 }
2752
TEST_F(PhoneNumberUtilTest,IsVoip)2753 TEST_F(PhoneNumberUtilTest, IsVoip) {
2754 PhoneNumber number;
2755 number.set_country_code(44);
2756 number.set_national_number(uint64{5631231234});
2757 EXPECT_EQ(PhoneNumberUtil::VOIP, phone_util_.GetNumberType(number));
2758 }
2759
TEST_F(PhoneNumberUtilTest,IsPersonalNumber)2760 TEST_F(PhoneNumberUtilTest, IsPersonalNumber) {
2761 PhoneNumber number;
2762 number.set_country_code(44);
2763 number.set_national_number(uint64{7031231234});
2764 EXPECT_EQ(PhoneNumberUtil::PERSONAL_NUMBER,
2765 phone_util_.GetNumberType(number));
2766 }
2767
TEST_F(PhoneNumberUtilTest,IsUnknown)2768 TEST_F(PhoneNumberUtilTest, IsUnknown) {
2769 PhoneNumber number;
2770 number.set_country_code(1);
2771 number.set_national_number(uint64{65025311111});
2772 EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(number));
2773 }
2774
TEST_F(PhoneNumberUtilTest,GetCountryCodeForRegion)2775 TEST_F(PhoneNumberUtilTest, GetCountryCodeForRegion) {
2776 EXPECT_EQ(1, phone_util_.GetCountryCodeForRegion(RegionCode::US()));
2777 EXPECT_EQ(64, phone_util_.GetCountryCodeForRegion(RegionCode::NZ()));
2778 EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::GetUnknown()));
2779 EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::UN001()));
2780 // CS is already deprecated so the library doesn't support it.
2781 EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::CS()));
2782 }
2783
TEST_F(PhoneNumberUtilTest,GetNationalDiallingPrefixForRegion)2784 TEST_F(PhoneNumberUtilTest, GetNationalDiallingPrefixForRegion) {
2785 string ndd_prefix;
2786 phone_util_.GetNddPrefixForRegion(RegionCode::US(), false, &ndd_prefix);
2787 EXPECT_EQ("1", ndd_prefix);
2788
2789 // Test non-main country to see it gets the national dialling prefix for the
2790 // main country with that country calling code.
2791 ndd_prefix.clear();
2792 phone_util_.GetNddPrefixForRegion(RegionCode::BS(), false, &ndd_prefix);
2793 EXPECT_EQ("1", ndd_prefix);
2794
2795 ndd_prefix.clear();
2796 phone_util_.GetNddPrefixForRegion(RegionCode::NZ(), false, &ndd_prefix);
2797 EXPECT_EQ("0", ndd_prefix);
2798
2799 ndd_prefix.clear();
2800 // Test case with non digit in the national prefix.
2801 phone_util_.GetNddPrefixForRegion(RegionCode::AO(), false, &ndd_prefix);
2802 EXPECT_EQ("0~0", ndd_prefix);
2803
2804 ndd_prefix.clear();
2805 phone_util_.GetNddPrefixForRegion(RegionCode::AO(), true, &ndd_prefix);
2806 EXPECT_EQ("00", ndd_prefix);
2807
2808 // Test cases with invalid regions.
2809 ndd_prefix.clear();
2810 phone_util_.GetNddPrefixForRegion(RegionCode::GetUnknown(), false,
2811 &ndd_prefix);
2812 EXPECT_EQ("", ndd_prefix);
2813
2814 ndd_prefix.clear();
2815 phone_util_.GetNddPrefixForRegion(RegionCode::UN001(), false, &ndd_prefix);
2816 EXPECT_EQ("", ndd_prefix);
2817
2818 // CS is already deprecated so the library doesn't support it.
2819 ndd_prefix.clear();
2820 phone_util_.GetNddPrefixForRegion(RegionCode::CS(), false, &ndd_prefix);
2821 EXPECT_EQ("", ndd_prefix);
2822 }
2823
TEST_F(PhoneNumberUtilTest,IsViablePhoneNumber)2824 TEST_F(PhoneNumberUtilTest, IsViablePhoneNumber) {
2825 EXPECT_FALSE(IsViablePhoneNumber("1"));
2826 // Only one or two digits before strange non-possible punctuation.
2827 EXPECT_FALSE(IsViablePhoneNumber("1+1+1"));
2828 EXPECT_FALSE(IsViablePhoneNumber("80+0"));
2829 // Two digits is viable.
2830 EXPECT_TRUE(IsViablePhoneNumber("00"));
2831 EXPECT_TRUE(IsViablePhoneNumber("111"));
2832 // Alpha numbers.
2833 EXPECT_TRUE(IsViablePhoneNumber("0800-4-pizza"));
2834 EXPECT_TRUE(IsViablePhoneNumber("0800-4-PIZZA"));
2835 // We need at least three digits before any alpha characters.
2836 EXPECT_FALSE(IsViablePhoneNumber("08-PIZZA"));
2837 EXPECT_FALSE(IsViablePhoneNumber("8-PIZZA"));
2838 EXPECT_FALSE(IsViablePhoneNumber("12. March"));
2839 }
2840
TEST_F(PhoneNumberUtilTest,IsViablePhoneNumberNonAscii)2841 TEST_F(PhoneNumberUtilTest, IsViablePhoneNumberNonAscii) {
2842 // Only one or two digits before possible punctuation followed by more digits.
2843 // The punctuation used here is the unicode character u+3000.
2844 EXPECT_TRUE(IsViablePhoneNumber("1\xE3\x80\x80" "34" /* "1 34" */));
2845 EXPECT_FALSE(IsViablePhoneNumber("1\xE3\x80\x80" "3+4" /* "1 3+4" */));
2846 // Unicode variants of possible starting character and other allowed
2847 // punctuation/digits.
2848 EXPECT_TRUE(IsViablePhoneNumber("\xEF\xBC\x88" "1\xEF\xBC\x89\xE3\x80\x80"
2849 "3456789" /* "(1) 3456789" */));
2850 // Testing a leading + is okay.
2851 EXPECT_TRUE(IsViablePhoneNumber("+1\xEF\xBC\x89\xE3\x80\x80"
2852 "3456789" /* "+1) 3456789" */));
2853 }
2854
TEST_F(PhoneNumberUtilTest,ConvertAlphaCharactersInNumber)2855 TEST_F(PhoneNumberUtilTest, ConvertAlphaCharactersInNumber) {
2856 string input("1800-ABC-DEF");
2857 phone_util_.ConvertAlphaCharactersInNumber(&input);
2858 // Alpha chars are converted to digits; everything else is left untouched.
2859 static const string kExpectedOutput = "1800-222-333";
2860 EXPECT_EQ(kExpectedOutput, input);
2861
2862 // Try with some non-ASCII characters.
2863 input.assign("1\xE3\x80\x80\xEF\xBC\x88" "800) ABC-DEF"
2864 /* "1 (800) ABC-DEF" */);
2865 static const string kExpectedFullwidthOutput =
2866 "1\xE3\x80\x80\xEF\xBC\x88" "800) 222-333" /* "1 (800) 222-333" */;
2867 phone_util_.ConvertAlphaCharactersInNumber(&input);
2868 EXPECT_EQ(kExpectedFullwidthOutput, input);
2869 }
2870
TEST_F(PhoneNumberUtilTest,NormaliseRemovePunctuation)2871 TEST_F(PhoneNumberUtilTest, NormaliseRemovePunctuation) {
2872 string input_number("034-56&+#2" "\xC2\xAD" "34");
2873 Normalize(&input_number);
2874 static const string kExpectedOutput("03456234");
2875 EXPECT_EQ(kExpectedOutput, input_number)
2876 << "Conversion did not correctly remove punctuation";
2877 }
2878
TEST_F(PhoneNumberUtilTest,NormaliseReplaceAlphaCharacters)2879 TEST_F(PhoneNumberUtilTest, NormaliseReplaceAlphaCharacters) {
2880 string input_number("034-I-am-HUNGRY");
2881 Normalize(&input_number);
2882 static const string kExpectedOutput("034426486479");
2883 EXPECT_EQ(kExpectedOutput, input_number)
2884 << "Conversion did not correctly replace alpha characters";
2885 }
2886
TEST_F(PhoneNumberUtilTest,NormaliseOtherDigits)2887 TEST_F(PhoneNumberUtilTest, NormaliseOtherDigits) {
2888 // The first digit is a full-width 2, the last digit is an Arabic-indic digit
2889 // 5.
2890 string input_number("\xEF\xBC\x92" "5\xD9\xA5" /* "25٥" */);
2891 Normalize(&input_number);
2892 static const string kExpectedOutput("255");
2893 EXPECT_EQ(kExpectedOutput, input_number)
2894 << "Conversion did not correctly replace non-latin digits";
2895 // The first digit is an Eastern-Arabic 5, the latter an Eastern-Arabic 0.
2896 string eastern_arabic_input_number("\xDB\xB5" "2\xDB\xB0" /* "۵2۰" */);
2897 Normalize(&eastern_arabic_input_number);
2898 static const string kExpectedOutput2("520");
2899 EXPECT_EQ(kExpectedOutput2, eastern_arabic_input_number)
2900 << "Conversion did not correctly replace non-latin digits";
2901 }
2902
TEST_F(PhoneNumberUtilTest,NormaliseStripAlphaCharacters)2903 TEST_F(PhoneNumberUtilTest, NormaliseStripAlphaCharacters) {
2904 string input_number("034-56&+a#234");
2905 phone_util_.NormalizeDigitsOnly(&input_number);
2906 static const string kExpectedOutput("03456234");
2907 EXPECT_EQ(kExpectedOutput, input_number)
2908 << "Conversion did not correctly remove alpha characters";
2909 }
2910
TEST_F(PhoneNumberUtilTest,NormaliseStripNonDiallableCharacters)2911 TEST_F(PhoneNumberUtilTest, NormaliseStripNonDiallableCharacters) {
2912 string input_number("03*4-56&+1a#234");
2913 phone_util_.NormalizeDiallableCharsOnly(&input_number);
2914 static const string kExpectedOutput("03*456+1#234");
2915 EXPECT_EQ(kExpectedOutput, input_number)
2916 << "Conversion did not correctly remove non-diallable characters";
2917 }
2918
TEST_F(PhoneNumberUtilTest,MaybeStripInternationalPrefix)2919 TEST_F(PhoneNumberUtilTest, MaybeStripInternationalPrefix) {
2920 string international_prefix("00[39]");
2921 string number_to_strip("0034567700-3898003");
2922 // Note the dash is removed as part of the normalization.
2923 string stripped_number("45677003898003");
2924 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
2925 MaybeStripInternationalPrefixAndNormalize(international_prefix,
2926 &number_to_strip));
2927 EXPECT_EQ(stripped_number, number_to_strip)
2928 << "The number was not stripped of its international prefix.";
2929
2930 // Now the number no longer starts with an IDD prefix, so it should now report
2931 // FROM_DEFAULT_COUNTRY.
2932 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
2933 MaybeStripInternationalPrefixAndNormalize(international_prefix,
2934 &number_to_strip));
2935
2936 number_to_strip.assign("00945677003898003");
2937 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
2938 MaybeStripInternationalPrefixAndNormalize(international_prefix,
2939 &number_to_strip));
2940 EXPECT_EQ(stripped_number, number_to_strip)
2941 << "The number was not stripped of its international prefix.";
2942
2943 // Test it works when the international prefix is broken up by spaces.
2944 number_to_strip.assign("00 9 45677003898003");
2945 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
2946 MaybeStripInternationalPrefixAndNormalize(international_prefix,
2947 &number_to_strip));
2948 EXPECT_EQ(stripped_number, number_to_strip)
2949 << "The number was not stripped of its international prefix.";
2950 // Now the number no longer starts with an IDD prefix, so it should now report
2951 // FROM_DEFAULT_COUNTRY.
2952 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
2953 MaybeStripInternationalPrefixAndNormalize(international_prefix,
2954 &number_to_strip));
2955
2956 // Test the + symbol is also recognised and stripped.
2957 number_to_strip.assign("+45677003898003");
2958 stripped_number.assign("45677003898003");
2959 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
2960 MaybeStripInternationalPrefixAndNormalize(international_prefix,
2961 &number_to_strip));
2962 EXPECT_EQ(stripped_number, number_to_strip)
2963 << "The number supplied was not stripped of the plus symbol.";
2964
2965 // If the number afterwards is a zero, we should not strip this - no country
2966 // code begins with 0.
2967 number_to_strip.assign("0090112-3123");
2968 stripped_number.assign("00901123123");
2969 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
2970 MaybeStripInternationalPrefixAndNormalize(international_prefix,
2971 &number_to_strip));
2972 EXPECT_EQ(stripped_number, number_to_strip)
2973 << "The number had a 0 after the match so shouldn't be stripped.";
2974 // Here the 0 is separated by a space from the IDD.
2975 number_to_strip.assign("009 0-112-3123");
2976 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
2977 MaybeStripInternationalPrefixAndNormalize(international_prefix,
2978 &number_to_strip));
2979 }
2980
TEST_F(PhoneNumberUtilTest,MaybeStripNationalPrefixAndCarrierCode)2981 TEST_F(PhoneNumberUtilTest, MaybeStripNationalPrefixAndCarrierCode) {
2982 PhoneMetadata metadata;
2983 metadata.set_national_prefix_for_parsing("34");
2984 metadata.mutable_general_desc()->set_national_number_pattern("\\d{4,8}");
2985 string number_to_strip("34356778");
2986 string stripped_number("356778");
2987 string carrier_code;
2988 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
2989 &carrier_code);
2990 EXPECT_EQ(stripped_number, number_to_strip)
2991 << "Should have had national prefix stripped.";
2992 EXPECT_EQ("", carrier_code) << "Should have had no carrier code stripped.";
2993 // Retry stripping - now the number should not start with the national prefix,
2994 // so no more stripping should occur.
2995 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
2996 &carrier_code);
2997 EXPECT_EQ(stripped_number, number_to_strip)
2998 << "Should have had no change - no national prefix present.";
2999 // Some countries have no national prefix. Repeat test with none specified.
3000 metadata.clear_national_prefix_for_parsing();
3001 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
3002 &carrier_code);
3003 EXPECT_EQ(stripped_number, number_to_strip)
3004 << "Should have had no change - empty national prefix.";
3005 // If the resultant number doesn't match the national rule, it shouldn't be
3006 // stripped.
3007 metadata.set_national_prefix_for_parsing("3");
3008 number_to_strip.assign("3123");
3009 stripped_number.assign("3123");
3010 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
3011 &carrier_code);
3012 EXPECT_EQ(stripped_number, number_to_strip)
3013 << "Should have had no change - after stripping, it wouldn't have "
3014 << "matched the national rule.";
3015 // Test extracting carrier selection code.
3016 metadata.set_national_prefix_for_parsing("0(81)?");
3017 number_to_strip.assign("08122123456");
3018 stripped_number.assign("22123456");
3019 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
3020 &carrier_code);
3021 EXPECT_EQ("81", carrier_code) << "Should have had carrier code stripped.";
3022 EXPECT_EQ(stripped_number, number_to_strip)
3023 << "Should have had national prefix and carrier code stripped.";
3024 // If there was a transform rule, check it was applied.
3025 metadata.set_national_prefix_transform_rule("5$15");
3026 // Note that a capturing group is present here.
3027 metadata.set_national_prefix_for_parsing("0(\\d{2})");
3028 number_to_strip.assign("031123");
3029 string transformed_number("5315123");
3030 MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
3031 &carrier_code);
3032 EXPECT_EQ(transformed_number, number_to_strip)
3033 << "Was not successfully transformed.";
3034 }
3035
TEST_F(PhoneNumberUtilTest,MaybeStripExtension)3036 TEST_F(PhoneNumberUtilTest, MaybeStripExtension) {
3037 // One with extension.
3038 string number("1234576 ext. 1234");
3039 string extension;
3040 string expected_extension("1234");
3041 string stripped_number("1234576");
3042 EXPECT_TRUE(MaybeStripExtension(&number, &extension));
3043 EXPECT_EQ(stripped_number, number);
3044 EXPECT_EQ(expected_extension, extension);
3045
3046 // One without extension.
3047 number.assign("1234-576");
3048 extension.clear();
3049 stripped_number.assign("1234-576");
3050 EXPECT_FALSE(MaybeStripExtension(&number, &extension));
3051 EXPECT_EQ(stripped_number, number);
3052 EXPECT_TRUE(extension.empty());
3053
3054 // One with an extension caught by the second capturing group in
3055 // kKnownExtnPatterns.
3056 number.assign("1234576-123#");
3057 extension.clear();
3058 expected_extension.assign("123");
3059 stripped_number.assign("1234576");
3060 EXPECT_TRUE(MaybeStripExtension(&number, &extension));
3061 EXPECT_EQ(stripped_number, number);
3062 EXPECT_EQ(expected_extension, extension);
3063
3064 number.assign("1234576 ext.123#");
3065 extension.clear();
3066 EXPECT_TRUE(MaybeStripExtension(&number, &extension));
3067 EXPECT_EQ(stripped_number, number);
3068 EXPECT_EQ(expected_extension, extension);
3069 }
3070
TEST_F(PhoneNumberUtilTest,MaybeExtractCountryCode)3071 TEST_F(PhoneNumberUtilTest, MaybeExtractCountryCode) {
3072 PhoneNumber number;
3073 const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::US());
3074 // Note that for the US, the IDD is 011.
3075 string phone_number("011112-3456789");
3076 string stripped_number("123456789");
3077 int expected_country_code = 1;
3078 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3079 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
3080 EXPECT_EQ(expected_country_code, number.country_code());
3081 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD, number.country_code_source());
3082 EXPECT_EQ(stripped_number, phone_number);
3083
3084 number.Clear();
3085 phone_number.assign("+80012345678");
3086 stripped_number.assign("12345678");
3087 expected_country_code = 800;
3088 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3089 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
3090 EXPECT_EQ(expected_country_code, number.country_code());
3091 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
3092 number.country_code_source());
3093 EXPECT_EQ(stripped_number, phone_number);
3094
3095 number.Clear();
3096 phone_number.assign("+6423456789");
3097 stripped_number.assign("23456789");
3098 expected_country_code = 64;
3099 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3100 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
3101 EXPECT_EQ(expected_country_code, number.country_code());
3102 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
3103 number.country_code_source());
3104 EXPECT_EQ(stripped_number, phone_number);
3105
3106 // Should not have extracted a country code - no international prefix present.
3107 number.Clear();
3108 expected_country_code = 0;
3109 phone_number.assign("2345-6789");
3110 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3111 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
3112 EXPECT_EQ(expected_country_code, number.country_code());
3113 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY, number.country_code_source());
3114 EXPECT_EQ(stripped_number, phone_number);
3115
3116 expected_country_code = 0;
3117 phone_number.assign("0119991123456789");
3118 stripped_number.assign(phone_number);
3119 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
3120 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
3121
3122 number.Clear();
3123 phone_number.assign("(1 610) 619 4466");
3124 stripped_number.assign("6106194466");
3125 expected_country_code = 1;
3126 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3127 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
3128 EXPECT_EQ(expected_country_code, number.country_code());
3129 EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN,
3130 number.country_code_source());
3131 EXPECT_EQ(stripped_number, phone_number);
3132
3133 number.Clear();
3134 phone_number.assign("(1 610) 619 4466");
3135 stripped_number.assign("6106194466");
3136 expected_country_code = 1;
3137 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3138 MaybeExtractCountryCode(metadata, false, &phone_number, &number));
3139 EXPECT_EQ(expected_country_code, number.country_code());
3140 EXPECT_FALSE(number.has_country_code_source());
3141 EXPECT_EQ(stripped_number, phone_number);
3142
3143 // Should not have extracted a country code - invalid number after extraction
3144 // of uncertain country code.
3145 number.Clear();
3146 phone_number.assign("(1 610) 619 446");
3147 stripped_number.assign("1610619446");
3148 expected_country_code = 0;
3149 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3150 MaybeExtractCountryCode(metadata, false, &phone_number, &number));
3151 EXPECT_EQ(expected_country_code, number.country_code());
3152 EXPECT_FALSE(number.has_country_code_source());
3153 EXPECT_EQ(stripped_number, phone_number);
3154
3155 number.Clear();
3156 phone_number.assign("(1 610) 619");
3157 stripped_number.assign("1610619");
3158 expected_country_code = 0;
3159 // Should not have extracted a country code - invalid number both before and
3160 // after extraction of uncertain country code.
3161 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3162 MaybeExtractCountryCode(metadata, true, &phone_number, &number));
3163 EXPECT_EQ(expected_country_code, number.country_code());
3164 EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY, number.country_code_source());
3165 EXPECT_EQ(stripped_number, phone_number);
3166 }
3167
TEST_F(PhoneNumberUtilTest,CountryWithNoNumberDesc)3168 TEST_F(PhoneNumberUtilTest, CountryWithNoNumberDesc) {
3169 string formatted_number;
3170 // Andorra is a country where we don't have PhoneNumberDesc info in the
3171 // metadata.
3172 PhoneNumber ad_number;
3173 ad_number.set_country_code(376);
3174 ad_number.set_national_number(uint64{12345});
3175 phone_util_.Format(ad_number, PhoneNumberUtil::INTERNATIONAL,
3176 &formatted_number);
3177 EXPECT_EQ("+376 12345", formatted_number);
3178 phone_util_.Format(ad_number, PhoneNumberUtil::E164, &formatted_number);
3179 EXPECT_EQ("+37612345", formatted_number);
3180 phone_util_.Format(ad_number, PhoneNumberUtil::NATIONAL, &formatted_number);
3181 EXPECT_EQ("12345", formatted_number);
3182 EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(ad_number));
3183 EXPECT_FALSE(phone_util_.IsValidNumber(ad_number));
3184
3185 // Test dialing a US number from within Andorra.
3186 PhoneNumber us_number;
3187 us_number.set_country_code(1);
3188 us_number.set_national_number(uint64{6502530000});
3189 phone_util_.FormatOutOfCountryCallingNumber(us_number, RegionCode::AD(),
3190 &formatted_number);
3191 EXPECT_EQ("00 1 650 253 0000", formatted_number);
3192 }
3193
TEST_F(PhoneNumberUtilTest,UnknownCountryCallingCode)3194 TEST_F(PhoneNumberUtilTest, UnknownCountryCallingCode) {
3195 PhoneNumber invalid_number;
3196 invalid_number.set_country_code(kInvalidCountryCode);
3197 invalid_number.set_national_number(uint64{12345});
3198
3199 EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
3200
3201 // It's not very well defined as to what the E164 representation for a number
3202 // with an invalid country calling code is, but just prefixing the country
3203 // code and national number is about the best we can do.
3204 string formatted_number;
3205 phone_util_.Format(invalid_number, PhoneNumberUtil::E164, &formatted_number);
3206 EXPECT_EQ("+212345", formatted_number);
3207 }
3208
TEST_F(PhoneNumberUtilTest,IsNumberMatchMatches)3209 TEST_F(PhoneNumberUtilTest, IsNumberMatchMatches) {
3210 // Test simple matches where formatting is different, or leading zeros, or
3211 // country code has been specified.
3212 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3213 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331 6005",
3214 "+64 03 331 6005"));
3215 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3216 phone_util_.IsNumberMatchWithTwoStrings("+800 1234 5678",
3217 "+80012345678"));
3218 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3219 phone_util_.IsNumberMatchWithTwoStrings("+64 03 331-6005",
3220 "+64 03331 6005"));
3221 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3222 phone_util_.IsNumberMatchWithTwoStrings("+643 331-6005",
3223 "+64033316005"));
3224 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3225 phone_util_.IsNumberMatchWithTwoStrings("+643 331-6005",
3226 "+6433316005"));
3227 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3228 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
3229 "+6433316005"));
3230 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3231 phone_util_.IsNumberMatchWithTwoStrings(
3232 "+64 3 331-6005", "tel:+64-3-331-6005;isub=123"));
3233 // Test alpha numbers.
3234 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3235 phone_util_.IsNumberMatchWithTwoStrings("+1800 siX-Flags",
3236 "+1 800 7493 5247"));
3237 // Test numbers with extensions.
3238 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3239 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 extn 1234",
3240 "+6433316005#1234"));
3241 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3242 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 extn 1234",
3243 "+6433316005;1234"));
3244 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3245 phone_util_.IsNumberMatchWithTwoStrings(
3246 "+7 423 202-25-11 ext 100",
3247 "+7 4232022511 \xd0\xb4\xd0\xbe\xd0\xb1. 100"));
3248
3249 // Test proto buffers.
3250 PhoneNumber nz_number;
3251 nz_number.set_country_code(64);
3252 nz_number.set_national_number(uint64{33316005});
3253 nz_number.set_extension("3456");
3254 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3255 phone_util_.IsNumberMatchWithOneString(nz_number,
3256 "+643 331 6005 ext 3456"));
3257 nz_number.clear_extension();
3258 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3259 phone_util_.IsNumberMatchWithOneString(nz_number,
3260 "+643 331 6005"));
3261 // Check empty extensions are ignored.
3262 nz_number.set_extension("");
3263 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3264 phone_util_.IsNumberMatchWithOneString(nz_number,
3265 "+643 331 6005"));
3266 // Check variant with two proto buffers.
3267 PhoneNumber nz_number_2;
3268 nz_number_2.set_country_code(64);
3269 nz_number_2.set_national_number(uint64{33316005});
3270 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3271 phone_util_.IsNumberMatch(nz_number, nz_number_2));
3272 }
3273
TEST_F(PhoneNumberUtilTest,IsNumberMatchShortMatchIfDiffNumLeadingZeros)3274 TEST_F(PhoneNumberUtilTest, IsNumberMatchShortMatchIfDiffNumLeadingZeros) {
3275 PhoneNumber nz_number_one;
3276 nz_number_one.set_country_code(64);
3277 nz_number_one.set_national_number(uint64{33316005});
3278 nz_number_one.set_italian_leading_zero(true);
3279
3280 PhoneNumber nz_number_two;
3281 nz_number_two.set_country_code(64);
3282 nz_number_two.set_national_number(uint64{33316005});
3283 nz_number_two.set_italian_leading_zero(true);
3284 nz_number_two.set_number_of_leading_zeros(2);
3285
3286 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3287 phone_util_.IsNumberMatch(nz_number_one, nz_number_two));
3288
3289 nz_number_one.set_italian_leading_zero(false);
3290 nz_number_one.set_number_of_leading_zeros(1);
3291 nz_number_two.set_italian_leading_zero(true);
3292 nz_number_two.set_number_of_leading_zeros(1);
3293 // Since one doesn't have the "italian_leading_zero" set to true, we ignore
3294 // the number of leading zeros present (1 is in any case the default value).
3295 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3296 phone_util_.IsNumberMatch(nz_number_one, nz_number_two));
3297 }
3298
TEST_F(PhoneNumberUtilTest,IsNumberMatchAcceptsProtoDefaultsAsMatch)3299 TEST_F(PhoneNumberUtilTest, IsNumberMatchAcceptsProtoDefaultsAsMatch) {
3300 PhoneNumber nz_number_one;
3301 nz_number_one.set_country_code(64);
3302 nz_number_one.set_national_number(uint64{33316005});
3303 nz_number_one.set_italian_leading_zero(true);
3304
3305 PhoneNumber nz_number_two;
3306 nz_number_two.set_country_code(64);
3307 nz_number_two.set_national_number(uint64{33316005});
3308 nz_number_two.set_italian_leading_zero(true);
3309 // The default for number_of_leading_zeros is 1, so it shouldn't normally be
3310 // set, however if it is it should be considered equivalent.
3311 nz_number_two.set_number_of_leading_zeros(1);
3312 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3313 phone_util_.IsNumberMatch(nz_number_one, nz_number_two));
3314 }
3315
TEST_F(PhoneNumberUtilTest,IsNumberMatchMatchesDiffLeadingZerosIfItalianLeadingZeroFalse)3316 TEST_F(PhoneNumberUtilTest,
3317 IsNumberMatchMatchesDiffLeadingZerosIfItalianLeadingZeroFalse) {
3318 PhoneNumber nz_number_one;
3319 nz_number_one.set_country_code(64);
3320 nz_number_one.set_national_number(uint64{33316005});
3321
3322 PhoneNumber nz_number_two;
3323 nz_number_two.set_country_code(64);
3324 nz_number_two.set_national_number(uint64{33316005});
3325 // The default for number_of_leading_zeros is 1, so it shouldn't normally be
3326 // set, however if it is it should be considered equivalent.
3327 nz_number_two.set_number_of_leading_zeros(1);
3328 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3329 phone_util_.IsNumberMatch(nz_number_one, nz_number_two));
3330 // Even if it is set to ten, it is still equivalent because in both cases
3331 // italian_leading_zero is not true.
3332 nz_number_two.set_number_of_leading_zeros(10);
3333 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3334 phone_util_.IsNumberMatch(nz_number_one, nz_number_two));
3335 }
3336
TEST_F(PhoneNumberUtilTest,IsNumberMatchIgnoresSomeFields)3337 TEST_F(PhoneNumberUtilTest, IsNumberMatchIgnoresSomeFields) {
3338 // Check raw_input, country_code_source and preferred_domestic_carrier_code
3339 // are ignored.
3340 PhoneNumber br_number_1;
3341 PhoneNumber br_number_2;
3342 br_number_1.set_country_code(55);
3343 br_number_1.set_national_number(uint64{3121286979});
3344 br_number_1.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
3345 br_number_1.set_preferred_domestic_carrier_code("12");
3346 br_number_1.set_raw_input("012 3121286979");
3347 br_number_2.set_country_code(55);
3348 br_number_2.set_national_number(uint64{3121286979});
3349 br_number_2.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
3350 br_number_2.set_preferred_domestic_carrier_code("14");
3351 br_number_2.set_raw_input("143121286979");
3352 EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
3353 phone_util_.IsNumberMatch(br_number_1, br_number_2));
3354 }
3355
TEST_F(PhoneNumberUtilTest,IsNumberMatchNonMatches)3356 TEST_F(PhoneNumberUtilTest, IsNumberMatchNonMatches) {
3357 // NSN matches.
3358 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
3359 phone_util_.IsNumberMatchWithTwoStrings("03 331 6005",
3360 "03 331 6006"));
3361 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
3362 phone_util_.IsNumberMatchWithTwoStrings("+800 1234 5678",
3363 "+1 800 1234 5678"));
3364 // Different country code, partial number match.
3365 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
3366 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
3367 "+16433316005"));
3368 // Different country code, same number.
3369 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
3370 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
3371 "+6133316005"));
3372 // Extension different, all else the same.
3373 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
3374 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 extn 1234",
3375 "+0116433316005#1235"));
3376 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
3377 phone_util_.IsNumberMatchWithTwoStrings(
3378 "+64 3 331-6005 extn 1234", "tel:+64-3-331-6005;ext=1235"));
3379 // NSN matches, but extension is different - not the same number.
3380 EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
3381 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 ext.1235",
3382 "3 331 6005#1234"));
3383 // Invalid numbers that can't be parsed.
3384 EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
3385 phone_util_.IsNumberMatchWithTwoStrings("4", "3 331 6043"));
3386 // Invalid numbers that can't be parsed.
3387 EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
3388 phone_util_.IsNumberMatchWithTwoStrings("+43", "+64 3 331 6005"));
3389 EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
3390 phone_util_.IsNumberMatchWithTwoStrings("+43", "64 3 331 6005"));
3391 EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
3392 phone_util_.IsNumberMatchWithTwoStrings("Dog", "64 3 331 6005"));
3393 }
3394
TEST_F(PhoneNumberUtilTest,IsNumberMatchNsnMatches)3395 TEST_F(PhoneNumberUtilTest, IsNumberMatchNsnMatches) {
3396 // NSN matches.
3397 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3398 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
3399 "03 331 6005"));
3400 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3401 phone_util_.IsNumberMatchWithTwoStrings(
3402 "+64 3 331-6005",
3403 "tel:03-331-6005;isub=1234;phone-context=abc.nz"));
3404
3405 PhoneNumber nz_number;
3406 nz_number.set_country_code(64);
3407 nz_number.set_national_number(uint64{33316005});
3408 nz_number.set_extension("");
3409 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3410 phone_util_.IsNumberMatchWithOneString(nz_number, "03 331 6005"));
3411 // Here the second number possibly starts with the country code for New
3412 // Zealand, although we are unsure.
3413 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3414 phone_util_.IsNumberMatchWithOneString(nz_number,
3415 "(64-3) 331 6005"));
3416
3417 // Here, the 1 might be a national prefix, if we compare it to the US number,
3418 // so the resultant match is an NSN match.
3419 PhoneNumber us_number;
3420 us_number.set_country_code(1);
3421 us_number.set_national_number(uint64{2345678901});
3422 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3423 phone_util_.IsNumberMatchWithOneString(us_number,
3424 "1-234-567-8901"));
3425 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3426 phone_util_.IsNumberMatchWithOneString(us_number, "2345678901"));
3427 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3428 phone_util_.IsNumberMatchWithTwoStrings("+1 234-567 8901",
3429 "1 234 567 8901"));
3430 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3431 phone_util_.IsNumberMatchWithTwoStrings("1 234-567 8901",
3432 "1 234 567 8901"));
3433 EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
3434 phone_util_.IsNumberMatchWithTwoStrings("1 234-567 8901",
3435 "+1 234 567 8901"));
3436 // For this case, the match will be a short NSN match, because we cannot
3437 // assume that the 1 might be a national prefix, so don't remove it when
3438 // parsing.
3439 PhoneNumber random_number;
3440 random_number.set_country_code(41);
3441 random_number.set_national_number(uint64{2345678901});
3442 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3443 phone_util_.IsNumberMatchWithOneString(random_number,
3444 "1-234-567-8901"));
3445 }
3446
TEST_F(PhoneNumberUtilTest,IsNumberMatchShortNsnMatches)3447 TEST_F(PhoneNumberUtilTest, IsNumberMatchShortNsnMatches) {
3448 // Short NSN matches with the country not specified for either one or both
3449 // numbers.
3450 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3451 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
3452 "331 6005"));
3453 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3454 phone_util_.IsNumberMatchWithTwoStrings(
3455 "+64 3 331-6005", "tel:331-6005;phone-context=abc.nz"));
3456 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3457 phone_util_.IsNumberMatchWithTwoStrings(
3458 "+64 3 331-6005",
3459 "tel:331-6005;isub=1234;phone-context=abc.nz"));
3460 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3461 phone_util_.IsNumberMatchWithTwoStrings(
3462 "+64 3 331-6005",
3463 "tel:331-6005;isub=1234;phone-context=abc.nz;a=%A1"));
3464
3465 // We did not know that the "0" was a national prefix since neither number has
3466 // a country code, so this is considered a SHORT_NSN_MATCH.
3467 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3468 phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
3469 "03 331 6005"));
3470
3471 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3472 phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
3473 "331 6005"));
3474
3475 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3476 phone_util_.IsNumberMatchWithTwoStrings(
3477 "3 331-6005", "tel:331-6005;phone-context=abc.nz"));
3478 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3479 phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
3480 "+64 331 6005"));
3481
3482 // Short NSN match with the country specified.
3483 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3484 phone_util_.IsNumberMatchWithTwoStrings("03 331-6005",
3485 "331 6005"));
3486
3487 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3488 phone_util_.IsNumberMatchWithTwoStrings("1 234 345 6789",
3489 "345 6789"));
3490
3491 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3492 phone_util_.IsNumberMatchWithTwoStrings("+1 (234) 345 6789",
3493 "345 6789"));
3494
3495 // NSN matches, country code omitted for one number, extension missing for
3496 // one.
3497 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3498 phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
3499 "3 331 6005#1234"));
3500
3501 // One has Italian leading zero, one does not.
3502 PhoneNumber it_number_1, it_number_2;
3503 it_number_1.set_country_code(39);
3504 it_number_1.set_national_number(uint64{1234});
3505 it_number_1.set_italian_leading_zero(true);
3506 it_number_2.set_country_code(39);
3507 it_number_2.set_national_number(uint64{1234});
3508 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3509 phone_util_.IsNumberMatch(it_number_1, it_number_2));
3510
3511 // One has an extension, the other has an extension of "".
3512 it_number_1.set_extension("1234");
3513 it_number_1.clear_italian_leading_zero();
3514 it_number_2.set_extension("");
3515 EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
3516 phone_util_.IsNumberMatch(it_number_1, it_number_2));
3517 }
3518
TEST_F(PhoneNumberUtilTest,ParseNationalNumber)3519 TEST_F(PhoneNumberUtilTest, ParseNationalNumber) {
3520 PhoneNumber nz_number;
3521 nz_number.set_country_code(64);
3522 nz_number.set_national_number(uint64{33316005});
3523 PhoneNumber test_number;
3524 // National prefix attached.
3525 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3526 phone_util_.Parse("033316005", RegionCode::NZ(), &test_number));
3527 EXPECT_EQ(nz_number, test_number);
3528 // Some fields are not filled in by Parse, but only by ParseAndKeepRawInput.
3529 EXPECT_FALSE(nz_number.has_country_code_source());
3530 EXPECT_EQ(PhoneNumber::UNSPECIFIED, nz_number.country_code_source());
3531
3532 // National prefix missing.
3533 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3534 phone_util_.Parse("33316005", RegionCode::NZ(), &test_number));
3535 EXPECT_EQ(nz_number, test_number);
3536 // National prefix attached and some formatting present.
3537 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3538 phone_util_.Parse("03-331 6005", RegionCode::NZ(), &test_number));
3539 EXPECT_EQ(nz_number, test_number);
3540 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3541 phone_util_.Parse("03 331 6005", RegionCode::NZ(), &test_number));
3542 EXPECT_EQ(nz_number, test_number);
3543 // Test parsing RFC3966 format with a phone context.
3544 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3545 phone_util_.Parse("tel:03-331-6005;phone-context=+64",
3546 RegionCode::NZ(), &test_number));
3547 EXPECT_EQ(nz_number, test_number);
3548 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3549 phone_util_.Parse("tel:331-6005;phone-context=+64-3",
3550 RegionCode::NZ(), &test_number));
3551 EXPECT_EQ(nz_number, test_number);
3552 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3553 phone_util_.Parse("tel:331-6005;phone-context=+64-3",
3554 RegionCode::US(), &test_number));
3555 EXPECT_EQ(nz_number, test_number);
3556 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3557 phone_util_.Parse("My number is tel:03-331-6005;phone-context=+64",
3558 RegionCode::NZ(), &test_number));
3559 EXPECT_EQ(nz_number, test_number);
3560 // Test parsing RFC3966 format with optional user-defined parameters. The
3561 // parameters will appear after the context if present.
3562 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3563 phone_util_.Parse("tel:03-331-6005;phone-context=+64;a=%A1",
3564 RegionCode::NZ(), &test_number));
3565 EXPECT_EQ(nz_number, test_number);
3566 // Test parsing RFC3966 with an ISDN subaddress.
3567 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3568 phone_util_.Parse("tel:03-331-6005;isub=12345;phone-context=+64",
3569 RegionCode::NZ(), &test_number));
3570 EXPECT_EQ(nz_number, test_number);
3571 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3572 phone_util_.Parse("tel:+64-3-331-6005;isub=12345",
3573 RegionCode::US(), &test_number));
3574 EXPECT_EQ(nz_number, test_number);
3575 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3576 phone_util_.Parse("03-331-6005;phone-context=+64",
3577 RegionCode::NZ(), &test_number));
3578 EXPECT_EQ(nz_number, test_number);
3579 // Testing international prefixes.
3580 // Should strip country code.
3581 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3582 phone_util_.Parse("0064 3 331 6005",
3583 RegionCode::NZ(), &test_number));
3584 EXPECT_EQ(nz_number, test_number);
3585 // Try again, but this time we have an international number with Region Code
3586 // US. It should recognise the country code and parse accordingly.
3587 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3588 phone_util_.Parse("01164 3 331 6005",
3589 RegionCode::US(), &test_number));
3590 EXPECT_EQ(nz_number, test_number);
3591 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3592 phone_util_.Parse("+64 3 331 6005",
3593 RegionCode::US(), &test_number));
3594 EXPECT_EQ(nz_number, test_number);
3595 // We should ignore the leading plus here, since it is not followed by a valid
3596 // country code but instead is followed by the IDD for the US.
3597 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3598 phone_util_.Parse("+01164 3 331 6005",
3599 RegionCode::US(), &test_number));
3600 EXPECT_EQ(nz_number, test_number);
3601 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3602 phone_util_.Parse("+0064 3 331 6005",
3603 RegionCode::NZ(), &test_number));
3604 EXPECT_EQ(nz_number, test_number);
3605 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3606 phone_util_.Parse("+ 00 64 3 331 6005",
3607 RegionCode::NZ(), &test_number));
3608 EXPECT_EQ(nz_number, test_number);
3609
3610 PhoneNumber us_local_number;
3611 us_local_number.set_country_code(1);
3612 us_local_number.set_national_number(uint64{2530000});
3613 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3614 phone_util_.Parse("tel:253-0000;phone-context=www.google.com",
3615 RegionCode::US(), &test_number));
3616 EXPECT_EQ(us_local_number, test_number);
3617 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3618 phone_util_.Parse(
3619 "tel:253-0000;isub=12345;phone-context=www.google.com",
3620 RegionCode::US(), &test_number));
3621 EXPECT_EQ(us_local_number, test_number);
3622 // This is invalid because no "+" sign is present as part of phone-context.
3623 // The phone context is simply ignored in this case just as if it contains a
3624 // domain.
3625 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3626 phone_util_.Parse("tel:2530000;isub=12345;phone-context=1-650",
3627 RegionCode::US(), &test_number));
3628 EXPECT_EQ(us_local_number, test_number);
3629 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3630 phone_util_.Parse("tel:2530000;isub=12345;phone-context=1234.com",
3631 RegionCode::US(), &test_number));
3632 EXPECT_EQ(us_local_number, test_number);
3633
3634 // Test for http://b/issue?id=2247493
3635 nz_number.Clear();
3636 nz_number.set_country_code(64);
3637 nz_number.set_national_number(uint64{64123456});
3638 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3639 phone_util_.Parse("+64(0)64123456",
3640 RegionCode::US(), &test_number));
3641 EXPECT_EQ(nz_number, test_number);
3642
3643 // Check that using a "/" is fine in a phone number.
3644 PhoneNumber de_number;
3645 de_number.set_country_code(49);
3646 de_number.set_national_number(uint64{12345678});
3647 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3648 phone_util_.Parse("123/45678", RegionCode::DE(), &test_number));
3649 EXPECT_EQ(de_number, test_number);
3650
3651 PhoneNumber us_number;
3652 us_number.set_country_code(1);
3653 // Check it doesn't use the '1' as a country code when parsing if the phone
3654 // number was already possible.
3655 us_number.set_national_number(uint64{1234567890});
3656 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3657 phone_util_.Parse("123-456-7890", RegionCode::US(), &test_number));
3658 EXPECT_EQ(us_number, test_number);
3659
3660 // Test star numbers. Although this is not strictly valid, we would like to
3661 // make sure we can parse the output we produce when formatting the number.
3662 PhoneNumber star_number;
3663 star_number.set_country_code(81);
3664 star_number.set_national_number(uint64{2345});
3665 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3666 phone_util_.Parse("+81 *2345", RegionCode::JP(), &test_number));
3667 EXPECT_EQ(star_number, test_number);
3668
3669 PhoneNumber short_number;
3670 short_number.set_country_code(64);
3671 short_number.set_national_number(uint64{12});
3672 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3673 phone_util_.Parse("12", RegionCode::NZ(), &test_number));
3674 EXPECT_EQ(short_number, test_number);
3675
3676 // Test for short-code with leading zero for a country which has 0 as
3677 // national prefix. Ensure it's not interpreted as national prefix if the
3678 // remaining number length is local-only in terms of length. Example: In GB,
3679 // length 6-7 are only possible local-only.
3680 short_number.set_country_code(44);
3681 short_number.set_national_number(123456);
3682 short_number.set_italian_leading_zero(true);
3683 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3684 phone_util_.Parse("0123456", RegionCode::GB(), &test_number));
3685 EXPECT_EQ(short_number, test_number);
3686 }
3687
TEST_F(PhoneNumberUtilTest,ParseNumberWithAlphaCharacters)3688 TEST_F(PhoneNumberUtilTest, ParseNumberWithAlphaCharacters) {
3689 // Test case with alpha characters.
3690 PhoneNumber test_number;
3691 PhoneNumber tollfree_number;
3692 tollfree_number.set_country_code(64);
3693 tollfree_number.set_national_number(uint64{800332005});
3694 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3695 phone_util_.Parse("0800 DDA 005", RegionCode::NZ(), &test_number));
3696 EXPECT_EQ(tollfree_number, test_number);
3697
3698 PhoneNumber premium_number;
3699 premium_number.set_country_code(64);
3700 premium_number.set_national_number(uint64{9003326005});
3701 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3702 phone_util_.Parse("0900 DDA 6005", RegionCode::NZ(), &test_number));
3703 EXPECT_EQ(premium_number, test_number);
3704
3705 // Not enough alpha characters for them to be considered intentional, so they
3706 // are stripped.
3707 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3708 phone_util_.Parse("0900 332 6005a",
3709 RegionCode::NZ(), &test_number));
3710 EXPECT_EQ(premium_number, test_number);
3711 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3712 phone_util_.Parse("0900 332 600a5",
3713 RegionCode::NZ(), &test_number));
3714 EXPECT_EQ(premium_number, test_number);
3715
3716 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3717 phone_util_.Parse("0900 332 600A5",
3718 RegionCode::NZ(), &test_number));
3719 EXPECT_EQ(premium_number, test_number);
3720
3721 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3722 phone_util_.Parse("0900 a332 600A5",
3723 RegionCode::NZ(), &test_number));
3724 EXPECT_EQ(premium_number, test_number);
3725 }
3726
TEST_F(PhoneNumberUtilTest,ParseWithInternationalPrefixes)3727 TEST_F(PhoneNumberUtilTest, ParseWithInternationalPrefixes) {
3728 PhoneNumber us_number;
3729 us_number.set_country_code(1);
3730 us_number.set_national_number(uint64{6503336000});
3731 PhoneNumber test_number;
3732 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3733 phone_util_.Parse("+1 (650) 333-6000",
3734 RegionCode::US(), &test_number));
3735 EXPECT_EQ(us_number, test_number);
3736 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3737 phone_util_.Parse("+1-650-333-6000",
3738 RegionCode::US(), &test_number));
3739 EXPECT_EQ(us_number, test_number);
3740
3741 // Calling the US number from Singapore by using different service providers
3742 // 1st test: calling using SingTel IDD service (IDD is 001)
3743 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3744 phone_util_.Parse("0011-650-333-6000",
3745 RegionCode::SG(), &test_number));
3746 EXPECT_EQ(us_number, test_number);
3747 // 2nd test: calling using StarHub IDD service (IDD is 008)
3748 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3749 phone_util_.Parse("0081-650-333-6000",
3750 RegionCode::SG(), &test_number));
3751 EXPECT_EQ(us_number, test_number);
3752 // 3rd test: calling using SingTel V019 service (IDD is 019)
3753 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3754 phone_util_.Parse("0191-650-333-6000",
3755 RegionCode::SG(), &test_number));
3756 EXPECT_EQ(us_number, test_number);
3757 // Calling the US number from Poland
3758 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3759 phone_util_.Parse("0~01-650-333-6000",
3760 RegionCode::PL(), &test_number));
3761 EXPECT_EQ(us_number, test_number);
3762
3763 // Using "++" at the start.
3764 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3765 phone_util_.Parse("++1 (650) 333-6000",
3766 RegionCode::PL(), &test_number));
3767 EXPECT_EQ(us_number, test_number);
3768 // Using a full-width plus sign.
3769 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3770 phone_util_.Parse("\xEF\xBC\x8B" "1 (650) 333-6000",
3771 /* "+1 (650) 333-6000" */
3772 RegionCode::SG(), &test_number));
3773 EXPECT_EQ(us_number, test_number);
3774 // Using a soft hyphen U+00AD.
3775 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3776 phone_util_.Parse("1 (650) 333" "\xC2\xAD" "-6000",
3777 /* "1 (650) 333-6000" */
3778 RegionCode::US(), &test_number));
3779 EXPECT_EQ(us_number, test_number);
3780 // The whole number, including punctuation, is here represented in full-width
3781 // form.
3782 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3783 phone_util_.Parse("\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88"
3784 "\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89"
3785 "\xE3\x80\x80\xEF\xBC\x93\xEF\xBC\x93\xEF\xBC\x93"
3786 "\xEF\xBC\x8D\xEF\xBC\x96\xEF\xBC\x90\xEF\xBC\x90"
3787 "\xEF\xBC\x90",
3788 /* "+1 (650) 333-6000" */
3789 RegionCode::SG(), &test_number));
3790 EXPECT_EQ(us_number, test_number);
3791
3792 // Using the U+30FC dash.
3793 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3794 phone_util_.Parse("\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88"
3795 "\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89"
3796 "\xE3\x80\x80\xEF\xBC\x93\xEF\xBC\x93\xEF\xBC\x93"
3797 "\xE3\x83\xBC\xEF\xBC\x96\xEF\xBC\x90\xEF\xBC\x90"
3798 "\xEF\xBC\x90",
3799 /* "+1 (650) 333ー6000" */
3800 RegionCode::SG(), &test_number));
3801 EXPECT_EQ(us_number, test_number);
3802
3803 PhoneNumber toll_free_number;
3804 toll_free_number.set_country_code(800);
3805 toll_free_number.set_national_number(uint64{12345678});
3806 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3807 phone_util_.Parse("011 800 1234 5678",
3808 RegionCode::US(), &test_number));
3809 EXPECT_EQ(toll_free_number, test_number);
3810 }
3811
TEST_F(PhoneNumberUtilTest,ParseWithLeadingZero)3812 TEST_F(PhoneNumberUtilTest, ParseWithLeadingZero) {
3813 PhoneNumber it_number;
3814 it_number.set_country_code(39);
3815 it_number.set_national_number(uint64{236618300});
3816 it_number.set_italian_leading_zero(true);
3817 PhoneNumber test_number;
3818 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3819 phone_util_.Parse("+39 02-36618 300",
3820 RegionCode::NZ(), &test_number));
3821 EXPECT_EQ(it_number, test_number);
3822 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3823 phone_util_.Parse("02-36618 300", RegionCode::IT(), &test_number));
3824 EXPECT_EQ(it_number, test_number);
3825
3826 it_number.Clear();
3827 it_number.set_country_code(39);
3828 it_number.set_national_number(uint64{312345678});
3829 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3830 phone_util_.Parse("312 345 678", RegionCode::IT(), &test_number));
3831 EXPECT_EQ(it_number, test_number);
3832 }
3833
TEST_F(PhoneNumberUtilTest,ParseNationalNumberArgentina)3834 TEST_F(PhoneNumberUtilTest, ParseNationalNumberArgentina) {
3835 // Test parsing mobile numbers of Argentina.
3836 PhoneNumber ar_number;
3837 ar_number.set_country_code(54);
3838 ar_number.set_national_number(uint64{93435551212});
3839 PhoneNumber test_number;
3840 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3841 phone_util_.Parse("+54 9 343 555 1212", RegionCode::AR(),
3842 &test_number));
3843 EXPECT_EQ(ar_number, test_number);
3844 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3845 phone_util_.Parse("0343 15 555 1212", RegionCode::AR(),
3846 &test_number));
3847 EXPECT_EQ(ar_number, test_number);
3848
3849 ar_number.set_national_number(uint64{93715654320});
3850 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3851 phone_util_.Parse("+54 9 3715 65 4320", RegionCode::AR(),
3852 &test_number));
3853 EXPECT_EQ(ar_number, test_number);
3854 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3855 phone_util_.Parse("03715 15 65 4320", RegionCode::AR(),
3856 &test_number));
3857 EXPECT_EQ(ar_number, test_number);
3858
3859 // Test parsing fixed-line numbers of Argentina.
3860 ar_number.set_national_number(uint64{1137970000});
3861 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3862 phone_util_.Parse("+54 11 3797 0000", RegionCode::AR(),
3863 &test_number));
3864 EXPECT_EQ(ar_number, test_number);
3865 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3866 phone_util_.Parse("011 3797 0000", RegionCode::AR(), &test_number));
3867 EXPECT_EQ(ar_number, test_number);
3868
3869 ar_number.set_national_number(uint64{3715654321});
3870 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3871 phone_util_.Parse("+54 3715 65 4321", RegionCode::AR(),
3872 &test_number));
3873 EXPECT_EQ(ar_number, test_number);
3874 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3875 phone_util_.Parse("03715 65 4321", RegionCode::AR(), &test_number));
3876 EXPECT_EQ(ar_number, test_number);
3877
3878 ar_number.set_national_number(uint64{2312340000});
3879 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3880 phone_util_.Parse("+54 23 1234 0000", RegionCode::AR(),
3881 &test_number));
3882 EXPECT_EQ(ar_number, test_number);
3883 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3884 phone_util_.Parse("023 1234 0000", RegionCode::AR(), &test_number));
3885 EXPECT_EQ(ar_number, test_number);
3886 }
3887
TEST_F(PhoneNumberUtilTest,ParseWithXInNumber)3888 TEST_F(PhoneNumberUtilTest, ParseWithXInNumber) {
3889 // Test that having an 'x' in the phone number at the start is ok and that it
3890 // just gets removed.
3891 PhoneNumber ar_number;
3892 ar_number.set_country_code(54);
3893 ar_number.set_national_number(uint64{123456789});
3894 PhoneNumber test_number;
3895 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3896 phone_util_.Parse("0123456789", RegionCode::AR(), &test_number));
3897 EXPECT_EQ(ar_number, test_number);
3898 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3899 phone_util_.Parse("(0) 123456789", RegionCode::AR(), &test_number));
3900 EXPECT_EQ(ar_number, test_number);
3901 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3902 phone_util_.Parse("0 123456789", RegionCode::AR(), &test_number));
3903 EXPECT_EQ(ar_number, test_number);
3904 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3905 phone_util_.Parse("(0xx) 123456789", RegionCode::AR(),
3906 &test_number));
3907 EXPECT_EQ(ar_number, test_number);
3908
3909 PhoneNumber ar_from_us;
3910 ar_from_us.set_country_code(54);
3911 ar_from_us.set_national_number(uint64{81429712});
3912 // This test is intentionally constructed such that the number of digit after
3913 // xx is larger than 7, so that the number won't be mistakenly treated as an
3914 // extension, as we allow extensions up to 7 digits. This assumption is okay
3915 // for now as all the countries where a carrier selection code is written in
3916 // the form of xx have a national significant number of length larger than 7.
3917 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3918 phone_util_.Parse("011xx5481429712", RegionCode::US(),
3919 &test_number));
3920 EXPECT_EQ(ar_from_us, test_number);
3921 }
3922
TEST_F(PhoneNumberUtilTest,ParseNumbersMexico)3923 TEST_F(PhoneNumberUtilTest, ParseNumbersMexico) {
3924 // Test parsing fixed-line numbers of Mexico.
3925 PhoneNumber mx_number;
3926
3927 mx_number.set_country_code(52);
3928 mx_number.set_national_number(uint64{4499780001});
3929 PhoneNumber test_number;
3930 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3931 phone_util_.Parse("+52 (449)978-0001", RegionCode::MX(),
3932 &test_number));
3933 EXPECT_EQ(mx_number, test_number);
3934 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3935 phone_util_.Parse("01 (449)978-0001", RegionCode::MX(),
3936 &test_number));
3937 EXPECT_EQ(mx_number, test_number);
3938 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3939 phone_util_.Parse("(449)978-0001", RegionCode::MX(),
3940 &test_number));
3941 EXPECT_EQ(mx_number, test_number);
3942
3943 // Test parsing mobile numbers of Mexico.
3944 mx_number.Clear();
3945 mx_number.set_country_code(52);
3946 mx_number.set_national_number(uint64{13312345678});
3947 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3948 phone_util_.Parse("+52 1 33 1234-5678", RegionCode::MX(),
3949 &test_number));
3950 EXPECT_EQ(mx_number, test_number);
3951 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3952 phone_util_.Parse("044 (33) 1234-5678", RegionCode::MX(),
3953 &test_number));
3954 EXPECT_EQ(mx_number, test_number);
3955 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3956 phone_util_.Parse("045 33 1234-5678", RegionCode::MX(),
3957 &test_number));
3958 EXPECT_EQ(mx_number, test_number);
3959 }
3960
TEST_F(PhoneNumberUtilTest,FailedParseOnInvalidNumbers)3961 TEST_F(PhoneNumberUtilTest, FailedParseOnInvalidNumbers) {
3962 PhoneNumber test_number;
3963 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3964 phone_util_.Parse("This is not a phone number", RegionCode::NZ(),
3965 &test_number));
3966 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3967
3968 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3969 phone_util_.Parse("1 Still not a number", RegionCode::NZ(),
3970 &test_number));
3971 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3972
3973 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3974 phone_util_.Parse("1 MICROSOFT", RegionCode::NZ(),
3975 &test_number));
3976 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3977
3978 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3979 phone_util_.Parse("12 MICROSOFT", RegionCode::NZ(),
3980 &test_number));
3981 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3982
3983 EXPECT_EQ(PhoneNumberUtil::TOO_LONG_NSN,
3984 phone_util_.Parse("01495 72553301873 810104", RegionCode::GB(),
3985 &test_number));
3986 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3987
3988 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3989 phone_util_.Parse("+---", RegionCode::DE(),
3990 &test_number));
3991 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3992
3993 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3994 phone_util_.Parse("+***", RegionCode::DE(),
3995 &test_number));
3996 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3997
3998 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3999 phone_util_.Parse("+*******91", RegionCode::DE(),
4000 &test_number));
4001 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4002
4003 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_NSN,
4004 phone_util_.Parse("+49 0", RegionCode::DE(),
4005 &test_number));
4006 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4007
4008 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
4009 phone_util_.Parse("+210 3456 56789", RegionCode::NZ(),
4010 &test_number));
4011 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4012
4013 // 00 is a correct IDD, but 210 is not a valid country code.
4014 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
4015 phone_util_.Parse("+ 00 210 3 331 6005", RegionCode::NZ(),
4016 &test_number));
4017 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4018
4019 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
4020 phone_util_.Parse("123 456 7890", RegionCode::GetUnknown(),
4021 &test_number));
4022 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4023
4024 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
4025 phone_util_.Parse("123 456 7890", RegionCode::CS(),
4026 &test_number));
4027 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4028
4029 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
4030 phone_util_.Parse("0044-----", RegionCode::GB(),
4031 &test_number));
4032 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4033 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
4034 phone_util_.Parse("0044", RegionCode::GB(),
4035 &test_number));
4036 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4037
4038 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
4039 phone_util_.Parse("011", RegionCode::US(),
4040 &test_number));
4041 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4042 EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
4043 phone_util_.Parse("0119", RegionCode::US(),
4044 &test_number));
4045 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4046
4047 // RFC3966 phone-context is a website.
4048 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
4049 phone_util_.Parse("tel:555-1234;phone-context=www.google.com",
4050 RegionCode::ZZ(), &test_number));
4051 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4052 // This is invalid because no "+" sign is present as part of phone-context.
4053 // This should not succeed in being parsed.
4054 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
4055 phone_util_.Parse("tel:555-1234;phone-context=1-331",
4056 RegionCode::ZZ(), &test_number));
4057 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4058
4059 // Only the phone-context symbol is present, but no data.
4060 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
4061 phone_util_.Parse(";phone-context=",
4062 RegionCode::ZZ(), &test_number));
4063 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4064 }
4065
TEST_F(PhoneNumberUtilTest,ParseNumbersWithPlusWithNoRegion)4066 TEST_F(PhoneNumberUtilTest, ParseNumbersWithPlusWithNoRegion) {
4067 PhoneNumber nz_number;
4068 nz_number.set_country_code(64);
4069 nz_number.set_national_number(uint64{33316005});
4070 // RegionCode::GetUnknown() is allowed only if the number starts with a '+' -
4071 // then the country code can be calculated.
4072 PhoneNumber result_proto;
4073 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4074 phone_util_.Parse("+64 3 331 6005", RegionCode::GetUnknown(),
4075 &result_proto));
4076 EXPECT_EQ(nz_number, result_proto);
4077
4078 // Test with full-width plus.
4079 result_proto.Clear();
4080 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4081 phone_util_.Parse("\xEF\xBC\x8B" "64 3 331 6005",
4082 /* "+64 3 331 6005" */
4083 RegionCode::GetUnknown(), &result_proto));
4084 EXPECT_EQ(nz_number, result_proto);
4085 // Test with normal plus but leading characters that need to be stripped.
4086 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4087 phone_util_.Parse(" +64 3 331 6005", RegionCode::GetUnknown(),
4088 &result_proto));
4089 EXPECT_EQ(nz_number, result_proto);
4090
4091 PhoneNumber toll_free_number;
4092 toll_free_number.set_country_code(800);
4093 toll_free_number.set_national_number(uint64{12345678});
4094 result_proto.Clear();
4095 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4096 phone_util_.Parse("+800 1234 5678",
4097 RegionCode::GetUnknown(), &result_proto));
4098 EXPECT_EQ(toll_free_number, result_proto);
4099
4100 PhoneNumber universal_premium_rate;
4101 universal_premium_rate.set_country_code(979);
4102 universal_premium_rate.set_national_number(uint64{123456789});
4103 result_proto.Clear();
4104 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4105 phone_util_.Parse("+979 123 456 789",
4106 RegionCode::GetUnknown(), &result_proto));
4107 EXPECT_EQ(universal_premium_rate, result_proto);
4108
4109 result_proto.Clear();
4110 // Test parsing RFC3966 format with a phone context.
4111 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4112 phone_util_.Parse("tel:03-331-6005;phone-context=+64",
4113 RegionCode::GetUnknown(), &result_proto));
4114 EXPECT_EQ(nz_number, result_proto);
4115 result_proto.Clear();
4116 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4117 phone_util_.Parse(" tel:03-331-6005;phone-context=+64",
4118 RegionCode::GetUnknown(), &result_proto));
4119 EXPECT_EQ(nz_number, result_proto);
4120 result_proto.Clear();
4121 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4122 phone_util_.Parse("tel:03-331-6005;isub=12345;phone-context=+64",
4123 RegionCode::GetUnknown(), &result_proto));
4124 EXPECT_EQ(nz_number, result_proto);
4125
4126 nz_number.set_raw_input("+64 3 331 6005");
4127 nz_number.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
4128 result_proto.Clear();
4129 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4130 phone_util_.ParseAndKeepRawInput("+64 3 331 6005",
4131 RegionCode::GetUnknown(),
4132 &result_proto));
4133 EXPECT_EQ(nz_number, result_proto);
4134 }
4135
TEST_F(PhoneNumberUtilTest,ParseNumberTooShortIfNationalPrefixStripped)4136 TEST_F(PhoneNumberUtilTest, ParseNumberTooShortIfNationalPrefixStripped) {
4137 PhoneNumber test_number;
4138
4139 // Test that a number whose first digits happen to coincide with the national
4140 // prefix does not get them stripped if doing so would result in a number too
4141 // short to be a possible (regular length) phone number for that region.
4142 PhoneNumber by_number;
4143 by_number.set_country_code(375);
4144 by_number.set_national_number(8123L);
4145 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4146 phone_util_.Parse("8123", RegionCode::BY(),
4147 &test_number));
4148 EXPECT_EQ(by_number, test_number);
4149 by_number.set_national_number(81234L);
4150 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4151 phone_util_.Parse("81234", RegionCode::BY(),
4152 &test_number));
4153 EXPECT_EQ(by_number, test_number);
4154
4155 // The prefix doesn't get stripped, since the input is a viable 6-digit
4156 // number, whereas the result of stripping is only 5 digits.
4157 by_number.set_national_number(812345L);
4158 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4159 phone_util_.Parse("812345", RegionCode::BY(),
4160 &test_number));
4161 EXPECT_EQ(by_number, test_number);
4162
4163 // The prefix gets stripped, since only 6-digit numbers are possible.
4164 by_number.set_national_number(123456L);
4165 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4166 phone_util_.Parse("8123456", RegionCode::BY(),
4167 &test_number));
4168 EXPECT_EQ(by_number, test_number);
4169 }
4170
TEST_F(PhoneNumberUtilTest,ParseExtensions)4171 TEST_F(PhoneNumberUtilTest, ParseExtensions) {
4172 PhoneNumber nz_number;
4173 nz_number.set_country_code(64);
4174 nz_number.set_national_number(uint64{33316005});
4175 nz_number.set_extension("3456");
4176 PhoneNumber test_number;
4177 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4178 phone_util_.Parse("03 331 6005 ext 3456", RegionCode::NZ(),
4179 &test_number));
4180 EXPECT_EQ(nz_number, test_number);
4181 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4182 phone_util_.Parse("03 331 6005x3456", RegionCode::NZ(),
4183 &test_number));
4184 EXPECT_EQ(nz_number, test_number);
4185 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4186 phone_util_.Parse("03-331 6005 int.3456", RegionCode::NZ(),
4187 &test_number));
4188 EXPECT_EQ(nz_number, test_number);
4189 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4190 phone_util_.Parse("03 331 6005 #3456", RegionCode::NZ(),
4191 &test_number));
4192 EXPECT_EQ(nz_number, test_number);
4193
4194 // Test the following do not extract extensions:
4195 PhoneNumber non_extn_number;
4196 non_extn_number.set_country_code(1);
4197 non_extn_number.set_national_number(uint64{80074935247});
4198 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4199 phone_util_.Parse("1800 six-flags", RegionCode::US(),
4200 &test_number));
4201 EXPECT_EQ(non_extn_number, test_number);
4202 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4203 phone_util_.Parse("1800 SIX-FLAGS", RegionCode::US(),
4204 &test_number));
4205 EXPECT_EQ(non_extn_number, test_number);
4206 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4207 phone_util_.Parse("0~0 1800 7493 5247", RegionCode::PL(),
4208 &test_number));
4209 EXPECT_EQ(non_extn_number, test_number);
4210 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4211 phone_util_.Parse("(1800) 7493.5247", RegionCode::US(),
4212 &test_number));
4213 EXPECT_EQ(non_extn_number, test_number);
4214
4215 // Check that the last instance of an extension token is matched.
4216 PhoneNumber extn_number;
4217 extn_number.set_country_code(1);
4218 extn_number.set_national_number(uint64{80074935247});
4219 extn_number.set_extension("1234");
4220 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4221 phone_util_.Parse("0~0 1800 7493 5247 ~1234", RegionCode::PL(),
4222 &test_number));
4223 EXPECT_EQ(extn_number, test_number);
4224
4225 // Verifying bug-fix where the last digit of a number was previously omitted
4226 // if it was a 0 when extracting the extension. Also verifying a few different
4227 // cases of extensions.
4228 PhoneNumber uk_number;
4229 uk_number.set_country_code(44);
4230 uk_number.set_national_number(uint64{2034567890});
4231 uk_number.set_extension("456");
4232 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4233 phone_util_.Parse("+44 2034567890x456", RegionCode::NZ(),
4234 &test_number));
4235 EXPECT_EQ(uk_number, test_number);
4236 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4237 phone_util_.Parse("+44 2034567890x456", RegionCode::GB(),
4238 &test_number));
4239 EXPECT_EQ(uk_number, test_number);
4240 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4241 phone_util_.Parse("+44 2034567890 x456", RegionCode::GB(),
4242 &test_number));
4243 EXPECT_EQ(uk_number, test_number);
4244 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4245 phone_util_.Parse("+44 2034567890 X456", RegionCode::GB(),
4246 &test_number));
4247 EXPECT_EQ(uk_number, test_number);
4248 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4249 phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
4250 &test_number));
4251 EXPECT_EQ(uk_number, test_number);
4252 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4253 phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
4254 &test_number));
4255 EXPECT_EQ(uk_number, test_number);
4256 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4257 phone_util_.Parse("+44 2034567890 x 456 ", RegionCode::GB(),
4258 &test_number));
4259 EXPECT_EQ(uk_number, test_number);
4260 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4261 phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
4262 &test_number));
4263 EXPECT_EQ(uk_number, test_number);
4264 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4265 phone_util_.Parse("+44-2034567890;ext=456", RegionCode::GB(),
4266 &test_number));
4267 EXPECT_EQ(uk_number, test_number);
4268 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4269 phone_util_.Parse("tel:2034567890;ext=456;phone-context=+44",
4270 RegionCode::ZZ(), &test_number));
4271 EXPECT_EQ(uk_number, test_number);
4272
4273 // Full-width extension, "extn" only.
4274 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4275 phone_util_.Parse(
4276 "+442034567890\xEF\xBD\x85\xEF\xBD\x98\xEF\xBD\x94\xEF\xBD\x8E"
4277 "456", RegionCode::GB(), &test_number));
4278 EXPECT_EQ(uk_number, test_number);
4279 // "xtn" only.
4280 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4281 phone_util_.Parse(
4282 "+44-2034567890\xEF\xBD\x98\xEF\xBD\x94\xEF\xBD\x8E""456",
4283 RegionCode::GB(), &test_number));
4284 EXPECT_EQ(uk_number, test_number);
4285 // "xt" only.
4286 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4287 phone_util_.Parse("+44-2034567890\xEF\xBD\x98\xEF\xBD\x94""456",
4288 RegionCode::GB(), &test_number));
4289 EXPECT_EQ(uk_number, test_number);
4290
4291 PhoneNumber us_with_extension;
4292 us_with_extension.set_country_code(1);
4293 us_with_extension.set_national_number(uint64{8009013355});
4294 us_with_extension.set_extension("7246433");
4295 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4296 phone_util_.Parse("(800) 901-3355 x 7246433", RegionCode::US(),
4297 &test_number));
4298 EXPECT_EQ(us_with_extension, test_number);
4299 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4300 phone_util_.Parse("(800) 901-3355 , ext 7246433", RegionCode::US(),
4301 &test_number));
4302 EXPECT_EQ(us_with_extension, test_number);
4303 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4304 phone_util_.Parse("(800) 901-3355 ; 7246433", RegionCode::US(),
4305 &test_number));
4306 EXPECT_EQ(us_with_extension, test_number);
4307 // To test an extension character without surrounding spaces.
4308 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4309 phone_util_.Parse("(800) 901-3355;7246433", RegionCode::US(),
4310 &test_number));
4311 EXPECT_EQ(us_with_extension, test_number);
4312 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4313 phone_util_.Parse("(800) 901-3355 ,extension 7246433",
4314 RegionCode::US(),
4315 &test_number));
4316 EXPECT_EQ(us_with_extension, test_number);
4317 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4318 phone_util_.Parse("(800) 901-3355 ,extensi\xC3\xB3n 7246433",
4319 /* "(800) 901-3355 ,extensión 7246433" */
4320 RegionCode::US(),
4321 &test_number));
4322 EXPECT_EQ(us_with_extension, test_number);
4323 // Repeat with the small letter o with acute accent created by combining
4324 // characters.
4325 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4326 phone_util_.Parse("(800) 901-3355 ,extensio\xCC\x81n 7246433",
4327 /* "(800) 901-3355 ,extensión 7246433" */
4328 RegionCode::US(),
4329 &test_number));
4330 EXPECT_EQ(us_with_extension, test_number);
4331 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4332 phone_util_.Parse("(800) 901-3355 , 7246433", RegionCode::US(),
4333 &test_number));
4334 EXPECT_EQ(us_with_extension, test_number);
4335 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4336 phone_util_.Parse("(800) 901-3355 ext: 7246433", RegionCode::US(),
4337 &test_number));
4338 EXPECT_EQ(us_with_extension, test_number);
4339 // Testing Russian extension "доб" with variants found onli
4340 PhoneNumber ru_with_extension;
4341 ru_with_extension.set_country_code(7);
4342 ru_with_extension.set_national_number(4232022511L);
4343 ru_with_extension.set_extension("100");
4344 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4345 phone_util_.Parse(
4346 "8 (423) 202-25-11, \xd0\xb4\xd0\xbe\xd0\xb1. 100",
4347 RegionCode::RU(), &test_number));
4348 EXPECT_EQ(ru_with_extension, test_number);
4349 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4350 phone_util_.Parse(
4351 "8 (423) 202-25-11 \xd0\xb4\xd0\xbe\xd0\xb1. 100",
4352 RegionCode::RU(), &test_number));
4353 EXPECT_EQ(ru_with_extension, test_number);
4354 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4355 phone_util_.Parse(
4356 "8 (423) 202-25-11, \xd0\xb4\xd0\xbe\xd0\xb1 100",
4357 RegionCode::RU(), &test_number));
4358 EXPECT_EQ(ru_with_extension, test_number);
4359 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4360 phone_util_.Parse(
4361 "8 (423) 202-25-11 \xd0\xb4\xd0\xbe\xd0\xb1 100",
4362 RegionCode::RU(), &test_number));
4363 EXPECT_EQ(ru_with_extension, test_number);
4364 // We are suppose to test input without spaces before and after this extension
4365 // character. As hex escape sequence becomes out of range, postfixed a space
4366 // to extension character here.
4367 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4368 phone_util_.Parse(
4369 "8 (423) 202-25-11\xd0\xb4\xd0\xbe\xd0\xb1 100",
4370 RegionCode::RU(), &test_number));
4371 // In upper case
4372 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4373 phone_util_.Parse(
4374 "8 (423) 202-25-11 \xd0\x94\xd0\x9e\xd0\x91 100",
4375 RegionCode::RU(), &test_number));
4376 EXPECT_EQ(ru_with_extension, test_number);
4377
4378 // Test that if a number has two extensions specified, we ignore the second.
4379 PhoneNumber us_with_two_extensions_number;
4380 us_with_two_extensions_number.set_country_code(1);
4381 us_with_two_extensions_number.set_national_number(uint64{2121231234});
4382 us_with_two_extensions_number.set_extension("508");
4383 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4384 phone_util_.Parse("(212)123-1234 x508/x1234", RegionCode::US(),
4385 &test_number));
4386 EXPECT_EQ(us_with_two_extensions_number, test_number);
4387 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4388 phone_util_.Parse("(212)123-1234 x508/ x1234", RegionCode::US(),
4389 &test_number));
4390 EXPECT_EQ(us_with_two_extensions_number, test_number);
4391 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4392 phone_util_.Parse("(212)123-1234 x508\\x1234", RegionCode::US(),
4393 &test_number));
4394 EXPECT_EQ(us_with_two_extensions_number, test_number);
4395
4396 // Test parsing numbers in the form (645) 123-1234-910# works, where the last
4397 // 3 digits before the # are an extension.
4398 us_with_extension.Clear();
4399 us_with_extension.set_country_code(1);
4400 us_with_extension.set_national_number(uint64{6451231234});
4401 us_with_extension.set_extension("910");
4402 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4403 phone_util_.Parse("+1 (645) 123 1234-910#", RegionCode::US(),
4404 &test_number));
4405 EXPECT_EQ(us_with_extension, test_number);
4406 }
4407
TEST_F(PhoneNumberUtilTest,TestParseHandlesLongExtensionsWithExplicitLabels)4408 TEST_F(PhoneNumberUtilTest, TestParseHandlesLongExtensionsWithExplicitLabels) {
4409 // Test lower and upper limits of extension lengths for each type of label.
4410 PhoneNumber nz_number;
4411 nz_number.set_country_code(64);
4412 nz_number.set_national_number(33316005ULL);
4413 PhoneNumber test_number;
4414
4415 // Firstly, when in RFC format: ext_limit_after_explicit_label
4416 nz_number.set_extension("0");
4417 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4418 phone_util_.Parse("tel:+6433316005;ext=0", RegionCode::NZ(),
4419 &test_number));
4420 EXPECT_EQ(nz_number, test_number);
4421
4422 nz_number.set_extension("01234567890123456789");
4423 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4424 phone_util_.Parse("tel:+6433316005;ext=01234567890123456789",
4425 RegionCode::NZ(), &test_number));
4426 EXPECT_EQ(nz_number, test_number);
4427
4428 // Extension too long.
4429 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
4430 phone_util_.Parse("tel:+6433316005;ext=012345678901234567890",
4431 RegionCode::NZ(), &test_number));
4432
4433 // Explicit extension label: ext_limit_after_explicit_label
4434 nz_number.set_extension("1");
4435 EXPECT_EQ(
4436 PhoneNumberUtil::NO_PARSING_ERROR,
4437 phone_util_.Parse("03 3316005ext:1", RegionCode::NZ(), &test_number));
4438 EXPECT_EQ(nz_number, test_number);
4439
4440 nz_number.set_extension("12345678901234567890");
4441 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4442 phone_util_.Parse("03 3316005 xtn:12345678901234567890",
4443 RegionCode::NZ(), &test_number));
4444 EXPECT_EQ(nz_number, test_number);
4445
4446 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4447 phone_util_.Parse("03 3316005 extension\t12345678901234567890",
4448 RegionCode::NZ(), &test_number));
4449 EXPECT_EQ(nz_number, test_number);
4450
4451 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4452 phone_util_.Parse("03 3316005 xtensio:12345678901234567890",
4453 RegionCode::NZ(), &test_number));
4454 EXPECT_EQ(nz_number, test_number);
4455
4456 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4457 phone_util_.Parse("03 3316005 xtensión, 12345678901234567890#",
4458 RegionCode::NZ(), &test_number));
4459 EXPECT_EQ(nz_number, test_number);
4460
4461 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4462 phone_util_.Parse("03 3316005extension.12345678901234567890",
4463 RegionCode::NZ(), &test_number));
4464 EXPECT_EQ(nz_number, test_number);
4465
4466 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4467 phone_util_.Parse("03 3316005 доб:12345678901234567890",
4468 RegionCode::NZ(), &test_number));
4469 EXPECT_EQ(nz_number, test_number);
4470
4471 // Extension too long.
4472 EXPECT_EQ(PhoneNumberUtil::TOO_LONG_NSN,
4473 phone_util_.Parse("03 3316005 extension 123456789012345678901",
4474 RegionCode::NZ(), &test_number));
4475 }
4476
TEST_F(PhoneNumberUtilTest,TestParseHandlesLongExtensionsWithAutoDiallingLabels)4477 TEST_F(PhoneNumberUtilTest,
4478 TestParseHandlesLongExtensionsWithAutoDiallingLabels) {
4479 // Secondly, cases of auto-dialling and other standard extension labels:
4480 // ext_limit_after_likely_label
4481 PhoneNumber us_number_user_input;
4482 us_number_user_input.set_country_code(1);
4483 us_number_user_input.set_national_number(2679000000ULL);
4484 PhoneNumber test_number;
4485 us_number_user_input.set_extension("123456789012345");
4486
4487 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4488 phone_util_.Parse("+12679000000,,123456789012345#",
4489 RegionCode::US(), &test_number));
4490 EXPECT_EQ(us_number_user_input, test_number);
4491
4492 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4493 phone_util_.Parse("+12679000000;123456789012345#", RegionCode::US(),
4494 &test_number));
4495 EXPECT_EQ(us_number_user_input, test_number);
4496
4497 PhoneNumber uk_number_user_input;
4498 uk_number_user_input.set_country_code(44);
4499 uk_number_user_input.set_national_number(2034000000ULL);
4500 uk_number_user_input.set_extension("123456789");
4501
4502 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4503 phone_util_.Parse("+442034000000,,123456789#", RegionCode::GB(),
4504 &test_number));
4505
4506 // Extension too long.
4507 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
4508 phone_util_.Parse("+12679000000,,1234567890123456#",
4509 RegionCode::US(), &test_number));
4510 }
4511
TEST_F(PhoneNumberUtilTest,TestParseHandlesShortExtensionsWithAmbiguousChar)4512 TEST_F(PhoneNumberUtilTest, TestParseHandlesShortExtensionsWithAmbiguousChar) {
4513 // Thirdly, for single and non-standard cases: ext_limit_after_ambiguous_char
4514 PhoneNumber nz_number;
4515 nz_number.set_country_code(64);
4516 nz_number.set_national_number(33316005ULL);
4517 PhoneNumber test_number;
4518 nz_number.set_extension("123456789");//
4519
4520 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4521 phone_util_.Parse("03 3316005 x 123456789", RegionCode::NZ(),
4522 &test_number));
4523 EXPECT_EQ(nz_number, test_number);
4524
4525 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4526 phone_util_.Parse("03 3316005 x. 123456789", RegionCode::NZ(),
4527 &test_number));
4528 EXPECT_EQ(nz_number, test_number);
4529
4530 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4531 phone_util_.Parse("03 3316005 #123456789#", RegionCode::NZ(),
4532 &test_number));
4533 EXPECT_EQ(nz_number, test_number);
4534
4535 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4536 phone_util_.Parse("03 3316005 ~ 123456789", RegionCode::NZ(),
4537 &test_number));
4538 EXPECT_EQ(nz_number, test_number);
4539
4540 EXPECT_EQ(PhoneNumberUtil::TOO_LONG_NSN,
4541 phone_util_.Parse("03 3316005 ~ 1234567890", RegionCode::NZ(),
4542 &test_number));
4543 }
4544
TEST_F(PhoneNumberUtilTest,TestParseHandlesShortExtensionsWhenNotSureOfLabel)4545 TEST_F(PhoneNumberUtilTest, TestParseHandlesShortExtensionsWhenNotSureOfLabel) {
4546 // Thirdly, when no explicit extension label present, but denoted by
4547 // tailing #: ext_limit_when_not_sure
4548 PhoneNumber us_number;
4549 us_number.set_country_code(1);
4550 us_number.set_national_number(1234567890ULL);
4551 PhoneNumber test_number;
4552 us_number.set_extension("666666");
4553
4554 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4555 phone_util_.Parse("+1123-456-7890 666666#", RegionCode::US(),
4556 &test_number));
4557 EXPECT_EQ(us_number, test_number);
4558
4559 us_number.set_extension("6");
4560 EXPECT_EQ(
4561 PhoneNumberUtil::NO_PARSING_ERROR,
4562 phone_util_.Parse("+11234567890-6#", RegionCode::US(), &test_number));
4563 EXPECT_EQ(us_number, test_number);
4564
4565 // Extension too long.
4566 EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
4567 phone_util_.Parse("+1123-456-7890 7777777#", RegionCode::US(),
4568 &test_number));
4569 }
4570
TEST_F(PhoneNumberUtilTest,ParseAndKeepRaw)4571 TEST_F(PhoneNumberUtilTest, ParseAndKeepRaw) {
4572 PhoneNumber alpha_numeric_number;
4573 alpha_numeric_number.set_country_code(1);
4574 alpha_numeric_number.set_national_number(uint64{80074935247});
4575 alpha_numeric_number.set_raw_input("800 six-flags");
4576 alpha_numeric_number.set_country_code_source(
4577 PhoneNumber::FROM_DEFAULT_COUNTRY);
4578
4579 PhoneNumber test_number;
4580 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4581 phone_util_.ParseAndKeepRawInput("800 six-flags", RegionCode::US(),
4582 &test_number));
4583 EXPECT_EQ(alpha_numeric_number, test_number);
4584
4585 alpha_numeric_number.set_national_number(uint64{8007493524});
4586 alpha_numeric_number.set_raw_input("1800 six-flag");
4587 alpha_numeric_number.set_country_code_source(
4588 PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN);
4589 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4590 phone_util_.ParseAndKeepRawInput("1800 six-flag", RegionCode::US(),
4591 &test_number));
4592 EXPECT_EQ(alpha_numeric_number, test_number);
4593
4594 alpha_numeric_number.set_raw_input("+1800 six-flag");
4595 alpha_numeric_number.set_country_code_source(
4596 PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
4597 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4598 phone_util_.ParseAndKeepRawInput("+1800 six-flag", RegionCode::CN(),
4599 &test_number));
4600 EXPECT_EQ(alpha_numeric_number, test_number);
4601
4602 alpha_numeric_number.set_raw_input("001800 six-flag");
4603 alpha_numeric_number.set_country_code_source(
4604 PhoneNumber::FROM_NUMBER_WITH_IDD);
4605 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4606 phone_util_.ParseAndKeepRawInput("001800 six-flag",
4607 RegionCode::NZ(),
4608 &test_number));
4609 EXPECT_EQ(alpha_numeric_number, test_number);
4610
4611 // Try with invalid region - expect failure. We clear the test number first
4612 // because if parsing isn't successful, the number parsed in won't be changed.
4613 test_number.Clear();
4614 EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
4615 phone_util_.Parse("123 456 7890", RegionCode::CS(), &test_number));
4616 EXPECT_EQ(PhoneNumber::default_instance(), test_number);
4617
4618 PhoneNumber korean_number;
4619 korean_number.set_country_code(82);
4620 korean_number.set_national_number(22123456);
4621 korean_number.set_raw_input("08122123456");
4622 korean_number.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
4623 korean_number.set_preferred_domestic_carrier_code("81");
4624 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4625 phone_util_.ParseAndKeepRawInput("08122123456",
4626 RegionCode::KR(),
4627 &test_number));
4628 EXPECT_EQ(korean_number, test_number);
4629 }
4630
TEST_F(PhoneNumberUtilTest,ParseItalianLeadingZeros)4631 TEST_F(PhoneNumberUtilTest, ParseItalianLeadingZeros) {
4632 PhoneNumber zeros_number;
4633 zeros_number.set_country_code(61);
4634 PhoneNumber test_number;
4635
4636 // Test the number "011".
4637 zeros_number.set_national_number(11L);
4638 zeros_number.set_italian_leading_zero(true);
4639 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4640 phone_util_.Parse("011", RegionCode::AU(),
4641 &test_number));
4642 EXPECT_EQ(zeros_number, test_number);
4643
4644 // Test the number "001".
4645 zeros_number.set_national_number(1L);
4646 zeros_number.set_italian_leading_zero(true);
4647 zeros_number.set_number_of_leading_zeros(2);
4648 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4649 phone_util_.Parse("001", RegionCode::AU(),
4650 &test_number));
4651 EXPECT_EQ(zeros_number, test_number);
4652
4653 // Test the number "000". This number has 2 leading zeros.
4654 zeros_number.set_national_number(0L);
4655 zeros_number.set_italian_leading_zero(true);
4656 zeros_number.set_number_of_leading_zeros(2);
4657 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4658 phone_util_.Parse("000", RegionCode::AU(),
4659 &test_number));
4660 EXPECT_EQ(zeros_number, test_number);
4661
4662 // Test the number "0000". This number has 3 leading zeros.
4663 zeros_number.set_national_number(0L);
4664 zeros_number.set_italian_leading_zero(true);
4665 zeros_number.set_number_of_leading_zeros(3);
4666 EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
4667 phone_util_.Parse("0000", RegionCode::AU(),
4668 &test_number));
4669 EXPECT_EQ(zeros_number, test_number);
4670 }
4671
TEST_F(PhoneNumberUtilTest,CanBeInternationallyDialled)4672 TEST_F(PhoneNumberUtilTest, CanBeInternationallyDialled) {
4673 PhoneNumber test_number;
4674 test_number.set_country_code(1);
4675
4676 // We have no-international-dialling rules for the US in our test metadata
4677 // that say that toll-free numbers cannot be dialled internationally.
4678 test_number.set_national_number(uint64{8002530000});
4679 EXPECT_FALSE(phone_util_.CanBeInternationallyDialled(test_number));
4680
4681 // Normal US numbers can be internationally dialled.
4682 test_number.set_national_number(uint64{6502530000});
4683 EXPECT_TRUE(phone_util_.CanBeInternationallyDialled(test_number));
4684
4685 // Invalid number.
4686 test_number.set_national_number(uint64{2530000});
4687 EXPECT_TRUE(phone_util_.CanBeInternationallyDialled(test_number));
4688
4689 // We have no data for NZ - should return true.
4690 test_number.set_country_code(64);
4691 test_number.set_national_number(uint64{33316005});
4692 EXPECT_TRUE(phone_util_.CanBeInternationallyDialled(test_number));
4693
4694 test_number.set_country_code(800);
4695 test_number.set_national_number(uint64{12345678});
4696 EXPECT_TRUE(phone_util_.CanBeInternationallyDialled(test_number));
4697 }
4698
TEST_F(PhoneNumberUtilTest,IsAlphaNumber)4699 TEST_F(PhoneNumberUtilTest, IsAlphaNumber) {
4700 EXPECT_TRUE(phone_util_.IsAlphaNumber("1800 six-flags"));
4701 EXPECT_TRUE(phone_util_.IsAlphaNumber("1800 six-flags ext. 1234"));
4702 EXPECT_TRUE(phone_util_.IsAlphaNumber("+800 six-flags"));
4703 EXPECT_TRUE(phone_util_.IsAlphaNumber("180 six-flags"));
4704 EXPECT_FALSE(phone_util_.IsAlphaNumber("1800 123-1234"));
4705 EXPECT_FALSE(phone_util_.IsAlphaNumber("1 six-flags"));
4706 EXPECT_FALSE(phone_util_.IsAlphaNumber("18 six-flags"));
4707 EXPECT_FALSE(phone_util_.IsAlphaNumber("1800 123-1234 extension: 1234"));
4708 EXPECT_FALSE(phone_util_.IsAlphaNumber("+800 1234-1234"));
4709 }
4710
4711 } // namespace phonenumbers
4712 } // namespace i18n
4713