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