cpp/test/phonenumbers/shortnumberinfo_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: David Yonge-Mallo
  16
  17 // Note that these tests use the test metadata, not the normal metadata file, so
  18 // should not be used for regression test purposes - these tests are
  19 // illustrative only and test functionality.
  20
  21 #include "phonenumbers/shortnumberinfo.h"
  22
  23 #include <gtest/gtest.h>
  24
  25 #include "phonenumbers/base/logging.h"
  26 #include "phonenumbers/default_logger.h"
  27 #include "phonenumbers/phonenumberutil.h"
  28 #include "phonenumbers/stringutil.h"
  29 #include "phonenumbers/test_util.h"
  30
  31 namespace i18n {
  32 namespace phonenumbers {
  33
  34 class ShortNumberInfoTest : public testing::Test {
  35  protected:
  36   PhoneNumber ParseNumberForTesting(const string& number,
  37                                     const string& region_code) {
  38     PhoneNumber phone_number;
  39     PhoneNumberUtil::ErrorType error_type = phone_util_.Parse(
  40                                            number, region_code, &phone_number);
  41     CHECK_EQ(error_type, PhoneNumberUtil::NO_PARSING_ERROR);
  42     IGNORE_UNUSED(error_type);
  43     return phone_number;
  44   }
  45
  46   ShortNumberInfoTest() : short_info_() {
  47     PhoneNumberUtil::GetInstance()->SetLogger(new StdoutLogger());
  48   }
  49
  50   const PhoneNumberUtil phone_util_;
  51   const ShortNumberInfo short_info_;
  52
  53  private:
  54   DISALLOW_COPY_AND_ASSIGN(ShortNumberInfoTest);
  55 };
  56
  57 TEST_F(ShortNumberInfoTest, IsPossibleShortNumber) {
  58   PhoneNumber possible_number;
  59   possible_number.set_country_code(33);
  60   possible_number.set_national_number(123456ULL);
  61   EXPECT_TRUE(short_info_.IsPossibleShortNumber(possible_number));
  62   EXPECT_TRUE(short_info_.IsPossibleShortNumberForRegion(
  63       ParseNumberForTesting("123456", RegionCode::FR()), RegionCode::FR()));
  64
  65   PhoneNumber impossible_number;
  66   impossible_number.set_country_code(33);
  67   impossible_number.set_national_number(9ULL);
  68   EXPECT_FALSE(short_info_.IsPossibleShortNumber(impossible_number));
  69
  70   // Note that GB and GG share the country calling code 44, and that this
  71   // number is possible but not valid.
  72   PhoneNumber shared_number;
  73   shared_number.set_country_code(44);
  74   shared_number.set_national_number(11001ULL);
  75   EXPECT_TRUE(short_info_.IsPossibleShortNumber(shared_number));
  76 }
  77
  78 TEST_F(ShortNumberInfoTest, IsValidShortNumber) {
  79   PhoneNumber valid_number;
  80   valid_number.set_country_code(33);
  81   valid_number.set_national_number(1010ULL);
  82   EXPECT_TRUE(short_info_.IsValidShortNumber(valid_number));
  83   EXPECT_TRUE(short_info_.IsValidShortNumberForRegion(
  84       ParseNumberForTesting("1010", RegionCode::FR()), RegionCode::FR()));
  85
  86   PhoneNumber invalid_number;
  87   invalid_number.set_country_code(33);
  88   invalid_number.set_national_number(123456ULL);
  89   EXPECT_FALSE(short_info_.IsValidShortNumber(invalid_number));
  90   EXPECT_FALSE(short_info_.IsValidShortNumberForRegion(
  91       ParseNumberForTesting("123456", RegionCode::FR()), RegionCode::FR()));
  92
  93   // Note that GB and GG share the country calling code 44.
  94   PhoneNumber shared_number;
  95   shared_number.set_country_code(44);
  96   shared_number.set_national_number(18001ULL);
  97   EXPECT_TRUE(short_info_.IsValidShortNumber(shared_number));
  98 }
  99
 100 TEST_F(ShortNumberInfoTest, GetExpectedCost) {
 101   uint64 national_number;
 102   const string& premium_rate_example =
 103       short_info_.GetExampleShortNumberForCost(
 104           RegionCode::FR(), ShortNumberInfo::PREMIUM_RATE);
 105   EXPECT_EQ(ShortNumberInfo::PREMIUM_RATE,
 106             short_info_.GetExpectedCostForRegion(
 107                 ParseNumberForTesting(premium_rate_example, RegionCode::FR()),
 108                 RegionCode::FR()));
 109   PhoneNumber premium_rate_number;
 110   premium_rate_number.set_country_code(33);
 111   safe_strtou64(premium_rate_example, &national_number);
 112   premium_rate_number.set_national_number(national_number);
 113   EXPECT_EQ(ShortNumberInfo::PREMIUM_RATE,
 114      short_info_.GetExpectedCost(premium_rate_number));
 115
 116   const string& standard_rate_example =
 117       short_info_.GetExampleShortNumberForCost(
 118           RegionCode::FR(), ShortNumberInfo::STANDARD_RATE);
 119   EXPECT_EQ(ShortNumberInfo::STANDARD_RATE,
 120             short_info_.GetExpectedCostForRegion(
 121                 ParseNumberForTesting(standard_rate_example, RegionCode::FR()),
 122                 RegionCode::FR()));
 123   PhoneNumber standard_rate_number;
 124   standard_rate_number.set_country_code(33);
 125   safe_strtou64(standard_rate_example, &national_number);
 126   standard_rate_number.set_national_number(national_number);
 127   EXPECT_EQ(ShortNumberInfo::STANDARD_RATE,
 128      short_info_.GetExpectedCost(standard_rate_number));
 129
 130   const string& toll_free_example =
 131       short_info_.GetExampleShortNumberForCost(
 132           RegionCode::FR(), ShortNumberInfo::TOLL_FREE);
 133   EXPECT_EQ(ShortNumberInfo::TOLL_FREE,
 134             short_info_.GetExpectedCostForRegion(
 135                 ParseNumberForTesting(toll_free_example, RegionCode::FR()),
 136                 RegionCode::FR()));
 137   PhoneNumber toll_free_number;
 138   toll_free_number.set_country_code(33);
 139   safe_strtou64(toll_free_example, &national_number);
 140   toll_free_number.set_national_number(national_number);
 141   EXPECT_EQ(ShortNumberInfo::TOLL_FREE,
 142      short_info_.GetExpectedCost(toll_free_number));
 143
 144   EXPECT_EQ(
 145       ShortNumberInfo::UNKNOWN_COST,
 146       short_info_.GetExpectedCostForRegion(
 147           ParseNumberForTesting("12345", RegionCode::FR()), RegionCode::FR()));
 148   PhoneNumber unknown_cost_number;
 149   unknown_cost_number.set_country_code(33);
 150   unknown_cost_number.set_national_number(12345ULL);
 151   EXPECT_EQ(ShortNumberInfo::UNKNOWN_COST,
 152      short_info_.GetExpectedCost(unknown_cost_number));
 153
 154   // Test that an invalid number may nevertheless have a cost other than
 155   // UNKNOWN_COST.
 156   EXPECT_FALSE(short_info_.IsValidShortNumberForRegion(
 157       ParseNumberForTesting("116123", RegionCode::FR()), RegionCode::FR()));
 158   EXPECT_EQ(
 159       ShortNumberInfo::TOLL_FREE,
 160       short_info_.GetExpectedCostForRegion(
 161           ParseNumberForTesting("116123", RegionCode::FR()), RegionCode::FR()));
 162   PhoneNumber invalid_number;
 163   invalid_number.set_country_code(33);
 164   invalid_number.set_national_number(116123ULL);
 165   EXPECT_FALSE(short_info_.IsValidShortNumber(invalid_number));
 166   EXPECT_EQ(ShortNumberInfo::TOLL_FREE,
 167       short_info_.GetExpectedCost(invalid_number));
 168
 169   // Test a nonexistent country code.
 170   EXPECT_EQ(
 171       ShortNumberInfo::UNKNOWN_COST,
 172       short_info_.GetExpectedCostForRegion(
 173           ParseNumberForTesting("911", RegionCode::US()), RegionCode::ZZ()));
 174   unknown_cost_number.Clear();
 175   unknown_cost_number.set_country_code(123);
 176   unknown_cost_number.set_national_number(911ULL);
 177   EXPECT_EQ(ShortNumberInfo::UNKNOWN_COST,
 178       short_info_.GetExpectedCost(unknown_cost_number));
 179 }
 180
 181 TEST_F(ShortNumberInfoTest, GetExpectedCostForSharedCountryCallingCode) {
 182   // Test some numbers which have different costs in countries sharing the same
 183   // country calling code. In Australia, 1234 is premium-rate, 1194 is
 184   // standard-rate, and 733 is toll-free. These are not known to be valid
 185   // numbers in the Christmas Islands.
 186   string ambiguous_premium_rate_string("1234");
 187   PhoneNumber ambiguous_premium_rate_number;
 188   ambiguous_premium_rate_number.set_country_code(61);
 189   ambiguous_premium_rate_number.set_national_number(1234ULL);
 190   string ambiguous_standard_rate_string("1194");
 191   PhoneNumber ambiguous_standard_rate_number;
 192   ambiguous_standard_rate_number.set_country_code(61);
 193   ambiguous_standard_rate_number.set_national_number(1194ULL);
 194   string ambiguous_toll_free_string("733");
 195   PhoneNumber ambiguous_toll_free_number;
 196   ambiguous_toll_free_number.set_country_code(61);
 197   ambiguous_toll_free_number.set_national_number(733ULL);
 198
 199   EXPECT_TRUE(short_info_.IsValidShortNumber(ambiguous_premium_rate_number));
 200   EXPECT_TRUE(short_info_.IsValidShortNumber(ambiguous_standard_rate_number));
 201   EXPECT_TRUE(short_info_.IsValidShortNumber(ambiguous_toll_free_number));
 202
 203   EXPECT_TRUE(short_info_.IsValidShortNumberForRegion(
 204       ParseNumberForTesting(ambiguous_premium_rate_string, RegionCode::AU()),
 205       RegionCode::AU()));
 206   EXPECT_EQ(ShortNumberInfo::PREMIUM_RATE,
 207             short_info_.GetExpectedCostForRegion(
 208                 ParseNumberForTesting(ambiguous_premium_rate_string,
 209                                       RegionCode::AU()),
 210                 RegionCode::AU()));
 211
 212   EXPECT_FALSE(short_info_.IsValidShortNumberForRegion(
 213       ParseNumberForTesting(ambiguous_premium_rate_string, RegionCode::CX()),
 214       RegionCode::CX()));
 215   EXPECT_EQ(ShortNumberInfo::UNKNOWN_COST,
 216             short_info_.GetExpectedCostForRegion(
 217                 ParseNumberForTesting(ambiguous_premium_rate_string,
 218                                       RegionCode::CX()),
 219                 RegionCode::CX()));
 220   // PREMIUM_RATE takes precedence over UNKNOWN_COST.
 221   EXPECT_EQ(ShortNumberInfo::PREMIUM_RATE,
 222       short_info_.GetExpectedCost(ambiguous_premium_rate_number));
 223
 224   EXPECT_TRUE(short_info_.IsValidShortNumberForRegion(
 225       ParseNumberForTesting(ambiguous_standard_rate_string, RegionCode::AU()),
 226       RegionCode::AU()));
 227   EXPECT_EQ(ShortNumberInfo::STANDARD_RATE,
 228             short_info_.GetExpectedCostForRegion(
 229                 ParseNumberForTesting(ambiguous_standard_rate_string,
 230                                       RegionCode::AU()),
 231                 RegionCode::AU()));
 232
 233   EXPECT_FALSE(short_info_.IsValidShortNumberForRegion(
 234       ParseNumberForTesting(ambiguous_standard_rate_string, RegionCode::CX()),
 235       RegionCode::CX()));
 236   EXPECT_EQ(ShortNumberInfo::UNKNOWN_COST,
 237             short_info_.GetExpectedCostForRegion(
 238                 ParseNumberForTesting(ambiguous_standard_rate_string,
 239                                       RegionCode::CX()),
 240                 RegionCode::CX()));
 241   EXPECT_EQ(ShortNumberInfo::UNKNOWN_COST,
 242       short_info_.GetExpectedCost(ambiguous_standard_rate_number));
 243
 244   EXPECT_TRUE(short_info_.IsValidShortNumberForRegion(
 245       ParseNumberForTesting(ambiguous_toll_free_string, RegionCode::AU()),
 246       RegionCode::AU()));
 247   EXPECT_EQ(
 248       ShortNumberInfo::TOLL_FREE,
 249       short_info_.GetExpectedCostForRegion(
 250           ParseNumberForTesting(ambiguous_toll_free_string, RegionCode::AU()),
 251           RegionCode::AU()));
 252
 253   EXPECT_FALSE(short_info_.IsValidShortNumberForRegion(
 254       ParseNumberForTesting(ambiguous_toll_free_string, RegionCode::CX()),
 255       RegionCode::CX()));
 256   EXPECT_EQ(
 257       ShortNumberInfo::UNKNOWN_COST,
 258       short_info_.GetExpectedCostForRegion(
 259           ParseNumberForTesting(ambiguous_toll_free_string, RegionCode::CX()),
 260           RegionCode::CX()));
 261   EXPECT_EQ(ShortNumberInfo::UNKNOWN_COST,
 262       short_info_.GetExpectedCost(ambiguous_toll_free_number));
 263 }
 264
 265 TEST_F(ShortNumberInfoTest, GetExampleShortNumber) {
 266   EXPECT_EQ("8711", short_info_.GetExampleShortNumber(RegionCode::AM()));
 267   EXPECT_EQ("1010", short_info_.GetExampleShortNumber(RegionCode::FR()));
 268   EXPECT_EQ("", short_info_.GetExampleShortNumber(RegionCode::UN001()));
 269   EXPECT_EQ("", short_info_.GetExampleShortNumber(RegionCode::GetUnknown()));
 270 }
 271
 272 TEST_F(ShortNumberInfoTest, GetExampleShortNumberForCost) {
 273   EXPECT_EQ("3010",
 274       short_info_.GetExampleShortNumberForCost(RegionCode::FR(),
 275       ShortNumberInfo::TOLL_FREE));
 276   EXPECT_EQ("1023",
 277       short_info_.GetExampleShortNumberForCost(RegionCode::FR(),
 278       ShortNumberInfo::STANDARD_RATE));
 279   EXPECT_EQ("42000",
 280       short_info_.GetExampleShortNumberForCost(RegionCode::FR(),
 281       ShortNumberInfo::PREMIUM_RATE));
 282   EXPECT_EQ("", short_info_.GetExampleShortNumberForCost(RegionCode::FR(),
 283       ShortNumberInfo::UNKNOWN_COST));
 284 }
 285
 286 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumber_US) {
 287   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("911", RegionCode::US()));
 288   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("112", RegionCode::US()));
 289   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("999", RegionCode::US()));
 290 }
 291
 292 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumberLongNumber_US) {
 293   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("9116666666",
 294       RegionCode::US()));
 295   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("1126666666",
 296       RegionCode::US()));
 297   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("9996666666",
 298       RegionCode::US()));
 299 }
 300
 301 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumberWithFormatting_US) {
 302   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("9-1-1", RegionCode::US()));
 303   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("1-1-2", RegionCode::US()));
 304   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("9-9-9",
 305       RegionCode::US()));
 306 }
 307
 308 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumberWithPlusSign_US) {
 309   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("+911", RegionCode::US()));
 310   // This hex sequence is the full-width plus sign U+FF0B.
 311   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("\xEF\xBC\x8B" "911",
 312       RegionCode::US()));
 313   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber(" +911",
 314       RegionCode::US()));
 315   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("+112", RegionCode::US()));
 316   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("+999", RegionCode::US()));
 317 }
 318
 319 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumber_BR) {
 320   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("911", RegionCode::BR()));
 321   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("190", RegionCode::BR()));
 322   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("999", RegionCode::BR()));
 323 }
 324
 325 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumberLongNumber_BR) {
 326   // Brazilian emergency numbers don't work when additional digits are appended.
 327   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("9111", RegionCode::BR()));
 328   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("1900", RegionCode::BR()));
 329   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("9996", RegionCode::BR()));
 330 }
 331
 332 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumber_CL) {
 333   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("131", RegionCode::CL()));
 334   EXPECT_TRUE(short_info_.ConnectsToEmergencyNumber("133", RegionCode::CL()));
 335 }
 336
 337 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumberLongNumber_CL) {
 338   // Chilean emergency numbers don't work when additional digits are appended.
 339   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("1313", RegionCode::CL()));
 340   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("1330", RegionCode::CL()));
 341 }
 342
 343 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumber_AO) {
 344   // Angola doesn't have any metadata for emergency numbers in the test
 345   // metadata.
 346   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("911", RegionCode::AO()));
 347   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("222123456",
 348       RegionCode::AO()));
 349   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("923123456",
 350       RegionCode::AO()));
 351 }
 352
 353 TEST_F(ShortNumberInfoTest, ConnectsToEmergencyNumber_ZW) {
 354   // Zimbabwe doesn't have any metadata in the test metadata.
 355   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("911", RegionCode::ZW()));
 356   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("01312345",
 357       RegionCode::ZW()));
 358   EXPECT_FALSE(short_info_.ConnectsToEmergencyNumber("0711234567",
 359       RegionCode::ZW()));
 360 }
 361
 362 TEST_F(ShortNumberInfoTest, IsEmergencyNumber_US) {
 363   EXPECT_TRUE(short_info_.IsEmergencyNumber("911", RegionCode::US()));
 364   EXPECT_TRUE(short_info_.IsEmergencyNumber("112", RegionCode::US()));
 365   EXPECT_FALSE(short_info_.IsEmergencyNumber("999", RegionCode::US()));
 366 }
 367
 368 TEST_F(ShortNumberInfoTest, IsEmergencyNumberLongNumber_US) {
 369   EXPECT_FALSE(short_info_.IsEmergencyNumber("9116666666", RegionCode::US()));
 370   EXPECT_FALSE(short_info_.IsEmergencyNumber("1126666666", RegionCode::US()));
 371   EXPECT_FALSE(short_info_.IsEmergencyNumber("9996666666", RegionCode::US()));
 372 }
 373
 374 TEST_F(ShortNumberInfoTest, IsEmergencyNumberWithFormatting_US) {
 375   EXPECT_TRUE(short_info_.IsEmergencyNumber("9-1-1", RegionCode::US()));
 376   EXPECT_TRUE(short_info_.IsEmergencyNumber("*911", RegionCode::US()));
 377   EXPECT_TRUE(short_info_.IsEmergencyNumber("1-1-2", RegionCode::US()));
 378   EXPECT_TRUE(short_info_.IsEmergencyNumber("*112", RegionCode::US()));
 379   EXPECT_FALSE(short_info_.IsEmergencyNumber("9-9-9", RegionCode::US()));
 380   EXPECT_FALSE(short_info_.IsEmergencyNumber("*999", RegionCode::US()));
 381 }
 382
 383 TEST_F(ShortNumberInfoTest, IsEmergencyNumberWithPlusSign_US) {
 384   EXPECT_FALSE(short_info_.IsEmergencyNumber("+911", RegionCode::US()));
 385   // This hex sequence is the full-width plus sign U+FF0B.
 386   EXPECT_FALSE(short_info_.IsEmergencyNumber("\xEF\xBC\x8B" "911",
 387       RegionCode::US()));
 388   EXPECT_FALSE(short_info_.IsEmergencyNumber(" +911", RegionCode::US()));
 389   EXPECT_FALSE(short_info_.IsEmergencyNumber("+112", RegionCode::US()));
 390   EXPECT_FALSE(short_info_.IsEmergencyNumber("+999", RegionCode::US()));
 391 }
 392
 393 TEST_F(ShortNumberInfoTest, IsEmergencyNumber_BR) {
 394   EXPECT_TRUE(short_info_.IsEmergencyNumber("911", RegionCode::BR()));
 395   EXPECT_TRUE(short_info_.IsEmergencyNumber("190", RegionCode::BR()));
 396   EXPECT_FALSE(short_info_.IsEmergencyNumber("999", RegionCode::BR()));
 397 }
 398
 399 TEST_F(ShortNumberInfoTest, EmergencyNumberLongNumber_BR) {
 400   EXPECT_FALSE(short_info_.IsEmergencyNumber("9111", RegionCode::BR()));
 401   EXPECT_FALSE(short_info_.IsEmergencyNumber("1900", RegionCode::BR()));
 402   EXPECT_FALSE(short_info_.IsEmergencyNumber("9996", RegionCode::BR()));
 403 }
 404
 405 TEST_F(ShortNumberInfoTest, IsEmergencyNumber_AO) {
 406   // Angola doesn't have any metadata for emergency numbers in the test
 407   // metadata.
 408   EXPECT_FALSE(short_info_.IsEmergencyNumber("911", RegionCode::AO()));
 409   EXPECT_FALSE(short_info_.IsEmergencyNumber("222123456", RegionCode::AO()));
 410   EXPECT_FALSE(short_info_.IsEmergencyNumber("923123456", RegionCode::AO()));
 411 }
 412
 413 TEST_F(ShortNumberInfoTest, IsEmergencyNumber_ZW) {
 414   // Zimbabwe doesn't have any metadata in the test metadata.
 415   EXPECT_FALSE(short_info_.IsEmergencyNumber("911", RegionCode::ZW()));
 416   EXPECT_FALSE(short_info_.IsEmergencyNumber("01312345", RegionCode::ZW()));
 417   EXPECT_FALSE(short_info_.IsEmergencyNumber("0711234567", RegionCode::ZW()));
 418 }
 419
 420 TEST_F(ShortNumberInfoTest, EmergencyNumberForSharedCountryCallingCode) {
 421   // Test the emergency number 112, which is valid in both Australia and the
 422   // Christmas Islands.
 423   EXPECT_TRUE(short_info_.IsEmergencyNumber("112", RegionCode::AU()));
 424   EXPECT_TRUE(short_info_.IsValidShortNumberForRegion(
 425       ParseNumberForTesting("112", RegionCode::AU()), RegionCode::AU()));
 426   EXPECT_EQ(
 427       ShortNumberInfo::TOLL_FREE,
 428       short_info_.GetExpectedCostForRegion(
 429           ParseNumberForTesting("112", RegionCode::AU()), RegionCode::AU()));
 430
 431   EXPECT_TRUE(short_info_.IsEmergencyNumber("112", RegionCode::CX()));
 432   EXPECT_TRUE(short_info_.IsValidShortNumberForRegion(
 433       ParseNumberForTesting("112", RegionCode::CX()), RegionCode::CX()));
 434   EXPECT_EQ(
 435       ShortNumberInfo::TOLL_FREE,
 436       short_info_.GetExpectedCostForRegion(
 437           ParseNumberForTesting("112", RegionCode::CX()), RegionCode::CX()));
 438
 439   PhoneNumber shared_emergency_number;
 440   shared_emergency_number.set_country_code(61);
 441   shared_emergency_number.set_national_number(112ULL);
 442   EXPECT_TRUE(short_info_.IsValidShortNumber(shared_emergency_number));
 443   EXPECT_EQ(ShortNumberInfo::TOLL_FREE,
 444       short_info_.GetExpectedCost(shared_emergency_number));
 445 }
 446
 447 TEST_F(ShortNumberInfoTest, OverlappingNANPANumber) {
 448   // 211 is an emergency number in Barbados, while it is a toll-free
 449   // information line in Canada and the USA.
 450   EXPECT_TRUE(short_info_.IsEmergencyNumber("211", RegionCode::BB()));
 451   EXPECT_EQ(
 452       ShortNumberInfo::TOLL_FREE,
 453       short_info_.GetExpectedCostForRegion(
 454           ParseNumberForTesting("211", RegionCode::BB()), RegionCode::BB()));
 455
 456   EXPECT_FALSE(short_info_.IsEmergencyNumber("211", RegionCode::US()));
 457   EXPECT_EQ(
 458       ShortNumberInfo::UNKNOWN_COST,
 459       short_info_.GetExpectedCostForRegion(
 460           ParseNumberForTesting("211", RegionCode::US()), RegionCode::US()));
 461
 462   EXPECT_FALSE(short_info_.IsEmergencyNumber("211", RegionCode::CA()));
 463   EXPECT_EQ(
 464       ShortNumberInfo::UNKNOWN_COST,
 465       short_info_.GetExpectedCostForRegion(
 466           ParseNumberForTesting("211", RegionCode::CA()), RegionCode::CA()));
 467 }
 468
 469 }  // namespace phonenumbers
 470 }  // namespace i18n