// Author: Shaopeng Jia
// Author: Lara Rennie
// Open-sourced by: Philippe Liard
+//
+// Note that these tests use the metadata contained in the test metadata file,
+// not the normal metadata file, so should not be used for regression test
+// purposes - these tests are illustrative only and test functionality.
+
+#include "phonenumbers/phonenumberutil.h"
+#include <algorithm>
#include <iostream>
+#include <list>
#include <set>
#include <string>
#include <gtest/gtest.h>
+#include "phonenumbers/default_logger.h"
#include "phonenumbers/phonemetadata.pb.h"
#include "phonenumbers/phonenumber.h"
#include "phonenumbers/phonenumber.pb.h"
-#include "phonenumbers/phonenumberutil.h"
#include "phonenumbers/test_util.h"
namespace i18n {
namespace phonenumbers {
-using std::endl;
-using std::make_pair;
+using std::find;
using std::ostream;
using google::protobuf::RepeatedPtrField;
+static const int kInvalidCountryCode = 2;
+
class PhoneNumberUtilTest : public testing::Test {
protected:
PhoneNumberUtilTest() : phone_util_(*PhoneNumberUtil::GetInstance()) {
+ PhoneNumberUtil::GetInstance()->SetLogger(new StdoutLogger());
}
// Wrapper functions for private functions that we want to test.
return phone_util_.GetMetadataForRegion(region_code);
}
+ const PhoneMetadata* GetMetadataForNonGeographicalRegion(
+ int country_code) const {
+ return phone_util_.GetMetadataForNonGeographicalRegion(country_code);
+ }
+
void GetSupportedRegions(set<string>* regions) {
phone_util_.GetSupportedRegions(regions);
}
+ void GetRegionCodesForCountryCallingCode(
+ int country_calling_code,
+ list<string>* regions) {
+ phone_util_.GetRegionCodesForCountryCallingCode(country_calling_code,
+ regions);
+ }
+
void ExtractPossibleNumber(const string& number,
string* extracted_number) const {
phone_util_.ExtractPossibleNumber(number, extracted_number);
phone_util_.Normalize(number);
}
+ void NormalizeDiallableCharsOnly(string* number) const {
+ phone_util_.NormalizeDiallableCharsOnly(number);
+ }
+
+ bool IsNumberGeographical(const PhoneNumber& phone_number) const {
+ return phone_util_.IsNumberGeographical(phone_number);
+ }
+
bool IsLeadingZeroPossible(int country_calling_code) const {
return phone_util_.IsLeadingZeroPossible(country_calling_code);
}
}
const PhoneNumberUtil& phone_util_;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(PhoneNumberUtilTest);
};
TEST_F(PhoneNumberUtilTest, ContainsOnlyValidDigits) {
EXPECT_GT(regions.size(), 0U);
}
+TEST_F(PhoneNumberUtilTest, GetSupportedGlobalNetworkCallingCodes) {
+ set<int> calling_codes;
+
+ phone_util_.GetSupportedGlobalNetworkCallingCodes(&calling_codes);
+ EXPECT_GT(calling_codes.size(), 0U);
+ for (set<int>::const_iterator it = calling_codes.begin();
+ it != calling_codes.end(); ++it) {
+ EXPECT_GT(*it, 0);
+ string region_code;
+ phone_util_.GetRegionCodeForCountryCode(*it, ®ion_code);
+ EXPECT_EQ(RegionCode::UN001(), region_code);
+ }
+}
+
+TEST_F(PhoneNumberUtilTest, GetRegionCodesForCountryCallingCode) {
+ list<string> regions;
+
+ GetRegionCodesForCountryCallingCode(1, ®ions);
+ EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::US())
+ != regions.end());
+ EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::BS())
+ != regions.end());
+
+ regions.clear();
+ GetRegionCodesForCountryCallingCode(44, ®ions);
+ EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::GB())
+ != regions.end());
+
+ regions.clear();
+ GetRegionCodesForCountryCallingCode(49, ®ions);
+ EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::DE())
+ != regions.end());
+
+ regions.clear();
+ GetRegionCodesForCountryCallingCode(800, ®ions);
+ EXPECT_TRUE(find(regions.begin(), regions.end(), RegionCode::UN001())
+ != regions.end());
+
+ regions.clear();
+ GetRegionCodesForCountryCallingCode(kInvalidCountryCode, ®ions);
+ EXPECT_TRUE(regions.empty());
+}
+
TEST_F(PhoneNumberUtilTest, GetInstanceLoadUSMetadata) {
const PhoneMetadata* metadata = GetPhoneMetadata(RegionCode::US());
EXPECT_EQ("US", metadata->id());
EXPECT_EQ("$1 $2 $3 $4", metadata->intl_number_format(3).format());
}
+TEST_F(PhoneNumberUtilTest, GetInstanceLoadInternationalTollFreeMetadata) {
+ const PhoneMetadata* metadata = GetMetadataForNonGeographicalRegion(800);
+ EXPECT_FALSE(metadata == NULL);
+ EXPECT_EQ("001", metadata->id());
+ EXPECT_EQ(800, metadata->country_code());
+ EXPECT_EQ("$1 $2", metadata->number_format(0).format());
+ EXPECT_EQ("(\\d{4})(\\d{4})", metadata->number_format(0).pattern());
+ EXPECT_EQ("12345678", metadata->general_desc().example_number());
+ EXPECT_EQ("12345678", metadata->toll_free().example_number());
+}
+
TEST_F(PhoneNumberUtilTest, GetNationalSignificantNumber) {
PhoneNumber number;
number.set_country_code(1);
phone_util_.GetNationalSignificantNumber(number,
&national_significant_number);
EXPECT_EQ("0236618300", national_significant_number);
+
+ national_significant_number.clear();
+ number.Clear();
+ number.set_country_code(800);
+ number.set_national_number(12345678ULL);
+ phone_util_.GetNationalSignificantNumber(number,
+ &national_significant_number);
+ EXPECT_EQ("12345678", national_significant_number);
}
TEST_F(PhoneNumberUtilTest, GetExampleNumber) {
bool success = phone_util_.GetExampleNumber(RegionCode::DE(), &test_number);
EXPECT_TRUE(success);
EXPECT_EQ(de_number, test_number);
+
success = phone_util_.GetExampleNumberForType(RegionCode::DE(),
PhoneNumberUtil::FIXED_LINE,
&test_number);
EXPECT_TRUE(success);
EXPECT_EQ(de_number, test_number);
- test_number.Clear();
+
success = phone_util_.GetExampleNumberForType(RegionCode::DE(),
PhoneNumberUtil::MOBILE,
&test_number);
// Here we test that an example number was not returned, and that the number
// passed in was not modified.
+ test_number.Clear();
EXPECT_FALSE(success);
EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
// For the US, the example number is placed under general description, and
// hence should be used for both fixed line and mobile, so neither of these
// should return null.
- test_number.Clear();
success = phone_util_.GetExampleNumberForType(RegionCode::US(),
PhoneNumberUtil::FIXED_LINE,
&test_number);
// number passed in was modified.
EXPECT_TRUE(success);
EXPECT_NE(PhoneNumber::default_instance(), test_number);
- test_number.Clear();
success = phone_util_.GetExampleNumberForType(RegionCode::US(),
PhoneNumberUtil::MOBILE,
&test_number);
EXPECT_TRUE(success);
EXPECT_NE(PhoneNumber::default_instance(), test_number);
- test_number.Clear();
// CS is an invalid region, so we have no data for it. We should return false.
+ test_number.Clear();
EXPECT_FALSE(phone_util_.GetExampleNumberForType(RegionCode::CS(),
PhoneNumberUtil::MOBILE,
&test_number));
EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
+ // RegionCode 001 is reserved for supporting non-geographical country calling
+ // code. We don't support getting an example number for it with this method.
+ EXPECT_FALSE(phone_util_.GetExampleNumber(RegionCode::UN001(), &test_number));
+}
+
+TEST_F(PhoneNumberUtilTest, GetExampleNumberForNonGeoEntity) {
+ PhoneNumber toll_free_number;
+ toll_free_number.set_country_code(800);
+ toll_free_number.set_national_number(12345678ULL);
+ PhoneNumber test_number;
+ bool success =
+ phone_util_.GetExampleNumberForNonGeoEntity(800 , &test_number);
+ EXPECT_TRUE(success);
+ EXPECT_EQ(toll_free_number, test_number);
+
+ PhoneNumber universal_premium_rate;
+ universal_premium_rate.set_country_code(979);
+ universal_premium_rate.set_national_number(123456789ULL);
+ success = phone_util_.GetExampleNumberForNonGeoEntity(979 , &test_number);
+ EXPECT_TRUE(success);
+ EXPECT_EQ(universal_premium_rate, test_number);
}
TEST_F(PhoneNumberUtilTest, FormatUSNumber) {
&formatted_number);
EXPECT_EQ("+1 900 253 0000", formatted_number);
phone_util_.Format(test_number, PhoneNumberUtil::RFC3966, &formatted_number);
- EXPECT_EQ("+1-900-253-0000", formatted_number);
+ EXPECT_EQ("tel:+1-900-253-0000", formatted_number);
test_number.set_national_number(0ULL);
phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
EXPECT_EQ("0", formatted_number);
&formatted_number);
EXPECT_EQ("+49 30/1234", formatted_number);
phone_util_.Format(test_number, PhoneNumberUtil::RFC3966, &formatted_number);
- EXPECT_EQ("+49-30-1234", formatted_number);
+ EXPECT_EQ("tel:+49-30-1234", formatted_number);
test_number.set_national_number(291123ULL);
phone_util_.Format(test_number, PhoneNumberUtil::NATIONAL, &formatted_number);
&formatted_number);
EXPECT_EQ("9477 7892", formatted_number);
+ test_number.set_country_code(800);
+ test_number.set_national_number(12345678ULL);
+ phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
+ &formatted_number);
+ EXPECT_EQ("011 800 1234 5678", formatted_number);
+
test_number.set_country_code(54);
test_number.set_national_number(91187654321ULL);
phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::US(),
phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::AQ(),
&formatted_number);
EXPECT_EQ("+1 650 253 0000", formatted_number);
+ // For region code 001, the out-of-country format always turns into the
+ // international format.
+ phone_util_.FormatOutOfCountryCallingNumber(test_number, RegionCode::UN001(),
+ &formatted_number);
+ EXPECT_EQ("+1 650 253 0000", formatted_number);
}
TEST_F(PhoneNumberUtilTest, FormatOutOfCountryWithPreferredIntlPrefix) {
RegionCode::SG(),
&formatted_number);
EXPECT_EQ("+61 1-800-SIX-FLAG", formatted_number);
+ // Testing the case of calling from a non-supported region.
+ phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
+ RegionCode::AQ(),
+ &formatted_number);
+ EXPECT_EQ("+61 1-800-SIX-FLAG", formatted_number);
// Testing the case with an invalid country code.
formatted_number.clear();
&formatted_number);
// No country-code stripping can be done.
EXPECT_EQ("00 1 180-SIX", formatted_number);
+ // Testing the case of calling from a non-supported region.
+ phone_util_.FormatOutOfCountryKeepingAlphaChars(alpha_numeric_number,
+ RegionCode::AQ(),
+ &formatted_number);
+ // No country-code stripping can be done since the number is invalid.
+ EXPECT_EQ("+1 180-SIX", formatted_number);
}
TEST_F(PhoneNumberUtilTest, FormatWithCarrierCode) {
// Here the international rule is used, so no carrier code should be present.
phone_util_.Format(ar_number, PhoneNumberUtil::E164, &formatted_number);
EXPECT_EQ("+5491234125678", formatted_number);
+
// We don't support this for the US so there should be no change.
PhoneNumber us_number;
us_number.set_country_code(1);
phone_util_.FormatNationalNumberWithCarrierCode(us_number, "15",
&formatted_number);
EXPECT_EQ("424 123 1234", formatted_number);
+
+ // Invalid country code should just get the NSN.
+ PhoneNumber invalid_number;
+ invalid_number.set_country_code(kInvalidCountryCode);
+ invalid_number.set_national_number(12345ULL);
+ phone_util_.FormatNationalNumberWithCarrierCode(invalid_number, "89",
+ &formatted_number);
+ EXPECT_EQ("12345", formatted_number);
}
TEST_F(PhoneNumberUtilTest, FormatWithPreferredCarrierCode) {
TEST_F(PhoneNumberUtilTest, FormatNumberForMobileDialing) {
PhoneNumber test_number;
string formatted_number;
- test_number.set_country_code(1);
+ // Numbers are normally dialed in national format in-country, and
+ // international format from outside the country.
+ test_number.set_country_code(49);
+ test_number.set_national_number(30123456ULL);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::DE(), false, /* remove formatting */
+ &formatted_number);
+ EXPECT_EQ("030123456", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::CH(), false, /* remove formatting */
+ &formatted_number);
+ EXPECT_EQ("+4930123456", formatted_number);
+
+ test_number.set_extension("1234");
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::DE(), false, /* remove formatting */
+ &formatted_number);
+ EXPECT_EQ("030123456", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::CH(), false, /* remove formatting */
+ &formatted_number);
+ EXPECT_EQ("+4930123456", formatted_number);
+
+ test_number.set_country_code(1);
+ test_number.clear_extension();
// US toll free numbers are marked as noInternationalDialling in the test
- // metadata for testing purposes.
+ // metadata for testing purposes. For such numbers, we expect nothing to be
+ // returned when the region code is not the same one.
test_number.set_national_number(8002530000ULL);
phone_util_.FormatNumberForMobileDialing(
- test_number, RegionCode::US(), true, &formatted_number);
+ test_number, RegionCode::US(), true, /* keep formatting */
+ &formatted_number);
EXPECT_EQ("800 253 0000", formatted_number);
phone_util_.FormatNumberForMobileDialing(
test_number, RegionCode::CN(), true, &formatted_number);
EXPECT_EQ("", formatted_number);
phone_util_.FormatNumberForMobileDialing(
- test_number, RegionCode::US(), false, &formatted_number);
+ test_number, RegionCode::US(), false, /* remove formatting */
+ &formatted_number);
EXPECT_EQ("8002530000", formatted_number);
phone_util_.FormatNumberForMobileDialing(
test_number, RegionCode::CN(), false, &formatted_number);
phone_util_.FormatNumberForMobileDialing(
test_number, RegionCode::US(), false, &formatted_number);
EXPECT_EQ("+16502530000", formatted_number);
+
+ // An invalid US number, which is one digit too long.
+ test_number.set_national_number(65025300001ULL);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::US(), true, &formatted_number);
+ EXPECT_EQ("+1 65025300001", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::US(), false, &formatted_number);
+ EXPECT_EQ("+165025300001", formatted_number);
+
+ // Star numbers. In real life they appear in Israel, but we have them in JP
+ // in our test metadata.
+ test_number.set_country_code(81);
+ test_number.set_national_number(2345ULL);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::JP(), true, &formatted_number);
+ EXPECT_EQ("*2345", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::JP(), false, &formatted_number);
+ EXPECT_EQ("*2345", formatted_number);
+
+ test_number.set_country_code(800);
+ test_number.set_national_number(12345678ULL);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::JP(), false, &formatted_number);
+ EXPECT_EQ("+80012345678", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::JP(), true, &formatted_number);
+ EXPECT_EQ("+800 1234 5678", formatted_number);
+
+ // UAE numbers beginning with 600 (classified as UAN) need to be dialled
+ // without +971 locally.
+ test_number.set_country_code(971);
+ test_number.set_national_number(600123456ULL);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::JP(), false, &formatted_number);
+ EXPECT_EQ("+971600123456", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::AE(), true, &formatted_number);
+ EXPECT_EQ("600123456", formatted_number);
+
+ test_number.set_country_code(52);
+ test_number.set_national_number(3312345678ULL);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::MX(), false, &formatted_number);
+ EXPECT_EQ("+523312345678", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::US(), false, &formatted_number);
+ EXPECT_EQ("+523312345678", formatted_number);
+
+ // Non-geographical numbers should always be dialed in international format.
+ test_number.set_country_code(800);
+ test_number.set_national_number(12345678ULL);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::US(), false, &formatted_number);
+ EXPECT_EQ("+80012345678", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::UN001(), false, &formatted_number);
+ EXPECT_EQ("+80012345678", formatted_number);
+
+ // Test that a short number is formatted correctly for mobile dialing within
+ // the region, and is not diallable from outside the region.
+ test_number.set_country_code(49);
+ test_number.set_national_number(123L);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::DE(), false, &formatted_number);
+ EXPECT_EQ("123", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::IT(), false, &formatted_number);
+ EXPECT_EQ("", formatted_number);
+
+ // Test the special logic for Hungary, where the national prefix must be
+ // added before dialing from a mobile phone for regular length numbers, but
+ // not for short numbers.
+ test_number.set_country_code(36);
+ test_number.set_national_number(301234567L);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::HU(), false, &formatted_number);
+ EXPECT_EQ("06301234567", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::JP(), false, &formatted_number);
+ EXPECT_EQ("+36301234567", formatted_number);
+ test_number.set_national_number(104L);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::HU(), false, &formatted_number);
+ EXPECT_EQ("104", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::JP(), false, &formatted_number);
+ EXPECT_EQ("", formatted_number);
+
+ // Test the special logic for NANPA countries, for which regular length phone
+ // numbers are always output in international format, but short numbers are
+ // in national format.
+ test_number.set_country_code(1);
+ test_number.set_national_number(6502530000LL);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::US(), false, &formatted_number);
+ EXPECT_EQ("+16502530000", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::CA(), false, &formatted_number);
+ EXPECT_EQ("+16502530000", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::BR(), false, &formatted_number);
+ EXPECT_EQ("+16502530000", formatted_number);
+ test_number.set_national_number(911L);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::US(), false, &formatted_number);
+ EXPECT_EQ("911", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::CA(), false, &formatted_number);
+ EXPECT_EQ("", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::BR(), false, &formatted_number);
+ EXPECT_EQ("", formatted_number);
+ // Test that the Australian emergency number 000 is formatted correctly.
+ test_number.set_country_code(61);
+ test_number.set_national_number(0L);
+ test_number.set_italian_leading_zero(true);
+ test_number.set_number_of_leading_zeros(2);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::AU(), false, &formatted_number);
+ EXPECT_EQ("000", formatted_number);
+ phone_util_.FormatNumberForMobileDialing(
+ test_number, RegionCode::NZ(), false, &formatted_number);
+ EXPECT_EQ("", formatted_number);
}
TEST_F(PhoneNumberUtilTest, FormatByPattern) {
number_formats,
&formatted_number);
EXPECT_EQ("+1 (650) 253-0000", formatted_number);
+ phone_util_.FormatByPattern(test_number, PhoneNumberUtil::RFC3966,
+ number_formats,
+ &formatted_number);
+ EXPECT_EQ("tel:+1-650-253-0000", formatted_number);
// $NP is set to '1' for the US. Here we check that for other NANPA countries
// the US rules are followed.
test_number.set_national_number(301234ULL);
phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
EXPECT_EQ("+49301234", formatted_number);
+
+ test_number.set_country_code(800);
+ test_number.set_national_number(12345678ULL);
+ phone_util_.Format(test_number, PhoneNumberUtil::E164, &formatted_number);
+ EXPECT_EQ("+80012345678", formatted_number);
}
TEST_F(PhoneNumberUtilTest, FormatNumberWithExtension) {
EXPECT_EQ("03-331 6005 ext. 1234", formatted_number);
// Uses RFC 3966 syntax.
phone_util_.Format(nz_number, PhoneNumberUtil::RFC3966, &formatted_number);
- EXPECT_EQ("+64-3-331-6005;ext=1234", formatted_number);
+ EXPECT_EQ("tel:+64-3-331-6005;ext=1234", formatted_number);
// Extension prefix overridden in the territory information for the US:
PhoneNumber us_number_with_extension;
us_number_with_extension.set_country_code(1);
number.set_national_number(293744000ULL);
EXPECT_EQ(1, phone_util_.GetLengthOfGeographicalAreaCode(number));
+ // Italian numbers - there is no national prefix, but it still has an area
+ // code.
+ number.set_country_code(39);
+ number.set_national_number(236618300ULL);
+ number.set_italian_leading_zero(true);
+ EXPECT_EQ(2, phone_util_.GetLengthOfGeographicalAreaCode(number));
+
// Google Singapore. Singapore has no area code and no national prefix.
number.set_country_code(65);
number.set_national_number(65218000ULL);
+ number.set_italian_leading_zero(false);
+ EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
+
+ // An international toll free number, which has no area code.
+ number.set_country_code(800);
+ number.set_national_number(12345678ULL);
EXPECT_EQ(0, phone_util_.GetLengthOfGeographicalAreaCode(number));
}
number.set_national_number(1155303000ULL);
EXPECT_EQ(2, phone_util_.GetLengthOfNationalDestinationCode(number));
+ // An Argentinian mobile which has NDC "911".
+ number.set_country_code(54);
+ number.set_national_number(91187654321ULL);
+ EXPECT_EQ(3, phone_util_.GetLengthOfNationalDestinationCode(number));
+
// Google Sydney, which has NDC "2".
number.set_country_code(61);
number.set_national_number(293744000ULL);
number.set_national_number(12345ULL);
number.set_extension("321");
EXPECT_EQ(0, phone_util_.GetLengthOfNationalDestinationCode(number));
+
+ // An international toll free number, which has NDC "1234".
+ number.Clear();
+ number.set_country_code(800);
+ number.set_national_number(12345678ULL);
+ EXPECT_EQ(4, phone_util_.GetLengthOfNationalDestinationCode(number));
+}
+
+TEST_F(PhoneNumberUtilTest, GetCountryMobileToken) {
+ int country_calling_code;
+ string mobile_token;
+
+ country_calling_code = phone_util_.GetCountryCodeForRegion(RegionCode::MX());
+ phone_util_.GetCountryMobileToken(country_calling_code, &mobile_token);
+ EXPECT_EQ("1", mobile_token);
+
+ // Country calling code for Sweden, which has no mobile token.
+ country_calling_code = phone_util_.GetCountryCodeForRegion(RegionCode::SE());
+ phone_util_.GetCountryMobileToken(country_calling_code, &mobile_token);
+ EXPECT_EQ("", mobile_token);
}
TEST_F(PhoneNumberUtilTest, ExtractPossibleNumber) {
TEST_F(PhoneNumberUtilTest, IsNANPACountry) {
EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::US()));
EXPECT_TRUE(phone_util_.IsNANPACountry(RegionCode::BS()));
+ EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::DE()));
+ EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::GetUnknown()));
+ EXPECT_FALSE(phone_util_.IsNANPACountry(RegionCode::UN001()));
}
TEST_F(PhoneNumberUtilTest, IsValidNumber) {
nz_number.set_country_code(64);
nz_number.set_national_number(21387835ULL);
EXPECT_TRUE(phone_util_.IsValidNumber(nz_number));
+
+ PhoneNumber intl_toll_free_number;
+ intl_toll_free_number.set_country_code(800);
+ intl_toll_free_number.set_national_number(12345678ULL);
+ EXPECT_TRUE(phone_util_.IsValidNumber(intl_toll_free_number));
+
+ PhoneNumber universal_premium_rate;
+ universal_premium_rate.set_country_code(979);
+ universal_premium_rate.set_national_number(123456789ULL);
+ EXPECT_TRUE(phone_util_.IsValidNumber(universal_premium_rate));
}
TEST_F(PhoneNumberUtilTest, IsValidForRegion) {
re_number.set_national_number(800123456ULL);
EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::YT()));
EXPECT_TRUE(phone_util_.IsValidNumberForRegion(re_number, RegionCode::RE()));
+
+ PhoneNumber intl_toll_free_number;
+ intl_toll_free_number.set_country_code(800);
+ intl_toll_free_number.set_national_number(12345678ULL);
+ EXPECT_TRUE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
+ RegionCode::UN001()));
+ EXPECT_FALSE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
+ RegionCode::US()));
+ EXPECT_FALSE(phone_util_.IsValidNumberForRegion(intl_toll_free_number,
+ RegionCode::ZZ()));
+
+ PhoneNumber invalid_number;
+ // Invalid country calling codes.
+ invalid_number.set_country_code(3923);
+ invalid_number.set_national_number(2366ULL);
+ EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
+ RegionCode::ZZ()));
+ invalid_number.set_country_code(3923);
+ invalid_number.set_national_number(2366ULL);
+ EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
+ RegionCode::UN001()));
+ invalid_number.set_country_code(0);
+ invalid_number.set_national_number(2366ULL);
+ EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
+ RegionCode::UN001()));
+ invalid_number.set_country_code(0);
+ EXPECT_FALSE(phone_util_.IsValidNumberForRegion(invalid_number,
+ RegionCode::ZZ()));
}
TEST_F(PhoneNumberUtilTest, IsNotValidNumber) {
nz_number.set_country_code(64);
nz_number.set_national_number(3316005ULL);
EXPECT_FALSE(phone_util_.IsValidNumber(nz_number));
+
+ PhoneNumber invalid_number;
+ // Invalid country calling codes.
+ invalid_number.set_country_code(3923);
+ invalid_number.set_national_number(2366ULL);
+ EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
+ invalid_number.set_country_code(0);
+ EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
+
+ PhoneNumber intl_toll_free_number_too_long;
+ intl_toll_free_number_too_long.set_country_code(800);
+ intl_toll_free_number_too_long.set_national_number(123456789ULL);
+ EXPECT_FALSE(phone_util_.IsValidNumber(intl_toll_free_number_too_long));
+}
+
+TEST_F(PhoneNumberUtilTest, GetRegionCodeForCountryCode) {
+ string region_code;
+ phone_util_.GetRegionCodeForCountryCode(1, ®ion_code);
+ EXPECT_EQ(RegionCode::US(), region_code);
+ phone_util_.GetRegionCodeForCountryCode(44, ®ion_code);
+ EXPECT_EQ(RegionCode::GB(), region_code);
+ phone_util_.GetRegionCodeForCountryCode(49, ®ion_code);
+ EXPECT_EQ(RegionCode::DE(), region_code);
+ phone_util_.GetRegionCodeForCountryCode(800, ®ion_code);
+ EXPECT_EQ(RegionCode::UN001(), region_code);
+ phone_util_.GetRegionCodeForCountryCode(979, ®ion_code);
+ EXPECT_EQ(RegionCode::UN001(), region_code);
+}
+
+TEST_F(PhoneNumberUtilTest, GetRegionCodeForNumber) {
+ string region_code;
+ PhoneNumber bs_number;
+ bs_number.set_country_code(1);
+ bs_number.set_national_number(2423232345ULL);
+ phone_util_.GetRegionCodeForNumber(bs_number, ®ion_code);
+ EXPECT_EQ(RegionCode::BS(), region_code);
+
+ PhoneNumber us_number;
+ us_number.set_country_code(1);
+ us_number.set_national_number(4241231234ULL);
+ phone_util_.GetRegionCodeForNumber(us_number, ®ion_code);
+ EXPECT_EQ(RegionCode::US(), region_code);
+
+ PhoneNumber gb_mobile;
+ gb_mobile.set_country_code(44);
+ gb_mobile.set_national_number(7912345678ULL);
+ phone_util_.GetRegionCodeForNumber(gb_mobile, ®ion_code);
+ EXPECT_EQ(RegionCode::GB(), region_code);
+
+ PhoneNumber intl_toll_free_number;
+ intl_toll_free_number.set_country_code(800);
+ intl_toll_free_number.set_national_number(12345678ULL);
+ phone_util_.GetRegionCodeForNumber(intl_toll_free_number, ®ion_code);
+ EXPECT_EQ(RegionCode::UN001(), region_code);
+
+ PhoneNumber universal_premium_rate;
+ universal_premium_rate.set_country_code(979);
+ universal_premium_rate.set_national_number(123456789ULL);
+ phone_util_.GetRegionCodeForNumber(universal_premium_rate, ®ion_code);
+ EXPECT_EQ(RegionCode::UN001(), region_code);
}
TEST_F(PhoneNumberUtilTest, IsPossibleNumber) {
number.set_national_number(2070313000ULL);
EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
+ number.set_country_code(800);
+ number.set_national_number(12345678ULL);
+ EXPECT_TRUE(phone_util_.IsPossibleNumber(number));
+
EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 253 0000",
RegionCode::US()));
EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+1 650 GOO OGLE",
RegionCode::GB()));
EXPECT_TRUE(phone_util_.IsPossibleNumberForString("3331 6005",
RegionCode::NZ()));
+ EXPECT_TRUE(phone_util_.IsPossibleNumberForString("+800 1234 5678",
+ RegionCode::UN001()));
}
TEST_F(PhoneNumberUtilTest, IsPossibleNumberWithReason) {
EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
phone_util_.IsPossibleNumberWithReason(number));
- // Try with number that we don't have metadata for.
- PhoneNumber ad_number;
- ad_number.set_country_code(376);
- ad_number.set_national_number(12345ULL);
- EXPECT_EQ(PhoneNumberUtil::IS_POSSIBLE,
- phone_util_.IsPossibleNumberWithReason(ad_number));
- ad_number.set_country_code(376);
- ad_number.set_national_number(13ULL);
- EXPECT_EQ(PhoneNumberUtil::TOO_SHORT,
- phone_util_.IsPossibleNumberWithReason(ad_number));
- ad_number.set_country_code(376);
- ad_number.set_national_number(12345678901234567ULL);
+ number.set_country_code(800);
+ number.set_national_number(123456789ULL);
EXPECT_EQ(PhoneNumberUtil::TOO_LONG,
- phone_util_.IsPossibleNumberWithReason(ad_number));
+ phone_util_.IsPossibleNumberWithReason(number));
}
TEST_F(PhoneNumberUtilTest, IsNotPossibleNumber) {
number.set_national_number(65025300000ULL);
EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
+ number.set_country_code(800);
+ number.set_national_number(123456789ULL);
+ EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
+
number.set_country_code(1);
number.set_national_number(253000ULL);
EXPECT_FALSE(phone_util_.IsPossibleNumber(number));
RegionCode::GB()));
EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+44 300",
RegionCode::GB()));
+ EXPECT_FALSE(phone_util_.IsPossibleNumberForString("+800 1234 5678 9",
+ RegionCode::UN001()));
}
TEST_F(PhoneNumberUtilTest, TruncateTooLongNumber) {
EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
EXPECT_EQ(valid_number, too_long_number);
+ too_long_number.set_country_code(800);
+ too_long_number.set_national_number(123456789ULL);
+ valid_number.set_country_code(800);
+ valid_number.set_national_number(12345678ULL);
+ EXPECT_TRUE(phone_util_.TruncateTooLongNumber(&too_long_number));
+ EXPECT_EQ(valid_number, too_long_number);
+
// GB number 080 1234 5678, but entered with 4 extra digits at the end.
too_long_number.set_country_code(44);
too_long_number.set_national_number(80123456780123ULL);
EXPECT_EQ(too_short_number_copy, too_short_number);
}
+TEST_F(PhoneNumberUtilTest, IsNumberGeographical) {
+ PhoneNumber number;
+
+ number.set_country_code(1);
+ number.set_national_number(2423570000ULL);
+ EXPECT_FALSE(IsNumberGeographical(number)); // Bahamas, mobile phone number.
+
+ number.set_country_code(61);
+ number.set_national_number(236618300ULL);
+ EXPECT_TRUE(IsNumberGeographical(number)); // Australian fixed line number.
+
+ number.set_country_code(800);
+ number.set_national_number(12345678ULL);
+ EXPECT_FALSE(IsNumberGeographical(number)); // Internation toll free number.
+}
+
TEST_F(PhoneNumberUtilTest, IsLeadingZeroPossible) {
EXPECT_TRUE(IsLeadingZeroPossible(39)); // Italy
EXPECT_FALSE(IsLeadingZeroPossible(1)); // USA
- EXPECT_FALSE(IsLeadingZeroPossible(800)); // Not in metadata file, should
+ EXPECT_TRUE(IsLeadingZeroPossible(800)); // International toll free
+ EXPECT_FALSE(IsLeadingZeroPossible(979)); // International premium-rate
+ EXPECT_FALSE(IsLeadingZeroPossible(888)); // Not in metadata file, should
// return default value of false.
}
-TEST_F(PhoneNumberUtilTest, FormatUsingOriginalNumberFormat) {
+TEST_F(PhoneNumberUtilTest, FormatInOriginalFormat) {
PhoneNumber phone_number;
string formatted_number;
phone_number.Clear();
formatted_number.clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
- phone_util_.ParseAndKeepRawInput("442087654321", RegionCode::GB(),
+ phone_util_.ParseAndKeepRawInput("442087654321", RegionCode::GB(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
+ &formatted_number);
+ EXPECT_EQ("44 20 8765 4321", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("+442087654321", RegionCode::GB(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
+ &formatted_number);
+ EXPECT_EQ("(020) 8765 4321", formatted_number);
+
+ // Invalid numbers that we have a formatting pattern for should be formatted
+ // properly. Note area codes starting with 7 are intentionally excluded in
+ // the test metadata for testing purposes.
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("7345678901", RegionCode::US(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
+ &formatted_number);
+ EXPECT_EQ("734 567 8901", formatted_number);
+
+ // US is not a leading zero country, and the presence of the leading zero
+ // leads us to format the number using raw_input.
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("0734567 8901", RegionCode::US(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
+ &formatted_number);
+ EXPECT_EQ("0734567 8901", formatted_number);
+
+ // This number is valid, but we don't have a formatting pattern for it. Fall
+ // back to the raw input.
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("02-4567-8900", RegionCode::KR(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::KR(),
+ &formatted_number);
+ EXPECT_EQ("02-4567-8900", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("01180012345678",
+ RegionCode::US(), &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
+ &formatted_number);
+ EXPECT_EQ("011 800 1234 5678", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("+80012345678", RegionCode::KR(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::KR(),
+ &formatted_number);
+ EXPECT_EQ("+800 1234 5678", formatted_number);
+
+ // US local numbers are formatted correctly, as we have formatting patterns
+ // for them.
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("2530000", RegionCode::US(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
+ &formatted_number);
+ EXPECT_EQ("253 0000", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // Number with national prefix in the US.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("18003456789", RegionCode::US(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
+ &formatted_number);
+ EXPECT_EQ("1 800 345 6789", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // Number without national prefix in the UK.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("2087654321", RegionCode::GB(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
+ &formatted_number);
+ EXPECT_EQ("20 8765 4321", formatted_number);
+ // Make sure no metadata is modified as a result of the previous function
+ // call.
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("+442087654321", RegionCode::GB(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
+ &formatted_number);
+ EXPECT_EQ("(020) 8765 4321", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // Number with national prefix in Mexico.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("013312345678", RegionCode::MX(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
+ &formatted_number);
+ EXPECT_EQ("01 33 1234 5678", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // Number without national prefix in Mexico.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("3312345678", RegionCode::MX(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
+ &formatted_number);
+ EXPECT_EQ("33 1234 5678", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // Italian fixed-line number.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("0212345678", RegionCode::IT(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::IT(),
+ &formatted_number);
+ EXPECT_EQ("02 1234 5678", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // Number with national prefix in Japan.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("00777012", RegionCode::JP(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
+ &formatted_number);
+ EXPECT_EQ("0077-7012", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // Number without national prefix in Japan.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("0777012", RegionCode::JP(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
+ &formatted_number);
+ EXPECT_EQ("0777012", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // Number with carrier code in Brazil.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("012 3121286979", RegionCode::BR(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::BR(),
+ &formatted_number);
+ EXPECT_EQ("012 3121286979", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ // The default national prefix used in this case is 045. When a number with
+ // national prefix 044 is entered, we return the raw input as we don't want to
+ // change the number entered.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("044(33)1234-5678",
+ RegionCode::MX(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
+ &formatted_number);
+ EXPECT_EQ("044(33)1234-5678", formatted_number);
+
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("045(33)1234-5678",
+ RegionCode::MX(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::MX(),
+ &formatted_number);
+ EXPECT_EQ("045 33 1234 5678", formatted_number);
+
+ // The default international prefix used in this case is 0011. When a number
+ // with international prefix 0012 is entered, we return the raw input as we
+ // don't want to change the number entered.
+ phone_number.Clear();
+ formatted_number.clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.ParseAndKeepRawInput("0012 16502530000",
+ RegionCode::AU(),
&phone_number));
- phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::AU(),
&formatted_number);
- EXPECT_EQ("44 20 8765 4321", formatted_number);
+ EXPECT_EQ("0012 16502530000", formatted_number);
phone_number.Clear();
formatted_number.clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
- phone_util_.Parse("+442087654321", RegionCode::GB(),
- &phone_number));
- phone_util_.FormatInOriginalFormat(phone_number, RegionCode::GB(),
+ phone_util_.ParseAndKeepRawInput("0011 16502530000",
+ RegionCode::AU(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::AU(),
&formatted_number);
- EXPECT_EQ("(020) 8765 4321", formatted_number);
+ EXPECT_EQ("0011 1 650 253 0000", formatted_number);
- // Invalid numbers should be formatted using its raw input when that is
- // available. Note area codes starting with 7 are intentionally excluded in
- // the test metadata for testing purposes.
+ // Test the star sign is not removed from or added to the original input by
+ // this method.
phone_number.Clear();
formatted_number.clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
- phone_util_.ParseAndKeepRawInput("7345678901", RegionCode::US(),
+ phone_util_.ParseAndKeepRawInput("*1234",
+ RegionCode::JP(),
&phone_number));
- phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
&formatted_number);
- EXPECT_EQ("7345678901", formatted_number);
-
- // When the raw input is unavailable, format as usual.
+ EXPECT_EQ("*1234", formatted_number);
phone_number.Clear();
formatted_number.clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
- phone_util_.Parse("7345678901", RegionCode::US(), &phone_number));
+ phone_util_.ParseAndKeepRawInput("1234",
+ RegionCode::JP(),
+ &phone_number));
+ phone_util_.FormatInOriginalFormat(phone_number, RegionCode::JP(),
+ &formatted_number);
+ EXPECT_EQ("1234", formatted_number);
+
+ // Test that an invalid national number without raw input is just formatted
+ // as the national number.
+ phone_number.Clear();
+ formatted_number.clear();
+ phone_number.set_country_code_source(PhoneNumber::FROM_DEFAULT_COUNTRY);
+ phone_number.set_country_code(1);
+ phone_number.set_national_number(650253000ULL);
phone_util_.FormatInOriginalFormat(phone_number, RegionCode::US(),
&formatted_number);
- EXPECT_EQ("734 567 8901", formatted_number);
+ EXPECT_EQ("650253000", formatted_number);
}
TEST_F(PhoneNumberUtilTest, IsPremiumRate) {
number.set_country_code(49);
number.set_national_number(90091234567ULL);
EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
+
+ number.set_country_code(979);
+ number.set_national_number(123456789ULL);
+ EXPECT_EQ(PhoneNumberUtil::PREMIUM_RATE, phone_util_.GetNumberType(number));
}
TEST_F(PhoneNumberUtilTest, IsTollFree) {
number.set_country_code(49);
number.set_national_number(8001234567ULL);
EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
+
+ number.set_country_code(800);
+ number.set_national_number(12345678ULL);
+ EXPECT_EQ(PhoneNumberUtil::TOLL_FREE, phone_util_.GetNumberType(number));
}
TEST_F(PhoneNumberUtilTest, IsMobile) {
EXPECT_EQ(1, phone_util_.GetCountryCodeForRegion(RegionCode::US()));
EXPECT_EQ(64, phone_util_.GetCountryCodeForRegion(RegionCode::NZ()));
EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::GetUnknown()));
+ EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::UN001()));
// CS is already deprecated so the library doesn't support it.
EXPECT_EQ(0, phone_util_.GetCountryCodeForRegion(RegionCode::CS()));
}
GetNddPrefixForRegion(RegionCode::GetUnknown(), false, &ndd_prefix);
EXPECT_EQ("", ndd_prefix);
+ GetNddPrefixForRegion(RegionCode::UN001(), false, &ndd_prefix);
+ EXPECT_EQ("", ndd_prefix);
+
// CS is already deprecated so the library doesn't support it.
GetNddPrefixForRegion(RegionCode::CS(), false, &ndd_prefix);
EXPECT_EQ("", ndd_prefix);
}
TEST_F(PhoneNumberUtilTest, IsViablePhoneNumber) {
+ EXPECT_FALSE(IsViablePhoneNumber("1"));
// Only one or two digits before strange non-possible punctuation.
- EXPECT_FALSE(IsViablePhoneNumber("12. March"));
EXPECT_FALSE(IsViablePhoneNumber("1+1+1"));
EXPECT_FALSE(IsViablePhoneNumber("80+0"));
- EXPECT_FALSE(IsViablePhoneNumber("00"));
- // Three digits is viable.
+ // Two digits is viable.
+ EXPECT_TRUE(IsViablePhoneNumber("00"));
EXPECT_TRUE(IsViablePhoneNumber("111"));
// Alpha numbers.
EXPECT_TRUE(IsViablePhoneNumber("0800-4-pizza"));
EXPECT_TRUE(IsViablePhoneNumber("0800-4-PIZZA"));
+ // We need at least three digits before any alpha characters.
+ EXPECT_FALSE(IsViablePhoneNumber("08-PIZZA"));
+ EXPECT_FALSE(IsViablePhoneNumber("8-PIZZA"));
+ EXPECT_FALSE(IsViablePhoneNumber("12. March"));
+}
+
+TEST_F(PhoneNumberUtilTest, IsViablePhoneNumberNonAscii) {
// Only one or two digits before possible punctuation followed by more digits.
// The punctuation used here is the unicode character u+3000.
EXPECT_TRUE(IsViablePhoneNumber("1\xE3\x80\x80" "34" /* "1 34" */));
}
TEST_F(PhoneNumberUtilTest, NormaliseRemovePunctuation) {
- string input_number("034-56&+#234");
+ string input_number("034-56&+#2" "\xC2\xAD" "34");
Normalize(&input_number);
static const string kExpectedOutput("03456234");
EXPECT_EQ(kExpectedOutput, input_number)
<< "Conversion did not correctly remove alpha characters";
}
+TEST_F(PhoneNumberUtilTest, NormaliseStripNonDiallableCharacters) {
+ string input_number("03*4-56&+a#234");
+ NormalizeDiallableCharsOnly(&input_number);
+ static const string kExpectedOutput("03*456+234");
+ EXPECT_EQ(kExpectedOutput, input_number)
+ << "Conversion did not correctly remove non-diallable characters";
+}
+
TEST_F(PhoneNumberUtilTest, MaybeStripInternationalPrefix) {
string international_prefix("00[39]");
string number_to_strip("0034567700-3898003");
EXPECT_EQ(stripped_number, phone_number);
number.Clear();
+ phone_number.assign("+80012345678");
+ stripped_number.assign("12345678");
+ expected_country_code = 800;
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ MaybeExtractCountryCode(metadata, true, &phone_number, &number));
+ EXPECT_EQ(expected_country_code, number.country_code());
+ EXPECT_EQ(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN,
+ number.country_code_source());
+ EXPECT_EQ(stripped_number, phone_number);
+
+ number.Clear();
phone_number.assign("+6423456789");
stripped_number.assign("23456789");
expected_country_code = 64;
phone_util_.Format(ad_number, PhoneNumberUtil::NATIONAL, &formatted_number);
EXPECT_EQ("12345", formatted_number);
EXPECT_EQ(PhoneNumberUtil::UNKNOWN, phone_util_.GetNumberType(ad_number));
- EXPECT_TRUE(phone_util_.IsValidNumber(ad_number));
+ EXPECT_FALSE(phone_util_.IsValidNumber(ad_number));
// Test dialing a US number from within Andorra.
PhoneNumber us_number;
EXPECT_EQ("00 1 650 253 0000", formatted_number);
}
-TEST_F(PhoneNumberUtilTest, UnknownCountryCallingCodeForValidation) {
+TEST_F(PhoneNumberUtilTest, UnknownCountryCallingCode) {
PhoneNumber invalid_number;
- invalid_number.set_country_code(0);
- invalid_number.set_national_number(1234ULL);
+ invalid_number.set_country_code(kInvalidCountryCode);
+ invalid_number.set_national_number(12345ULL);
+
EXPECT_FALSE(phone_util_.IsValidNumber(invalid_number));
+
+ // It's not very well defined as to what the E164 representation for a number
+ // with an invalid country calling code is, but just prefixing the country
+ // code and national number is about the best we can do.
+ string formatted_number;
+ phone_util_.Format(invalid_number, PhoneNumberUtil::E164, &formatted_number);
+ EXPECT_EQ("+212345", formatted_number);
}
TEST_F(PhoneNumberUtilTest, IsNumberMatchMatches) {
- // Test simple matches where formatting is different, or leading zeroes, or
+ // Test simple matches where formatting is different, or leading zeros, or
// country code has been specified.
EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+64 3 331 6005",
"+64 03 331 6005"));
EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings("+800 1234 5678",
+ "+80012345678"));
+ EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+64 03 331-6005",
"+64 03331 6005"));
EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
"+6433316005"));
+ EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings(
+ "+64 3 331-6005", "tel:+64-3-331-6005;isub=123"));
// Test alpha numbers.
EXPECT_EQ(PhoneNumberUtil::EXACT_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+1800 siX-Flags",
phone_util_.IsNumberMatch(br_number_1, br_number_2));
}
-TEST_F(PhoneNumberUtilTest, IsNumberMatchNonMetches) {
+TEST_F(PhoneNumberUtilTest, IsNumberMatchNonMatches) {
// NSN matches.
EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("03 331 6005",
"03 331 6006"));
+ EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings("+800 1234 5678",
+ "+1 800 1234 5678"));
// Different country code, partial number match.
EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 extn 1234",
"+0116433316005#1235"));
+ EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings(
+ "+64 3 331-6005 extn 1234", "tel:+64-3-331-6005;ext=1235"));
// NSN matches, but extension is different - not the same number.
EXPECT_EQ(PhoneNumberUtil::NO_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005 ext.1235",
"3 331 6005#1234"));
// Invalid numbers that can't be parsed.
EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
- phone_util_.IsNumberMatchWithTwoStrings("43", "3 331 6043"));
+ phone_util_.IsNumberMatchWithTwoStrings("4", "3 331 6043"));
// Invalid numbers that can't be parsed.
EXPECT_EQ(PhoneNumberUtil::INVALID_NUMBER,
phone_util_.IsNumberMatchWithTwoStrings("+43", "+64 3 331 6005"));
EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
"03 331 6005"));
+ EXPECT_EQ(PhoneNumberUtil::NSN_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings(
+ "+64 3 331-6005",
+ "tel:03-331-6005;isub=1234;phone-context=abc.nz"));
PhoneNumber nz_number;
nz_number.set_country_code(64);
EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("+64 3 331-6005",
"331 6005"));
+ EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings(
+ "+64 3 331-6005", "tel:331-6005;phone-context=abc.nz"));
+ EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings(
+ "+64 3 331-6005",
+ "tel:331-6005;isub=1234;phone-context=abc.nz"));
+ EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings(
+ "+64 3 331-6005",
+ "tel:331-6005;isub=1234;phone-context=abc.nz;a=%A1"));
// We did not know that the "0" was a national prefix since neither number has
// a country code, so this is considered a SHORT_NSN_MATCH.
"331 6005"));
EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
+ phone_util_.IsNumberMatchWithTwoStrings(
+ "3 331-6005", "tel:331-6005;phone-context=abc.nz"));
+ EXPECT_EQ(PhoneNumberUtil::SHORT_NSN_MATCH,
phone_util_.IsNumberMatchWithTwoStrings("3 331-6005",
"+64 331 6005"));
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("03 331 6005", RegionCode::NZ(), &test_number));
EXPECT_EQ(nz_number, test_number);
-
+ // Test parsing RFC3966 format with a phone context.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:03-331-6005;phone-context=+64",
+ RegionCode::NZ(), &test_number));
+ EXPECT_EQ(nz_number, test_number);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:331-6005;phone-context=+64-3",
+ RegionCode::NZ(), &test_number));
+ EXPECT_EQ(nz_number, test_number);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:331-6005;phone-context=+64-3",
+ RegionCode::US(), &test_number));
+ EXPECT_EQ(nz_number, test_number);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("My number is tel:03-331-6005;phone-context=+64",
+ RegionCode::NZ(), &test_number));
+ EXPECT_EQ(nz_number, test_number);
+ // Test parsing RFC3966 format with optional user-defined parameters. The
+ // parameters will appear after the context if present.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:03-331-6005;phone-context=+64;a=%A1",
+ RegionCode::NZ(), &test_number));
+ EXPECT_EQ(nz_number, test_number);
+ // Test parsing RFC3966 with an ISDN subaddress.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:03-331-6005;isub=12345;phone-context=+64",
+ RegionCode::NZ(), &test_number));
+ EXPECT_EQ(nz_number, test_number);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:+64-3-331-6005;isub=12345",
+ RegionCode::US(), &test_number));
+ EXPECT_EQ(nz_number, test_number);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("03-331-6005;phone-context=+64",
+ RegionCode::NZ(), &test_number));
+ EXPECT_EQ(nz_number, test_number);
// Testing international prefixes.
// Should strip country code.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0064 3 331 6005",
RegionCode::NZ(), &test_number));
EXPECT_EQ(nz_number, test_number);
// Try again, but this time we have an international number with Region Code
// US. It should recognise the country code and parse accordingly.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("01164 3 331 6005",
RegionCode::US(), &test_number));
EXPECT_EQ(nz_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+64 3 331 6005",
RegionCode::US(), &test_number));
EXPECT_EQ(nz_number, test_number);
// We should ignore the leading plus here, since it is not followed by a valid
// country code but instead is followed by the IDD for the US.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+01164 3 331 6005",
RegionCode::US(), &test_number));
EXPECT_EQ(nz_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+0064 3 331 6005",
RegionCode::NZ(), &test_number));
EXPECT_EQ(nz_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+ 00 64 3 331 6005",
RegionCode::NZ(), &test_number));
EXPECT_EQ(nz_number, test_number);
+ PhoneNumber us_local_number;
+ us_local_number.set_country_code(1);
+ us_local_number.set_national_number(2530000ULL);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:253-0000;phone-context=www.google.com",
+ RegionCode::US(), &test_number));
+ EXPECT_EQ(us_local_number, test_number);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse(
+ "tel:253-0000;isub=12345;phone-context=www.google.com",
+ RegionCode::US(), &test_number));
+ EXPECT_EQ(us_local_number, test_number);
+ // This is invalid because no "+" sign is present as part of phone-context.
+ // The phone context is simply ignored in this case just as if it contains a
+ // domain.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:2530000;isub=12345;phone-context=1-650",
+ RegionCode::US(), &test_number));
+ EXPECT_EQ(us_local_number, test_number);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:2530000;isub=12345;phone-context=1234.com",
+ RegionCode::US(), &test_number));
+ EXPECT_EQ(us_local_number, test_number);
+
// Test for http://b/issue?id=2247493
nz_number.Clear();
nz_number.set_country_code(64);
nz_number.set_national_number(64123456ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+64(0)64123456",
RegionCode::US(), &test_number));
PhoneNumber de_number;
de_number.set_country_code(49);
de_number.set_national_number(12345678ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("123/45678", RegionCode::DE(), &test_number));
EXPECT_EQ(de_number, test_number);
// Check it doesn't use the '1' as a country code when parsing if the phone
// number was already possible.
us_number.set_national_number(1234567890ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("123-456-7890", RegionCode::US(), &test_number));
EXPECT_EQ(us_number, test_number);
+
+ // Test star numbers. Although this is not strictly valid, we would like to
+ // make sure we can parse the output we produce when formatting the number.
+ PhoneNumber star_number;
+ star_number.set_country_code(81);
+ star_number.set_national_number(2345ULL);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("+81 *2345", RegionCode::JP(), &test_number));
+ EXPECT_EQ(star_number, test_number);
+
+ PhoneNumber short_number;
+ short_number.set_country_code(64);
+ short_number.set_national_number(12ULL);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("12", RegionCode::NZ(), &test_number));
+ EXPECT_EQ(short_number, test_number);
}
TEST_F(PhoneNumberUtilTest, ParseNumberWithAlphaCharacters) {
phone_util_.Parse("0800 DDA 005", RegionCode::NZ(), &test_number));
EXPECT_EQ(tollfree_number, test_number);
- test_number.Clear();
PhoneNumber premium_number;
premium_number.set_country_code(64);
premium_number.set_national_number(9003326005ULL);
// Not enough alpha characters for them to be considered intentional, so they
// are stripped.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0900 332 6005a",
RegionCode::NZ(), &test_number));
EXPECT_EQ(premium_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0900 332 600a5",
RegionCode::NZ(), &test_number));
EXPECT_EQ(premium_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0900 332 600A5",
RegionCode::NZ(), &test_number));
EXPECT_EQ(premium_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0900 a332 600A5",
RegionCode::NZ(), &test_number));
phone_util_.Parse("+1 (650) 333-6000",
RegionCode::US(), &test_number));
EXPECT_EQ(us_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+1-650-333-6000",
RegionCode::US(), &test_number));
// Calling the US number from Singapore by using different service providers
// 1st test: calling using SingTel IDD service (IDD is 001)
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0011-650-333-6000",
RegionCode::SG(), &test_number));
EXPECT_EQ(us_number, test_number);
// 2nd test: calling using StarHub IDD service (IDD is 008)
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0081-650-333-6000",
RegionCode::SG(), &test_number));
EXPECT_EQ(us_number, test_number);
// 3rd test: calling using SingTel V019 service (IDD is 019)
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0191-650-333-6000",
RegionCode::SG(), &test_number));
EXPECT_EQ(us_number, test_number);
// Calling the US number from Poland
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0~01-650-333-6000",
RegionCode::PL(), &test_number));
EXPECT_EQ(us_number, test_number);
// Using "++" at the start.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("++1 (650) 333-6000",
RegionCode::PL(), &test_number));
EXPECT_EQ(us_number, test_number);
// Using a full-width plus sign.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("\xEF\xBC\x8B" "1 (650) 333-6000",
/* "＋1 (650) 333-6000" */
RegionCode::SG(), &test_number));
+ // Using a soft hyphen U+00AD.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("1 (650) 333" "\xC2\xAD" "-6000",
+ /* "1 (650) 333-6000" */
+ RegionCode::US(), &test_number));
EXPECT_EQ(us_number, test_number);
// The whole number, including punctuation, is here represented in full-width
// form.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88"
"\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89"
EXPECT_EQ(us_number, test_number);
// Using the U+30FC dash.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("\xEF\xBC\x8B\xEF\xBC\x91\xE3\x80\x80\xEF\xBC\x88"
"\xEF\xBC\x96\xEF\xBC\x95\xEF\xBC\x90\xEF\xBC\x89"
/* "＋１ （６５０） ３３３ー６０００" */
RegionCode::SG(), &test_number));
EXPECT_EQ(us_number, test_number);
+
+ PhoneNumber toll_free_number;
+ toll_free_number.set_country_code(800);
+ toll_free_number.set_national_number(12345678ULL);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("011 800 1234 5678",
+ RegionCode::US(), &test_number));
+ EXPECT_EQ(toll_free_number, test_number);
}
TEST_F(PhoneNumberUtilTest, ParseWithLeadingZero) {
phone_util_.Parse("+39 02-36618 300",
RegionCode::NZ(), &test_number));
EXPECT_EQ(it_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("02-36618 300", RegionCode::IT(), &test_number));
EXPECT_EQ(it_number, test_number);
it_number.Clear();
it_number.set_country_code(39);
it_number.set_national_number(312345678ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("312 345 678", RegionCode::IT(), &test_number));
EXPECT_EQ(it_number, test_number);
phone_util_.Parse("+54 9 343 555 1212", RegionCode::AR(),
&test_number));
EXPECT_EQ(ar_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0343 15 555 1212", RegionCode::AR(),
&test_number));
EXPECT_EQ(ar_number, test_number);
ar_number.set_national_number(93715654320ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+54 9 3715 65 4320", RegionCode::AR(),
&test_number));
EXPECT_EQ(ar_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("03715 15 65 4320", RegionCode::AR(),
&test_number));
// Test parsing fixed-line numbers of Argentina.
ar_number.set_national_number(1137970000ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+54 11 3797 0000", RegionCode::AR(),
&test_number));
EXPECT_EQ(ar_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("011 3797 0000", RegionCode::AR(), &test_number));
EXPECT_EQ(ar_number, test_number);
ar_number.set_national_number(3715654321ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+54 3715 65 4321", RegionCode::AR(),
&test_number));
EXPECT_EQ(ar_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("03715 65 4321", RegionCode::AR(), &test_number));
EXPECT_EQ(ar_number, test_number);
ar_number.set_national_number(2312340000ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+54 23 1234 0000", RegionCode::AR(),
&test_number));
EXPECT_EQ(ar_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("023 1234 0000", RegionCode::AR(), &test_number));
EXPECT_EQ(ar_number, test_number);
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0123456789", RegionCode::AR(), &test_number));
EXPECT_EQ(ar_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(0) 123456789", RegionCode::AR(), &test_number));
EXPECT_EQ(ar_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0 123456789", RegionCode::AR(), &test_number));
EXPECT_EQ(ar_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(0xx) 123456789", RegionCode::AR(),
&test_number));
// extension, as we allow extensions up to 7 digits. This assumption is okay
// for now as all the countries where a carrier selection code is written in
// the form of xx have a national significant number of length larger than 7.
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("011xx5481429712", RegionCode::US(),
&test_number));
phone_util_.Parse("+52 (449)978-0001", RegionCode::MX(),
&test_number));
EXPECT_EQ(mx_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("01 (449)978-0001", RegionCode::MX(),
&test_number));
EXPECT_EQ(mx_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(449)978-0001", RegionCode::MX(),
&test_number));
mx_number.Clear();
mx_number.set_country_code(52);
mx_number.set_national_number(13312345678ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+52 1 33 1234-5678", RegionCode::MX(),
&test_number));
EXPECT_EQ(mx_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("044 (33) 1234-5678", RegionCode::MX(),
&test_number));
EXPECT_EQ(mx_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("045 33 1234-5678", RegionCode::MX(),
&test_number));
&test_number));
EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+ EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
+ phone_util_.Parse("1 Still not a number", RegionCode::NZ(),
+ &test_number));
+ EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
+ EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
+ phone_util_.Parse("1 MICROSOFT", RegionCode::NZ(),
+ &test_number));
+ EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
+ EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
+ phone_util_.Parse("12 MICROSOFT", RegionCode::NZ(),
+ &test_number));
+ EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
EXPECT_EQ(PhoneNumberUtil::TOO_LONG_NSN,
phone_util_.Parse("01495 72553301873 810104", RegionCode::GB(),
&test_number));
EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+ EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
+ phone_util_.Parse("+---", RegionCode::DE(),
+ &test_number));
+ EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
+ EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
+ phone_util_.Parse("+***", RegionCode::DE(),
+ &test_number));
+ EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
+ EXPECT_EQ(PhoneNumberUtil::NOT_A_NUMBER,
+ phone_util_.Parse("+*******91", RegionCode::DE(),
+ &test_number));
+ EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
EXPECT_EQ(PhoneNumberUtil::TOO_SHORT_NSN,
phone_util_.Parse("+49 0", RegionCode::DE(),
&test_number));
phone_util_.Parse("0119", RegionCode::US(),
&test_number));
EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+
+ // RFC3966 phone-context is a website.
+ EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
+ phone_util_.Parse("tel:555-1234;phone-context=www.google.com",
+ RegionCode::ZZ(), &test_number));
+ EXPECT_EQ(PhoneNumber::default_instance(), test_number);
+ // This is invalid because no "+" sign is present as part of phone-context.
+ // This should not succeed in being parsed.
+ EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
+ phone_util_.Parse("tel:555-1234;phone-context=1-331",
+ RegionCode::ZZ(), &test_number));
+ EXPECT_EQ(PhoneNumber::default_instance(), test_number);
}
TEST_F(PhoneNumberUtilTest, ParseNumbersWithPlusWithNoRegion) {
&result_proto));
EXPECT_EQ(nz_number, result_proto);
+ PhoneNumber toll_free_number;
+ toll_free_number.set_country_code(800);
+ toll_free_number.set_national_number(12345678ULL);
+ result_proto.Clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("+800 1234 5678",
+ RegionCode::GetUnknown(), &result_proto));
+ EXPECT_EQ(toll_free_number, result_proto);
+
+ PhoneNumber universal_premium_rate;
+ universal_premium_rate.set_country_code(979);
+ universal_premium_rate.set_national_number(123456789ULL);
+ result_proto.Clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("+979 123 456 789",
+ RegionCode::GetUnknown(), &result_proto));
+ EXPECT_EQ(universal_premium_rate, result_proto);
+
+ result_proto.Clear();
+ // Test parsing RFC3966 format with a phone context.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:03-331-6005;phone-context=+64",
+ RegionCode::GetUnknown(), &result_proto));
+ EXPECT_EQ(nz_number, result_proto);
+ result_proto.Clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse(" tel:03-331-6005;phone-context=+64",
+ RegionCode::GetUnknown(), &result_proto));
+ EXPECT_EQ(nz_number, result_proto);
+ result_proto.Clear();
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:03-331-6005;isub=12345;phone-context=+64",
+ RegionCode::GetUnknown(), &result_proto));
+ EXPECT_EQ(nz_number, result_proto);
+
nz_number.set_raw_input("+64 3 331 6005");
nz_number.set_country_code_source(PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN);
// It is important that we set this to an empty string, since we used
EXPECT_EQ(nz_number, result_proto);
}
+TEST_F(PhoneNumberUtilTest, ParseNumberTooShortIfNationalPrefixStripped) {
+ PhoneNumber test_number;
+
+ // Test that a number whose first digits happen to coincide with the national
+ // prefix does not get them stripped if doing so would result in a number too
+ // short to be a possible (regular length) phone number for that region.
+ PhoneNumber by_number;
+ by_number.set_country_code(375);
+ by_number.set_national_number(8123L);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("8123", RegionCode::BY(),
+ &test_number));
+ EXPECT_EQ(by_number, test_number);
+ by_number.set_national_number(81234L);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("81234", RegionCode::BY(),
+ &test_number));
+ EXPECT_EQ(by_number, test_number);
+
+ // The prefix doesn't get stripped, since the input is a viable 6-digit
+ // number, whereas the result of stripping is only 5 digits.
+ by_number.set_national_number(812345L);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("812345", RegionCode::BY(),
+ &test_number));
+ EXPECT_EQ(by_number, test_number);
+
+ // The prefix gets stripped, since only 6-digit numbers are possible.
+ by_number.set_national_number(123456L);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("8123456", RegionCode::BY(),
+ &test_number));
+ EXPECT_EQ(by_number, test_number);
+}
+
TEST_F(PhoneNumberUtilTest, ParseExtensions) {
PhoneNumber nz_number;
nz_number.set_country_code(64);
phone_util_.Parse("03 331 6005 ext 3456", RegionCode::NZ(),
&test_number));
EXPECT_EQ(nz_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("03 331 6005x3456", RegionCode::NZ(),
&test_number));
EXPECT_EQ(nz_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("03-331 6005 int.3456", RegionCode::NZ(),
&test_number));
EXPECT_EQ(nz_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("03 331 6005 #3456", RegionCode::NZ(),
&test_number));
PhoneNumber non_extn_number;
non_extn_number.set_country_code(1);
non_extn_number.set_national_number(80074935247ULL);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("1800 six-flags", RegionCode::US(),
&test_number));
EXPECT_EQ(non_extn_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("1800 SIX-FLAGS", RegionCode::US(),
&test_number));
EXPECT_EQ(non_extn_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0~0 1800 7493 5247", RegionCode::PL(),
&test_number));
EXPECT_EQ(non_extn_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(1800) 7493.5247", RegionCode::US(),
&test_number));
extn_number.set_country_code(1);
extn_number.set_national_number(80074935247ULL);
extn_number.set_extension("1234");
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("0~0 1800 7493 5247 ~1234", RegionCode::PL(),
&test_number));
uk_number.set_country_code(44);
uk_number.set_national_number(2034567890ULL);
uk_number.set_extension("456");
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44 2034567890x456", RegionCode::NZ(),
&test_number));
EXPECT_EQ(uk_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44 2034567890x456", RegionCode::GB(),
&test_number));
EXPECT_EQ(uk_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44 2034567890 x456", RegionCode::GB(),
&test_number));
EXPECT_EQ(uk_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44 2034567890 X456", RegionCode::GB(),
&test_number));
EXPECT_EQ(uk_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
&test_number));
EXPECT_EQ(uk_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
&test_number));
EXPECT_EQ(uk_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44 2034567890 x 456 ", RegionCode::GB(),
&test_number));
EXPECT_EQ(uk_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44 2034567890 X 456", RegionCode::GB(),
&test_number));
EXPECT_EQ(uk_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+44-2034567890;ext=456", RegionCode::GB(),
&test_number));
EXPECT_EQ(uk_number, test_number);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("tel:2034567890;ext=456;phone-context=+44",
+ RegionCode::ZZ(), &test_number));
+ EXPECT_EQ(uk_number, test_number);
+
+ // Full-width extension, "extn" only.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse(
+ "+442034567890\xEF\xBD\x85\xEF\xBD\x98\xEF\xBD\x94\xEF\xBD\x8E"
+ "456", RegionCode::GB(), &test_number));
+ EXPECT_EQ(uk_number, test_number);
+ // "xtn" only.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse(
+ "+44-2034567890\xEF\xBD\x98\xEF\xBD\x94\xEF\xBD\x8E""456",
+ RegionCode::GB(), &test_number));
+ EXPECT_EQ(uk_number, test_number);
+ // "xt" only.
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("+44-2034567890\xEF\xBD\x98\xEF\xBD\x94""456",
+ RegionCode::GB(), &test_number));
+ EXPECT_EQ(uk_number, test_number);
PhoneNumber us_with_extension;
us_with_extension.set_country_code(1);
us_with_extension.set_national_number(8009013355ULL);
us_with_extension.set_extension("7246433");
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(800) 901-3355 x 7246433", RegionCode::US(),
&test_number));
EXPECT_EQ(us_with_extension, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(800) 901-3355 , ext 7246433", RegionCode::US(),
&test_number));
EXPECT_EQ(us_with_extension, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(800) 901-3355 ,extension 7246433",
RegionCode::US(),
&test_number));
EXPECT_EQ(us_with_extension, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(800) 901-3355 ,extensi\xC3\xB3n 7246433",
/* "(800) 901-3355 ,extensión 7246433" */
RegionCode::US(),
&test_number));
EXPECT_EQ(us_with_extension, test_number);
- test_number.Clear();
// Repeat with the small letter o with acute accent created by combining
// characters.
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
RegionCode::US(),
&test_number));
EXPECT_EQ(us_with_extension, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(800) 901-3355 , 7246433", RegionCode::US(),
&test_number));
EXPECT_EQ(us_with_extension, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(800) 901-3355 ext: 7246433", RegionCode::US(),
&test_number));
us_with_two_extensions_number.set_country_code(1);
us_with_two_extensions_number.set_national_number(2121231234ULL);
us_with_two_extensions_number.set_extension("508");
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(212)123-1234 x508/x1234", RegionCode::US(),
&test_number));
EXPECT_EQ(us_with_two_extensions_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(212)123-1234 x508/ x1234", RegionCode::US(),
&test_number));
EXPECT_EQ(us_with_two_extensions_number, test_number);
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("(212)123-1234 x508\\x1234", RegionCode::US(),
&test_number));
us_with_extension.set_country_code(1);
us_with_extension.set_national_number(6451231234ULL);
us_with_extension.set_extension("910");
- test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
phone_util_.Parse("+1 (645) 123 1234-910#", RegionCode::US(),
&test_number));
&test_number));
EXPECT_EQ(alpha_numeric_number, test_number);
- // Try with invalid region - expect failure.
+ // Try with invalid region - expect failure. We clear the test number first
+ // because if parsing isn't successful, the number parsed in won't be changed.
test_number.Clear();
EXPECT_EQ(PhoneNumberUtil::INVALID_COUNTRY_CODE_ERROR,
phone_util_.Parse("123 456 7890", RegionCode::CS(), &test_number));
EXPECT_EQ(korean_number, test_number);
}
+TEST_F(PhoneNumberUtilTest, ParseItalianLeadingZeros) {
+ PhoneNumber zeros_number;
+ zeros_number.set_country_code(61);
+ PhoneNumber test_number;
+
+ // Test the number "011".
+ zeros_number.set_national_number(11L);
+ zeros_number.set_italian_leading_zero(true);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("011", RegionCode::AU(),
+ &test_number));
+ EXPECT_EQ(zeros_number, test_number);
+
+ // Test the number "001".
+ zeros_number.set_national_number(1L);
+ zeros_number.set_italian_leading_zero(true);
+ zeros_number.set_number_of_leading_zeros(2);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("001", RegionCode::AU(),
+ &test_number));
+ EXPECT_EQ(zeros_number, test_number);
+
+ // Test the number "000". This number has 2 leading zeros.
+ zeros_number.set_national_number(0L);
+ zeros_number.set_italian_leading_zero(true);
+ zeros_number.set_number_of_leading_zeros(2);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("000", RegionCode::AU(),
+ &test_number));
+ EXPECT_EQ(zeros_number, test_number);
+
+ // Test the number "0000". This number has 3 leading zeros.
+ zeros_number.set_national_number(0L);
+ zeros_number.set_italian_leading_zero(true);
+ zeros_number.set_number_of_leading_zeros(3);
+ EXPECT_EQ(PhoneNumberUtil::NO_PARSING_ERROR,
+ phone_util_.Parse("0000", RegionCode::AU(),
+ &test_number));
+ EXPECT_EQ(zeros_number, test_number);
+}
+
TEST_F(PhoneNumberUtilTest, CanBeInternationallyDialled) {
PhoneNumber test_number;
test_number.set_country_code(1);
test_number.set_country_code(64);
test_number.set_national_number(33316005ULL);
EXPECT_TRUE(CanBeInternationallyDialled(test_number));
+
+ test_number.set_country_code(800);
+ test_number.set_national_number(12345678ULL);
+ EXPECT_TRUE(CanBeInternationallyDialled(test_number));
}
TEST_F(PhoneNumberUtilTest, IsAlphaNumber) {
- static const string kAlphaNumber("1800 six-flags");
- EXPECT_TRUE(phone_util_.IsAlphaNumber(kAlphaNumber));
- static const string kAlphaNumberWithExtension = "1800 six-flags ext. 1234";
- EXPECT_TRUE(phone_util_.IsAlphaNumber(kAlphaNumberWithExtension));
- static const string kNonAlphaNumber("1800 123-1234");
- EXPECT_FALSE(phone_util_.IsAlphaNumber(kNonAlphaNumber));
- static const string kNonAlphaNumberWithExtension(
- "1800 123-1234 extension: 1234");
- EXPECT_FALSE(phone_util_.IsAlphaNumber(kNonAlphaNumberWithExtension));
+ EXPECT_TRUE(phone_util_.IsAlphaNumber("1800 six-flags"));
+ EXPECT_TRUE(phone_util_.IsAlphaNumber("1800 six-flags ext. 1234"));
+ EXPECT_TRUE(phone_util_.IsAlphaNumber("+800 six-flags"));
+ EXPECT_TRUE(phone_util_.IsAlphaNumber("180 six-flags"));
+ EXPECT_FALSE(phone_util_.IsAlphaNumber("1800 123-1234"));
+ EXPECT_FALSE(phone_util_.IsAlphaNumber("1 six-flags"));
+ EXPECT_FALSE(phone_util_.IsAlphaNumber("18 six-flags"));
+ EXPECT_FALSE(phone_util_.IsAlphaNumber("1800 123-1234 extension: 1234"));
+ EXPECT_FALSE(phone_util_.IsAlphaNumber("+800 1234-1234"));
}
} // namespace phonenumbers
projects / platform / upstream / libphonenumber.git / blobdiff