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