cpp/test/phonenumbers/phonenumberutil_test.cc

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