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