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   test_number.set_country_code(1);
 951
 952   // US toll free numbers are marked as noInternationalDialling in the test
 953   // metadata for testing purposes.
 954   test_number.set_national_number(8002530000ULL);
 955   phone_util_.FormatNumberForMobileDialing(
 956       test_number, RegionCode::US(), true, /* keep formatting */
 957       &formatted_number);
 958   EXPECT_EQ("800 253 0000", formatted_number);
 959   phone_util_.FormatNumberForMobileDialing(
 960       test_number, RegionCode::CN(), true, &formatted_number);
 961   EXPECT_EQ("", formatted_number);
 962   phone_util_.FormatNumberForMobileDialing(
 963       test_number, RegionCode::US(), false, /* remove formatting */
 964       &formatted_number);
 965   EXPECT_EQ("8002530000", formatted_number);
 966   phone_util_.FormatNumberForMobileDialing(
 967       test_number, RegionCode::CN(), false, &formatted_number);
 968   EXPECT_EQ("", formatted_number);
 969
 970   test_number.set_national_number(6502530000ULL);
 971   phone_util_.FormatNumberForMobileDialing(
 972       test_number, RegionCode::US(), true, &formatted_number);
 973   EXPECT_EQ("+1 650 253 0000", formatted_number);
 974   phone_util_.FormatNumberForMobileDialing(
 975       test_number, RegionCode::US(), false, &formatted_number);
 976   EXPECT_EQ("+16502530000", formatted_number);
 977
 978   test_number.set_extension("1234");
 979   phone_util_.FormatNumberForMobileDialing(
 980       test_number, RegionCode::US(), true, &formatted_number);
 981   EXPECT_EQ("+1 650 253 0000", formatted_number);
 982   phone_util_.FormatNumberForMobileDialing(
 983       test_number, RegionCode::US(), false, &formatted_number);
 984   EXPECT_EQ("+16502530000", formatted_number);
 985
 986   // An invalid US number, which is one digit too long.
 987   test_number.set_national_number(65025300001ULL);
 988   phone_util_.FormatNumberForMobileDialing(
 989       test_number, RegionCode::US(), true, &formatted_number);
 990   EXPECT_EQ("+1 65025300001", formatted_number);
 991   phone_util_.FormatNumberForMobileDialing(
 992       test_number, RegionCode::US(), false, &formatted_number);
 993   EXPECT_EQ("+165025300001", formatted_number);
 994
 995   // Star numbers. In real life they appear in Israel, but we have them in JP
 996   // in our test metadata.
 997   test_number.set_country_code(81);
 998   test_number.set_national_number(2345ULL);
 999   phone_util_.FormatNumberForMobileDialing(
1000       test_number, RegionCode::JP(), true, &formatted_number);
1001   EXPECT_EQ("*2345", formatted_number);
1002   phone_util_.FormatNumberForMobileDialing(
1003       test_number, RegionCode::JP(), false, &formatted_number);
1004   EXPECT_EQ("*2345", formatted_number);
1005
1006   test_number.set_country_code(800);
1007   test_number.set_national_number(12345678ULL);
1008   phone_util_.FormatNumberForMobileDialing(
1009       test_number, RegionCode::JP(), false, &formatted_number);
1010   EXPECT_EQ("+80012345678", formatted_number);
1011   phone_util_.FormatNumberForMobileDialing(
1012       test_number, RegionCode::JP(), true, &formatted_number);
1013   EXPECT_EQ("+800 1234 5678", formatted_number);
1014
1015   // UAE numbers beginning with 600 (classified as UAN) need to be dialled
1016   // without +971 locally.
1017   test_number.set_country_code(971);
1018   test_number.set_national_number(600123456ULL);
1019   phone_util_.FormatNumberForMobileDialing(
1020       test_number, RegionCode::JP(), false, &formatted_number);
1021   EXPECT_EQ("+971600123456", formatted_number);
1022   phone_util_.FormatNumberForMobileDialing(
1023       test_number, RegionCode::AE(), true, &formatted_number);
1024   EXPECT_EQ("600123456", formatted_number);
1025 }
1026
1027 TEST_F(PhoneNumberUtilTest, FormatByPattern) {
1028   PhoneNumber test_number;
1029   string formatted_number;
1030   test_number.set_country_code(1);
1031   test_number.set_national_number(6502530000ULL);
1032
1033   RepeatedPtrField<NumberFormat> number_formats;
1034   NumberFormat* number_format = number_formats.Add();
1035   number_format->set_pattern("(\\d{3})(\\d{3})(\\d{4})");
1036   number_format->set_format("($1) $2-$3");
1037   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1038                               number_formats,
1039                               &formatted_number);
1040   EXPECT_EQ("(650) 253-0000", formatted_number);
1041   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
1042                               number_formats,
1043                               &formatted_number);
1044   EXPECT_EQ("+1 (650) 253-0000", formatted_number);
1045   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::RFC3966,
1046                               number_formats,
1047                               &formatted_number);
1048   EXPECT_EQ("tel:+1-650-253-0000", formatted_number);
1049
1050   // $NP is set to '1' for the US. Here we check that for other NANPA countries
1051   // the US rules are followed.
1052   number_format->set_national_prefix_formatting_rule("$NP ($FG)");
1053   number_format->set_format("$1 $2-$3");
1054   test_number.set_country_code(1);
1055   test_number.set_national_number(4168819999ULL);
1056   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1057                               number_formats,
1058                               &formatted_number);
1059   EXPECT_EQ("1 (416) 881-9999", formatted_number);
1060   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
1061                               number_formats,
1062                               &formatted_number);
1063   EXPECT_EQ("+1 416 881-9999", formatted_number);
1064
1065   test_number.set_country_code(39);
1066   test_number.set_national_number(236618300ULL);
1067   test_number.set_italian_leading_zero(true);
1068   number_format->set_pattern("(\\d{2})(\\d{5})(\\d{3})");
1069   number_format->set_format("$1-$2 $3");
1070   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1071                               number_formats,
1072                               &formatted_number);
1073   EXPECT_EQ("02-36618 300", formatted_number);
1074   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
1075                               number_formats,
1076                               &formatted_number);
1077   EXPECT_EQ("+39 02-36618 300", formatted_number);
1078
1079   test_number.set_country_code(44);
1080   test_number.set_national_number(2012345678ULL);
1081   test_number.set_italian_leading_zero(false);
1082   number_format->set_national_prefix_formatting_rule("$NP$FG");
1083   number_format->set_pattern("(\\d{2})(\\d{4})(\\d{4})");
1084   number_format->set_format("$1 $2 $3");
1085   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1086                               number_formats,
1087                               &formatted_number);
1088   EXPECT_EQ("020 1234 5678", formatted_number);
1089
1090   number_format->set_national_prefix_formatting_rule("($NP$FG)");
1091   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1092                               number_formats,
1093                               &formatted_number);
1094   EXPECT_EQ("(020) 1234 5678", formatted_number);
1095   number_format->set_national_prefix_formatting_rule("");
1096   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::NATIONAL,
1097                               number_formats,
1098                               &formatted_number);
1099   EXPECT_EQ("20 1234 5678", formatted_number);
1100   number_format->set_national_prefix_formatting_rule("");
1101   phone_util_.FormatByPattern(test_number, PhoneNumberUtil::INTERNATIONAL,
1102                               number_formats,
1103                               &formatted_number);
1104   EXPECT_EQ("+44 20 1234 5678", formatted_number);
1105 }
1106
1107 TEST_F(PhoneNumberUtilTest, FormatE164Number) {
1108   PhoneNumber test_number;
1109   string formatted_number;
1110   test_number.set_country_code(1);
1111   test_number.set_national_number(6502530000ULL);
1112   phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
1113   EXPECT_EQ("+16502530000", formatted_number);
1114
1115   test_number.set_country_code(49);
1116   test_number.set_national_number(301234ULL);
1117   phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
1118   EXPECT_EQ("+49301234", formatted_number);
1119
1120   test_number.set_country_code(800);
1121   test_number.set_national_number(12345678ULL);
1122   phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
1123   EXPECT_EQ("+80012345678", formatted_number);
1124 }
1125
1126 TEST_F(PhoneNumberUtilTest, FormatNumberWithExtension) {
1127   PhoneNumber nz_number;
1128   nz_number.set_country_code(64);
1129   nz_number.set_national_number(33316005ULL);
1130   nz_number.set_extension("1234");
1131   string formatted_number;
1132   // Uses default extension prefix:
1133   phone_util_.Format(nz_number, PhoneNumberUtil::NATIONAL, &formatted_number);
1134   EXPECT_EQ("03-331 6005 ext. 1234", formatted_number);
1135   // Uses RFC 3966 syntax.
1136   phone_util_.Format(nz_number, PhoneNumberUtil::RFC3966, &formatted_number);
1137   EXPECT_EQ("tel:+64-3-331-6005;ext=1234", formatted_number);
1138   // Extension prefix overridden in the territory information for the US:
1139   PhoneNumber us_number_with_extension;
1140   us_number_with_extension.set_country_code(1);
1141   us_number_with_extension.set_national_number(6502530000ULL);
1142   us_number_with_extension.set_extension("4567");
1143   phone_util_.Format(us_number_with_extension,
1144                      PhoneNumberUtil::NATIONAL, &formatted_number);
1145   EXPECT_EQ("650 253 0000 extn. 4567", formatted_number);
1146 }
1147
1148 TEST_F(PhoneNumberUtilTest, GetLengthOfGeographicalAreaCode) {
1149   PhoneNumber number;
1150   // Google MTV, which has area code "650".
1151   number.set_country_code(1);
1152   number.set_national_number(6502530000ULL);
1153   EXPECT_EQ(3, phone_util_.GetLengthOfGeographicalAreaCode(number));
1154
1155   // A North America toll-free number, which has no area code.
1156   number.set_country_code(1);
1157   number.set_national_number(8002530000ULL);
1158   EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1159
1160   // An invalid US number (1 digit shorter), which has no area code.
1161   number.set_country_code(1);
1162   number.set_national_number(650253000ULL);
1163   EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1164
1165   // Google London, which has area code "20".
1166   number.set_country_code(44);
1167   number.set_national_number(2070313000ULL);
1168   EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
1169
1170   // A UK mobile phone, which has no area code.
1171   number.set_country_code(44);
1172   number.set_national_number(7123456789ULL);
1173   EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1174
1175   // Google Buenos Aires, which has area code "11".
1176   number.set_country_code(54);
1177   number.set_national_number(1155303000ULL);
1178   EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
1179
1180   // Google Sydney, which has area code "2".
1181   number.set_country_code(61);
1182   number.set_national_number(293744000ULL);
1183   EXPECT_EQ(1, phone_util_.GetLengthOfGeographicalAreaCode(number));
1184
1185   // Italian numbers - there is no national prefix, but it still has an area
1186   // code.
1187   number.set_country_code(39);
1188   number.set_national_number(236618300ULL);
1189   number.set_italian_leading_zero(true);
1190   EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
1191
1192   // Google Singapore. Singapore has no area code and no national prefix.
1193   number.set_country_code(65);
1194   number.set_national_number(65218000ULL);
1195   number.set_italian_leading_zero(false);
1196   EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1197
1198   // An international toll free number, which has no area code.
1199   number.set_country_code(800);
1200   number.set_national_number(12345678ULL);
1201   EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
1202 }
1203
1204 TEST_F(PhoneNumberUtilTest, GetLengthOfNationalDestinationCode) {
1205   PhoneNumber number;
1206   // Google MTV, which has national destination code (NDC) "650".
1207   number.set_country_code(1);
1208   number.set_national_number(6502530000ULL);
1209   EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));
1210
1211   // A North America toll-free number, which has NDC "800".
1212   number.set_country_code(1);
1213   number.set_national_number(8002530000ULL);
1214   EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));
1215
1216   // Google London, which has NDC "20".
1217   number.set_country_code(44);
1218   number.set_national_number(2070313000ULL);
1219   EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));
1220
1221   // A UK mobile phone, which has NDC "7123"
1222   number.set_country_code(44);
1223   number.set_national_number(7123456789ULL);
1224   EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
1225
1226   // Google Buenos Aires, which has NDC "11".
1227   number.set_country_code(54);
1228   number.set_national_number(1155303000ULL);
1229   EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));
1230
1231   // Google Sydney, which has NDC "2".
1232   number.set_country_code(61);
1233   number.set_national_number(293744000ULL);
1234   EXPECT_EQ(1, phone_util_.GetLengthOfNationalDestinationCode(number));
1235
1236   // Google Singapore. Singapore has NDC "6521".
1237   number.set_country_code(65);
1238   number.set_national_number(65218000ULL);
1239   EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
1240
1241   // An invalid US number (1 digit shorter), which has no NDC.
1242   number.set_country_code(1);
1243   number.set_national_number(650253000ULL);
1244   EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1245
1246   // A number containing an invalid country code, which shouldn't have any NDC.
1247   number.set_country_code(123);
1248   number.set_national_number(650253000ULL);
1249   EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1250
1251   // A number that has only one group of digits after country code when
1252   // formatted in the international format.
1253   number.set_country_code(376);
1254   number.set_national_number(12345ULL);
1255   EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1256
1257   // The same number above, but with an extension.
1258   number.set_country_code(376);
1259   number.set_national_number(12345ULL);
1260   number.set_extension("321");
1261   EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
1262
1263   // An international toll free number, which has NDC "1234".
1264   number.Clear();
1265   number.set_country_code(800);
1266   number.set_national_number(12345678ULL);
1267   EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
1268 }
1269
1270 TEST_F(PhoneNumberUtilTest, ExtractPossibleNumber) {
1271   // Removes preceding funky punctuation and letters but leaves the rest
1272   // untouched.
1273   string extracted_number;
1274   ExtractPossibleNumber("Tel:0800-345-600", &extracted_number);
1275   EXPECT_EQ("0800-345-600", extracted_number);
1276   ExtractPossibleNumber("Tel:0800 FOR PIZZA", &extracted_number);
1277   EXPECT_EQ("0800 FOR PIZZA", extracted_number);
1278
1279   // Should not remove plus sign.
1280   ExtractPossibleNumber("Tel:+800-345-600", &extracted_number);
1281   EXPECT_EQ("+800-345-600", extracted_number);
1282   // Should recognise wide digits as possible start values.
1283   ExtractPossibleNumber("\xEF\xBC\x90\xEF\xBC\x92\xEF\xBC\x93" /* "０２３" */,
1284                         &extracted_number);
1285   EXPECT_EQ("\xEF\xBC\x90\xEF\xBC\x92\xEF\xBC\x93" /* "０２３" */,
1286             extracted_number);
1287   // Dashes are not possible start values and should be removed.
1288   ExtractPossibleNumber("Num-\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93"
1289                         /* "Num-１２３" */, &extracted_number);
1290   EXPECT_EQ("\xEF\xBC\x91\xEF\xBC\x92\xEF\xBC\x93" /* "１２３" */,
1291             extracted_number);
1292   // If not possible number present, return empty string.
1293   ExtractPossibleNumber("Num-....", &extracted_number);
1294   EXPECT_EQ("", extracted_number);
1295   // Leading brackets are stripped - these are not used when parsing.
1296   ExtractPossibleNumber("(650) 253-0000", &extracted_number);
1297   EXPECT_EQ("650) 253-0000", extracted_number);
1298
1299   // Trailing non-alpha-numeric characters should be removed.
1300   ExtractPossibleNumber("(650) 253-0000..- ..", &extracted_number);
1301   EXPECT_EQ("650) 253-0000", extracted_number);
1302   ExtractPossibleNumber("(650) 253-0000.", &extracted_number);
1303   EXPECT_EQ("650) 253-0000", extracted_number);
1304   // This case has a trailing RTL char.
1305   ExtractPossibleNumber("(650) 253-0000\xE2\x80\x8F"
1306                         /* "(650) 253-0000‏" */, &extracted_number);
1307   EXPECT_EQ("650) 253-0000", extracted_number);
1308 }
1309
1310 TEST_F(PhoneNumberUtilTest, IsNANPACountry) {
1311   EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::US()));
1312   EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::BS()));
1313   EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::DE()));
1314   EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::GetUnknown()));
1315   EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::UN001()));
1316 }
1317
1318 TEST_F(PhoneNumberUtilTest, IsValidNumber) {
1319   PhoneNumber us_number;
1320   us_number.set_country_code(1);
1321   us_number.set_national_number(6502530000ULL);
1322   EXPECT_TRUE(phone_util_.IsValidNumber(us_number));
1323
1324   PhoneNumber it_number;
1325   it_number.set_country_code(39);
1326   it_number.set_national_number(236618300ULL);
1327   it_number.set_italian_leading_zero(true);
1328   EXPECT_TRUE(phone_util_.IsValidNumber(it_number));
1329
1330   PhoneNumber gb_number;
1331   gb_number.set_country_code(44);
1332   gb_number.set_national_number(7912345678ULL);
1333   EXPECT_TRUE(phone_util_.IsValidNumber(gb_number));
1334
1335   PhoneNumber nz_number;
1336   nz_number.set_country_code(64);
1337   nz_number.set_national_number(21387835ULL);
1338   EXPECT_TRUE(phone_util_.IsValidNumber(nz_number));
1339
1340   PhoneNumber intl_toll_free_number;
1341   intl_toll_free_number.set_country_code(800);
1342   intl_toll_free_number.set_national_number(12345678ULL);
1343   EXPECT_TRUE(phone_util_.IsValidNumber(intl_toll_free_number));
1344
1345   PhoneNumber universal_premium_rate;
1346   universal_premium_rate.set_country_code(979);
1347   universal_premium_rate.set_national_number(123456789ULL);
1348   EXPECT_TRUE(phone_util_.IsValidNumber(universal_premium_rate));
1349 }
1350
1351 TEST_F(PhoneNumberUtilTest, IsValidForRegion) {
1352   // This number is valid for the Bahamas, but is not a valid US number.
1353   PhoneNumber bs_number;
1354   bs_number.set_country_code(1);
1355   bs_number.set_national_number(2423232345ULL);
1356   EXPECT_TRUE(phone_util_.IsValidNumber(bs_number));
1357   EXPECT_TRUE(phone_util_.IsValidNumberForRegion(bs_number, RegionCode::BS()));
1358   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(bs_number, RegionCode::US()));
1359   bs_number.set_national_number(2421232345ULL);
1360   // This number is no longer valid.
1361   EXPECT_FALSE(phone_util_.IsValidNumber(bs_number));
1362
1363   // La Mayotte and Réunion use 'leadingDigits' to differentiate them.
1364   PhoneNumber re_number;
1365   re_number.set_country_code(262);
1366   re_number.set_national_number(262123456ULL);
1367   EXPECT_TRUE(phone_util_.IsValidNumber(re_number));
1368   EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1369   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1370   // Now change the number to be a number for La Mayotte.
1371   re_number.set_national_number(269601234ULL);
1372   EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1373   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1374   // This number is no longer valid.
1375   re_number.set_national_number(269123456ULL);
1376   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1377   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1378   EXPECT_FALSE(phone_util_.IsValidNumber(re_number));
1379   // However, it should be recognised as from La Mayotte.
1380   string region_code;
1381   phone_util_.GetRegionCodeForNumber(re_number, &region_code);
1382   EXPECT_EQ(RegionCode::YT(), region_code);
1383   // This number is valid in both places.
1384   re_number.set_national_number(800123456ULL);
1385   EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
1386   EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
1387
1388   PhoneNumber intl_toll_free_number;
1389   intl_toll_free_number.set_country_code(800);
1390   intl_toll_free_number.set_national_number(12345678ULL);
1391   EXPECT_TRUE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
1392                                                  RegionCode::UN001()));
1393   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
1394                                                   RegionCode::US()));
1395   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
1396                                                   RegionCode::ZZ()));
1397
1398   PhoneNumber invalid_number;
1399   // Invalid country calling codes.
1400   invalid_number.set_country_code(3923);
1401   invalid_number.set_national_number(2366ULL);
1402   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
1403                                                   RegionCode::ZZ()));
1404   invalid_number.set_country_code(3923);
1405   invalid_number.set_national_number(2366ULL);
1406   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
1407                                                   RegionCode::UN001()));
1408   invalid_number.set_country_code(0);
1409   invalid_number.set_national_number(2366ULL);
1410   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
1411                                                   RegionCode::UN001()));
1412   invalid_number.set_country_code(0);
1413   EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
1414                                                   RegionCode::ZZ()));
1415 }
1416
1417 TEST_F(PhoneNumberUtilTest, IsNotValidNumber) {
1418   PhoneNumber us_number;
1419   us_number.set_country_code(1);
1420   us_number.set_national_number(2530000ULL);
1421   EXPECT_FALSE(phone_util_.IsValidNumber(us_number));
1422
1423   PhoneNumber it_number;
1424   it_number.set_country_code(39);
1425   it_number.set_national_number(23661830000ULL);
1426   it_number.set_italian_leading_zero(true);
1427   EXPECT_FALSE(phone_util_.IsValidNumber(it_number));
1428
1429   PhoneNumber gb_number;
1430   gb_number.set_country_code(44);
1431   gb_number.set_national_number(791234567ULL);
1432   EXPECT_FALSE(phone_util_.IsValidNumber(gb_number));
1433
1434   PhoneNumber de_number;
1435   de_number.set_country_code(49);
1436   de_number.set_national_number(1234ULL);
1437   EXPECT_FALSE(phone_util_.IsValidNumber(de_number));
1438
1439   PhoneNumber nz_number;
1440   nz_number.set_country_code(64);
1441   nz_number.set_national_number(3316005ULL);
1442   EXPECT_FALSE(phone_util_.IsValidNumber(nz_number));
1443
1444   PhoneNumber invalid_number;
1445   // Invalid country calling codes.
1446   invalid_number.set_country_code(3923);
1447   invalid_number.set_national_number(2366ULL);
1448   EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
1449   invalid_number.set_country_code(0);
1450   EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
1451
1452   PhoneNumber intl_toll_free_number_too_long;
1453   intl_toll_free_number_too_long.set_country_code(800);
1454   intl_toll_free_number_too_long.set_national_number(123456789ULL);
1455   EXPECT_FALSE(phone_util_.IsValidNumber(intl_toll_free_number_too_long));
1456 }
1457
1458 TEST_F(PhoneNumberUtilTest, GetRegionCodeForCountryCode) {
1459   string region_code;
1460   phone_util_.GetRegionCodeForCountryCode(1, &region_code);
1461   EXPECT_EQ(RegionCode::US(), region_code);
1462   phone_util_.GetRegionCodeForCountryCode(44, &region_code);
1463   EXPECT_EQ(RegionCode::GB(), region_code);
1464   phone_util_.GetRegionCodeForCountryCode(49, &region_code);
1465   EXPECT_EQ(RegionCode::DE(), region_code);
1466   phone_util_.GetRegionCodeForCountryCode(800, &region_code);
1467   EXPECT_EQ(RegionCode::UN001(), region_code);
1468   phone_util_.GetRegionCodeForCountryCode(979, &region_code);
1469   EXPECT_EQ(RegionCode::UN001(), region_code);
1470 }
1471
1472 TEST_F(PhoneNumberUtilTest, GetRegionCodeForNumber) {
1473   string region_code;
1474   PhoneNumber bs_number;
1475   bs_number.set_country_code(1);
1476   bs_number.set_national_number(2423232345ULL);
1477   phone_util_.GetRegionCodeForNumber(bs_number, &region_code);
1478   EXPECT_EQ(RegionCode::BS(), region_code);
1479
1480   PhoneNumber us_number;
1481   us_number.set_country_code(1);
1482   us_number.set_national_number(4241231234ULL);
1483   phone_util_.GetRegionCodeForNumber(us_number, &region_code);
1484   EXPECT_EQ(RegionCode::US(), region_code);
1485
1486   PhoneNumber gb_mobile;
1487   gb_mobile.set_country_code(44);
1488   gb_mobile.set_national_number(7912345678ULL);
1489   phone_util_.GetRegionCodeForNumber(gb_mobile, &region_code);
1490   EXPECT_EQ(RegionCode::GB(), region_code);
1491
1492   PhoneNumber intl_toll_free_number;
1493   intl_toll_free_number.set_country_code(800);
1494   intl_toll_free_number.set_national_number(12345678ULL);
1495   phone_util_.GetRegionCodeForNumber(intl_toll_free_number, &region_code);
1496   EXPECT_EQ(RegionCode::UN001(), region_code);
1497
1498   PhoneNumber universal_premium_rate;
1499   universal_premium_rate.set_country_code(979);
1500   universal_premium_rate.set_national_number(123456789ULL);
1501   phone_util_.GetRegionCodeForNumber(universal_premium_rate, &region_code);
1502   EXPECT_EQ(RegionCode::UN001(), region_code);
1503 }
1504
1505 TEST_F(PhoneNumberUtilTest, IsPossibleNumber) {
1506   PhoneNumber number;
1507   number.set_country_code(1);
1508   number.set_national_number(6502530000ULL);
1509   EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1510
1511   number.set_country_code(1);
1512   number.set_national_number(2530000ULL);
1513   EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1514
1515   number.set_country_code(44);
1516   number.set_national_number(2070313000ULL);
1517   EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1518
1519   number.set_country_code(800);
1520   number.set_national_number(12345678ULL);
1521   EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
1522
1523   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 253 0000",
1524                                                     RegionCode::US()));
1525   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 GOO OGLE",
1526                                                     RegionCode::US()));
1527   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("(650) 253-0000",
1528                                                     RegionCode::US()));
1529   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("253-0000",
1530                                                     RegionCode::US()));
1531   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 253 0000",
1532                                                     RegionCode::GB()));
1533   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+44 20 7031 3000",
1534                                                     RegionCode::GB()));
1535   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("(020) 7031 3000",
1536                                                     RegionCode::GB()));
1537   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("7031 3000",
1538                                                     RegionCode::GB()));
1539   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("3331 6005",
1540                                                     RegionCode::NZ()));
1541   EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+800 1234 5678",
1542                                                     RegionCode::UN001()));
1543 }
1544
1545 TEST_F(PhoneNumberUtilTest, IsPossibleNumberWithReason) {
1546   // FYI, national numbers for country code +1 that are within 7 to 10 digits
1547   // are possible.
1548   PhoneNumber number;
1549   number.set_country_code(1);
1550   number.set_national_number(6502530000ULL);
1551   EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1552             phone_util_.IsPossibleNumberWithReason(number));
1553
1554   number.set_country_code(1);
1555   number.set_national_number(2530000ULL);
1556   EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1557             phone_util_.IsPossibleNumberWithReason(number));
1558
1559   number.set_country_code(0);
1560   number.set_national_number(2530000ULL);
1561   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE,
1562             phone_util_.IsPossibleNumberWithReason(number));
1563
1564   number.set_country_code(1);
1565   number.set_national_number(253000ULL);
1566   EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
1567             phone_util_.IsPossibleNumberWithReason(number));
1568
1569   number.set_country_code(1);
1570   number.set_national_number(65025300000ULL);
1571   EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
1572             phone_util_.IsPossibleNumberWithReason(number));
1573
1574   number.set_country_code(44);
1575   number.set_national_number(2070310000ULL);
1576   EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1577             phone_util_.IsPossibleNumberWithReason(number));
1578
1579   number.set_country_code(49);
1580   number.set_national_number(30123456ULL);
1581   EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1582             phone_util_.IsPossibleNumberWithReason(number));
1583
1584   number.set_country_code(65);
1585   number.set_national_number(1234567890ULL);
1586   EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1587             phone_util_.IsPossibleNumberWithReason(number));
1588
1589   number.set_country_code(800);
1590   number.set_national_number(123456789ULL);
1591   EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
1592             phone_util_.IsPossibleNumberWithReason(number));
1593
1594   // Try with number that we don't have metadata for.
1595   PhoneNumber ad_number;
1596   ad_number.set_country_code(376);
1597   ad_number.set_national_number(12345ULL);
1598   EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
1599             phone_util_.IsPossibleNumberWithReason(ad_number));
1600   ad_number.set_country_code(376);
1601   ad_number.set_national_number(1ULL);
1602   EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
1603             phone_util_.IsPossibleNumberWithReason(ad_number));
1604   ad_number.set_country_code(376);
1605   ad_number.set_national_number(12345678901234567ULL);
1606   EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
1607             phone_util_.IsPossibleNumberWithReason(ad_number));
1608 }
1609
1610 TEST_F(PhoneNumberUtilTest, IsNotPossibleNumber) {
1611   PhoneNumber number;
1612   number.set_country_code(1);
1613   number.set_national_number(65025300000ULL);
1614   EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
1615
1616   number.set_country_code(800);
1617   number.set_national_number(123456789ULL);
1618   EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
1619
1620   number.set_country_code(1);
1621   number.set_national_number(253000ULL);
1622   EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
1623
1624   number.set_country_code(44);
1625   number.set_national_number(300ULL);
1626   EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
1627
1628   EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+1 650 253 00000",
1629                                                      RegionCode::US()));
1630   EXPECT_FALSE(phone_util_.IsPossibleNumberForString("(650) 253-00000",
1631                                                      RegionCode::US()));
1632   EXPECT_FALSE(phone_util_.IsPossibleNumberForString("I want a Pizza",
1633                                                      RegionCode::US()));
1634   EXPECT_FALSE(phone_util_.IsPossibleNumberForString("253-000",
1635                                                      RegionCode::US()));
1636   EXPECT_FALSE(phone_util_.IsPossibleNumberForString("1 3000",
1637                                                      RegionCode::GB()));
1638   EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+44 300",
1639                                                      RegionCode::GB()));
1640   EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+800 1234 5678 9",
1641                                                      RegionCode::UN001()));
1642 }
1643
1644 TEST_F(PhoneNumberUtilTest, TruncateTooLongNumber) {
1645   // US number 650-253-0000, but entered with one additional digit at the end.
1646   PhoneNumber too_long_number;
1647   too_long_number.set_country_code(1);
1648   too_long_number.set_national_number(65025300001ULL);
1649   PhoneNumber valid_number;
1650   valid_number.set_country_code(1);
1651   valid_number.set_national_number(6502530000ULL);
1652   EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
1653   EXPECT_EQ(valid_number, too_long_number);
1654
1655   too_long_number.set_country_code(800);
1656   too_long_number.set_national_number(123456789ULL);
1657   valid_number.set_country_code(800);
1658   valid_number.set_national_number(12345678ULL);
1659   EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
1660   EXPECT_EQ(valid_number, too_long_number);
1661
1662   // GB number 080 1234 5678, but entered with 4 extra digits at the end.
1663   too_long_number.set_country_code(44);
1664   too_long_number.set_national_number(80123456780123ULL);
1665   valid_number.set_country_code(44);
1666   valid_number.set_national_number(8012345678ULL);
1667   EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
1668   EXPECT_EQ(valid_number, too_long_number);
1669
1670   // IT number 022 3456 7890, but entered with 3 extra digits at the end.
1671   too_long_number.set_country_code(39);
1672   too_long_number.set_national_number(2234567890123ULL);
1673   too_long_number.set_italian_leading_zero(true);
1674   valid_number.set_country_code(39);
1675   valid_number.set_national_number(2234567890ULL);
1676   valid_number.set_italian_leading_zero(true);
1677   EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
1678   EXPECT_EQ(valid_number, too_long_number);
1679
1680   // Tests what happens when a valid number is passed in.
1681   PhoneNumber valid_number_copy(valid_number);
1682   EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&valid_number));
1683   // Tests the number is not modified.
1684   EXPECT_EQ(valid_number_copy, valid_number);
1685
1686   // Tests what happens when a number with invalid prefix is passed in.
1687   PhoneNumber number_with_invalid_prefix;
1688   number_with_invalid_prefix.set_country_code(1);
1689   // The test metadata says US numbers cannot have prefix 240.
1690   number_with_invalid_prefix.set_national_number(2401234567ULL);
1691   PhoneNumber invalid_number_copy(number_with_invalid_prefix);
1692   EXPECT_FALSE(phone_util_.TruncateTooLongNumber(&number_with_invalid_prefix));
1693   // Tests the number is not modified.
1694   EXPECT_EQ(invalid_number_copy, number_with_invalid_prefix);
1695
1696   // Tests what happens when a too short number is passed in.
1697   PhoneNumber too_short_number;
1698   too_short_number.set_country_code(1);
1699   too_short_number.set_national_number(1234ULL);
1700   PhoneNumber too_short_number_copy(too_short_number);
1701   EXPECT_FALSE(phone_util_.TruncateTooLongNumber(&too_short_number));
1702   // Tests the number is not modified.
1703   EXPECT_EQ(too_short_number_copy, too_short_number);
1704 }
1705
1706 TEST_F(PhoneNumberUtilTest, IsNumberGeographical) {
1707   PhoneNumber number;
1708
1709   number.set_country_code(1);
1710   number.set_national_number(2423570000ULL);
1711   EXPECT_FALSE(IsNumberGeographical(number));  // Bahamas, mobile phone number.
1712
1713   number.set_country_code(61);
1714   number.set_national_number(236618300ULL);
1715   EXPECT_TRUE(IsNumberGeographical(number));  // Australian fixed line number.
1716
1717   number.set_country_code(800);
1718   number.set_national_number(12345678ULL);
1719   EXPECT_FALSE(IsNumberGeographical(number));  // Internation toll free number.
1720 }
1721
1722 TEST_F(PhoneNumberUtilTest, IsLeadingZeroPossible) {
1723   EXPECT_TRUE(IsLeadingZeroPossible(39));  // Italy
1724   EXPECT_FALSE(IsLeadingZeroPossible(1));  // USA
1725   EXPECT_TRUE(IsLeadingZeroPossible(800));  // International toll free
1726   EXPECT_FALSE(IsLeadingZeroPossible(979));  // International premium-rate
1727   EXPECT_FALSE(IsLeadingZeroPossible(888));  // Not in metadata file, should
1728                                              // return default value of false.
1729 }
1730
1731 TEST_F(PhoneNumberUtilTest, FormatInOriginalFormat) {
1732   PhoneNumber phone_number;
1733   string formatted_number;
1734
1735   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1736             phone_util_.ParseAndKeepRawInput("+442087654321", RegionCode::GB(),
1737                                              &phone_number));
1738   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1739                                      &formatted_number);
1740   EXPECT_EQ("+44 20 8765 4321", formatted_number);
1741
1742   phone_number.Clear();
1743   formatted_number.clear();
1744   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1745             phone_util_.ParseAndKeepRawInput("02087654321", RegionCode::GB(),
1746                                              &phone_number));
1747   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1748                                      &formatted_number);
1749   EXPECT_EQ("(020) 8765 4321", formatted_number);
1750
1751   phone_number.Clear();
1752   formatted_number.clear();
1753   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1754             phone_util_.ParseAndKeepRawInput("011442087654321",
1755                                              RegionCode::US(), &phone_number));
1756   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
1757                                      &formatted_number);
1758   EXPECT_EQ("011 44 20 8765 4321", formatted_number);
1759
1760   phone_number.Clear();
1761   formatted_number.clear();
1762   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1763             phone_util_.ParseAndKeepRawInput("442087654321", RegionCode::GB(),
1764                                              &phone_number));
1765   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1766                                      &formatted_number);
1767   EXPECT_EQ("44 20 8765 4321", formatted_number);
1768
1769   phone_number.Clear();
1770   formatted_number.clear();
1771   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1772             phone_util_.Parse("+442087654321", RegionCode::GB(),
1773                               &phone_number));
1774   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1775                                      &formatted_number);
1776   EXPECT_EQ("(020) 8765 4321", formatted_number);
1777
1778   // Invalid numbers that we have a formatting pattern for should be formatted
1779   // properly.  Note area codes starting with 7 are intentionally excluded in
1780   // the test metadata for testing purposes.
1781   phone_number.Clear();
1782   formatted_number.clear();
1783   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1784             phone_util_.ParseAndKeepRawInput("7345678901", RegionCode::US(),
1785                                              &phone_number));
1786   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
1787                                      &formatted_number);
1788   EXPECT_EQ("734 567 8901", formatted_number);
1789
1790   // US is not a leading zero country, and the presence of the leading zero
1791   // leads us to format the number using raw_input.
1792   phone_number.Clear();
1793   formatted_number.clear();
1794   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1795             phone_util_.ParseAndKeepRawInput("0734567 8901", RegionCode::US(),
1796                                              &phone_number));
1797   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
1798                                      &formatted_number);
1799   EXPECT_EQ("0734567 8901", formatted_number);
1800
1801   // This number is valid, but we don't have a formatting pattern for it. Fall
1802   // back to the raw input.
1803   phone_number.Clear();
1804   formatted_number.clear();
1805   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1806             phone_util_.ParseAndKeepRawInput("02-4567-8900", RegionCode::KR(),
1807                                              &phone_number));
1808   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::KR(),
1809                                      &formatted_number);
1810   EXPECT_EQ("02-4567-8900", formatted_number);
1811
1812   phone_number.Clear();
1813   formatted_number.clear();
1814   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1815             phone_util_.ParseAndKeepRawInput("01180012345678",
1816                                              RegionCode::US(), &phone_number));
1817   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
1818                                      &formatted_number);
1819   EXPECT_EQ("011 800 1234 5678", formatted_number);
1820
1821   phone_number.Clear();
1822   formatted_number.clear();
1823   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1824             phone_util_.ParseAndKeepRawInput("+80012345678", RegionCode::KR(),
1825                                              &phone_number));
1826   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::KR(),
1827                                      &formatted_number);
1828   EXPECT_EQ("+800 1234 5678", formatted_number);
1829
1830   // US local numbers are formatted correctly, as we have formatting patterns
1831   // for them.
1832   phone_number.Clear();
1833   formatted_number.clear();
1834   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1835             phone_util_.ParseAndKeepRawInput("2530000", RegionCode::US(),
1836                                              &phone_number));
1837   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
1838                                      &formatted_number);
1839   EXPECT_EQ("253 0000", formatted_number);
1840
1841   phone_number.Clear();
1842   formatted_number.clear();
1843   // Number with national prefix in the US.
1844   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1845             phone_util_.ParseAndKeepRawInput("18003456789", RegionCode::US(),
1846                                              &phone_number));
1847   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
1848                                      &formatted_number);
1849   EXPECT_EQ("1 800 345 6789", formatted_number);
1850
1851   phone_number.Clear();
1852   formatted_number.clear();
1853   // Number without national prefix in the UK.
1854   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1855             phone_util_.ParseAndKeepRawInput("2087654321", RegionCode::GB(),
1856                                              &phone_number));
1857   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1858                                      &formatted_number);
1859   EXPECT_EQ("20 8765 4321", formatted_number);
1860   // Make sure no metadata is modified as a result of the previous function
1861   // call.
1862   phone_number.Clear();
1863   formatted_number.clear();
1864   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1865             phone_util_.Parse("+442087654321", RegionCode::GB(),
1866                               &phone_number));
1867   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
1868                                      &formatted_number);
1869   EXPECT_EQ("(020) 8765 4321", formatted_number);
1870
1871   phone_number.Clear();
1872   formatted_number.clear();
1873   // Number with national prefix in Mexico.
1874   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1875             phone_util_.ParseAndKeepRawInput("013312345678", RegionCode::MX(),
1876                                              &phone_number));
1877   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
1878                                      &formatted_number);
1879   EXPECT_EQ("01 33 1234 5678", formatted_number);
1880
1881   phone_number.Clear();
1882   formatted_number.clear();
1883   // Number without national prefix in Mexico.
1884   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1885             phone_util_.ParseAndKeepRawInput("3312345678", RegionCode::MX(),
1886                                              &phone_number));
1887   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
1888                                      &formatted_number);
1889   EXPECT_EQ("33 1234 5678", formatted_number);
1890
1891   phone_number.Clear();
1892   formatted_number.clear();
1893   // Italian fixed-line number.
1894   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1895             phone_util_.ParseAndKeepRawInput("0212345678", RegionCode::IT(),
1896                                              &phone_number));
1897   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::IT(),
1898                                      &formatted_number);
1899   EXPECT_EQ("02 1234 5678", formatted_number);
1900
1901   phone_number.Clear();
1902   formatted_number.clear();
1903   // Number with national prefix in Japan.
1904   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1905             phone_util_.ParseAndKeepRawInput("00777012", RegionCode::JP(),
1906                                              &phone_number));
1907   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
1908                                      &formatted_number);
1909   EXPECT_EQ("0077-7012", formatted_number);
1910
1911   phone_number.Clear();
1912   formatted_number.clear();
1913   // Number without national prefix in Japan.
1914   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1915             phone_util_.ParseAndKeepRawInput("0777012", RegionCode::JP(),
1916                                              &phone_number));
1917   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
1918                                      &formatted_number);
1919   EXPECT_EQ("0777012", formatted_number);
1920
1921   phone_number.Clear();
1922   formatted_number.clear();
1923   // Number with carrier code in Brazil.
1924   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1925             phone_util_.ParseAndKeepRawInput("012 3121286979", RegionCode::BR(),
1926                                              &phone_number));
1927   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::BR(),
1928                                      &formatted_number);
1929   EXPECT_EQ("012 3121286979", formatted_number);
1930
1931   phone_number.Clear();
1932   formatted_number.clear();
1933   // The default national prefix used in this case is 045. When a number with
1934   // national prefix 044 is entered, we return the raw input as we don't want to
1935   // change the number entered.
1936   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1937             phone_util_.ParseAndKeepRawInput("044(33)1234-5678",
1938                                              RegionCode::MX(),
1939                                              &phone_number));
1940   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
1941                                      &formatted_number);
1942   EXPECT_EQ("044(33)1234-5678", formatted_number);
1943
1944   phone_number.Clear();
1945   formatted_number.clear();
1946   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1947             phone_util_.ParseAndKeepRawInput("045(33)1234-5678",
1948                                              RegionCode::MX(),
1949                                              &phone_number));
1950   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
1951                                      &formatted_number);
1952   EXPECT_EQ("045 33 1234 5678", formatted_number);
1953
1954   // The default international prefix used in this case is 0011. When a number
1955   // with international prefix 0012 is entered, we return the raw input as we
1956   // don't want to change the number entered.
1957   phone_number.Clear();
1958   formatted_number.clear();
1959   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1960             phone_util_.ParseAndKeepRawInput("0012 16502530000",
1961                                              RegionCode::AU(),
1962                                              &phone_number));
1963   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::AU(),
1964                                      &formatted_number);
1965   EXPECT_EQ("0012 16502530000", formatted_number);
1966
1967   phone_number.Clear();
1968   formatted_number.clear();
1969   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1970             phone_util_.ParseAndKeepRawInput("0011 16502530000",
1971                                              RegionCode::AU(),
1972                                              &phone_number));
1973   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::AU(),
1974                                      &formatted_number);
1975   EXPECT_EQ("0011 1 650 253 0000", formatted_number);
1976
1977   // Test the star sign is not removed from or added to the original input by
1978   // this method.
1979   phone_number.Clear();
1980   formatted_number.clear();
1981   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1982             phone_util_.ParseAndKeepRawInput("*1234",
1983                                              RegionCode::JP(),
1984                                              &phone_number));
1985   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
1986                                      &formatted_number);
1987   EXPECT_EQ("*1234", formatted_number);
1988   phone_number.Clear();
1989   formatted_number.clear();
1990   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
1991             phone_util_.ParseAndKeepRawInput("1234",
1992                                              RegionCode::JP(),
1993                                              &phone_number));
1994   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
1995                                      &formatted_number);
1996   EXPECT_EQ("1234", formatted_number);
1997
1998   // Test that an invalid national number without raw input is just formatted
1999   // as the national number.
2000   phone_number.Clear();
2001   formatted_number.clear();
2002   phone_number.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
2003   phone_number.set_country_code(1);
2004   phone_number.set_national_number(650253000ULL);
2005   phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
2006                                      &formatted_number);
2007   EXPECT_EQ("650253000", formatted_number);
2008 }
2009
2010 TEST_F(PhoneNumberUtilTest, IsPremiumRate) {
2011   PhoneNumber number;
2012   number.set_country_code(1);
2013   number.set_national_number(9004433030ULL);
2014   EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2015
2016   number.set_country_code(39);
2017   number.set_national_number(892123ULL);
2018   EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2019
2020   number.set_country_code(44);
2021   number.set_national_number(9187654321ULL);
2022   EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2023
2024   number.set_country_code(49);
2025   number.set_national_number(9001654321ULL);
2026   EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2027
2028   number.set_country_code(49);
2029   number.set_national_number(90091234567ULL);
2030   EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2031
2032   number.set_country_code(979);
2033   number.set_national_number(123456789ULL);
2034   EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
2035 }
2036
2037 TEST_F(PhoneNumberUtilTest, IsTollFree) {
2038   PhoneNumber number;
2039   number.set_country_code(1);
2040   number.set_national_number(8881234567ULL);
2041   EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2042
2043   number.set_country_code(39);
2044   number.set_national_number(803123ULL);
2045   EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2046
2047   number.set_country_code(44);
2048   number.set_national_number(8012345678ULL);
2049   EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2050
2051   number.set_country_code(49);
2052   number.set_national_number(8001234567ULL);
2053   EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2054
2055   number.set_country_code(800);
2056   number.set_national_number(12345678ULL);
2057   EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
2058 }
2059
2060 TEST_F(PhoneNumberUtilTest, IsMobile) {
2061   PhoneNumber number;
2062   // A Bahama mobile number
2063   number.set_country_code(1);
2064   number.set_national_number(2423570000ULL);
2065   EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2066
2067   number.set_country_code(39);
2068   number.set_national_number(312345678ULL);
2069   EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2070
2071   number.set_country_code(44);
2072   number.set_national_number(7912345678ULL);
2073   EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2074
2075   number.set_country_code(49);
2076   number.set_national_number(15123456789ULL);
2077   EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2078
2079   number.set_country_code(54);
2080   number.set_national_number(91187654321ULL);
2081   EXPECT_EQ(PhoneNumberUtil::MOBILE, phone_util_.GetNumberType(number));
2082 }
2083
2084 TEST_F(PhoneNumberUtilTest, IsFixedLine) {
2085   PhoneNumber number;
2086   // A Bahama fixed-line number
2087   number.set_country_code(1);
2088   number.set_national_number(2423651234ULL);
2089   EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
2090
2091   // An Italian fixed-line number
2092   number.Clear();
2093   number.set_country_code(39);
2094   number.set_national_number(236618300ULL);
2095   number.set_italian_leading_zero(true);
2096   EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
2097
2098   number.Clear();
2099   number.set_country_code(44);
2100   number.set_national_number(2012345678ULL);
2101   EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
2102
2103   number.set_country_code(49);
2104   number.set_national_number(301234ULL);
2105   EXPECT_EQ(PhoneNumberUtil::FIXED_LINE, phone_util_.GetNumberType(number));
2106 }
2107
2108 TEST_F(PhoneNumberUtilTest, IsFixedLineAndMobile) {
2109   PhoneNumber number;
2110   number.set_country_code(1);
2111   number.set_national_number(6502531111ULL);
2112   EXPECT_EQ(PhoneNumberUtil::FIXED_LINE_OR_MOBILE,
2113             phone_util_.GetNumberType(number));
2114
2115   number.set_country_code(54);
2116   number.set_national_number(1987654321ULL);
2117   EXPECT_EQ(PhoneNumberUtil::FIXED_LINE_OR_MOBILE,
2118             phone_util_.GetNumberType(number));
2119 }
2120
2121 TEST_F(PhoneNumberUtilTest, IsSharedCost) {
2122   PhoneNumber number;
2123   number.set_country_code(44);
2124   number.set_national_number(8431231234ULL);
2125   EXPECT_EQ(PhoneNumberUtil::SHARED_COST, phone_util_.GetNumberType(number));
2126 }
2127
2128 TEST_F(PhoneNumberUtilTest, IsVoip) {
2129   PhoneNumber number;
2130   number.set_country_code(44);
2131   number.set_national_number(5631231234ULL);
2132   EXPECT_EQ(PhoneNumberUtil::VOIP, phone_util_.GetNumberType(number));
2133 }
2134
2135 TEST_F(PhoneNumberUtilTest, IsPersonalNumber) {
2136   PhoneNumber number;
2137   number.set_country_code(44);
2138   number.set_national_number(7031231234ULL);
2139   EXPECT_EQ(PhoneNumberUtil::PERSONAL_NUMBER,
2140             phone_util_.GetNumberType(number));
2141 }
2142
2143 TEST_F(PhoneNumberUtilTest, IsUnknown) {
2144   PhoneNumber number;
2145   number.set_country_code(1);
2146   number.set_national_number(65025311111ULL);
2147   EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(number));
2148 }
2149
2150 TEST_F(PhoneNumberUtilTest, GetCountryCodeForRegion) {
2151   EXPECT_EQ(1, phone_util_.GetCountryCodeForRegion(RegionCode::US()));
2152   EXPECT_EQ(64, phone_util_.GetCountryCodeForRegion(RegionCode::NZ()));
2153   EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::GetUnknown()));
2154   EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::UN001()));
2155   // CS is already deprecated so the library doesn't support it.
2156   EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::CS()));
2157 }
2158
2159 TEST_F(PhoneNumberUtilTest, GetNationalDiallingPrefixForRegion) {
2160   string ndd_prefix;
2161   GetNddPrefixForRegion(RegionCode::US(), false, &ndd_prefix);
2162   EXPECT_EQ("1", ndd_prefix);
2163
2164   // Test non-main country to see it gets the national dialling prefix for the
2165   // main country with that country calling code.
2166   GetNddPrefixForRegion(RegionCode::BS(), false, &ndd_prefix);
2167   EXPECT_EQ("1", ndd_prefix);
2168
2169   GetNddPrefixForRegion(RegionCode::NZ(), false, &ndd_prefix);
2170   EXPECT_EQ("0", ndd_prefix);
2171
2172   // Test case with non digit in the national prefix.
2173   GetNddPrefixForRegion(RegionCode::AO(), false, &ndd_prefix);
2174   EXPECT_EQ("0~0", ndd_prefix);
2175
2176   GetNddPrefixForRegion(RegionCode::AO(), true, &ndd_prefix);
2177   EXPECT_EQ("00", ndd_prefix);
2178
2179   // Test cases with invalid regions.
2180   GetNddPrefixForRegion(RegionCode::GetUnknown(), false, &ndd_prefix);
2181   EXPECT_EQ("", ndd_prefix);
2182
2183   GetNddPrefixForRegion(RegionCode::UN001(), false, &ndd_prefix);
2184   EXPECT_EQ("", ndd_prefix);
2185
2186   // CS is already deprecated so the library doesn't support it.
2187   GetNddPrefixForRegion(RegionCode::CS(), false, &ndd_prefix);
2188   EXPECT_EQ("", ndd_prefix);
2189 }
2190
2191 TEST_F(PhoneNumberUtilTest, IsViablePhoneNumber) {
2192   EXPECT_FALSE(IsViablePhoneNumber("1"));
2193   // Only one or two digits before strange non-possible punctuation.
2194   EXPECT_FALSE(IsViablePhoneNumber("1+1+1"));
2195   EXPECT_FALSE(IsViablePhoneNumber("80+0"));
2196   // Two digits is viable.
2197   EXPECT_TRUE(IsViablePhoneNumber("00"));
2198   EXPECT_TRUE(IsViablePhoneNumber("111"));
2199   // Alpha numbers.
2200   EXPECT_TRUE(IsViablePhoneNumber("0800-4-pizza"));
2201   EXPECT_TRUE(IsViablePhoneNumber("0800-4-PIZZA"));
2202   // We need at least three digits before any alpha characters.
2203   EXPECT_FALSE(IsViablePhoneNumber("08-PIZZA"));
2204   EXPECT_FALSE(IsViablePhoneNumber("8-PIZZA"));
2205   EXPECT_FALSE(IsViablePhoneNumber("12. March"));
2206 }
2207
2208 TEST_F(PhoneNumberUtilTest, IsViablePhoneNumberNonAscii) {
2209   // Only one or two digits before possible punctuation followed by more digits.
2210   // The punctuation used here is the unicode character u+3000.
2211   EXPECT_TRUE(IsViablePhoneNumber("1\xE3\x80\x80" "34" /* "1　34" */));
2212   EXPECT_FALSE(IsViablePhoneNumber("1\xE3\x80\x80" "3+4" /* "1　3+4" */));
2213   // Unicode variants of possible starting character and other allowed
2214   // punctuation/digits.
2215   EXPECT_TRUE(IsViablePhoneNumber("\xEF\xBC\x88" "1\xEF\xBC\x89\xE3\x80\x80"
2216                                   "3456789" /* "（1）　3456789" */));
2217   // Testing a leading + is okay.
2218   EXPECT_TRUE(IsViablePhoneNumber("+1\xEF\xBC\x89\xE3\x80\x80"
2219                                   "3456789" /* "+1）　3456789" */));
2220 }
2221
2222 TEST_F(PhoneNumberUtilTest, ConvertAlphaCharactersInNumber) {
2223   string input("1800-ABC-DEF");
2224   phone_util_.ConvertAlphaCharactersInNumber(&input);
2225   // Alpha chars are converted to digits; everything else is left untouched.
2226   static const string kExpectedOutput = "1800-222-333";
2227   EXPECT_EQ(kExpectedOutput, input);
2228
2229   // Try with some non-ASCII characters.
2230   input.assign("1\xE3\x80\x80\xEF\xBC\x88" "800) ABC-DEF"
2231                /* "1　（800) ABCD-DEF" */);
2232   static const string kExpectedFullwidthOutput =
2233       "1\xE3\x80\x80\xEF\xBC\x88" "800) 222-333" /* "1　（800) 222-333" */;
2234   phone_util_.ConvertAlphaCharactersInNumber(&input);
2235   EXPECT_EQ(kExpectedFullwidthOutput, input);
2236 }
2237
2238 TEST_F(PhoneNumberUtilTest, NormaliseRemovePunctuation) {
2239   string input_number("034-56&+#2" "\xC2\xAD" "34");
2240   Normalize(&input_number);
2241   static const string kExpectedOutput("03456234");
2242   EXPECT_EQ(kExpectedOutput, input_number)
2243       << "Conversion did not correctly remove punctuation";
2244 }
2245
2246 TEST_F(PhoneNumberUtilTest, NormaliseReplaceAlphaCharacters) {
2247   string input_number("034-I-am-HUNGRY");
2248   Normalize(&input_number);
2249   static const string kExpectedOutput("034426486479");
2250   EXPECT_EQ(kExpectedOutput, input_number)
2251       << "Conversion did not correctly replace alpha characters";
2252 }
2253
2254 TEST_F(PhoneNumberUtilTest, NormaliseOtherDigits) {
2255   // The first digit is a full-width 2, the last digit is an Arabic-indic digit
2256   // 5.
2257   string input_number("\xEF\xBC\x92" "5\xD9\xA5" /* "２5٥" */);
2258   Normalize(&input_number);
2259   static const string kExpectedOutput("255");
2260   EXPECT_EQ(kExpectedOutput, input_number)
2261       << "Conversion did not correctly replace non-latin digits";
2262   // The first digit is an Eastern-Arabic 5, the latter an Eastern-Arabic 0.
2263   string eastern_arabic_input_number("\xDB\xB5" "2\xDB\xB0" /* "۵2۰" */);
2264   Normalize(&eastern_arabic_input_number);
2265   static const string kExpectedOutput2("520");
2266   EXPECT_EQ(kExpectedOutput2, eastern_arabic_input_number)
2267       << "Conversion did not correctly replace non-latin digits";
2268 }
2269
2270 TEST_F(PhoneNumberUtilTest, NormaliseStripAlphaCharacters) {
2271   string input_number("034-56&+a#234");
2272   phone_util_.NormalizeDigitsOnly(&input_number);
2273   static const string kExpectedOutput("03456234");
2274   EXPECT_EQ(kExpectedOutput, input_number)
2275       << "Conversion did not correctly remove alpha characters";
2276 }
2277
2278 TEST_F(PhoneNumberUtilTest, MaybeStripInternationalPrefix) {
2279   string international_prefix("00[39]");
2280   string number_to_strip("0034567700-3898003");
2281   // Note the dash is removed as part of the normalization.
2282   string stripped_number("45677003898003");
2283   EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
2284       MaybeStripInternationalPrefixAndNormalize(international_prefix,
2285                                                 &number_to_strip));
2286   EXPECT_EQ(stripped_number, number_to_strip)
2287       << "The number was not stripped of its international prefix.";
2288
2289   // Now the number no longer starts with an IDD prefix, so it should now report
2290   // FROM_DEFAULT_COUNTRY.
2291   EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
2292       MaybeStripInternationalPrefixAndNormalize(international_prefix,
2293                                                 &number_to_strip));
2294
2295   number_to_strip.assign("00945677003898003");
2296   EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
2297       MaybeStripInternationalPrefixAndNormalize(international_prefix,
2298                                                 &number_to_strip));
2299   EXPECT_EQ(stripped_number, number_to_strip)
2300       << "The number was not stripped of its international prefix.";
2301
2302   // Test it works when the international prefix is broken up by spaces.
2303   number_to_strip.assign("00 9 45677003898003");
2304   EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD,
2305       MaybeStripInternationalPrefixAndNormalize(international_prefix,
2306                                                 &number_to_strip));
2307   EXPECT_EQ(stripped_number, number_to_strip)
2308       << "The number was not stripped of its international prefix.";
2309   // Now the number no longer starts with an IDD prefix, so it should now report
2310   // FROM_DEFAULT_COUNTRY.
2311   EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
2312       MaybeStripInternationalPrefixAndNormalize(international_prefix,
2313                                                 &number_to_strip));
2314
2315   // Test the + symbol is also recognised and stripped.
2316   number_to_strip.assign("+45677003898003");
2317   stripped_number.assign("45677003898003");
2318   EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
2319       MaybeStripInternationalPrefixAndNormalize(international_prefix,
2320                                                 &number_to_strip));
2321   EXPECT_EQ(stripped_number, number_to_strip)
2322       << "The number supplied was not stripped of the plus symbol.";
2323
2324   // If the number afterwards is a zero, we should not strip this - no country
2325   // code begins with 0.
2326   number_to_strip.assign("0090112-3123");
2327   stripped_number.assign("00901123123");
2328   EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
2329       MaybeStripInternationalPrefixAndNormalize(international_prefix,
2330                                                 &number_to_strip));
2331   EXPECT_EQ(stripped_number, number_to_strip)
2332       << "The number had a 0 after the match so shouldn't be stripped.";
2333   // Here the 0 is separated by a space from the IDD.
2334   number_to_strip.assign("009 0-112-3123");
2335   EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY,
2336       MaybeStripInternationalPrefixAndNormalize(international_prefix,
2337                                                 &number_to_strip));
2338 }
2339
2340 TEST_F(PhoneNumberUtilTest, MaybeStripNationalPrefixAndCarrierCode) {
2341   PhoneMetadata metadata;
2342   metadata.set_national_prefix_for_parsing("34");
2343   metadata.mutable_general_desc()->set_national_number_pattern("\\d{4,8}");
2344   string number_to_strip("34356778");
2345   string stripped_number("356778");
2346   string carrier_code;
2347   MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
2348                                          &carrier_code);
2349   EXPECT_EQ(stripped_number, number_to_strip)
2350       << "Should have had national prefix stripped.";
2351   EXPECT_EQ("", carrier_code) << "Should have had no carrier code stripped.";
2352   // Retry stripping - now the number should not start with the national prefix,
2353   // so no more stripping should occur.
2354   MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
2355                                          &carrier_code);
2356   EXPECT_EQ(stripped_number, number_to_strip)
2357       << "Should have had no change - no national prefix present.";
2358   // Some countries have no national prefix. Repeat test with none specified.
2359   metadata.clear_national_prefix_for_parsing();
2360   MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
2361                                          &carrier_code);
2362   EXPECT_EQ(stripped_number, number_to_strip)
2363       << "Should have had no change - empty national prefix.";
2364   // If the resultant number doesn't match the national rule, it shouldn't be
2365   // stripped.
2366   metadata.set_national_prefix_for_parsing("3");
2367   number_to_strip.assign("3123");
2368   stripped_number.assign("3123");
2369   MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
2370                                          &carrier_code);
2371   EXPECT_EQ(stripped_number, number_to_strip)
2372       << "Should have had no change - after stripping, it wouldn't have "
2373       << "matched the national rule.";
2374   // Test extracting carrier selection code.
2375   metadata.set_national_prefix_for_parsing("0(81)?");
2376   number_to_strip.assign("08122123456");
2377   stripped_number.assign("22123456");
2378   MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
2379                                          &carrier_code);
2380   EXPECT_EQ("81", carrier_code) << "Should have had carrier code stripped.";
2381   EXPECT_EQ(stripped_number, number_to_strip)
2382       << "Should have had national prefix and carrier code stripped.";
2383   // If there was a transform rule, check it was applied.
2384   metadata.set_national_prefix_transform_rule("5$15");
2385   // Note that a capturing group is present here.
2386   metadata.set_national_prefix_for_parsing("0(\\d{2})");
2387   number_to_strip.assign("031123");
2388   string transformed_number("5315123");
2389   MaybeStripNationalPrefixAndCarrierCode(metadata, &number_to_strip,
2390                                          &carrier_code);
2391   EXPECT_EQ(transformed_number, number_to_strip)
2392       << "Was not successfully transformed.";
2393 }
2394
2395 TEST_F(PhoneNumberUtilTest, MaybeStripExtension) {
2396   // One with extension.
2397   string number("1234576 ext. 1234");
2398   string extension;
2399   string expected_extension("1234");
2400   string stripped_number("1234576");
2401   EXPECT_TRUE(MaybeStripExtension(&number, &extension));
2402   EXPECT_EQ(stripped_number, number);
2403   EXPECT_EQ(expected_extension, extension);
2404
2405   // One without extension.
2406   number.assign("1234-576");
2407   extension.clear();
2408   stripped_number.assign("1234-576");
2409   EXPECT_FALSE(MaybeStripExtension(&number, &extension));
2410   EXPECT_EQ(stripped_number, number);
2411   EXPECT_TRUE(extension.empty());
2412
2413   // One with an extension caught by the second capturing group in
2414   // kKnownExtnPatterns.
2415   number.assign("1234576-123#");
2416   extension.clear();
2417   expected_extension.assign("123");
2418   stripped_number.assign("1234576");
2419   EXPECT_TRUE(MaybeStripExtension(&number, &extension));
2420   EXPECT_EQ(stripped_number, number);
2421   EXPECT_EQ(expected_extension, extension);
2422
2423   number.assign("1234576 ext.123#");
2424   extension.clear();
2425   EXPECT_TRUE(MaybeStripExtension(&number, &extension));
2426   EXPECT_EQ(stripped_number, number);
2427   EXPECT_EQ(expected_extension, extension);
2428 }
2429
2430 TEST_F(PhoneNumberUtilTest, MaybeExtractCountryCode) {
2431   PhoneNumber number;
2432   const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::US());
2433   // Note that for the US, the IDD is 011.
2434   string phone_number("011112-3456789");
2435   string stripped_number("123456789");
2436   int expected_country_code = 1;
2437   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2438             MaybeExtractCountryCode(metadata, true, &phone_number, &number));
2439   EXPECT_EQ(expected_country_code, number.country_code());
2440   EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_IDD, number.country_code_source());
2441   EXPECT_EQ(stripped_number, phone_number);
2442
2443   number.Clear();
2444   phone_number.assign("+80012345678");
2445   stripped_number.assign("12345678");
2446   expected_country_code = 800;
2447   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2448             MaybeExtractCountryCode(metadata, true, &phone_number, &number));
2449   EXPECT_EQ(expected_country_code, number.country_code());
2450   EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
2451             number.country_code_source());
2452   EXPECT_EQ(stripped_number, phone_number);
2453
2454   number.Clear();
2455   phone_number.assign("+6423456789");
2456   stripped_number.assign("23456789");
2457   expected_country_code = 64;
2458   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2459             MaybeExtractCountryCode(metadata, true, &phone_number, &number));
2460   EXPECT_EQ(expected_country_code, number.country_code());
2461   EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
2462             number.country_code_source());
2463   EXPECT_EQ(stripped_number, phone_number);
2464
2465   // Should not have extracted a country code - no international prefix present.
2466   number.Clear();
2467   expected_country_code = 0;
2468   phone_number.assign("2345-6789");
2469   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2470             MaybeExtractCountryCode(metadata, true, &phone_number, &number));
2471   EXPECT_EQ(expected_country_code, number.country_code());
2472   EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY, number.country_code_source());
2473   EXPECT_EQ(stripped_number, phone_number);
2474
2475   expected_country_code = 0;
2476   phone_number.assign("0119991123456789");
2477   stripped_number.assign(phone_number);
2478   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
2479             MaybeExtractCountryCode(metadata, true, &phone_number, &number));
2480
2481   number.Clear();
2482   phone_number.assign("(1 610) 619 4466");
2483   stripped_number.assign("6106194466");
2484   expected_country_code = 1;
2485   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2486             MaybeExtractCountryCode(metadata, true, &phone_number, &number));
2487   EXPECT_EQ(expected_country_code, number.country_code());
2488   EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN,
2489             number.country_code_source());
2490   EXPECT_EQ(stripped_number, phone_number);
2491
2492   number.Clear();
2493   phone_number.assign("(1 610) 619 4466");
2494   stripped_number.assign("6106194466");
2495   expected_country_code = 1;
2496   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2497             MaybeExtractCountryCode(metadata, false, &phone_number, &number));
2498   EXPECT_EQ(expected_country_code, number.country_code());
2499   EXPECT_FALSE(number.has_country_code_source());
2500   EXPECT_EQ(stripped_number, phone_number);
2501
2502   // Should not have extracted a country code - invalid number after extraction
2503   // of uncertain country code.
2504   number.Clear();
2505   phone_number.assign("(1 610) 619 446");
2506   stripped_number.assign("1610619446");
2507   expected_country_code = 0;
2508   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2509             MaybeExtractCountryCode(metadata, false, &phone_number, &number));
2510   EXPECT_EQ(expected_country_code, number.country_code());
2511   EXPECT_FALSE(number.has_country_code_source());
2512   EXPECT_EQ(stripped_number, phone_number);
2513
2514   number.Clear();
2515   phone_number.assign("(1 610) 619");
2516   stripped_number.assign("1610619");
2517   expected_country_code = 0;
2518   // Should not have extracted a country code - invalid number both before and
2519   // after extraction of uncertain country code.
2520   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2521             MaybeExtractCountryCode(metadata, true, &phone_number, &number));
2522   EXPECT_EQ(expected_country_code, number.country_code());
2523   EXPECT_EQ(PhoneNumber::FROM_DEFAULT_COUNTRY, number.country_code_source());
2524   EXPECT_EQ(stripped_number, phone_number);
2525 }
2526
2527 TEST_F(PhoneNumberUtilTest, CountryWithNoNumberDesc) {
2528   string formatted_number;
2529   // Andorra is a country where we don't have PhoneNumberDesc info in the
2530   // metadata.
2531   PhoneNumber ad_number;
2532   ad_number.set_country_code(376);
2533   ad_number.set_national_number(12345ULL);
2534   phone_util_.Format(ad_number, PhoneNumberUtil::INTERNATIONAL,
2535                      &formatted_number);
2536   EXPECT_EQ("+376 12345", formatted_number);
2537   phone_util_.Format(ad_number, PhoneNumberUtil::E164, &formatted_number);
2538   EXPECT_EQ("+37612345", formatted_number);
2539   phone_util_.Format(ad_number, PhoneNumberUtil::NATIONAL, &formatted_number);
2540   EXPECT_EQ("12345", formatted_number);
2541   EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(ad_number));
2542   EXPECT_TRUE(phone_util_.IsValidNumber(ad_number));
2543
2544   // Test dialing a US number from within Andorra.
2545   PhoneNumber us_number;
2546   us_number.set_country_code(1);
2547   us_number.set_national_number(6502530000ULL);
2548   phone_util_.FormatOutOfCountryCallingNumber(us_number, RegionCode::AD(),
2549                                               &formatted_number);
2550   EXPECT_EQ("00 1 650 253 0000", formatted_number);
2551 }
2552
2553 TEST_F(PhoneNumberUtilTest, UnknownCountryCallingCode) {
2554   PhoneNumber invalid_number;
2555   invalid_number.set_country_code(kInvalidCountryCode);
2556   invalid_number.set_national_number(12345ULL);
2557
2558   EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
2559
2560   // It's not very well defined as to what the E164 representation for a number
2561   // with an invalid country calling code is, but just prefixing the country
2562   // code and national number is about the best we can do.
2563   string formatted_number;
2564   phone_util_.Format(invalid_number, PhoneNumberUtil::E164, &formatted_number);
2565   EXPECT_EQ("+212345", formatted_number);
2566 }
2567
2568 TEST_F(PhoneNumberUtilTest, IsNumberMatchMatches) {
2569   // Test simple matches where formatting is different, or leading zeroes, or
2570   // country code has been specified.
2571   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2572             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331 6005",
2573                                                     "+64 03 331 6005"));
2574   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2575             phone_util_.IsNumberMatchWithTwoStrings("+800 1234 5678",
2576                                                     "+80012345678"));
2577   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2578             phone_util_.IsNumberMatchWithTwoStrings("+64 03 331-6005",
2579                                                     "+64 03331 6005"));
2580   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2581             phone_util_.IsNumberMatchWithTwoStrings("+643 331-6005",
2582                                                     "+64033316005"));
2583   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2584             phone_util_.IsNumberMatchWithTwoStrings("+643 331-6005",
2585                                                     "+6433316005"));
2586   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2587             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2588                                                     "+6433316005"));
2589   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2590             phone_util_.IsNumberMatchWithTwoStrings(
2591                 "+64 3 331-6005", "tel:+64-3-331-6005;isub=123"));
2592   // Test alpha numbers.
2593   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2594             phone_util_.IsNumberMatchWithTwoStrings("+1800 siX-Flags",
2595                                                     "+1 800 7493 5247"));
2596   // Test numbers with extensions.
2597   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2598             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 extn 1234",
2599                                                     "+6433316005#1234"));
2600   // Test proto buffers.
2601   PhoneNumber nz_number;
2602   nz_number.set_country_code(64);
2603   nz_number.set_national_number(33316005ULL);
2604   nz_number.set_extension("3456");
2605   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2606             phone_util_.IsNumberMatchWithOneString(nz_number,
2607                                                    "+643 331 6005 ext 3456"));
2608   nz_number.clear_extension();
2609   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2610             phone_util_.IsNumberMatchWithOneString(nz_number,
2611                                                    "+643 331 6005"));
2612   // Check empty extensions are ignored.
2613   nz_number.set_extension("");
2614   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2615             phone_util_.IsNumberMatchWithOneString(nz_number,
2616                                                    "+643 331 6005"));
2617   // Check variant with two proto buffers.
2618   PhoneNumber nz_number_2;
2619   nz_number_2.set_country_code(64);
2620   nz_number_2.set_national_number(33316005ULL);
2621   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2622             phone_util_.IsNumberMatch(nz_number, nz_number_2));
2623
2624   // Check raw_input, country_code_source and preferred_domestic_carrier_code
2625   // are ignored.
2626   PhoneNumber br_number_1;
2627   PhoneNumber br_number_2;
2628   br_number_1.set_country_code(55);
2629   br_number_1.set_national_number(3121286979ULL);
2630   br_number_1.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
2631   br_number_1.set_preferred_domestic_carrier_code("12");
2632   br_number_1.set_raw_input("012 3121286979");
2633   br_number_2.set_country_code(55);
2634   br_number_2.set_national_number(3121286979ULL);
2635   br_number_2.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
2636   br_number_2.set_preferred_domestic_carrier_code("14");
2637   br_number_2.set_raw_input("143121286979");
2638   EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
2639             phone_util_.IsNumberMatch(br_number_1, br_number_2));
2640 }
2641
2642 TEST_F(PhoneNumberUtilTest, IsNumberMatchNonMatches) {
2643   // NSN matches.
2644   EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2645             phone_util_.IsNumberMatchWithTwoStrings("03 331 6005",
2646                                                     "03 331 6006"));
2647   EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2648             phone_util_.IsNumberMatchWithTwoStrings("+800 1234 5678",
2649                                                     "+1 800 1234 5678"));
2650   // Different country code, partial number match.
2651   EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2652             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2653                                                     "+16433316005"));
2654   // Different country code, same number.
2655   EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2656             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2657                                                     "+6133316005"));
2658   // Extension different, all else the same.
2659   EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2660             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 extn 1234",
2661                                                     "+0116433316005#1235"));
2662   EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2663             phone_util_.IsNumberMatchWithTwoStrings(
2664                 "+64 3 331-6005 extn 1234", "tel:+64-3-331-6005;ext=1235"));
2665   // NSN matches, but extension is different - not the same number.
2666   EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
2667             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 ext.1235",
2668                                                     "3 331 6005#1234"));
2669   // Invalid numbers that can't be parsed.
2670   EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
2671             phone_util_.IsNumberMatchWithTwoStrings("4", "3 331 6043"));
2672   // Invalid numbers that can't be parsed.
2673   EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
2674             phone_util_.IsNumberMatchWithTwoStrings("+43", "+64 3 331 6005"));
2675   EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
2676             phone_util_.IsNumberMatchWithTwoStrings("+43", "64 3 331 6005"));
2677   EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
2678             phone_util_.IsNumberMatchWithTwoStrings("Dog", "64 3 331 6005"));
2679 }
2680
2681 TEST_F(PhoneNumberUtilTest, IsNumberMatchNsnMatches) {
2682   // NSN matches.
2683   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2684             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2685                                                     "03 331 6005"));
2686   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2687             phone_util_.IsNumberMatchWithTwoStrings(
2688                 "+64 3 331-6005",
2689                 "tel:03-331-6005;isub=1234;phone-context=abc.nz"));
2690
2691   PhoneNumber nz_number;
2692   nz_number.set_country_code(64);
2693   nz_number.set_national_number(33316005ULL);
2694   nz_number.set_extension("");
2695   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2696             phone_util_.IsNumberMatchWithOneString(nz_number, "03 331 6005"));
2697   // Here the second number possibly starts with the country code for New
2698   // Zealand, although we are unsure.
2699   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2700             phone_util_.IsNumberMatchWithOneString(nz_number,
2701                                                    "(64-3) 331 6005"));
2702
2703   // Here, the 1 might be a national prefix, if we compare it to the US number,
2704   // so the resultant match is an NSN match.
2705   PhoneNumber us_number;
2706   us_number.set_country_code(1);
2707   us_number.set_national_number(2345678901ULL);
2708   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2709             phone_util_.IsNumberMatchWithOneString(us_number,
2710                                                    "1-234-567-8901"));
2711   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2712             phone_util_.IsNumberMatchWithOneString(us_number, "2345678901"));
2713   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2714             phone_util_.IsNumberMatchWithTwoStrings("+1 234-567 8901",
2715                                                     "1 234 567 8901"));
2716   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2717             phone_util_.IsNumberMatchWithTwoStrings("1 234-567 8901",
2718                                                     "1 234 567 8901"));
2719   EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
2720             phone_util_.IsNumberMatchWithTwoStrings("1 234-567 8901",
2721                                                     "+1 234 567 8901"));
2722   // For this case, the match will be a short NSN match, because we cannot
2723   // assume that the 1 might be a national prefix, so don't remove it when
2724   // parsing.
2725   PhoneNumber random_number;
2726   random_number.set_country_code(41);
2727   random_number.set_national_number(2345678901ULL);
2728   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2729             phone_util_.IsNumberMatchWithOneString(random_number,
2730                                                    "1-234-567-8901"));
2731 }
2732
2733 TEST_F(PhoneNumberUtilTest, IsNumberMatchShortNsnMatches) {
2734   // Short NSN matches with the country not specified for either one or both
2735   // numbers.
2736   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2737             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2738                                                     "331 6005"));
2739   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2740             phone_util_.IsNumberMatchWithTwoStrings(
2741                 "+64 3 331-6005", "tel:331-6005;phone-context=abc.nz"));
2742   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2743               phone_util_.IsNumberMatchWithTwoStrings(
2744                   "+64 3 331-6005",
2745                   "tel:331-6005;isub=1234;phone-context=abc.nz"));
2746   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2747               phone_util_.IsNumberMatchWithTwoStrings(
2748                   "+64 3 331-6005",
2749                   "tel:331-6005;isub=1234;phone-context=abc.nz;a=%A1"));
2750
2751   // We did not know that the "0" was a national prefix since neither number has
2752   // a country code, so this is considered a SHORT_NSN_MATCH.
2753   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2754             phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
2755                                                     "03 331 6005"));
2756
2757   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2758               phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
2759                                                       "331 6005"));
2760
2761   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2762               phone_util_.IsNumberMatchWithTwoStrings(
2763                   "3 331-6005", "tel:331-6005;phone-context=abc.nz"));
2764   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2765             phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
2766                                                     "+64 331 6005"));
2767
2768   // Short NSN match with the country specified.
2769   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2770             phone_util_.IsNumberMatchWithTwoStrings("03 331-6005",
2771                                                     "331 6005"));
2772
2773   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2774               phone_util_.IsNumberMatchWithTwoStrings("1 234 345 6789",
2775                                                       "345 6789"));
2776
2777   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2778             phone_util_.IsNumberMatchWithTwoStrings("+1 (234) 345 6789",
2779                                                     "345 6789"));
2780
2781   // NSN matches, country code omitted for one number, extension missing for
2782   // one.
2783   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2784             phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
2785                                                     "3 331 6005#1234"));
2786
2787   // One has Italian leading zero, one does not.
2788   PhoneNumber it_number_1, it_number_2;
2789   it_number_1.set_country_code(39);
2790   it_number_1.set_national_number(1234ULL);
2791   it_number_1.set_italian_leading_zero(true);
2792   it_number_2.set_country_code(39);
2793   it_number_2.set_national_number(1234ULL);
2794   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2795             phone_util_.IsNumberMatch(it_number_1, it_number_2));
2796
2797   // One has an extension, the other has an extension of "".
2798   it_number_1.set_extension("1234");
2799   it_number_1.clear_italian_leading_zero();
2800   it_number_2.set_extension("");
2801   EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
2802             phone_util_.IsNumberMatch(it_number_1, it_number_2));
2803 }
2804
2805 TEST_F(PhoneNumberUtilTest, ParseNationalNumber) {
2806   PhoneNumber nz_number;
2807   nz_number.set_country_code(64);
2808   nz_number.set_national_number(33316005ULL);
2809   PhoneNumber test_number;
2810   // National prefix attached.
2811   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2812             phone_util_.Parse("033316005", RegionCode::NZ(), &test_number));
2813   EXPECT_EQ(nz_number, test_number);
2814   // National prefix missing.
2815   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2816             phone_util_.Parse("33316005", RegionCode::NZ(), &test_number));
2817   EXPECT_EQ(nz_number, test_number);
2818   // National prefix attached and some formatting present.
2819   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2820             phone_util_.Parse("03-331 6005", RegionCode::NZ(), &test_number));
2821   EXPECT_EQ(nz_number, test_number);
2822   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2823             phone_util_.Parse("03 331 6005", RegionCode::NZ(), &test_number));
2824   EXPECT_EQ(nz_number, test_number);
2825   // Test parsing RFC3966 format with a phone context.
2826   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2827             phone_util_.Parse("tel:03-331-6005;phone-context=+64",
2828                               RegionCode::NZ(), &test_number));
2829   EXPECT_EQ(nz_number, test_number);
2830   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2831             phone_util_.Parse("tel:331-6005;phone-context=+64-3",
2832                               RegionCode::NZ(), &test_number));
2833   EXPECT_EQ(nz_number, test_number);
2834   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2835             phone_util_.Parse("tel:331-6005;phone-context=+64-3",
2836                               RegionCode::US(), &test_number));
2837   EXPECT_EQ(nz_number, test_number);
2838   // Test parsing RFC3966 format with optional user-defined parameters. The
2839   // parameters will appear after the context if present.
2840   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2841             phone_util_.Parse("tel:03-331-6005;phone-context=+64;a=%A1",
2842                               RegionCode::NZ(), &test_number));
2843   EXPECT_EQ(nz_number, test_number);
2844   // Test parsing RFC3966 with an ISDN subaddress.
2845   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2846             phone_util_.Parse("tel:03-331-6005;isub=12345;phone-context=+64",
2847                               RegionCode::NZ(), &test_number));
2848   EXPECT_EQ(nz_number, test_number);
2849   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2850             phone_util_.Parse("tel:+64-3-331-6005;isub=12345",
2851                               RegionCode::US(), &test_number));
2852   EXPECT_EQ(nz_number, test_number);
2853   // Testing international prefixes.
2854   // Should strip country code.
2855   test_number.Clear();
2856   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2857             phone_util_.Parse("0064 3 331 6005",
2858                               RegionCode::NZ(), &test_number));
2859   EXPECT_EQ(nz_number, test_number);
2860   // Try again, but this time we have an international number with Region Code
2861   // US. It should recognise the country code and parse accordingly.
2862   test_number.Clear();
2863   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2864             phone_util_.Parse("01164 3 331 6005",
2865                               RegionCode::US(), &test_number));
2866   EXPECT_EQ(nz_number, test_number);
2867   test_number.Clear();
2868   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2869             phone_util_.Parse("+64 3 331 6005",
2870                               RegionCode::US(), &test_number));
2871   EXPECT_EQ(nz_number, test_number);
2872   // We should ignore the leading plus here, since it is not followed by a valid
2873   // country code but instead is followed by the IDD for the US.
2874   test_number.Clear();
2875   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2876             phone_util_.Parse("+01164 3 331 6005",
2877                               RegionCode::US(), &test_number));
2878   EXPECT_EQ(nz_number, test_number);
2879   test_number.Clear();
2880   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2881             phone_util_.Parse("+0064 3 331 6005",
2882                               RegionCode::NZ(), &test_number));
2883   EXPECT_EQ(nz_number, test_number);
2884   test_number.Clear();
2885   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2886             phone_util_.Parse("+ 00 64 3 331 6005",
2887                               RegionCode::NZ(), &test_number));
2888   EXPECT_EQ(nz_number, test_number);
2889
2890   PhoneNumber us_local_number;
2891   us_local_number.set_country_code(1);
2892   us_local_number.set_national_number(2530000ULL);
2893   test_number.Clear();
2894   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2895             phone_util_.Parse("tel:253-0000;phone-context=www.google.com",
2896                               RegionCode::US(), &test_number));
2897   EXPECT_EQ(us_local_number, test_number);
2898   test_number.Clear();
2899   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2900             phone_util_.Parse(
2901                 "tel:253-0000;isub=12345;phone-context=www.google.com",
2902                 RegionCode::US(), &test_number));
2903   EXPECT_EQ(us_local_number, test_number);
2904   // This is invalid because no "+" sign is present as part of phone-context.
2905   // The phone context is simply ignored in this case just as if it contains a
2906   // domain.
2907   test_number.Clear();
2908   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2909             phone_util_.Parse("tel:2530000;isub=12345;phone-context=1-650",
2910                               RegionCode::US(), &test_number));
2911   EXPECT_EQ(us_local_number, test_number);
2912   test_number.Clear();
2913   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2914             phone_util_.Parse("tel:2530000;isub=12345;phone-context=1234.com",
2915                               RegionCode::US(), &test_number));
2916   EXPECT_EQ(us_local_number, test_number);
2917
2918   // Test for http://b/issue?id=2247493
2919   nz_number.Clear();
2920   nz_number.set_country_code(64);
2921   nz_number.set_national_number(64123456ULL);
2922   test_number.Clear();
2923   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2924             phone_util_.Parse("+64(0)64123456",
2925                               RegionCode::US(), &test_number));
2926   EXPECT_EQ(nz_number, test_number);
2927
2928   // Check that using a "/" is fine in a phone number.
2929   PhoneNumber de_number;
2930   de_number.set_country_code(49);
2931   de_number.set_national_number(12345678ULL);
2932   test_number.Clear();
2933   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2934             phone_util_.Parse("123/45678", RegionCode::DE(), &test_number));
2935   EXPECT_EQ(de_number, test_number);
2936
2937   PhoneNumber us_number;
2938   us_number.set_country_code(1);
2939   // Check it doesn't use the '1' as a country code when parsing if the phone
2940   // number was already possible.
2941   us_number.set_national_number(1234567890ULL);
2942   test_number.Clear();
2943   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2944             phone_util_.Parse("123-456-7890", RegionCode::US(), &test_number));
2945   EXPECT_EQ(us_number, test_number);
2946
2947   // Test star numbers. Although this is not strictly valid, we would like to
2948   // make sure we can parse the output we produce when formatting the number.
2949   PhoneNumber star_number;
2950   star_number.set_country_code(81);
2951   star_number.set_national_number(2345ULL);
2952   test_number.Clear();
2953   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2954             phone_util_.Parse("+81 *2345", RegionCode::JP(), &test_number));
2955   EXPECT_EQ(star_number, test_number);
2956
2957   PhoneNumber short_number;
2958   short_number.set_country_code(64);
2959   short_number.set_national_number(12ULL);
2960   test_number.Clear();
2961   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2962             phone_util_.Parse("12", RegionCode::NZ(), &test_number));
2963   EXPECT_EQ(short_number, test_number);
2964 }
2965
2966 TEST_F(PhoneNumberUtilTest, ParseNumberWithAlphaCharacters) {
2967   // Test case with alpha characters.
2968   PhoneNumber test_number;
2969   PhoneNumber tollfree_number;
2970   tollfree_number.set_country_code(64);
2971   tollfree_number.set_national_number(800332005ULL);
2972   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2973             phone_util_.Parse("0800 DDA 005", RegionCode::NZ(), &test_number));
2974   EXPECT_EQ(tollfree_number, test_number);
2975
2976   test_number.Clear();
2977   PhoneNumber premium_number;
2978   premium_number.set_country_code(64);
2979   premium_number.set_national_number(9003326005ULL);
2980   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2981             phone_util_.Parse("0900 DDA 6005", RegionCode::NZ(), &test_number));
2982   EXPECT_EQ(premium_number, test_number);
2983
2984   // Not enough alpha characters for them to be considered intentional, so they
2985   // are stripped.
2986   test_number.Clear();
2987   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2988             phone_util_.Parse("0900 332 6005a",
2989                               RegionCode::NZ(), &test_number));
2990   EXPECT_EQ(premium_number, test_number);
2991   test_number.Clear();
2992   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2993             phone_util_.Parse("0900 332 600a5",
2994                               RegionCode::NZ(), &test_number));
2995   EXPECT_EQ(premium_number, test_number);
2996
2997   test_number.Clear();
2998   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
2999             phone_util_.Parse("0900 332 600A5",
3000                               RegionCode::NZ(), &test_number));
3001   EXPECT_EQ(premium_number, test_number);
3002
3003   test_number.Clear();
3004   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3005             phone_util_.Parse("0900 a332 600A5",
3006                               RegionCode::NZ(), &test_number));
3007   EXPECT_EQ(premium_number, test_number);
3008 }
3009
3010 TEST_F(PhoneNumberUtilTest, ParseWithInternationalPrefixes) {
3011   PhoneNumber us_number;
3012   us_number.set_country_code(1);
3013   us_number.set_national_number(6503336000ULL);
3014   PhoneNumber test_number;
3015   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3016             phone_util_.Parse("+1 (650) 333-6000",
3017                               RegionCode::US(), &test_number));
3018   EXPECT_EQ(us_number, test_number);
3019   test_number.Clear();
3020   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3021             phone_util_.Parse("+1-650-333-6000",
3022                               RegionCode::US(), &test_number));
3023   EXPECT_EQ(us_number, test_number);
3024
3025   // Calling the US number from Singapore by using different service providers
3026   // 1st test: calling using SingTel IDD service (IDD is 001)
3027   test_number.Clear();
3028   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3029             phone_util_.Parse("0011-650-333-6000",
3030                               RegionCode::SG(), &test_number));
3031   EXPECT_EQ(us_number, test_number);
3032   // 2nd test: calling using StarHub IDD service (IDD is 008)
3033   test_number.Clear();
3034   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3035             phone_util_.Parse("0081-650-333-6000",
3036                               RegionCode::SG(), &test_number));
3037   EXPECT_EQ(us_number, test_number);
3038   // 3rd test: calling using SingTel V019 service (IDD is 019)
3039   test_number.Clear();
3040   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3041             phone_util_.Parse("0191-650-333-6000",
3042                               RegionCode::SG(), &test_number));
3043   EXPECT_EQ(us_number, test_number);
3044   // Calling the US number from Poland
3045   test_number.Clear();
3046   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3047             phone_util_.Parse("0~01-650-333-6000",
3048                               RegionCode::PL(), &test_number));
3049   EXPECT_EQ(us_number, test_number);
3050
3051   // Using "++" at the start.
3052   test_number.Clear();
3053   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3054             phone_util_.Parse("++1 (650) 333-6000",
3055                               RegionCode::PL(), &test_number));
3056   EXPECT_EQ(us_number, test_number);
3057   // Using a full-width plus sign.
3058   test_number.Clear();
3059   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3060             phone_util_.Parse("\xEF\xBC\x8B" "1 (650) 333-6000",
3061                               /* "＋1 (650) 333-6000" */
3062                               RegionCode::SG(), &test_number));
3063   // Using a soft hyphen U+00AD.
3064   test_number.Clear();
3065   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3066             phone_util_.Parse("1 (650) 333" "\xC2\xAD" "-6000",
3067                               /* "1 (650) 333-6000" */
3068                               RegionCode::US(), &test_number));
3069   EXPECT_EQ(us_number, test_number);
3070   // The whole number, including punctuation, is here represented in full-width
3071   // form.
3072   test_number.Clear();
3073   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3074             phone_util_.Parse("\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88"
3075                               "\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89"
3076                               "\xE3\x80\x80\xEF\xBC\x93\xEF\xBC\x93\xEF\xBC\x93"
3077                               "\xEF\xBC\x8D\xEF\xBC\x96\xEF\xBC\x90\xEF\xBC\x90"
3078                               "\xEF\xBC\x90",
3079                               /* "＋１　（６５０）　３３３－６０００" */
3080                               RegionCode::SG(), &test_number));
3081   EXPECT_EQ(us_number, test_number);
3082
3083   // Using the U+30FC dash.
3084   test_number.Clear();
3085   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3086             phone_util_.Parse("\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88"
3087                               "\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89"
3088                               "\xE3\x80\x80\xEF\xBC\x93\xEF\xBC\x93\xEF\xBC\x93"
3089                               "\xE3\x83\xBC\xEF\xBC\x96\xEF\xBC\x90\xEF\xBC\x90"
3090                               "\xEF\xBC\x90",
3091                               /* "＋１　（６５０）　３３３ー６０００" */
3092                               RegionCode::SG(), &test_number));
3093   EXPECT_EQ(us_number, test_number);
3094
3095   PhoneNumber toll_free_number;
3096   toll_free_number.set_country_code(800);
3097   toll_free_number.set_national_number(12345678ULL);
3098   test_number.Clear();
3099   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3100             phone_util_.Parse("011 800 1234 5678",
3101                               RegionCode::US(), &test_number));
3102   EXPECT_EQ(toll_free_number, test_number);
3103 }
3104
3105 TEST_F(PhoneNumberUtilTest, ParseWithLeadingZero) {
3106   PhoneNumber it_number;
3107   it_number.set_country_code(39);
3108   it_number.set_national_number(236618300ULL);
3109   it_number.set_italian_leading_zero(true);
3110   PhoneNumber test_number;
3111   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3112             phone_util_.Parse("+39 02-36618 300",
3113                               RegionCode::NZ(), &test_number));
3114   EXPECT_EQ(it_number, test_number);
3115   test_number.Clear();
3116   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3117             phone_util_.Parse("02-36618 300", RegionCode::IT(), &test_number));
3118   EXPECT_EQ(it_number, test_number);
3119
3120   it_number.Clear();
3121   it_number.set_country_code(39);
3122   it_number.set_national_number(312345678ULL);
3123   test_number.Clear();
3124   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3125             phone_util_.Parse("312 345 678", RegionCode::IT(), &test_number));
3126   EXPECT_EQ(it_number, test_number);
3127 }
3128
3129 TEST_F(PhoneNumberUtilTest, ParseNationalNumberArgentina) {
3130   // Test parsing mobile numbers of Argentina.
3131   PhoneNumber ar_number;
3132   ar_number.set_country_code(54);
3133   ar_number.set_national_number(93435551212ULL);
3134   PhoneNumber test_number;
3135   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3136             phone_util_.Parse("+54 9 343 555 1212", RegionCode::AR(),
3137                               &test_number));
3138   EXPECT_EQ(ar_number, test_number);
3139   test_number.Clear();
3140   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3141             phone_util_.Parse("0343 15 555 1212", RegionCode::AR(),
3142                               &test_number));
3143   EXPECT_EQ(ar_number, test_number);
3144
3145   ar_number.set_national_number(93715654320ULL);
3146   test_number.Clear();
3147   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3148             phone_util_.Parse("+54 9 3715 65 4320", RegionCode::AR(),
3149                               &test_number));
3150   EXPECT_EQ(ar_number, test_number);
3151   test_number.Clear();
3152   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3153             phone_util_.Parse("03715 15 65 4320", RegionCode::AR(),
3154                               &test_number));
3155   EXPECT_EQ(ar_number, test_number);
3156
3157   // Test parsing fixed-line numbers of Argentina.
3158   ar_number.set_national_number(1137970000ULL);
3159   test_number.Clear();
3160   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3161             phone_util_.Parse("+54 11 3797 0000", RegionCode::AR(),
3162                               &test_number));
3163   EXPECT_EQ(ar_number, test_number);
3164   test_number.Clear();
3165   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3166             phone_util_.Parse("011 3797 0000", RegionCode::AR(), &test_number));
3167   EXPECT_EQ(ar_number, test_number);
3168
3169   ar_number.set_national_number(3715654321ULL);
3170   test_number.Clear();
3171   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3172             phone_util_.Parse("+54 3715 65 4321", RegionCode::AR(),
3173                               &test_number));
3174   EXPECT_EQ(ar_number, test_number);
3175   test_number.Clear();
3176   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3177             phone_util_.Parse("03715 65 4321", RegionCode::AR(), &test_number));
3178   EXPECT_EQ(ar_number, test_number);
3179
3180   ar_number.set_national_number(2312340000ULL);
3181   test_number.Clear();
3182   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3183             phone_util_.Parse("+54 23 1234 0000", RegionCode::AR(),
3184                               &test_number));
3185   EXPECT_EQ(ar_number, test_number);
3186   test_number.Clear();
3187   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3188             phone_util_.Parse("023 1234 0000", RegionCode::AR(), &test_number));
3189   EXPECT_EQ(ar_number, test_number);
3190 }
3191
3192 TEST_F(PhoneNumberUtilTest, ParseWithXInNumber) {
3193   // Test that having an 'x' in the phone number at the start is ok and that it
3194   // just gets removed.
3195   PhoneNumber ar_number;
3196   ar_number.set_country_code(54);
3197   ar_number.set_national_number(123456789ULL);
3198   PhoneNumber test_number;
3199   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3200             phone_util_.Parse("0123456789", RegionCode::AR(), &test_number));
3201   EXPECT_EQ(ar_number, test_number);
3202   test_number.Clear();
3203   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3204             phone_util_.Parse("(0) 123456789", RegionCode::AR(), &test_number));
3205   EXPECT_EQ(ar_number, test_number);
3206   test_number.Clear();
3207   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3208             phone_util_.Parse("0 123456789", RegionCode::AR(), &test_number));
3209   EXPECT_EQ(ar_number, test_number);
3210   test_number.Clear();
3211   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3212             phone_util_.Parse("(0xx) 123456789", RegionCode::AR(),
3213                               &test_number));
3214   EXPECT_EQ(ar_number, test_number);
3215
3216   PhoneNumber ar_from_us;
3217   ar_from_us.set_country_code(54);
3218   ar_from_us.set_national_number(81429712ULL);
3219   // This test is intentionally constructed such that the number of digit after
3220   // xx is larger than 7, so that the number won't be mistakenly treated as an
3221   // extension, as we allow extensions up to 7 digits. This assumption is okay
3222   // for now as all the countries where a carrier selection code is written in
3223   // the form of xx have a national significant number of length larger than 7.
3224   test_number.Clear();
3225   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3226             phone_util_.Parse("011xx5481429712", RegionCode::US(),
3227                               &test_number));
3228   EXPECT_EQ(ar_from_us, test_number);
3229 }
3230
3231 TEST_F(PhoneNumberUtilTest, ParseNumbersMexico) {
3232   // Test parsing fixed-line numbers of Mexico.
3233   PhoneNumber mx_number;
3234
3235   mx_number.set_country_code(52);
3236   mx_number.set_national_number(4499780001ULL);
3237   PhoneNumber test_number;
3238   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3239             phone_util_.Parse("+52 (449)978-0001", RegionCode::MX(),
3240                               &test_number));
3241   EXPECT_EQ(mx_number, test_number);
3242   test_number.Clear();
3243   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3244             phone_util_.Parse("01 (449)978-0001", RegionCode::MX(),
3245                               &test_number));
3246   EXPECT_EQ(mx_number, test_number);
3247   test_number.Clear();
3248   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3249             phone_util_.Parse("(449)978-0001", RegionCode::MX(),
3250                               &test_number));
3251   EXPECT_EQ(mx_number, test_number);
3252
3253   // Test parsing mobile numbers of Mexico.
3254   mx_number.Clear();
3255   mx_number.set_country_code(52);
3256   mx_number.set_national_number(13312345678ULL);
3257   test_number.Clear();
3258   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3259             phone_util_.Parse("+52 1 33 1234-5678", RegionCode::MX(),
3260                               &test_number));
3261   EXPECT_EQ(mx_number, test_number);
3262   test_number.Clear();
3263   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3264             phone_util_.Parse("044 (33) 1234-5678", RegionCode::MX(),
3265                               &test_number));
3266   EXPECT_EQ(mx_number, test_number);
3267   test_number.Clear();
3268   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3269             phone_util_.Parse("045 33 1234-5678", RegionCode::MX(),
3270                               &test_number));
3271   EXPECT_EQ(mx_number, test_number);
3272 }
3273
3274 TEST_F(PhoneNumberUtilTest, FailedParseOnInvalidNumbers) {
3275   PhoneNumber test_number;
3276   EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3277             phone_util_.Parse("This is not a phone number", RegionCode::NZ(),
3278                               &test_number));
3279   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3280
3281   EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3282             phone_util_.Parse("1 Still not a number", RegionCode::NZ(),
3283                               &test_number));
3284   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3285
3286   EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3287             phone_util_.Parse("1 MICROSOFT", RegionCode::NZ(),
3288                               &test_number));
3289   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3290
3291   EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3292             phone_util_.Parse("12 MICROSOFT", RegionCode::NZ(),
3293                               &test_number));
3294   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3295
3296   EXPECT_EQ(PhoneNumberUtil::TOO_LONG_NSN,
3297             phone_util_.Parse("01495 72553301873 810104", RegionCode::GB(),
3298                               &test_number));
3299   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3300
3301   EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3302             phone_util_.Parse("+---", RegionCode::DE(),
3303                               &test_number));
3304   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3305
3306   EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3307             phone_util_.Parse("+***", RegionCode::DE(),
3308                               &test_number));
3309   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3310
3311   EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
3312             phone_util_.Parse("+*******91", RegionCode::DE(),
3313                               &test_number));
3314   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3315
3316   EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_NSN,
3317             phone_util_.Parse("+49 0", RegionCode::DE(),
3318                               &test_number));
3319   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3320
3321   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
3322             phone_util_.Parse("+210 3456 56789", RegionCode::NZ(),
3323                               &test_number));
3324   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3325
3326   // 00 is a correct IDD, but 210 is not a valid country code.
3327   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
3328             phone_util_.Parse("+ 00 210 3 331 6005", RegionCode::NZ(),
3329                               &test_number));
3330   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3331
3332   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
3333             phone_util_.Parse("123 456 7890", RegionCode::GetUnknown(),
3334                               &test_number));
3335   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3336
3337   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
3338             phone_util_.Parse("123 456 7890", RegionCode::CS(),
3339                               &test_number));
3340   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3341
3342   EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
3343             phone_util_.Parse("0044-----", RegionCode::GB(),
3344                               &test_number));
3345   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3346   EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
3347             phone_util_.Parse("0044", RegionCode::GB(),
3348                               &test_number));
3349   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3350
3351   EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
3352             phone_util_.Parse("011", RegionCode::US(),
3353                               &test_number));
3354   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3355   EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_AFTER_IDD,
3356             phone_util_.Parse("0119", RegionCode::US(),
3357                               &test_number));
3358   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3359
3360   // RFC3966 phone-context is a website.
3361   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
3362             phone_util_.Parse("tel:555-1234;phone-context=www.google.com",
3363                               RegionCode::ZZ(), &test_number));
3364   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3365   // This is invalid because no "+" sign is present as part of phone-context.
3366   // This should not succeed in being parsed.
3367   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
3368             phone_util_.Parse("tel:555-1234;phone-context=1-331",
3369                               RegionCode::ZZ(), &test_number));
3370   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3371 }
3372
3373 TEST_F(PhoneNumberUtilTest, ParseNumbersWithPlusWithNoRegion) {
3374   PhoneNumber nz_number;
3375   nz_number.set_country_code(64);
3376   nz_number.set_national_number(33316005ULL);
3377   // RegionCode::GetUnknown() is allowed only if the number starts with a '+' -
3378   // then the country code can be calculated.
3379   PhoneNumber result_proto;
3380   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3381             phone_util_.Parse("+64 3 331 6005", RegionCode::GetUnknown(),
3382                               &result_proto));
3383   EXPECT_EQ(nz_number, result_proto);
3384
3385   // Test with full-width plus.
3386   result_proto.Clear();
3387   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3388             phone_util_.Parse("\xEF\xBC\x8B" "64 3 331 6005",
3389                               /* "＋64 3 331 6005" */
3390                               RegionCode::GetUnknown(), &result_proto));
3391   EXPECT_EQ(nz_number, result_proto);
3392   // Test with normal plus but leading characters that need to be stripped.
3393   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3394             phone_util_.Parse("  +64 3 331 6005", RegionCode::GetUnknown(),
3395                               &result_proto));
3396   EXPECT_EQ(nz_number, result_proto);
3397
3398   PhoneNumber toll_free_number;
3399   toll_free_number.set_country_code(800);
3400   toll_free_number.set_national_number(12345678ULL);
3401   result_proto.Clear();
3402   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3403             phone_util_.Parse("+800 1234 5678",
3404                               RegionCode::GetUnknown(), &result_proto));
3405   EXPECT_EQ(toll_free_number, result_proto);
3406
3407   PhoneNumber universal_premium_rate;
3408   universal_premium_rate.set_country_code(979);
3409   universal_premium_rate.set_national_number(123456789ULL);
3410   result_proto.Clear();
3411   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3412             phone_util_.Parse("+979 123 456 789",
3413                               RegionCode::GetUnknown(), &result_proto));
3414   EXPECT_EQ(universal_premium_rate, result_proto);
3415
3416   result_proto.Clear();
3417   // Test parsing RFC3966 format with a phone context.
3418   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3419             phone_util_.Parse("tel:03-331-6005;phone-context=+64",
3420                               RegionCode::GetUnknown(), &result_proto));
3421   EXPECT_EQ(nz_number, result_proto);
3422   result_proto.Clear();
3423   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3424             phone_util_.Parse("  tel:03-331-6005;phone-context=+64",
3425                               RegionCode::GetUnknown(), &result_proto));
3426   EXPECT_EQ(nz_number, result_proto);
3427   result_proto.Clear();
3428   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3429             phone_util_.Parse("tel:03-331-6005;isub=12345;phone-context=+64",
3430                               RegionCode::GetUnknown(), &result_proto));
3431   EXPECT_EQ(nz_number, result_proto);
3432
3433   nz_number.set_raw_input("+64 3 331 6005");
3434   nz_number.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
3435   // It is important that we set this to an empty string, since we used
3436   // ParseAndKeepRawInput and no carrrier code was found.
3437   nz_number.set_preferred_domestic_carrier_code("");
3438   result_proto.Clear();
3439   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3440             phone_util_.ParseAndKeepRawInput("+64 3 331 6005",
3441                                              RegionCode::GetUnknown(),
3442                                              &result_proto));
3443   EXPECT_EQ(nz_number, result_proto);
3444 }
3445
3446 TEST_F(PhoneNumberUtilTest, ParseExtensions) {
3447   PhoneNumber nz_number;
3448   nz_number.set_country_code(64);
3449   nz_number.set_national_number(33316005ULL);
3450   nz_number.set_extension("3456");
3451   PhoneNumber test_number;
3452   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3453             phone_util_.Parse("03 331 6005 ext 3456", RegionCode::NZ(),
3454                               &test_number));
3455   EXPECT_EQ(nz_number, test_number);
3456   test_number.Clear();
3457   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3458             phone_util_.Parse("03 331 6005x3456", RegionCode::NZ(),
3459                               &test_number));
3460   EXPECT_EQ(nz_number, test_number);
3461   test_number.Clear();
3462   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3463             phone_util_.Parse("03-331 6005 int.3456", RegionCode::NZ(),
3464                               &test_number));
3465   EXPECT_EQ(nz_number, test_number);
3466   test_number.Clear();
3467   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3468             phone_util_.Parse("03 331 6005 #3456", RegionCode::NZ(),
3469                               &test_number));
3470   EXPECT_EQ(nz_number, test_number);
3471
3472   // Test the following do not extract extensions:
3473   PhoneNumber non_extn_number;
3474   non_extn_number.set_country_code(1);
3475   non_extn_number.set_national_number(80074935247ULL);
3476   test_number.Clear();
3477   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3478             phone_util_.Parse("1800 six-flags", RegionCode::US(),
3479                               &test_number));
3480   EXPECT_EQ(non_extn_number, test_number);
3481   test_number.Clear();
3482   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3483             phone_util_.Parse("1800 SIX-FLAGS", RegionCode::US(),
3484                               &test_number));
3485   EXPECT_EQ(non_extn_number, test_number);
3486   test_number.Clear();
3487   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3488             phone_util_.Parse("0~0 1800 7493 5247", RegionCode::PL(),
3489                               &test_number));
3490   EXPECT_EQ(non_extn_number, test_number);
3491   test_number.Clear();
3492   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3493             phone_util_.Parse("(1800) 7493.5247", RegionCode::US(),
3494                               &test_number));
3495   EXPECT_EQ(non_extn_number, test_number);
3496
3497   // Check that the last instance of an extension token is matched.
3498   PhoneNumber extn_number;
3499   extn_number.set_country_code(1);
3500   extn_number.set_national_number(80074935247ULL);
3501   extn_number.set_extension("1234");
3502   test_number.Clear();
3503   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3504             phone_util_.Parse("0~0 1800 7493 5247 ~1234", RegionCode::PL(),
3505                               &test_number));
3506   EXPECT_EQ(extn_number, test_number);
3507
3508   // Verifying bug-fix where the last digit of a number was previously omitted
3509   // if it was a 0 when extracting the extension. Also verifying a few different
3510   // cases of extensions.
3511   PhoneNumber uk_number;
3512   uk_number.set_country_code(44);
3513   uk_number.set_national_number(2034567890ULL);
3514   uk_number.set_extension("456");
3515   test_number.Clear();
3516   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3517             phone_util_.Parse("+44 2034567890x456", RegionCode::NZ(),
3518                               &test_number));
3519   EXPECT_EQ(uk_number, test_number);
3520   test_number.Clear();
3521   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3522             phone_util_.Parse("+44 2034567890x456", RegionCode::GB(),
3523                               &test_number));
3524   EXPECT_EQ(uk_number, test_number);
3525   test_number.Clear();
3526   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3527             phone_util_.Parse("+44 2034567890 x456", RegionCode::GB(),
3528                               &test_number));
3529   EXPECT_EQ(uk_number, test_number);
3530   test_number.Clear();
3531   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3532             phone_util_.Parse("+44 2034567890 X456", RegionCode::GB(),
3533                               &test_number));
3534   EXPECT_EQ(uk_number, test_number);
3535   test_number.Clear();
3536   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3537             phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
3538                               &test_number));
3539   EXPECT_EQ(uk_number, test_number);
3540   test_number.Clear();
3541   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3542             phone_util_.Parse("+44 2034567890 X   456", RegionCode::GB(),
3543                               &test_number));
3544   EXPECT_EQ(uk_number, test_number);
3545   test_number.Clear();
3546   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3547             phone_util_.Parse("+44 2034567890 x 456  ", RegionCode::GB(),
3548                               &test_number));
3549   EXPECT_EQ(uk_number, test_number);
3550   test_number.Clear();
3551   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3552             phone_util_.Parse("+44 2034567890  X 456", RegionCode::GB(),
3553                               &test_number));
3554   EXPECT_EQ(uk_number, test_number);
3555   test_number.Clear();
3556   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3557             phone_util_.Parse("+44-2034567890;ext=456", RegionCode::GB(),
3558                               &test_number));
3559   EXPECT_EQ(uk_number, test_number);
3560   test_number.Clear();
3561   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3562             phone_util_.Parse("tel:2034567890;ext=456;phone-context=+44",
3563                               RegionCode::ZZ(), &test_number));
3564   EXPECT_EQ(uk_number, test_number);
3565
3566   // Full-width extension, "extn" only.
3567   test_number.Clear();
3568   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3569             phone_util_.Parse(
3570                 "+442034567890\xEF\xBD\x85\xEF\xBD\x98\xEF\xBD\x94\xEF\xBD\x8E"
3571                 "456", RegionCode::GB(), &test_number));
3572   EXPECT_EQ(uk_number, test_number);
3573   // "xtn" only.
3574   test_number.Clear();
3575   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3576             phone_util_.Parse(
3577                 "+44-2034567890\xEF\xBD\x98\xEF\xBD\x94\xEF\xBD\x8E""456",
3578                 RegionCode::GB(), &test_number));
3579   EXPECT_EQ(uk_number, test_number);
3580   // "xt" only.
3581   test_number.Clear();
3582   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3583             phone_util_.Parse("+44-2034567890\xEF\xBD\x98\xEF\xBD\x94""456",
3584                               RegionCode::GB(), &test_number));
3585   EXPECT_EQ(uk_number, test_number);
3586
3587   PhoneNumber us_with_extension;
3588   us_with_extension.set_country_code(1);
3589   us_with_extension.set_national_number(8009013355ULL);
3590   us_with_extension.set_extension("7246433");
3591   test_number.Clear();
3592   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3593             phone_util_.Parse("(800) 901-3355 x 7246433", RegionCode::US(),
3594                               &test_number));
3595   EXPECT_EQ(us_with_extension, test_number);
3596   test_number.Clear();
3597   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3598             phone_util_.Parse("(800) 901-3355 , ext 7246433", RegionCode::US(),
3599                               &test_number));
3600   EXPECT_EQ(us_with_extension, test_number);
3601   test_number.Clear();
3602   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3603             phone_util_.Parse("(800) 901-3355 ,extension 7246433",
3604                               RegionCode::US(),
3605                               &test_number));
3606   EXPECT_EQ(us_with_extension, test_number);
3607   test_number.Clear();
3608   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3609             phone_util_.Parse("(800) 901-3355 ,extensi\xC3\xB3n 7246433",
3610                               /* "(800) 901-3355 ,extensión 7246433" */
3611                               RegionCode::US(),
3612                               &test_number));
3613   EXPECT_EQ(us_with_extension, test_number);
3614   test_number.Clear();
3615   // Repeat with the small letter o with acute accent created by combining
3616   // characters.
3617   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3618             phone_util_.Parse("(800) 901-3355 ,extensio\xCC\x81n 7246433",
3619                               /* "(800) 901-3355 ,extensión 7246433" */
3620                               RegionCode::US(),
3621                               &test_number));
3622   EXPECT_EQ(us_with_extension, test_number);
3623   test_number.Clear();
3624   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3625             phone_util_.Parse("(800) 901-3355 , 7246433", RegionCode::US(),
3626                               &test_number));
3627   EXPECT_EQ(us_with_extension, test_number);
3628   test_number.Clear();
3629   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3630             phone_util_.Parse("(800) 901-3355 ext: 7246433", RegionCode::US(),
3631                               &test_number));
3632   EXPECT_EQ(us_with_extension, test_number);
3633
3634   // Test that if a number has two extensions specified, we ignore the second.
3635   PhoneNumber us_with_two_extensions_number;
3636   us_with_two_extensions_number.set_country_code(1);
3637   us_with_two_extensions_number.set_national_number(2121231234ULL);
3638   us_with_two_extensions_number.set_extension("508");
3639   test_number.Clear();
3640   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3641             phone_util_.Parse("(212)123-1234 x508/x1234", RegionCode::US(),
3642                               &test_number));
3643   EXPECT_EQ(us_with_two_extensions_number, test_number);
3644   test_number.Clear();
3645   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3646             phone_util_.Parse("(212)123-1234 x508/ x1234", RegionCode::US(),
3647                               &test_number));
3648   EXPECT_EQ(us_with_two_extensions_number, test_number);
3649   test_number.Clear();
3650   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3651             phone_util_.Parse("(212)123-1234 x508\\x1234", RegionCode::US(),
3652                               &test_number));
3653   EXPECT_EQ(us_with_two_extensions_number, test_number);
3654
3655   // Test parsing numbers in the form (645) 123-1234-910# works, where the last
3656   // 3 digits before the # are an extension.
3657   us_with_extension.Clear();
3658   us_with_extension.set_country_code(1);
3659   us_with_extension.set_national_number(6451231234ULL);
3660   us_with_extension.set_extension("910");
3661   test_number.Clear();
3662   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3663             phone_util_.Parse("+1 (645) 123 1234-910#", RegionCode::US(),
3664                               &test_number));
3665   EXPECT_EQ(us_with_extension, test_number);
3666 }
3667
3668 TEST_F(PhoneNumberUtilTest, ParseAndKeepRaw) {
3669   PhoneNumber alpha_numeric_number;
3670   alpha_numeric_number.set_country_code(1);
3671   alpha_numeric_number.set_national_number(80074935247ULL);
3672   alpha_numeric_number.set_raw_input("800 six-flags");
3673   alpha_numeric_number.set_country_code_source(
3674       PhoneNumber::FROM_DEFAULT_COUNTRY);
3675   alpha_numeric_number.set_preferred_domestic_carrier_code("");
3676
3677   PhoneNumber test_number;
3678   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3679             phone_util_.ParseAndKeepRawInput("800 six-flags", RegionCode::US(),
3680                                              &test_number));
3681   EXPECT_EQ(alpha_numeric_number, test_number);
3682
3683   alpha_numeric_number.set_national_number(8007493524ULL);
3684   alpha_numeric_number.set_raw_input("1800 six-flag");
3685   alpha_numeric_number.set_country_code_source(
3686       PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN);
3687   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3688             phone_util_.ParseAndKeepRawInput("1800 six-flag", RegionCode::US(),
3689                                              &test_number));
3690   EXPECT_EQ(alpha_numeric_number, test_number);
3691
3692   alpha_numeric_number.set_raw_input("+1800 six-flag");
3693   alpha_numeric_number.set_country_code_source(
3694       PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
3695   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3696             phone_util_.ParseAndKeepRawInput("+1800 six-flag", RegionCode::CN(),
3697                                              &test_number));
3698   EXPECT_EQ(alpha_numeric_number, test_number);
3699
3700   alpha_numeric_number.set_raw_input("001800 six-flag");
3701   alpha_numeric_number.set_country_code_source(
3702       PhoneNumber::FROM_NUMBER_WITH_IDD);
3703   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3704             phone_util_.ParseAndKeepRawInput("001800 six-flag",
3705                                              RegionCode::NZ(),
3706                                              &test_number));
3707   EXPECT_EQ(alpha_numeric_number, test_number);
3708
3709   // Try with invalid region - expect failure.
3710   test_number.Clear();
3711   EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
3712             phone_util_.Parse("123 456 7890", RegionCode::CS(), &test_number));
3713   EXPECT_EQ(PhoneNumber::default_instance(), test_number);
3714
3715   PhoneNumber korean_number;
3716   korean_number.set_country_code(82);
3717   korean_number.set_national_number(22123456);
3718   korean_number.set_raw_input("08122123456");
3719   korean_number.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
3720   korean_number.set_preferred_domestic_carrier_code("81");
3721   EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
3722             phone_util_.ParseAndKeepRawInput("08122123456",
3723                                              RegionCode::KR(),
3724                                              &test_number));
3725   EXPECT_EQ(korean_number, test_number);
3726 }
3727
3728 TEST_F(PhoneNumberUtilTest, CanBeInternationallyDialled) {
3729   PhoneNumber test_number;
3730   test_number.set_country_code(1);
3731
3732   // We have no-international-dialling rules for the US in our test metadata
3733   // that say that toll-free numbers cannot be dialled internationally.
3734   test_number.set_national_number(8002530000ULL);
3735   EXPECT_FALSE(CanBeInternationallyDialled(test_number));
3736
3737   // Normal US numbers can be internationally dialled.
3738   test_number.set_national_number(6502530000ULL);
3739   EXPECT_TRUE(CanBeInternationallyDialled(test_number));
3740
3741   // Invalid number.
3742   test_number.set_national_number(2530000ULL);
3743   EXPECT_TRUE(CanBeInternationallyDialled(test_number));
3744
3745   // We have no data for NZ - should return true.
3746   test_number.set_country_code(64);
3747   test_number.set_national_number(33316005ULL);
3748   EXPECT_TRUE(CanBeInternationallyDialled(test_number));
3749
3750   test_number.set_country_code(800);
3751   test_number.set_national_number(12345678ULL);
3752   EXPECT_TRUE(CanBeInternationallyDialled(test_number));
3753 }
3754
3755 TEST_F(PhoneNumberUtilTest, IsAlphaNumber) {
3756   EXPECT_TRUE(phone_util_.IsAlphaNumber("1800 six-flags"));
3757   EXPECT_TRUE(phone_util_.IsAlphaNumber("1800 six-flags ext. 1234"));
3758   EXPECT_TRUE(phone_util_.IsAlphaNumber("+800 six-flags"));
3759   EXPECT_TRUE(phone_util_.IsAlphaNumber("180 six-flags"));
3760   EXPECT_FALSE(phone_util_.IsAlphaNumber("1800 123-1234"));
3761   EXPECT_FALSE(phone_util_.IsAlphaNumber("1 six-flags"));
3762   EXPECT_FALSE(phone_util_.IsAlphaNumber("18 six-flags"));
3763   EXPECT_FALSE(phone_util_.IsAlphaNumber("1800 123-1234 extension: 1234"));
3764   EXPECT_FALSE(phone_util_.IsAlphaNumber("+800 1234-1234"));
3765 }
3766
3767 }  // namespace phonenumbers
3768 }  // namespace i18n