"""Unit tests for phonenumbers/__init__.py

def testSupportedRegions(self):

self.assertTrue(len(phonenumbers.SUPPORTED_REGIONS) > 0)

# Python version extra test

# Check the pseudo-code for non-geographic entities is not supported

self.assertFalse("001" in phonenumbers.SUPPORTED_REGIONS)

# Check a non-US NANPA country is correctly listed as supported

self.assertTrue("BS" in phonenumbers.SUPPORTED_REGIONS)

def testGetSupportedGlobalNetworkCallingCodes(self):

globalNetworkCallingCodes = phonenumbers.COUNTRY_CODES_FOR_NON_GEO_REGIONS

self.assertTrue(len(globalNetworkCallingCodes) > 0)

for callingCode in globalNetworkCallingCodes:

self.assertTrue(callingCode > 0)

self.assertEqual("001", region_code_for_country_code(callingCode))

def testGetSupportedCallingCodes(self):

callingCodes = phonenumbers.supported_calling_codes()

self.assertTrue(len(callingCodes) > 0)

for callingCode in callingCodes:

self.assertTrue(callingCode > 0)

self.assertTrue(region_code_for_country_code(callingCode) != "ZZ")

# There should be more than just the global network calling codes in this set.

self.assertTrue(len(callingCodes) > len(phonenumbers.COUNTRY_CODES_FOR_NON_GEO_REGIONS))

# But they should be included. Testing one of them.

self.assertTrue(979 in callingCodes)

def testGetSupportedTypesForRegion(self):

self.assertTrue(PhoneNumberType.FIXED_LINE in phonenumbers.supported_types_for_region("BR"))

# Our test data has no mobile numbers for Brazil.

self.assertFalse(PhoneNumberType.MOBILE in phonenumbers.supported_types_for_region("BR"))

# UNKNOWN should never be returned.

self.assertFalse(PhoneNumberType.UNKNOWN in phonenumbers.supported_types_for_region("BR"))

# In the US, many numbers are classified as FIXED_LINE_OR_MOBILE; but we don't want to expose

# this as a supported type, instead we say FIXED_LINE and MOBILE are both present.

self.assertTrue(PhoneNumberType.FIXED_LINE in phonenumbers.supported_types_for_region("US"))

self.assertTrue(PhoneNumberType.MOBILE in phonenumbers.supported_types_for_region("US"))

self.assertFalse(PhoneNumberType.FIXED_LINE_OR_MOBILE in phonenumbers.supported_types_for_region("US"))

# Test the invalid region code.

self.assertEqual(0, len(phonenumbers.supported_types_for_region("ZZ")))

def testGetSupportedTypesForNonGeoEntity(self):

# No data exists for 999 at all, no types should be returned.

self.assertEqual(0, len(phonenumbers.supported_types_for_non_geo_entity(999)))

typesFor979 = phonenumbers.supported_types_for_non_geo_entity(979)

self.assertTrue(PhoneNumberType.PREMIUM_RATE in typesFor979)

self.assertFalse(PhoneNumberType.MOBILE in typesFor979)

self.assertFalse(PhoneNumberType.UNKNOWN in typesFor979)

def testGetInstanceLoadUSMetadata(self):

metadata = PhoneMetadata.metadata_for_region("US")

self.assertEqual("US", metadata.id)

self.assertEqual(1, metadata.country_code)

self.assertEqual("011", metadata.international_prefix)

self.assertTrue(metadata.national_prefix is not None)

self.assertEqual(2, len(metadata.number_format))

self.assertEqual("(\\d{3})(\\d{3})(\\d{4})", metadata.number_format[1].pattern)

self.assertEqual("\\1 \\2 \\3", metadata.number_format[1].format)

self.assertEqual("[13-689]\\d{9}|2[0-35-9]\\d{8}",

metadata.general_desc.national_number_pattern)

self.assertEqual("[13-689]\\d{9}|2[0-35-9]\\d{8}", metadata.fixed_line.national_number_pattern)

self.assertEqual(1, len(metadata.general_desc.possible_length))

self.assertEqual(10, metadata.general_desc.possible_length[0])

# Python version: each number type description has its own possible_length value,

# rather than inheriting from the general_desc (like the Java code does).

self.assertEqual(1, len(metadata.toll_free.possible_length))

self.assertEqual(10, metadata.toll_free.possible_length[0])

self.assertEqual("900\\d{7}", metadata.premium_rate.national_number_pattern)

# No shared-cost data is available, so it should be initialised to None.

self.assertEqual(None, metadata.shared_cost)

def testGetInstanceLoadDEMetadata(self):

metadata = PhoneMetadata.metadata_for_region("DE")

self.assertEqual("DE", metadata.id)

self.assertEqual(49, metadata.country_code)

self.assertEqual("00", metadata.international_prefix)

self.assertEqual("0", metadata.national_prefix)

self.assertEqual(6, len(metadata.number_format))

self.assertEqual(1, len(metadata.number_format[5].leading_digits_pattern))

self.assertEqual("900", metadata.number_format[5].leading_digits_pattern[0])

self.assertEqual("(\\d{3})(\\d{3,4})(\\d{4})",

metadata.number_format[5].pattern)

self.assertEqual("\\1 \\2 \\3", metadata.number_format[5].format)

self.assertEqual(2, len(metadata.general_desc.possible_length_local_only))

self.assertEqual(8, len(metadata.general_desc.possible_length))

# Python version: each number type description has its own possible_length value,

# rather than inheriting from the general_desc (like the Java code does).

self.assertEqual(8, len(metadata.fixed_line.possible_length))

self.assertEqual(2, len(metadata.mobile.possible_length))

self.assertEqual("(?:[24-6]\\d{2}|3[03-9]\\d|[789](?:0[2-9]|[1-9]\\d))\\d{1,8}",

metadata.fixed_line.national_number_pattern)

self.assertEqual("30123456", metadata.fixed_line.example_number)

self.assertEqual(10, metadata.toll_free.possible_length[0])

self.assertEqual("900([135]\\d{6}|9\\d{7})", metadata.premium_rate.national_number_pattern)

def testGetInstanceLoadARMetadata(self):

metadata = PhoneMetadata.metadata_for_region("AR")

self.assertEqual("AR", metadata.id)

self.assertEqual(54, metadata.country_code)

self.assertEqual("00", metadata.international_prefix)

self.assertEqual("0", metadata.national_prefix)

self.assertEqual("0(?:(11|343|3715)15)?", metadata.national_prefix_for_parsing)

self.assertEqual("9\\1", metadata.national_prefix_transform_rule)

self.assertEqual("\\2 15 \\3-\\4", metadata.number_format[2].format)

self.assertEqual("(\\d)(\\d{4})(\\d{2})(\\d{4})",

metadata.number_format[3].pattern)

self.assertEqual("(\\d)(\\d{4})(\\d{2})(\\d{4})",

metadata.intl_number_format[3].pattern)

self.assertEqual("\\1 \\2 \\3 \\4", metadata.intl_number_format[3].format)

def testGetInstanceLoadInternationalTollFreeMetadata(self):

metadata = PhoneMetadata.metadata_for_nongeo_region(800)

self.assertEqual("001", metadata.id)

self.assertEqual(800, metadata.country_code)

self.assertEqual("\\1 \\2", metadata.number_format[0].format)

self.assertEqual("(\\d{4})(\\d{4})", metadata.number_format[0].pattern)

self.assertEqual(0, len(metadata.general_desc.possible_length_local_only))

self.assertEqual(1, len(metadata.general_desc.possible_length))

self.assertEqual("12345678", metadata.toll_free.example_number)

def testIsNumberGeographical(self):

self.assertFalse(phonenumberutil.is_number_geographical(BS_MOBILE)) # Bahamas, mobile phone number.

self.assertTrue(phonenumberutil.is_number_geographical(AU_NUMBER)) # Australian fixed line number.

self.assertFalse(phonenumberutil.is_number_geographical(INTERNATIONAL_TOLL_FREE)) # International toll free number

# We test that mobile phone numbers in relevant regions are indeed

# considered geographical.

self.assertTrue(phonenumberutil.is_number_geographical(AR_MOBILE)) # Argentina, mobile phone number.

self.assertTrue(phonenumberutil.is_number_geographical(MX_MOBILE1)) # Mexico, mobile phone number.

self.assertTrue(phonenumberutil.is_number_geographical(MX_MOBILE2)) # Mexico, another mobile phone number.

def testGetLengthOfGeographicalAreaCode(self):

# Google MTV, which has area code "650".

self.assertEqual(3, phonenumbers.length_of_geographical_area_code(US_NUMBER))

# A North America toll-free number, which has no area code.

self.assertEqual(0, phonenumbers.length_of_geographical_area_code(US_TOLLFREE))

# Google London, which has area code "20".

self.assertEqual(2, phonenumbers.length_of_geographical_area_code(GB_NUMBER))

# A mobile number in the UK does not have an area code (by default,

# mobile numbers do not, unless they have been added to our list of

# exceptions).

self.assertEqual(0, phonenumbers.length_of_geographical_area_code(GB_MOBILE))

# Google Buenos Aires, which has area code "11".

self.assertEqual(2, phonenumbers.length_of_geographical_area_code(AR_NUMBER))

# A mobile number in Argentina also has an area code.

self.assertEqual(3, phonenumbers.length_of_geographical_area_code(AR_MOBILE))

# Google Sydney, which has area code "2".

self.assertEqual(1, phonenumbers.length_of_geographical_area_code(AU_NUMBER))

# Italian numbers - there is no national prefix, but it still has an area code.

self.assertEqual(2, phonenumbers.length_of_geographical_area_code(IT_NUMBER))

# Google Singapore. Singapore has no area code and no national prefix.

self.assertEqual(0, phonenumbers.length_of_geographical_area_code(SG_NUMBER))

# An invalid US number (1 digit shorter), which has no area code.

self.assertEqual(0, phonenumbers.length_of_geographical_area_code(US_SHORT_BY_ONE_NUMBER))

# An international toll free number, which has no area code.

self.assertEqual(0, phonenumbers.length_of_geographical_area_code(INTERNATIONAL_TOLL_FREE))

# A mobile number from China is geographical, but does not have an area code.

cnMobile = PhoneNumber(country_code=86, national_number=18912341234)

self.assertEqual(0, phonenumbers.length_of_geographical_area_code(cnMobile))

def testGetLengthOfNationalDestinationCode(self):

# Google MTV, which has national destination code (NDC) "650".

self.assertEqual(3, phonenumbers.length_of_national_destination_code(US_NUMBER))

# A North America toll-free number, which has NDC "800".

self.assertEqual(3, phonenumbers.length_of_national_destination_code(US_TOLLFREE))

# Google London, which has NDC "20".

self.assertEqual(2, phonenumbers.length_of_national_destination_code(GB_NUMBER))

# A UK mobile phone, which has NDC "7912".

self.assertEqual(4, phonenumbers.length_of_national_destination_code(GB_MOBILE))

# Google Buenos Aires, which has NDC "11".

self.assertEqual(2, phonenumbers.length_of_national_destination_code(AR_NUMBER))

# An Argentinian mobile which has NDC "911".

self.assertEqual(3, phonenumbers.length_of_national_destination_code(AR_MOBILE))

# Google Sydney, which has NDC "2".

self.assertEqual(1, phonenumbers.length_of_national_destination_code(AU_NUMBER))

# Google Singapore, which has NDC "6521".

self.assertEqual(4, phonenumbers.length_of_national_destination_code(SG_NUMBER))

# An invalid US number (1 digit shorter), which has no NDC.

self.assertEqual(0, phonenumbers.length_of_national_destination_code(US_SHORT_BY_ONE_NUMBER))

# A number containing an invalid country calling code, which shouldn't have any NDC.

number = PhoneNumber(country_code=123, national_number=6502530000)

self.assertEqual(0, phonenumbers.length_of_national_destination_code(number))

# An international toll free number, which has NDC "1234".

self.assertEqual(4, phonenumbers.length_of_national_destination_code(INTERNATIONAL_TOLL_FREE))

# A mobile number from China is geographical, but does not have an area

# code: however it still can be considered to have a national

# destination code.

cnMobile = PhoneNumber(country_code=86, national_number=18912341234)

self.assertEqual(3, phonenumbers.length_of_national_destination_code(cnMobile))

# Python version extra test

# A number with an extension; still has NDC "7912"

number2 = PhoneNumber()

number2.merge_from(GB_MOBILE)

number2.extension = "1234"

self.assertEqual(4, phonenumbers.length_of_national_destination_code(number2))

def testGetCountryMobileToken(self):

self.assertEqual("9", phonenumbers.country_mobile_token(phonenumbers.country_code_for_region("AR")))

# Country calling code for Sweden, which has no mobile token.

# Python version change: Use GB instead, which exists in the test metadata

self.assertEqual("", phonenumbers.country_mobile_token(phonenumbers.country_code_for_region("GB")))

def testGetNationalSignificantNumber(self):

self.assertEqual("6502530000", phonenumbers.national_significant_number(US_NUMBER))

# An Italian mobile number.

self.assertEqual("345678901", phonenumbers.national_significant_number(IT_MOBILE))

# An Italian fixed line number.

self.assertEqual("0236618300", phonenumbers.national_significant_number(IT_NUMBER))

self.assertEqual("12345678", phonenumbers.national_significant_number(INTERNATIONAL_TOLL_FREE))

def testGetNationalSignificantNumber_ManyLeadingZeros(self):

number = PhoneNumber(country_code=1, national_number=650, italian_leading_zero=True, number_of_leading_zeros=2)

self.assertEqual("00650", phonenumbers.national_significant_number(number))

# Set a bad value; we shouldn't crash, we shouldn't output any leading zeros at all.

number.number_of_leading_zeros = -3

self.assertEqual("650", phonenumbers.national_significant_number(number))

def testGetExampleNumber(self):

self.assertEqual(DE_NUMBER, phonenumbers.example_number("DE"))

self.assertEqual(DE_NUMBER, phonenumbers.example_number_for_type("DE", PhoneNumberType.FIXED_LINE))

# Should return the same response if asked for FIXED_LINE_OR_MOBILE too.

self.assertEqual(DE_NUMBER,

phonenumbers.example_number_for_type("DE", PhoneNumberType.FIXED_LINE_OR_MOBILE))

self.assertTrue(phonenumbers.example_number_for_type("US", PhoneNumberType.FIXED_LINE) is not None)

self.assertTrue(phonenumbers.example_number_for_type("US", PhoneNumberType.MOBILE) is not None)

# We have data for the US, but no data for VOICEMAIL, so return null.

self.assertTrue(phonenumbers.example_number_for_type("US", PhoneNumberType.VOICEMAIL) is None)

# CS is an invalid region, so we have no data for it.

self.assertTrue(phonenumbers.example_number_for_type("CS", PhoneNumberType.MOBILE) is None)

# Python version extra test

self.assertTrue(phonenumbers.example_number_for_type("US", PhoneNumberType.UNKNOWN) is None)

# RegionCode 001 is reserved for supporting non-geographical country

# calling code. We don't support getting an example number for it with

# this method.

self.assertTrue(phonenumbers.example_number("001") is None)

def testGetInvalidExampleNumber(self):

# RegionCode 001 is reserved for supporting non-geographical country

# calling codes. We don't support getting an invalid example number

# for it with invalid_example_number.

self.assertTrue(phonenumbers.invalid_example_number("001") is None)

self.assertTrue(phonenumbers.invalid_example_number("CS") is None)

usInvalidNumber = phonenumbers.invalid_example_number("US")

self.assertEqual(1, usInvalidNumber.country_code)

self.assertFalse(usInvalidNumber.national_number == 0)

def testGetExampleNumberForNonGeoEntity(self):

self.assertEqual(INTERNATIONAL_TOLL_FREE, phonenumbers.example_number_for_non_geo_entity(800))

self.assertEqual(UNIVERSAL_PREMIUM_RATE, phonenumbers.example_number_for_non_geo_entity(979))

# Python version extra test

self.assertTrue(phonenumbers.example_number_for_non_geo_entity(666) is None)

def testGetExampleNumberWithoutRegion(self):

# In our test metadata we don't cover all types: in our real metadata, we do.

self.assertTrue(phonenumbers.example_number_for_type(None, PhoneNumberType.FIXED_LINE) is not None)

self.assertTrue(phonenumbers.example_number_for_type(None, PhoneNumberType.MOBILE) is not None)

self.assertTrue(phonenumbers.example_number_for_type(None, PhoneNumberType.PREMIUM_RATE) is not None)

# Python version extra test: temporarily drop SUPPORTED_REGIONS to check

# that example_number_for_type() falls back to non-geo numbers.

saved = phonenumberutil.SUPPORTED_REGIONS

phonenumberutil.SUPPORTED_REGIONS = set()

self.assertTrue(phonenumbers.example_number_for_type(None, PhoneNumberType.TOLL_FREE) is not None)

phonenumberutil.SUPPORTED_REGIONS = saved

def testConvertAlphaCharactersInNumber(self):

input = "1800-ABC-DEF"

# Alpha chars are converted to digits; everything else is left untouched.

expectedOutput = "1800-222-333"

self.assertEqual(expectedOutput, phonenumberutil.convert_alpha_characters_in_number(input))

def testNormaliseRemovePunctuation(self):

inputNumber = u("034-56&+#2\u00AD34")

expectedOutput = "03456234"

self.assertEqual(expectedOutput,

phonenumberutil._normalize(inputNumber),

msg="Conversion did not correctly remove punctuation")

def testNormaliseReplaceAlphaCharacters(self):

inputNumber = "034-I-am-HUNGRY"

expectedOutput = "034426486479"

self.assertEqual(expectedOutput,

phonenumberutil._normalize(inputNumber),

msg="Conversion did not correctly replace alpha characters")

def testNormaliseOtherDigits(self):

inputNumber = u("\uFF125\u0665")

expectedOutput = "255"

self.assertEqual(expectedOutput,

phonenumberutil._normalize(inputNumber),

msg="Conversion did not correctly replace non-latin digits")

# Eastern-Arabic digits.

inputNumber = u("\u06F52\u06F0")

expectedOutput = "520"

self.assertEqual(expectedOutput,

phonenumberutil._normalize(inputNumber),

msg="Conversion did not correctly replace non-latin digits")

def testNormaliseStripAlphaCharacters(self):

inputNumber = "034-56&+a#234"

expectedOutput = "03456234"

self.assertEqual(expectedOutput,

phonenumbers.normalize_digits_only(inputNumber),

msg="Conversion did not correctly remove alpha character")

def testNormaliseStripNonDiallableCharacters(self):

inputNumber = "03*4-56&+1a#234"

expectedOutput = "03*456+1#234"

self.assertEqual(expectedOutput,

phonenumberutil.normalize_diallable_chars_only(inputNumber),

msg="Conversion did not correctly remove non-diallable characters")

def testFormatUSNumber(self):

self.assertEqual("650 253 0000", phonenumbers.format_number(US_NUMBER, PhoneNumberFormat.NATIONAL))

self.assertEqual("+1 650 253 0000", phonenumbers.format_number(US_NUMBER, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("800 253 0000", phonenumbers.format_number(US_TOLLFREE, PhoneNumberFormat.NATIONAL))

self.assertEqual("+1 800 253 0000", phonenumbers.format_number(US_TOLLFREE, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("900 253 0000", phonenumbers.format_number(US_PREMIUM, PhoneNumberFormat.NATIONAL))

self.assertEqual("+1 900 253 0000", phonenumbers.format_number(US_PREMIUM, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("tel:+1-900-253-0000", phonenumbers.format_number(US_PREMIUM, PhoneNumberFormat.RFC3966))

# Numbers with all zeros in the national number part will be formatted by using the raw_input

# if that is available no matter which format is specified.

self.assertEqual("000-000-0000",

phonenumbers.format_number(US_SPOOF_WITH_RAW_INPUT, PhoneNumberFormat.NATIONAL))

self.assertEqual("0", phonenumbers.format_number(US_SPOOF, PhoneNumberFormat.NATIONAL))

def testFormatBSNumber(self):

self.assertEqual("242 365 1234", phonenumbers.format_number(BS_NUMBER, PhoneNumberFormat.NATIONAL))

self.assertEqual("+1 242 365 1234", phonenumbers.format_number(BS_NUMBER, PhoneNumberFormat.INTERNATIONAL))

def testFormatGBNumber(self):

self.assertEqual("(020) 7031 3000", phonenumbers.format_number(GB_NUMBER, PhoneNumberFormat.NATIONAL))

self.assertEqual("+44 20 7031 3000", phonenumbers.format_number(GB_NUMBER, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("(07912) 345 678", phonenumbers.format_number(GB_MOBILE, PhoneNumberFormat.NATIONAL))

self.assertEqual("+44 7912 345 678", phonenumbers.format_number(GB_MOBILE, PhoneNumberFormat.INTERNATIONAL))

def testFormatDENumber(self):

deNumber = PhoneNumber(country_code=49, national_number=301234)

self.assertEqual("030/1234", phonenumbers.format_number(deNumber, PhoneNumberFormat.NATIONAL))

self.assertEqual("+49 30/1234", phonenumbers.format_number(deNumber, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("tel:+49-30-1234", phonenumbers.format_number(deNumber, PhoneNumberFormat.RFC3966))

deNumber.clear()

deNumber.country_code = 49

deNumber.national_number = to_long(291123)

self.assertEqual("0291 123", phonenumbers.format_number(deNumber, PhoneNumberFormat.NATIONAL))

self.assertEqual("+49 291 123", phonenumbers.format_number(deNumber, PhoneNumberFormat.INTERNATIONAL))

deNumber.clear()

deNumber.country_code = 49

deNumber.national_number = to_long(29112345678)

self.assertEqual("0291 12345678", phonenumbers.format_number(deNumber, PhoneNumberFormat.NATIONAL))

self.assertEqual("+49 291 12345678", phonenumbers.format_number(deNumber, PhoneNumberFormat.INTERNATIONAL))

deNumber.clear()

deNumber.country_code = 49

deNumber.national_number = to_long(912312345)

self.assertEqual("09123 12345", phonenumbers.format_number(deNumber, PhoneNumberFormat.NATIONAL))

self.assertEqual("+49 9123 12345", phonenumbers.format_number(deNumber, PhoneNumberFormat.INTERNATIONAL))

deNumber.clear()

deNumber.country_code = 49

deNumber.national_number = to_long(80212345)

self.assertEqual("08021 2345", phonenumbers.format_number(deNumber, PhoneNumberFormat.NATIONAL))

self.assertEqual("+49 8021 2345", phonenumbers.format_number(deNumber, PhoneNumberFormat.INTERNATIONAL))

# Note this number is correctly formatted without national prefix. Most of the numbers that

# are treated as invalid numbers by the library are short numbers, and they are usually not

# dialed with national prefix.

self.assertEqual("1234", phonenumbers.format_number(DE_SHORT_NUMBER, PhoneNumberFormat.NATIONAL))

self.assertEqual("+49 1234", phonenumbers.format_number(DE_SHORT_NUMBER, PhoneNumberFormat.INTERNATIONAL))

deNumber.clear()

deNumber.country_code = 49

deNumber.national_number = 41341234

self.assertEqual("04134 1234", phonenumbers.format_number(deNumber, PhoneNumberFormat.NATIONAL))

def testFormatITNumber(self):

self.assertEqual("02 3661 8300", phonenumbers.format_number(IT_NUMBER, PhoneNumberFormat.NATIONAL))

self.assertEqual("+39 02 3661 8300", phonenumbers.format_number(IT_NUMBER, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+390236618300", phonenumbers.format_number(IT_NUMBER, PhoneNumberFormat.E164))

self.assertEqual("345 678 901", phonenumbers.format_number(IT_MOBILE, PhoneNumberFormat.NATIONAL))

self.assertEqual("+39 345 678 901", phonenumbers.format_number(IT_MOBILE, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+39345678901", phonenumbers.format_number(IT_MOBILE, PhoneNumberFormat.E164))

def testFormatAUNumber(self):

self.assertEqual("02 3661 8300", phonenumbers.format_number(AU_NUMBER, PhoneNumberFormat.NATIONAL))

self.assertEqual("+61 2 3661 8300", phonenumbers.format_number(AU_NUMBER, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+61236618300", phonenumbers.format_number(AU_NUMBER, PhoneNumberFormat.E164))

auNumber = PhoneNumber(country_code=61, national_number=1800123456)

self.assertEqual("1800 123 456", phonenumbers.format_number(auNumber, PhoneNumberFormat.NATIONAL))

self.assertEqual("+61 1800 123 456", phonenumbers.format_number(auNumber, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+611800123456", phonenumbers.format_number(auNumber, PhoneNumberFormat.E164))

def testFormatARNumber(self):

self.assertEqual("011 8765-4321", phonenumbers.format_number(AR_NUMBER, PhoneNumberFormat.NATIONAL))

self.assertEqual("+54 11 8765-4321", phonenumbers.format_number(AR_NUMBER, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+541187654321", phonenumbers.format_number(AR_NUMBER, PhoneNumberFormat.E164))

self.assertEqual("011 15 8765-4321", phonenumbers.format_number(AR_MOBILE, PhoneNumberFormat.NATIONAL))

self.assertEqual("+54 9 11 8765 4321", phonenumbers.format_number(AR_MOBILE, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+5491187654321", phonenumbers.format_number(AR_MOBILE, PhoneNumberFormat.E164))

def testFormatMXNumber(self):

self.assertEqual("045 234 567 8900", phonenumbers.format_number(MX_MOBILE1, PhoneNumberFormat.NATIONAL))

self.assertEqual("+52 1 234 567 8900", phonenumbers.format_number(MX_MOBILE1, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+5212345678900", phonenumbers.format_number(MX_MOBILE1, PhoneNumberFormat.E164))

self.assertEqual("045 55 1234 5678", phonenumbers.format_number(MX_MOBILE2, PhoneNumberFormat.NATIONAL))

self.assertEqual("+52 1 55 1234 5678", phonenumbers.format_number(MX_MOBILE2, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+5215512345678", phonenumbers.format_number(MX_MOBILE2, PhoneNumberFormat.E164))

self.assertEqual("01 33 1234 5678", phonenumbers.format_number(MX_NUMBER1, PhoneNumberFormat.NATIONAL))

self.assertEqual("+52 33 1234 5678", phonenumbers.format_number(MX_NUMBER1, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+523312345678", phonenumbers.format_number(MX_NUMBER1, PhoneNumberFormat.E164))

self.assertEqual("01 821 123 4567", phonenumbers.format_number(MX_NUMBER2, PhoneNumberFormat.NATIONAL))

self.assertEqual("+52 821 123 4567", phonenumbers.format_number(MX_NUMBER2, PhoneNumberFormat.INTERNATIONAL))

self.assertEqual("+528211234567", phonenumbers.format_number(MX_NUMBER2, PhoneNumberFormat.E164))

def testFormatOutOfCountryCallingNumber(self):

self.assertEqual("00 1 900 253 0000",

phonenumbers.format_out_of_country_calling_number(US_PREMIUM, "DE"))

self.assertEqual("1 650 253 0000",

phonenumbers.format_out_of_country_calling_number(US_NUMBER, "BS"))

self.assertEqual("00 1 650 253 0000",

phonenumbers.format_out_of_country_calling_number(US_NUMBER, "PL"))

self.assertEqual("011 44 7912 345 678",

phonenumbers.format_out_of_country_calling_number(GB_MOBILE, "US"))

self.assertEqual("00 49 1234",

phonenumbers.format_out_of_country_calling_number(DE_SHORT_NUMBER, "GB"))

# Note this number is correctly formatted without national

# prefix. Most of the numbers that are treated as invalid numbers by

# the library are short numbers, and they are usually not dialed with

# national prefix.

self.assertEqual("1234", phonenumbers.format_out_of_country_calling_number(DE_SHORT_NUMBER, "DE"))

self.assertEqual("011 39 02 3661 8300",

phonenumbers.format_out_of_country_calling_number(IT_NUMBER, "US"))

self.assertEqual("02 3661 8300",

phonenumbers.format_out_of_country_calling_number(IT_NUMBER, "IT"))

self.assertEqual("+39 02 3661 8300",

phonenumbers.format_out_of_country_calling_number(IT_NUMBER, "SG"))

self.assertEqual("6521 8000",

phonenumbers.format_out_of_country_calling_number(SG_NUMBER, "SG"))

self.assertEqual("011 54 9 11 8765 4321",

phonenumbers.format_out_of_country_calling_number(AR_MOBILE, "US"))

self.assertEqual("011 800 1234 5678",

phonenumbers.format_out_of_country_calling_number(INTERNATIONAL_TOLL_FREE, "US"))

arNumberWithExtn = PhoneNumber()

arNumberWithExtn.merge_from(AR_MOBILE)

arNumberWithExtn.extension = "1234"

self.assertEqual("011 54 9 11 8765 4321 ext. 1234",

phonenumbers.format_out_of_country_calling_number(arNumberWithExtn, "US"))

self.assertEqual("0011 54 9 11 8765 4321 ext. 1234",

phonenumbers.format_out_of_country_calling_number(arNumberWithExtn, "AU"))

self.assertEqual("011 15 8765-4321 ext. 1234",

phonenumbers.format_out_of_country_calling_number(arNumberWithExtn, "AR"))

# Python version extra tests

self.assertEqual("1234567890",

phonenumbers.format_out_of_country_calling_number(XY_NUMBER, "AR"))

self.assertEqual("1234567890",

phonenumbers.format_out_of_country_calling_number(XY_NUMBER, "XX"))

def testFormatOutOfCountryWithInvalidRegion(self):

# AQ/Antarctica isn't a valid region code for phone number formatting,

# so this falls back to intl formatting.

self.assertEqual("+1 650 253 0000",

phonenumbers.format_out_of_country_calling_number(US_NUMBER, "AQ"))

# For region code 001, the out-of-country format always turns into the

# international format.

self.assertEqual("+1 650 253 0000",

phonenumbers.format_out_of_country_calling_number(US_NUMBER, "001"))

def testFormatOutOfCountryWithPreferredIntlPrefix(self):

# This should use 0011, since that is the preferred international

# prefix (both 0011 and 0012 are accepted as possible international

# prefixes in our test metadta.)

self.assertEqual("0011 39 02 3661 8300",

phonenumbers.format_out_of_country_calling_number(IT_NUMBER, "AU"))

# For region code 001, the out-of-country format always turns into the international format.

self.assertEqual("+1 650 253 0000",

phonenumbers.format_out_of_country_calling_number(US_NUMBER, "001"))

def testFormatOutOfCountryKeepingAlphaChars(self):

alphaNumericNumber = PhoneNumber(country_code=1, national_number=8007493524)

alphaNumericNumber.raw_input = "1800 six-flag"

self.assertEqual("0011 1 800 SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AU"))

alphaNumericNumber.raw_input = "1-800-SIX-flag"

self.assertEqual("0011 1 800-SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AU"))

alphaNumericNumber.raw_input = "Call us from UK: 00 1 800 SIX-flag"

self.assertEqual("0011 1 800 SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AU"))

alphaNumericNumber.raw_input = "800 SIX-flag"

self.assertEqual("0011 1 800 SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AU"))

# Formatting from within the NANPA region.

self.assertEqual("1 800 SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "US"))

self.assertEqual("1 800 SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "BS"))

# Testing that if the raw input doesn't exist, it is formatted using

# formatOutOfCountryCallingNumber.

alphaNumericNumber.raw_input = None

self.assertEqual("00 1 800 749 3524",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "DE"))

# Testing AU alpha number formatted from Australia.

alphaNumericNumber.country_code = 61

alphaNumericNumber.national_number = to_long(827493524)

alphaNumericNumber.raw_input = "+61 82749-FLAG"

# This number should have the national prefix fixed.

self.assertEqual("082749-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AU"))

alphaNumericNumber.raw_input = "082749-FLAG"

self.assertEqual("082749-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AU"))

alphaNumericNumber.national_number = to_long(18007493524)

alphaNumericNumber.raw_input = "1-800-SIX-flag"

# This number should not have the national prefix prefixed, in

# accordance with the override for this specific formatting rule.

self.assertEqual("1-800-SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AU"))

# The metadata should not be permanently changed, since we copied it

# before modifying patterns. Here we check this.

alphaNumericNumber.national_number = to_long(1800749352)

self.assertEqual("1800 749 352",

phonenumbers.format_out_of_country_calling_number(alphaNumericNumber, "AU"))

# Testing a region with multiple international prefixes.

self.assertEqual("+61 1-800-SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "SG"))

# Testing the case of calling from a non-supported region.

self.assertEqual("+61 1-800-SIX-FLAG",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AQ"))

# Testing the case with an invalid country calling code.

alphaNumericNumber.country_code = 0

alphaNumericNumber.national_number = to_long(18007493524)

alphaNumericNumber.raw_input = "1-800-SIX-flag"

# Uses the raw input only.

self.assertEqual("1-800-SIX-flag",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "DE"))

# Testing the case of an invalid alpha number.

alphaNumericNumber.country_code = 1

alphaNumericNumber.national_number = to_long(80749)

alphaNumericNumber.raw_input = "180-SIX"

# No country-code stripping can be done.

self.assertEqual("00 1 180-SIX",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "DE"))

# Testing the case of calling from a non-supported region.

alphaNumericNumber.country_code = 1

alphaNumericNumber.national_number = to_long(80749)

alphaNumericNumber.raw_input = "180-SIX"

# No country-code stripping can be done since the number is invalid.

self.assertEqual("+1 180-SIX",

phonenumbers.format_out_of_country_keeping_alpha_chars(alphaNumericNumber, "AQ"))

def testFormatWithCarrierCode(self):

# We only support this for AR in our test metadata, and only for mobile numbers starting with

# certain values.

arMobile = PhoneNumber(country_code=54, national_number=92234654321)

self.assertEqual("02234 65-4321", phonenumbers.format_number(arMobile, PhoneNumberFormat.NATIONAL))

# Here we force 14 as the carrier code.

self.assertEqual("02234 14 65-4321",

phonenumbers.format_national_number_with_carrier_code(arMobile, "14"))

# Here we force the number to be shown with no carrier code.

self.assertEqual("02234 65-4321",

phonenumbers.format_national_number_with_carrier_code(arMobile, ""))

# Here the international rule is used, so no carrier code should be present.

self.assertEqual("+5492234654321", phonenumbers.format_number(arMobile, PhoneNumberFormat.E164))

# We don't support this for the US so there should be no change.

self.assertEqual("650 253 0000", phonenumbers.format_national_number_with_carrier_code(US_NUMBER, "15"))

# Invalid country code should just get the NSN.

self.assertEqual("12345",

phonenumbers.format_national_number_with_carrier_code(UNKNOWN_COUNTRY_CODE_NO_RAW_INPUT, "89"))

# Python version extra test

self.assertEqual("1234567890",

phonenumbers.format_national_number_with_carrier_code(XY_NUMBER, "123"))

def testFormatWithPreferredCarrierCode(self):

# We only support this for AR in our test metadata.

arNumber = PhoneNumber()

arNumber.country_code = 54

arNumber.national_number = to_long(91234125678)

# Test formatting with no preferred carrier code stored in the number itself.

self.assertEqual("01234 15 12-5678",

phonenumbers.format_national_number_with_preferred_carrier_code(arNumber, "15"))

self.assertEqual("01234 12-5678",

phonenumbers.format_national_number_with_preferred_carrier_code(arNumber, ""))

# Test formatting with preferred carrier code present.

arNumber.preferred_domestic_carrier_code = "19"

self.assertEqual("01234 12-5678", phonenumbers.format_number(arNumber, PhoneNumberFormat.NATIONAL))

self.assertEqual("01234 19 12-5678",

phonenumbers.format_national_number_with_preferred_carrier_code(arNumber, "15"))

self.assertEqual("01234 19 12-5678",

phonenumbers.format_national_number_with_preferred_carrier_code(arNumber, ""))

# Python version extra test: check string conversion with preferred carrier code

self.assertEqual('Country Code: 54 National Number: 91234125678 '

'Preferred Domestic Carrier Code: 19',

str(arNumber))

self.assertEqual("PhoneNumber(country_code=54, national_number=91234125678, extension=None, "

"italian_leading_zero=None, number_of_leading_zeros=None, "

"country_code_source=0, preferred_domestic_carrier_code='19')",

repr(arNumber))

# When the preferred_domestic_carrier_code is present (even when it is

# just a space), use it instead of the default carrier code passed in.

arNumber.preferred_domestic_carrier_code = " "

self.assertEqual("01234 12-5678",

phonenumbers.format_national_number_with_preferred_carrier_code(arNumber, "15"))

# When the preferred_domestic_carrier_code is present but empty, treat

# it as unset and use instead the default carrier code passed in.

arNumber.preferred_domestic_carrier_code = ""

self.assertEqual("01234 15 12-5678",

phonenumbers.format_national_number_with_preferred_carrier_code(arNumber, "15"))

# We don't support this for the US so there should be no change.

usNumber = PhoneNumber(country_code=1, national_number=4241231234, preferred_domestic_carrier_code="99")

self.assertEqual("424 123 1234", phonenumbers.format_number(usNumber, PhoneNumberFormat.NATIONAL))

self.assertEqual("424 123 1234",

phonenumbers.format_national_number_with_preferred_carrier_code(usNumber, "15"))

def testFormatNumberForMobileDialing(self):

# Numbers are normally dialed in national format in-country, and

# international format from outside the country.

self.assertEqual("030123456",

phonenumbers.format_number_for_mobile_dialing(DE_NUMBER, "DE", False))

self.assertEqual("+4930123456",

phonenumbers.format_number_for_mobile_dialing(DE_NUMBER, "CH", False))

deNumberWithExtn = PhoneNumber()

deNumberWithExtn.merge_from(DE_NUMBER)

deNumberWithExtn.extension = "1234"

self.assertEqual("030123456",

phonenumbers.format_number_for_mobile_dialing(deNumberWithExtn, "DE", False))

self.assertEqual("+4930123456",

phonenumbers.format_number_for_mobile_dialing(deNumberWithExtn, "CH", False))

# US toll free numbers are marked as noInternationalDialling in the

# test metadata for testing purposes.For such numbers, we expect

# nothing to be returned when the region code is not the same one.

self.assertEqual("800 253 0000",

phonenumbers.format_number_for_mobile_dialing(US_TOLLFREE, "US",

True)) # Keep formatting

self.assertEqual("", phonenumbers.format_number_for_mobile_dialing(US_TOLLFREE, "CN", True))

self.assertEqual("+1 650 253 0000",

phonenumbers.format_number_for_mobile_dialing(US_NUMBER, "US", True))

usNumberWithExtn = PhoneNumber()

usNumberWithExtn.merge_from(US_NUMBER)

usNumberWithExtn.extension = "1234"

self.assertEqual("+1 650 253 0000",

phonenumbers.format_number_for_mobile_dialing(usNumberWithExtn, "US", True))

self.assertEqual("8002530000",

phonenumbers.format_number_for_mobile_dialing(US_TOLLFREE, "US",

False)) # Remove formatting

self.assertEqual("", phonenumbers.format_number_for_mobile_dialing(US_TOLLFREE, "CN", False))

self.assertEqual("+16502530000",

phonenumbers.format_number_for_mobile_dialing(US_NUMBER, "US", False))

self.assertEqual("+16502530000",

phonenumbers.format_number_for_mobile_dialing(usNumberWithExtn, "US", False))

# An invalid US number, which is one digit too long.

self.assertEqual("+165025300001",

phonenumbers.format_number_for_mobile_dialing(US_LONG_NUMBER, "US", False))

self.assertEqual("+1 65025300001",

phonenumbers.format_number_for_mobile_dialing(US_LONG_NUMBER, "US", True))

# Star numbers. In real life they appear in Israel, but we have them

# in JP in our test metadata.

self.assertEqual("*2345",

phonenumbers.format_number_for_mobile_dialing(JP_STAR_NUMBER, "JP", False))

self.assertEqual("*2345",

phonenumbers.format_number_for_mobile_dialing(JP_STAR_NUMBER, "JP", True))

self.assertEqual("+80012345678",

phonenumbers.format_number_for_mobile_dialing(INTERNATIONAL_TOLL_FREE, "JP", False))

self.assertEqual("+800 1234 5678",

phonenumbers.format_number_for_mobile_dialing(INTERNATIONAL_TOLL_FREE, "JP", True))

# UAE numbers beginning with 600 (classified as UAN) need to be dialled without +971 locally.

self.assertEqual("+971600123456",

phonenumbers.format_number_for_mobile_dialing(AE_UAN, "JP", False))

self.assertEqual("600123456",

phonenumbers.format_number_for_mobile_dialing(AE_UAN, "AE", False))

self.assertEqual("+523312345678",

phonenumbers.format_number_for_mobile_dialing(MX_NUMBER1, "MX", False))

self.assertEqual("+523312345678",

phonenumbers.format_number_for_mobile_dialing(MX_NUMBER1, "US", False))

# Test whether Uzbek phone numbers are returned in international format even when dialled from

# same region or other regions.

self.assertEqual("+998612201234",

phonenumbers.format_number_for_mobile_dialing(UZ_FIXED_LINE, "UZ", False))

self.assertEqual("+998950123456",

phonenumbers.format_number_for_mobile_dialing(UZ_MOBILE, "UZ", False))

self.assertEqual("+998950123456",

phonenumbers.format_number_for_mobile_dialing(UZ_MOBILE, "US", False))

# Non-geographical numbers should always be dialed in international format.

self.assertEqual("+80012345678",

phonenumbers.format_number_for_mobile_dialing(INTERNATIONAL_TOLL_FREE, "US", False))

self.assertEqual("+80012345678",

phonenumbers.format_number_for_mobile_dialing(INTERNATIONAL_TOLL_FREE, "001", False))

# Test that a short number is formatted correctly for mobile dialing

# within the region, and is not diallable from outside the region.

deShortNumber = PhoneNumber(country_code=49, national_number=123)

self.assertEqual("123", phonenumbers.format_number_for_mobile_dialing(deShortNumber, "DE", False))

self.assertEqual("", phonenumbers.format_number_for_mobile_dialing(deShortNumber, "IT", False))

# 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.

self.assertEqual("+16502530000", phonenumbers.format_number_for_mobile_dialing(US_NUMBER, "US", False))

self.assertEqual("+16502530000", phonenumbers.format_number_for_mobile_dialing(US_NUMBER, "CA", False))

self.assertEqual("+16502530000", phonenumbers.format_number_for_mobile_dialing(US_NUMBER, "BR", False))

usShortNumber = PhoneNumber(country_code=1, national_number=911)

self.assertEqual("911", phonenumbers.format_number_for_mobile_dialing(usShortNumber, "US", False))

self.assertEqual("", phonenumbers.format_number_for_mobile_dialing(usShortNumber, "CA", False))

self.assertEqual("", phonenumbers.format_number_for_mobile_dialing(usShortNumber, "BR", False))

# Test that the Australian emergency number 000 is formatted correctly.

auNumber = PhoneNumber(country_code=61, national_number=0, italian_leading_zero=True, number_of_leading_zeros=2)

self.assertEqual("000", phonenumbers.format_number_for_mobile_dialing(auNumber, "AU", False))

self.assertEqual("", phonenumbers.format_number_for_mobile_dialing(auNumber, "NZ", False))

# Python version extra tests

self.assertNotEqual(-1, str(auNumber).find("Number of leading zeros"))

number = PhoneNumber()

number.merge_from(XY_NUMBER)

self.assertEqual("", phonenumbers.format_number_for_mobile_dialing(number, "US", False))

number.raw_input = " 123-456-7890"

self.assertEqual(" 123-456-7890", phonenumbers.format_number_for_mobile_dialing(number, "US", False))

def testFormatByPattern(self):

newNumFormat = NumberFormat(pattern="(\\d{3})(\\d{3})(\\d{4})", format="(\\1) \\2-\\3")

newNumFormat._mutable = True

newNumberFormats = [newNumFormat]

self.assertEqual("(650) 253-0000", phonenumbers.format_by_pattern(US_NUMBER, PhoneNumberFormat.NATIONAL,

newNumberFormats))

self.assertEqual("+1 (650) 253-0000", phonenumbers.format_by_pattern(US_NUMBER,

PhoneNumberFormat.INTERNATIONAL,

newNumberFormats))

self.assertEqual("tel:+1-650-253-0000", phonenumbers.format_by_pattern(US_NUMBER,

PhoneNumberFormat.RFC3966,

newNumberFormats))

# $NP is set to '1' for the US. Here we check that for other NANPA

# countries the US rules are followed.

newNumFormat.national_prefix_formatting_rule = "$NP ($FG)"

newNumFormat.format = "\\1 \\2-\\3"

self.assertEqual("1 (242) 365-1234",

phonenumbers.format_by_pattern(BS_NUMBER, PhoneNumberFormat.NATIONAL,

newNumberFormats))

self.assertEqual("+1 242 365-1234",

phonenumbers.format_by_pattern(BS_NUMBER, PhoneNumberFormat.INTERNATIONAL,

newNumberFormats))

newNumFormat.pattern = "(\\d{2})(\\d{5})(\\d{3})"

newNumFormat.format = "\\1-\\2 \\3"

newNumberFormats[0] = newNumFormat

self.assertEqual("02-36618 300",

phonenumbers.format_by_pattern(IT_NUMBER, PhoneNumberFormat.NATIONAL,

newNumberFormats))

self.assertEqual("+39 02-36618 300",

phonenumbers.format_by_pattern(IT_NUMBER, PhoneNumberFormat.INTERNATIONAL,

newNumberFormats))

newNumFormat.national_prefix_formatting_rule = "$NP$FG"

newNumFormat.pattern = "(\\d{2})(\\d{4})(\\d{4})"

newNumFormat.format = "\\1 \\2 \\3"

newNumberFormats[0] = newNumFormat

self.assertEqual("020 7031 3000",

phonenumbers.format_by_pattern(GB_NUMBER, PhoneNumberFormat.NATIONAL,

newNumberFormats))

newNumFormat.national_prefix_formatting_rule = "($NP$FG)"

self.assertEqual("(020) 7031 3000",

phonenumbers.format_by_pattern(GB_NUMBER, PhoneNumberFormat.NATIONAL,

newNumberFormats))

newNumFormat.national_prefix_formatting_rule = ""

self.assertEqual("20 7031 3000",

phonenumbers.format_by_pattern(GB_NUMBER, PhoneNumberFormat.NATIONAL,

newNumberFormats))

self.assertEqual("+44 20 7031 3000",

phonenumbers.format_by_pattern(GB_NUMBER, PhoneNumberFormat.INTERNATIONAL,

newNumberFormats))

# Python version extra tests

self.assertEqual("1234567890",

phonenumbers.format_by_pattern(XY_NUMBER, PhoneNumberFormat.E164,

newNumberFormats))

# None of the patterns in the list match (because it's an empty list)

self.assertEqual("6502530000", phonenumbers.format_by_pattern(US_NUMBER, PhoneNumberFormat.NATIONAL, []))

def testFormatE164Number(self):

self.assertEqual("+16502530000", phonenumbers.format_number(US_NUMBER, PhoneNumberFormat.E164))

self.assertEqual("+4930123456", phonenumbers.format_number(DE_NUMBER, PhoneNumberFormat.E164))

self.assertEqual("+80012345678", phonenumbers.format_number(INTERNATIONAL_TOLL_FREE, PhoneNumberFormat.E164))

def testFormatNumberWithExtension(self):

nzNumber = PhoneNumber()

nzNumber.merge_from(NZ_NUMBER)

nzNumber.extension = "1234"

# Uses default extension prefix:

self.assertEqual("03-331 6005 ext. 1234", phonenumbers.format_number(nzNumber, PhoneNumberFormat.NATIONAL))

# Uses RFC 3966 syntax.

self.assertEqual("tel:+64-3-331-6005;ext=1234", phonenumbers.format_number(nzNumber, PhoneNumberFormat.RFC3966))

# Extension prefix overridden in the territory information for the US:

usNumberWithExtension = PhoneNumber()

usNumberWithExtension.merge_from(US_NUMBER)

usNumberWithExtension.extension = "4567"

self.assertEqual("650 253 0000 extn. 4567", phonenumbers.format_number(usNumberWithExtension,

PhoneNumberFormat.NATIONAL))

def testFormatInOriginalFormat(self):

number1 = phonenumbers.parse("+442087654321", "GB", keep_raw_input=True)

self.assertEqual("+44 20 8765 4321", phonenumbers.format_in_original_format(number1, "GB"))

number2 = phonenumbers.parse("02087654321", "GB", keep_raw_input=True)

self.assertEqual("(020) 8765 4321", phonenumbers.format_in_original_format(number2, "GB"))

number3 = phonenumbers.parse("011442087654321", "US", keep_raw_input=True)

self.assertEqual("011 44 20 8765 4321", phonenumbers.format_in_original_format(number3, "US"))

number4 = phonenumbers.parse("442087654321", "GB", keep_raw_input=True)

self.assertEqual("44 20 8765 4321", phonenumbers.format_in_original_format(number4, "GB"))

number5 = phonenumbers.parse("+442087654321", "GB")

self.assertEqual("(020) 8765 4321", phonenumbers.format_in_original_format(number5, "GB"))

# 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.

number6 = phonenumbers.parse("7345678901", "US", keep_raw_input=True)

self.assertEqual("734 567 8901", phonenumbers.format_in_original_format(number6, "US"))

# US is not a leading zero country, and the presence of the leading zero leads us to format the

# number using raw_input.

number7 = phonenumbers.parse("0734567 8901", "US", keep_raw_input=True)

self.assertEqual("0734567 8901", phonenumbers.format_in_original_format(number7, "US"))

# This number is valid, but we don't have a formatting pattern for

# it. Fall back to the raw input.

number8 = phonenumbers.parse("02-4567-8900", "KR", keep_raw_input=True)