Google Git
Sign in
nest-open-source / nest-mobile-client-iphone / 4.4.2 / libPhoneNumber / 936f547c53cc477f3d47b76f97041296cbc65d3c / . / libPhoneNumberTests / NBPhoneNumberUtilTests.m
blob: 05a176125a41e53b25bf14ec9143ec25f824e670 [file] [log] [blame]
//
// NBPhoneNumberUtilTests.m
// NBPhoneNumberUtilTests
//
// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com)
//
#import "NBPhoneNumberUtilTests.h"
#import "NBPhoneMetaData.h"
#import "NBPhoneNumber.h"
#import "NBPhoneNumberDesc.h"
#import "NBPhoneNumberUtil.h"
#import "NBNumberFormat.h"
@interface NBPhoneNumberUtil (FOR_UNIT_TEST)
- (NBPhoneNumber*)getExampleNumber:(NSString*)regionCode;
- (NBPhoneNumber*)getExampleNumberForType:(NSString*)regionCode type:(NBEPhoneNumberType)type;
- (NBPhoneNumber*)getExampleNumberForNonGeoEntity:(NSNumber*)countryCallingCode;
- (NBPhoneMetaData*)getMetadataForRegion:(NSString*)regionCode;
- (BOOL)canBeInternationallyDialled:(NBPhoneNumber*)number;
- (BOOL)truncateTooLongNumber:(NBPhoneNumber*)number;
- (NBEValidationResult)isPossibleNumberWithReason:(NBPhoneNumber*)number;
- (BOOL)isPossibleNumber:(NBPhoneNumber*)number;
- (BOOL)isPossibleNumberString:(NSString*)number regionDialingFrom:(NSString*)regionDialingFrom;
- (NBEMatchType)isNumberMatch:(id)firstNumberIn second:(id)secondNumberIn;
- (NSUInteger)getLengthOfGeographicalAreaCode:(NBPhoneNumber*)phoneNumber;
- (NSUInteger)getLengthOfNationalDestinationCode:(NBPhoneNumber*)phoneNumber;
- (BOOL)maybeStripNationalPrefixAndCarrierCode:(NSString**)numberStr metadata:(NBPhoneMetaData*)metadata carrierCode:(NSString**)carrierCode;
- (NBECountryCodeSource)maybeStripInternationalPrefixAndNormalize:(NSString**)numberStr possibleIddPrefix:(NSString*)possibleIddPrefix;
- (NSNumber*)maybeExtractCountryCode:(NSString*)number metadata:(NBPhoneMetaData*)defaultRegionMetadata
nationalNumber:(NSString**)nationalNumber keepRawInput:(BOOL)keepRawInput phoneNumber:(NBPhoneNumber**)phoneNumber;
- (NBPhoneNumber*)parse:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion;
- (NBPhoneNumber*)parseAndKeepRawInput:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion;
- (NSString*)format:(NBPhoneNumber*)phoneNumber numberFormat:(NBEPhoneNumberFormat)numberFormat;
- (NSString*)formatByPattern:(NBPhoneNumber*)number numberFormat:(NBEPhoneNumberFormat)numberFormat userDefinedFormats:(NSArray*)userDefinedFormats;
- (NSString*)formatNumberForMobileDialing:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom withFormatting:(BOOL)withFormatting;
- (NSString*)formatOutOfCountryCallingNumber:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom;
- (NSString*)formatOutOfCountryKeepingAlphaChars:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom;
- (NSString*)formatNationalNumberWithCarrierCode:(NBPhoneNumber*)number carrierCode:(NSString*)carrierCode;
- (NSString*)formatInOriginalFormat:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom;
- (NSString*)formatNationalNumberWithPreferredCarrierCode:(NBPhoneNumber*)number fallbackCarrierCode:(NSString*)fallbackCarrierCode;
@end
@implementation NBPhoneNumberUtilTests
- (void)setUp
{
[super setUp];
// ...
}
- (void)tearDown
{
// ...
[super tearDown];
}
- (NSString*)stringForNumberType:(NBEPhoneNumberType)type
{
NSString *stringType = @"UNKNOWN";
switch (type) {
case 0: return @"FIXED_LINE";
case 1: return @"MOBILE";
case 2: return @"FIXED_LINE_OR_MOBILE";
case 3: return @"TOLL_FREE";
case 4: return @"PREMIUM_RATE";
case 5: return @"SHARED_COST";
case 6: return @"VOIP";
case 7: return @"PERSONAL_NUMBER";
case 8: return @"PAGER";
case 9: return @"UAN";
case 10: return @"VOICEMAIL";
default:
break;
}
return stringType;
}
// FIXME: This unit test ALWAYS FAIL ... until google libPhoneNumber fix this issue
- (void)testAustriaNationalNumberParsing
{
NSError *aError = nil;
NBPhoneNumberUtil *phoneUtil = [NBPhoneNumberUtil sharedInstance];
NSString *internationalNumberForInput = @"436606545646";
NSString *nationalNumberForExpect = @"6606545646";
NSString *defaultRegion = @"AT";
NBPhoneNumber *phoneNumber = [phoneUtil parse:internationalNumberForInput defaultRegion:defaultRegion error:&aError];
NSString *nationalNumberForActual = [NSString stringWithFormat:@"%@", phoneNumber.nationalNumber];
// ALWAYS FAIL need fix "google libPhoneNumber"
STAssertEqualObjects(nationalNumberForExpect, nationalNumberForActual, nil);
}
- (void)testNSDictionaryalbeKey
{
NBPhoneNumberUtil *phoneUtil = [NBPhoneNumberUtil sharedInstance];
NSError *aError = nil;
NBPhoneNumber *myNumber1 = [phoneUtil parse:@"971600123456" defaultRegion:@"AE" error:&aError];
NBPhoneNumber *myNumber2 = [phoneUtil parse:@"5491187654321" defaultRegion:@"AR" error:&aError];
NBPhoneNumber *myNumber3 = [phoneUtil parse:@"12423570000" defaultRegion:@"BS" error:&aError];
NBPhoneNumber *myNumber4 = [phoneUtil parse:@"39236618300" defaultRegion:@"IT" error:&aError];
NBPhoneNumber *myNumber5 = [phoneUtil parse:@"16502530000" defaultRegion:@"US" error:&aError];
NSMutableDictionary *dicTest = [[NSMutableDictionary alloc] init];
[dicTest setObject:@"AE" forKey:myNumber1];
[dicTest setObject:@"AR" forKey:myNumber2];
[dicTest setObject:@"BS" forKey:myNumber3];
[dicTest setObject:@"IT" forKey:myNumber4];
[dicTest setObject:@"US" forKey:myNumber5];
NSLog(@"%@", [dicTest objectForKey:myNumber1]);
NSLog(@"%@", [dicTest objectForKey:myNumber2]);
NSLog(@"%@", [dicTest objectForKey:myNumber3]);
NSLog(@"%@", [dicTest objectForKey:myNumber4]);
NSLog(@"%@", [dicTest objectForKey:myNumber5]);
}
- (void)testWithRealData
{
NBPhoneNumberUtil *phoneUtil = [NBPhoneNumberUtil sharedInstance];
#pragma mark - customTest
NSLog(@"-------------- customTest");
NSError *aError = nil;
NBPhoneNumber *myNumber = [phoneUtil parse:@"6766077303" defaultRegion:@"AT" error:&aError];
if (aError == nil)
{
NSLog(@"isValidPhoneNumber ? [%@]", [phoneUtil isValidNumber:myNumber] ? @"YES":@"NO");
NSLog(@"E164 : %@", [phoneUtil format:myNumber numberFormat:NBEPhoneNumberFormatE164 error:&aError]);
NSLog(@"INTERNATIONAL : %@", [phoneUtil format:myNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL error:&aError]);
NSLog(@"NATIONAL : %@", [phoneUtil format:myNumber numberFormat:NBEPhoneNumberFormatNATIONAL error:&aError]);
NSLog(@"RFC3966 : %@", [phoneUtil format:myNumber numberFormat:NBEPhoneNumberFormatRFC3966 error:&aError]);
}
else
{
NSLog(@"Error : %@", [aError localizedDescription]);
}
NSLog (@"extractCountryCode [%@]", [phoneUtil extractCountryCode:@"823213123123" nationalNumber:nil]);
NSString *res = nil;
NSNumber *dRes = [phoneUtil extractCountryCode:@"823213123123" nationalNumber:&res];
NSLog (@"extractCountryCode [%@] [%@]", dRes, res);
}
- (void)testWithTestData
{
// NSError *aError = nil;
NBPhoneNumberUtil *phoneUtil = [NBPhoneNumberUtil sharedInstanceForTest];
// Set up some test numbers to re-use.
// TODO: Rewrite this as static functions that return new numbers each time to
// avoid any risk of accidental changes to mutable static state affecting many
// tests.
NBPhoneNumber *ALPHA_NUMERIC_NUMBER = [[NBPhoneNumber alloc] init];
ALPHA_NUMERIC_NUMBER.countryCode = @1;
ALPHA_NUMERIC_NUMBER.nationalNumber = @80074935247;
NBPhoneNumber *AE_UAN = [[NBPhoneNumber alloc] init];
AE_UAN.countryCode = @971;
AE_UAN.nationalNumber = @600123456;
NBPhoneNumber *AR_MOBILE = [[NBPhoneNumber alloc] init];
AR_MOBILE.countryCode = @54;
AR_MOBILE.nationalNumber = @91187654321;
NBPhoneNumber *AR_NUMBER = [[NBPhoneNumber alloc] init];
AR_NUMBER.countryCode = @54;
AR_NUMBER.nationalNumber = @1187654321;
NBPhoneNumber *AU_NUMBER = [[NBPhoneNumber alloc] init];
AU_NUMBER.countryCode = @61;
AU_NUMBER.nationalNumber = @236618300;
NBPhoneNumber *BS_MOBILE = [[NBPhoneNumber alloc] init];
BS_MOBILE.countryCode = @1;
BS_MOBILE.nationalNumber = @2423570000;
NBPhoneNumber *BS_NUMBER = [[NBPhoneNumber alloc] init];
BS_NUMBER.countryCode = @1;
BS_NUMBER.nationalNumber = @2423651234;
// Note that this is the same as the example number for DE in the metadata.
NBPhoneNumber *DE_NUMBER = [[NBPhoneNumber alloc] init];
DE_NUMBER.countryCode = @49;
DE_NUMBER.nationalNumber = @30123456;
NBPhoneNumber *DE_SHORT_NUMBER = [[NBPhoneNumber alloc] init];
DE_SHORT_NUMBER.countryCode = @49;
DE_SHORT_NUMBER.nationalNumber = @1234;
NBPhoneNumber *GB_MOBILE = [[NBPhoneNumber alloc] init];
GB_MOBILE.countryCode = @44;
GB_MOBILE.nationalNumber = @7912345678;
NBPhoneNumber *GB_NUMBER = [[NBPhoneNumber alloc] init];
GB_NUMBER.countryCode = @44;
GB_NUMBER.nationalNumber = @2070313000;
NBPhoneNumber *IT_MOBILE = [[NBPhoneNumber alloc] init];
IT_MOBILE.countryCode = @39;
IT_MOBILE.nationalNumber = @345678901;
NBPhoneNumber *IT_NUMBER = [[NBPhoneNumber alloc] init];
IT_NUMBER.countryCode = @39;
IT_NUMBER.nationalNumber = @236618300;
IT_NUMBER.italianLeadingZero = YES;
NBPhoneNumber *JP_STAR_NUMBER = [[NBPhoneNumber alloc] init];
JP_STAR_NUMBER.countryCode = @81;
JP_STAR_NUMBER.nationalNumber = @2345;
// Numbers to test the formatting rules from Mexico.
NBPhoneNumber *MX_MOBILE1 = [[NBPhoneNumber alloc] init];
MX_MOBILE1.countryCode = @52;
MX_MOBILE1.nationalNumber = @12345678900;
NBPhoneNumber *MX_MOBILE2 = [[NBPhoneNumber alloc] init];
MX_MOBILE2.countryCode = @52;
MX_MOBILE2.nationalNumber = @15512345678;
NBPhoneNumber *MX_NUMBER1 = [[NBPhoneNumber alloc] init];
MX_NUMBER1.countryCode = @52;
MX_NUMBER1.nationalNumber = @3312345678;
NBPhoneNumber *MX_NUMBER2 = [[NBPhoneNumber alloc] init];
MX_NUMBER2.countryCode = @52;
MX_NUMBER2.nationalNumber = @8211234567;
NBPhoneNumber *NZ_NUMBER = [[NBPhoneNumber alloc] init];
NZ_NUMBER.countryCode = @64;
NZ_NUMBER.nationalNumber = @33316005;
NBPhoneNumber *SG_NUMBER = [[NBPhoneNumber alloc] init];
SG_NUMBER.countryCode = @65;
SG_NUMBER.nationalNumber = @65218000;
// A too-long and hence invalid US number.
NBPhoneNumber *US_LONG_NUMBER = [[NBPhoneNumber alloc] init];
US_LONG_NUMBER.countryCode = @1;
US_LONG_NUMBER.nationalNumber = @65025300001;
NBPhoneNumber *US_NUMBER = [[NBPhoneNumber alloc] init];
US_NUMBER.countryCode = @1;
US_NUMBER.nationalNumber = @6502530000;
NBPhoneNumber *US_PREMIUM = [[NBPhoneNumber alloc] init];
US_PREMIUM.countryCode = @1;
US_PREMIUM.nationalNumber = @9002530000;
// Too short, but still possible US numbers.
NBPhoneNumber *US_LOCAL_NUMBER = [[NBPhoneNumber alloc] init];
US_LOCAL_NUMBER.countryCode = @1;
US_LOCAL_NUMBER.nationalNumber = @2530000;
NBPhoneNumber *US_SHORT_BY_ONE_NUMBER = [[NBPhoneNumber alloc] init];
US_SHORT_BY_ONE_NUMBER.countryCode = @1;
US_SHORT_BY_ONE_NUMBER.nationalNumber = @650253000;
NBPhoneNumber *US_TOLLFREE = [[NBPhoneNumber alloc] init];
US_TOLLFREE.countryCode = @1;
US_TOLLFREE.nationalNumber = @8002530000;
NBPhoneNumber *US_SPOOF = [[NBPhoneNumber alloc] init];
US_SPOOF.countryCode = @1;
US_SPOOF.nationalNumber = @0;
NBPhoneNumber *US_SPOOF_WITH_RAW_INPUT = [[NBPhoneNumber alloc] init];
US_SPOOF_WITH_RAW_INPUT.countryCode = @1;
US_SPOOF_WITH_RAW_INPUT.nationalNumber = @0;
US_SPOOF_WITH_RAW_INPUT.rawInput = @"000-000-0000";
NBPhoneNumber *INTERNATIONAL_TOLL_FREE = [[NBPhoneNumber alloc] init];
INTERNATIONAL_TOLL_FREE.countryCode = @800;
INTERNATIONAL_TOLL_FREE.nationalNumber = @12345678;
// We set this to be the same length as numbers for the other non-geographical
// country prefix that we have in our test metadata. However, this is not
// considered valid because they differ in their country calling code.
NBPhoneNumber *INTERNATIONAL_TOLL_FREE_TOO_LONG = [[NBPhoneNumber alloc] init];
INTERNATIONAL_TOLL_FREE_TOO_LONG.countryCode = @800;
INTERNATIONAL_TOLL_FREE_TOO_LONG.nationalNumber = @123456789;
NBPhoneNumber *UNIVERSAL_PREMIUM_RATE = [[NBPhoneNumber alloc] init];
UNIVERSAL_PREMIUM_RATE.countryCode = @979;
UNIVERSAL_PREMIUM_RATE.nationalNumber = @123456789;
NBPhoneNumber *UNKNOWN_COUNTRY_CODE_NO_RAW_INPUT = [[NBPhoneNumber alloc] init];
UNKNOWN_COUNTRY_CODE_NO_RAW_INPUT.countryCode = @2;
UNKNOWN_COUNTRY_CODE_NO_RAW_INPUT.nationalNumber = @12345;
#pragma mark - testGetInstanceLoadUSMetadata
{
NBPhoneMetaData *metadata = [phoneUtil getMetadataForRegion:@"US"];
STAssertEqualObjects(@"US", metadata.codeID, nil);
STAssertTrue([metadata.countryCode isEqualToNumber:@1], nil);
STAssertEqualObjects(@"011", metadata.internationalPrefix, nil);
STAssertTrue(metadata.nationalPrefix != nil, nil);
STAssertEquals(2, (int)[metadata.numberFormats count], nil);
STAssertEqualObjects(@"(\\d{3})(\\d{3})(\\d{4})", ((NBNumberFormat*)metadata.numberFormats[1]).pattern, nil);
STAssertEqualObjects(@"$1 $2 $3", ((NBNumberFormat*)metadata.numberFormats[1]).format, nil);
STAssertEqualObjects(@"[13-689]\\d{9}|2[0-35-9]\\d{8}", metadata.generalDesc.nationalNumberPattern, nil);
STAssertEqualObjects(@"\\d{7}(?:\\d{3})?", metadata.generalDesc.possibleNumberPattern, nil);
STAssertTrue([metadata.generalDesc isEqual:metadata.fixedLine], nil);
STAssertEqualObjects(@"\\d{10}", metadata.tollFree.possibleNumberPattern, nil);
STAssertEqualObjects(@"900\\d{7}", metadata.premiumRate.nationalNumberPattern, nil);
// No shared-cost data is available, so it should be initialised to 'NA'.
STAssertEqualObjects(@"NA", metadata.sharedCost.nationalNumberPattern, nil);
STAssertEqualObjects(@"NA", metadata.sharedCost.possibleNumberPattern, nil);
}
#pragma mark - testGetInstanceLoadDEMetadata
{
NBPhoneMetaData *metadata = [phoneUtil getMetadataForRegion:@"DE"];
STAssertEqualObjects(@"DE", metadata.codeID, nil);
STAssertTrue([metadata.countryCode isEqualToNumber:@49], nil);
STAssertEqualObjects(@"00", metadata.internationalPrefix, nil);
STAssertEqualObjects(@"0", metadata.nationalPrefix, nil);
STAssertEquals(6, (int)[metadata.numberFormats count], nil);
STAssertEquals(1, (int)[((NBNumberFormat*)metadata.numberFormats[5]).leadingDigitsPatterns count], nil);
STAssertEqualObjects(@"900", ((NBNumberFormat*)metadata.numberFormats[5]).leadingDigitsPatterns[0], nil);
STAssertEqualObjects(@"(\\d{3})(\\d{3,4})(\\d{4})", ((NBNumberFormat*)metadata.numberFormats[5]).pattern, nil);
STAssertEqualObjects(@"$1 $2 $3", ((NBNumberFormat*)metadata.numberFormats[5]).format, nil);
STAssertEqualObjects(@"(?:[24-6]\\d{2}|3[03-9]\\d|[789](?:[1-9]\\d|0[2-9]))\\d{1,8}", metadata.fixedLine.nationalNumberPattern, nil);
STAssertEqualObjects(@"\\d{2,14}", metadata.fixedLine.possibleNumberPattern, nil);
STAssertEqualObjects(@"30123456", metadata.fixedLine.exampleNumber, nil);
STAssertEqualObjects(@"\\d{10}", metadata.tollFree.possibleNumberPattern, nil);
STAssertEqualObjects(@"900([135]\\d{6}|9\\d{7})", metadata.premiumRate.nationalNumberPattern, nil);
}
#pragma mark - testGetInstanceLoadARMetadata
{
NBPhoneMetaData *metadata = [phoneUtil getMetadataForRegion:@"AR"];
STAssertEqualObjects(@"AR", metadata.codeID, nil);
STAssertTrue([metadata.countryCode isEqualToNumber:@54], nil);
STAssertEqualObjects(@"00", metadata.internationalPrefix, nil);
STAssertEqualObjects(@"0", metadata.nationalPrefix, nil);
STAssertEqualObjects(@"0(?:(11|343|3715)15)?", metadata.nationalPrefixForParsing, nil);
STAssertEqualObjects(@"9$1", metadata.nationalPrefixTransformRule, nil);
STAssertEqualObjects(@"$2 15 $3-$4", ((NBNumberFormat*)metadata.numberFormats[2]).format, nil);
STAssertEqualObjects(@"(9)(\\d{4})(\\d{2})(\\d{4})", ((NBNumberFormat*)metadata.numberFormats[3]).pattern, nil);
STAssertEqualObjects(@"(9)(\\d{4})(\\d{2})(\\d{4})", ((NBNumberFormat*)metadata.intlNumberFormats[3]).pattern, nil);
STAssertEqualObjects(@"$1 $2 $3 $4", ((NBNumberFormat*)metadata.intlNumberFormats[3]).format, nil);
}
#pragma mark - testGetInstanceLoadInternationalTollFreeMetadata
{
NBPhoneMetaData *metadata = [phoneUtil getMetadataForNonGeographicalRegion:@800];
STAssertEqualObjects(@"001", metadata.codeID, nil);
STAssertTrue([metadata.countryCode isEqualToNumber:@800], nil);
STAssertEqualObjects(@"$1 $2", ((NBNumberFormat*)metadata.numberFormats[0]).format, nil);
STAssertEqualObjects(@"(\\d{4})(\\d{4})", ((NBNumberFormat*)metadata.numberFormats[0]).pattern, nil);
STAssertEqualObjects(@"12345678", metadata.generalDesc.exampleNumber, nil);
STAssertEqualObjects(@"12345678", metadata.tollFree.exampleNumber, nil);
}
#pragma mark - testIsNumberGeographical
{
// Bahamas, mobile phone number.
STAssertFalse([phoneUtil isNumberGeographical:BS_MOBILE], nil);
// Australian fixed line number.
STAssertTrue([phoneUtil isNumberGeographical:AU_NUMBER], nil);
// International toll free number.
STAssertFalse([phoneUtil isNumberGeographical:INTERNATIONAL_TOLL_FREE], nil);
}
#pragma mark - testIsLeadingZeroPossible
{
// Italy
STAssertTrue([phoneUtil isLeadingZeroPossible:@39], nil);
// USA
STAssertFalse([phoneUtil isLeadingZeroPossible:@1], nil);
// International toll free
STAssertTrue([phoneUtil isLeadingZeroPossible:@800], nil);
// International premium-rate
STAssertFalse([phoneUtil isLeadingZeroPossible:@979], nil);
// Not in metadata file, just default to false.
STAssertFalse([phoneUtil isLeadingZeroPossible:@888], nil);
}
#pragma mark - testgetLengthOfGeographicalAreaCode
{
// Google MTV, which has area code '650'.
STAssertEquals((NSUInteger)3, [phoneUtil getLengthOfGeographicalAreaCode:US_NUMBER], nil);
// A North America toll-free number, which has no area code.
STAssertEquals((NSUInteger)0, [phoneUtil getLengthOfGeographicalAreaCode:US_TOLLFREE], nil);
// Google London, which has area code '20'.
STAssertEquals((NSUInteger)2, [phoneUtil getLengthOfGeographicalAreaCode:GB_NUMBER], nil);
// A UK mobile phone, which has no area code.
STAssertEquals((NSUInteger)0, [phoneUtil getLengthOfGeographicalAreaCode:GB_MOBILE], nil);
// Google Buenos Aires, which has area code '11'.
STAssertEquals((NSUInteger)2, [phoneUtil getLengthOfGeographicalAreaCode:AR_NUMBER], nil);
// Google Sydney, which has area code '2'.
STAssertEquals((NSUInteger)1, [phoneUtil getLengthOfGeographicalAreaCode:AU_NUMBER], nil);
// Italian numbers - there is no national prefix, but it still has an area
// code.
STAssertEquals((NSUInteger)2, [phoneUtil getLengthOfGeographicalAreaCode:IT_NUMBER], nil);
// Google Singapore. Singapore has no area code and no national prefix.
STAssertEquals((NSUInteger)0, [phoneUtil getLengthOfGeographicalAreaCode:SG_NUMBER], nil);
// An invalid US number (1 digit shorter), which has no area code.
STAssertEquals((NSUInteger)0, [phoneUtil getLengthOfGeographicalAreaCode:US_SHORT_BY_ONE_NUMBER], nil);
// An international toll free number, which has no area code.
STAssertEquals((NSUInteger)0, [phoneUtil getLengthOfGeographicalAreaCode:INTERNATIONAL_TOLL_FREE], nil);
}
#pragma mark - testGetLengthOfNationalDestinationCode
{
// Google MTV, which has national destination code (NDC) '650'.
STAssertEquals((NSUInteger)3, [phoneUtil getLengthOfNationalDestinationCode:US_NUMBER], nil);
// A North America toll-free number, which has NDC '800'.
STAssertEquals((NSUInteger)3, [phoneUtil getLengthOfNationalDestinationCode:US_TOLLFREE], nil);
// Google London, which has NDC '20'.
STAssertEquals((NSUInteger)2, [phoneUtil getLengthOfNationalDestinationCode:GB_NUMBER], nil);
// A UK mobile phone, which has NDC '7912'.
STAssertEquals((NSUInteger)4, [phoneUtil getLengthOfNationalDestinationCode:GB_MOBILE], nil);
// Google Buenos Aires, which has NDC '11'.
STAssertEquals((NSUInteger)2, [phoneUtil getLengthOfNationalDestinationCode:AR_NUMBER], nil);
// An Argentinian mobile which has NDC '911'.
STAssertEquals((NSUInteger)3, [phoneUtil getLengthOfNationalDestinationCode:AR_MOBILE], nil);
// Google Sydney, which has NDC '2'.
STAssertEquals((NSUInteger)1, [phoneUtil getLengthOfNationalDestinationCode:AU_NUMBER], nil);
// Google Singapore, which has NDC '6521'.
STAssertEquals((NSUInteger)4, [phoneUtil getLengthOfNationalDestinationCode:SG_NUMBER], nil);
// An invalid US number (1 digit shorter), which has no NDC.
STAssertEquals((NSUInteger)0,
[phoneUtil getLengthOfNationalDestinationCode:US_SHORT_BY_ONE_NUMBER], nil);
// A number containing an invalid country calling code, which shouldn't have
// any NDC.
NBPhoneNumber *number = [[NBPhoneNumber alloc] init];
[number setCountryCode:@123];
[number setNationalNumber:@6502530000];
STAssertEquals((NSUInteger)0, [phoneUtil getLengthOfNationalDestinationCode:number], nil);
// An international toll free number, which has NDC '1234'.
STAssertEquals((NSUInteger)4, [phoneUtil getLengthOfNationalDestinationCode:INTERNATIONAL_TOLL_FREE], nil);
}
#pragma mark - testGetNationalSignificantNumber
{
STAssertEqualObjects(@"6502530000", [phoneUtil getNationalSignificantNumber:US_NUMBER], nil);
// An Italian mobile number.
STAssertEqualObjects(@"345678901", [phoneUtil getNationalSignificantNumber:IT_MOBILE], nil);
// An Italian fixed line number.
STAssertEqualObjects(@"0236618300", [phoneUtil getNationalSignificantNumber:IT_NUMBER], nil);
STAssertEqualObjects(@"12345678", [phoneUtil getNationalSignificantNumber:INTERNATIONAL_TOLL_FREE], nil);
}
#pragma mark - testGetExampleNumber
{
STAssertTrue([DE_NUMBER isEqual:[phoneUtil getExampleNumber:@"DE"]], nil);
STAssertTrue([DE_NUMBER isEqual:[phoneUtil getExampleNumberForType:@"DE" type:NBEPhoneNumberTypeFIXED_LINE]], nil);
STAssertNil([phoneUtil getExampleNumberForType:@"DE" type:NBEPhoneNumberTypeMOBILE], nil);
// 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 nil.
STAssertNotNil([phoneUtil getExampleNumberForType:@"US" type:NBEPhoneNumberTypeFIXED_LINE], nil);
STAssertNotNil([phoneUtil getExampleNumberForType:@"US" type:NBEPhoneNumberTypeMOBILE], nil);
// CS is an invalid region, so we have no data for it.
STAssertNil([phoneUtil getExampleNumberForType:@"CS" type:NBEPhoneNumberTypeMOBILE], nil);
// RegionCode 001 is reserved for supporting non-geographical country calling
// code. We don't support getting an example number for it with this method.
STAssertNil([phoneUtil getExampleNumber:@"001"], nil);
}
#pragma mark - testexampleNumberForNonGeoEntity
{
STAssertTrue([INTERNATIONAL_TOLL_FREE isEqual:[phoneUtil getExampleNumberForNonGeoEntity:@800]], nil);
STAssertTrue([UNIVERSAL_PREMIUM_RATE isEqual:[phoneUtil getExampleNumberForNonGeoEntity:@979]], nil);
}
#pragma mark - testConvertAlphaCharactersInNumber
{
NSString *input = @"1800-ABC-DEF";
// Alpha chars are converted to digits; everything else is left untouched.
NSString *expectedOutput = @"1800-222-333";
STAssertEqualObjects(expectedOutput, [phoneUtil convertAlphaCharactersInNumber:input], nil);
}
#pragma mark - testNormaliseRemovePunctuation
{
NSString *inputNumber = @"034-56&+#2\u00AD34";
NSString *expectedOutput = @"03456234";
STAssertEqualObjects(expectedOutput, [phoneUtil normalizePhoneNumber:inputNumber], @"Conversion did not correctly remove punctuation");
}
#pragma mark - testNormaliseReplaceAlphaCharacters
{
NSString *inputNumber = @"034-I-am-HUNGRY";
NSString *expectedOutput = @"034426486479";
STAssertEqualObjects(expectedOutput, [phoneUtil normalizePhoneNumber:inputNumber], @"Conversion did not correctly replace alpha characters");
}
#pragma mark - testNormaliseOtherDigits
{
NSString *inputNumber = @"\uFF125\u0665";
NSString *expectedOutput = @"255";
STAssertEqualObjects(expectedOutput, [phoneUtil normalizePhoneNumber:inputNumber], @"Conversion did not correctly replace non-latin digits");
// Eastern-Arabic digits.
inputNumber = @"\u06F52\u06F0";
expectedOutput = @"520";
STAssertEqualObjects(expectedOutput, [phoneUtil normalizePhoneNumber:inputNumber], @"Conversion did not correctly replace non-latin digits");
}
#pragma mark - testNormaliseStripAlphaCharacters
{
NSString *inputNumber = @"034-56&+a#234";
NSString *expectedOutput = @"03456234";
STAssertEqualObjects(expectedOutput, [phoneUtil normalizeDigitsOnly:inputNumber], @"Conversion did not correctly remove alpha character");
}
#pragma mark - testFormatUSNumber
{
STAssertEqualObjects(@"650 253 0000", [phoneUtil format:US_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+1 650 253 0000", [phoneUtil format:US_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"800 253 0000", [phoneUtil format:US_TOLLFREE numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+1 800 253 0000", [phoneUtil format:US_TOLLFREE numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"900 253 0000", [phoneUtil format:US_PREMIUM numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+1 900 253 0000", [phoneUtil format:US_PREMIUM numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"tel:+1-900-253-0000", [phoneUtil format:US_PREMIUM numberFormat:NBEPhoneNumberFormatRFC3966], nil);
// 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.
STAssertEqualObjects(@"000-000-0000", [phoneUtil format:US_SPOOF_WITH_RAW_INPUT numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"0", [phoneUtil format:US_SPOOF numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
}
#pragma mark - testFormatBSNumber
{
STAssertEqualObjects(@"242 365 1234", [phoneUtil format:BS_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+1 242 365 1234", [phoneUtil format:BS_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
}
#pragma mark - testFormatGBNumber
{
STAssertEqualObjects(@"(020) 7031 3000", [phoneUtil format:GB_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+44 20 7031 3000", [phoneUtil format:GB_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"(07912) 345 678", [phoneUtil format:GB_MOBILE numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+44 7912 345 678", [phoneUtil format:GB_MOBILE numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
}
#pragma mark - testFormatDENumber
{
id deNumber = [[NBPhoneNumber alloc] init];
[deNumber setCountryCode:@49];
[deNumber setNationalNumber:@301234];
STAssertEqualObjects(@"030/1234", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+49 30/1234", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"tel:+49-30-1234", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatRFC3966], nil);
deNumber = [[NBPhoneNumber alloc] init];
[deNumber setCountryCode:@49];
[deNumber setNationalNumber:@291123];
STAssertEqualObjects(@"0291 123", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+49 291 123", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
deNumber = [[NBPhoneNumber alloc] init];
[deNumber setCountryCode:@49];
[deNumber setNationalNumber:@29112345678];
STAssertEqualObjects(@"0291 12345678", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+49 291 12345678", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
deNumber = [[NBPhoneNumber alloc] init];
[deNumber setCountryCode:@49];
[deNumber setNationalNumber:@912312345];
STAssertEqualObjects(@"09123 12345", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+49 9123 12345", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
deNumber = [[NBPhoneNumber alloc] init];
[deNumber setCountryCode:@49];
[deNumber setNationalNumber:@80212345];
STAssertEqualObjects(@"08021 2345", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+49 8021 2345", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
// 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.
STAssertEqualObjects(@"1234", [phoneUtil format:DE_SHORT_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+49 1234", [phoneUtil format:DE_SHORT_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
deNumber = [[NBPhoneNumber alloc] init];
[deNumber setCountryCode:@49];
[deNumber setNationalNumber:@41341234];
STAssertEqualObjects(@"04134 1234", [phoneUtil format:deNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
}
#pragma mark - testFormatITNumber
{
STAssertEqualObjects(@"02 3661 8300", [phoneUtil format:IT_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+39 02 3661 8300", [phoneUtil format:IT_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+390236618300", [phoneUtil format:IT_NUMBER numberFormat:NBEPhoneNumberFormatE164], nil);
STAssertEqualObjects(@"345 678 901", [phoneUtil format:IT_MOBILE numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+39 345 678 901", [phoneUtil format:IT_MOBILE numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+39345678901", [phoneUtil format:IT_MOBILE numberFormat:NBEPhoneNumberFormatE164], nil);
}
#pragma mark - testFormatAUNumber
{
STAssertEqualObjects(@"02 3661 8300", [phoneUtil format:AU_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+61 2 3661 8300", [phoneUtil format:AU_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+61236618300", [phoneUtil format:AU_NUMBER numberFormat:NBEPhoneNumberFormatE164], nil);
id auNumber = [[NBPhoneNumber alloc] init];
[auNumber setCountryCode:@61];
[auNumber setNationalNumber:@1800123456];
STAssertEqualObjects(@"1800 123 456", [phoneUtil format:auNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+61 1800 123 456", [phoneUtil format:auNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+611800123456", [phoneUtil format:auNumber numberFormat:NBEPhoneNumberFormatE164], nil);
}
#pragma mark - testFormatARNumber
{
STAssertEqualObjects(@"011 8765-4321", [phoneUtil format:AR_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+54 11 8765-4321", [phoneUtil format:AR_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+541187654321", [phoneUtil format:AR_NUMBER numberFormat:NBEPhoneNumberFormatE164], nil);
STAssertEqualObjects(@"011 15 8765-4321", [phoneUtil format:AR_MOBILE numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+54 9 11 8765 4321", [phoneUtil format:AR_MOBILE numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+5491187654321", [phoneUtil format:AR_MOBILE numberFormat:NBEPhoneNumberFormatE164], nil);
}
#pragma mark - testFormatMXNumber
{
STAssertEqualObjects(@"045 234 567 8900", [phoneUtil format:MX_MOBILE1 numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+52 1 234 567 8900", [phoneUtil format:MX_MOBILE1 numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+5212345678900", [phoneUtil format:MX_MOBILE1 numberFormat:NBEPhoneNumberFormatE164], nil);
STAssertEqualObjects(@"045 55 1234 5678", [phoneUtil format:MX_MOBILE2 numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+52 1 55 1234 5678", [phoneUtil format:MX_MOBILE2 numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+5215512345678", [phoneUtil format:MX_MOBILE2 numberFormat:NBEPhoneNumberFormatE164], nil);
STAssertEqualObjects(@"01 33 1234 5678", [phoneUtil format:MX_NUMBER1 numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+52 33 1234 5678", [phoneUtil format:MX_NUMBER1 numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+523312345678", [phoneUtil format:MX_NUMBER1 numberFormat:NBEPhoneNumberFormatE164], nil);
STAssertEqualObjects(@"01 821 123 4567", [phoneUtil format:MX_NUMBER2 numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"+52 821 123 4567", [phoneUtil format:MX_NUMBER2 numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+528211234567", [phoneUtil format:MX_NUMBER2 numberFormat:NBEPhoneNumberFormatE164], nil);
}
#pragma mark - testFormatOutOfCountryCallingNumber
{
STAssertEqualObjects(@"00 1 900 253 0000", [phoneUtil formatOutOfCountryCallingNumber:US_PREMIUM regionCallingFrom:@"DE"], nil);
STAssertEqualObjects(@"1 650 253 0000", [phoneUtil formatOutOfCountryCallingNumber:US_NUMBER regionCallingFrom:@"BS"], nil);
STAssertEqualObjects(@"00 1 650 253 0000", [phoneUtil formatOutOfCountryCallingNumber:US_NUMBER regionCallingFrom:@"PL"], nil);
STAssertEqualObjects(@"011 44 7912 345 678", [phoneUtil formatOutOfCountryCallingNumber:GB_MOBILE regionCallingFrom:@"US"], nil);
STAssertEqualObjects(@"00 49 1234", [phoneUtil formatOutOfCountryCallingNumber:DE_SHORT_NUMBER regionCallingFrom:@"GB"], nil);
// 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.
STAssertEqualObjects(@"1234", [phoneUtil formatOutOfCountryCallingNumber:DE_SHORT_NUMBER regionCallingFrom:@"DE"], nil);
STAssertEqualObjects(@"011 39 02 3661 8300", [phoneUtil formatOutOfCountryCallingNumber:IT_NUMBER regionCallingFrom:@"US"], nil);
STAssertEqualObjects(@"02 3661 8300", [phoneUtil formatOutOfCountryCallingNumber:IT_NUMBER regionCallingFrom:@"IT"], nil);
STAssertEqualObjects(@"+39 02 3661 8300", [phoneUtil formatOutOfCountryCallingNumber:IT_NUMBER regionCallingFrom:@"SG"], nil);
STAssertEqualObjects(@"6521 8000", [phoneUtil formatOutOfCountryCallingNumber:SG_NUMBER regionCallingFrom:@"SG"], nil);
STAssertEqualObjects(@"011 54 9 11 8765 4321", [phoneUtil formatOutOfCountryCallingNumber:AR_MOBILE regionCallingFrom:@"US"], nil);
STAssertEqualObjects(@"011 800 1234 5678", [phoneUtil formatOutOfCountryCallingNumber:INTERNATIONAL_TOLL_FREE regionCallingFrom:@"US"], nil);
id arNumberWithExtn = [AR_MOBILE copy];
[arNumberWithExtn setExtension:@"1234"];
STAssertEqualObjects(@"011 54 9 11 8765 4321 ext. 1234", [phoneUtil formatOutOfCountryCallingNumber:arNumberWithExtn regionCallingFrom:@"US"], nil);
STAssertEqualObjects(@"0011 54 9 11 8765 4321 ext. 1234", [phoneUtil formatOutOfCountryCallingNumber:arNumberWithExtn regionCallingFrom:@"AU"], nil);
STAssertEqualObjects(@"011 15 8765-4321 ext. 1234", [phoneUtil formatOutOfCountryCallingNumber:arNumberWithExtn regionCallingFrom:@"AR"], nil);
}
#pragma mark - testFormatOutOfCountryWithInvalidRegion
{
// AQ/Antarctica isn't a valid region code for phone number formatting,
// so this falls back to intl formatting.
STAssertEqualObjects(@"+1 650 253 0000", [phoneUtil formatOutOfCountryCallingNumber:US_NUMBER regionCallingFrom:@"AQ"], nil);
// For region code 001, the out-of-country format always turns into the
// international format.
STAssertEqualObjects(@"+1 650 253 0000", [phoneUtil formatOutOfCountryCallingNumber:US_NUMBER regionCallingFrom:@"001"], nil);
}
#pragma mark - testFormatOutOfCountryWithPreferredIntlPrefix
{
// 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.)
STAssertEqualObjects(@"0011 39 02 3661 8300", [phoneUtil formatOutOfCountryCallingNumber:IT_NUMBER regionCallingFrom:@"AU"], nil);
}
#pragma mark - testFormatOutOfCountryKeepingAlphaChars
{
id alphaNumericNumber = [[NBPhoneNumber alloc] init];
[alphaNumericNumber setCountryCode:@1];
[alphaNumericNumber setNationalNumber:@8007493524];
[alphaNumericNumber setRawInput:@"1800 six-flag"];
STAssertEqualObjects(@"0011 1 800 SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AU"], nil);
[alphaNumericNumber setRawInput:@"1-800-SIX-flag"];
STAssertEqualObjects(@"0011 1 800-SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AU"], nil);
[alphaNumericNumber setRawInput:@"Call us from UK: 00 1 800 SIX-flag"];
STAssertEqualObjects(@"0011 1 800 SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AU"], nil);
[alphaNumericNumber setRawInput:@"800 SIX-flag"];
STAssertEqualObjects(@"0011 1 800 SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AU"], nil);
// Formatting from within the NANPA region.
STAssertEqualObjects(@"1 800 SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"US"], nil);
STAssertEqualObjects(@"1 800 SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"BS"], nil);
// Testing that if the raw input doesn't exist, it is formatted using
// formatOutOfCountryCallingNumber.
[alphaNumericNumber setRawInput:nil];
STAssertEqualObjects(@"00 1 800 749 3524", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"DE"], nil);
// Testing AU alpha number formatted from Australia.
[alphaNumericNumber setCountryCode:@61];
[alphaNumericNumber setNationalNumber:@827493524];
[alphaNumericNumber setRawInput:@"+61 82749-FLAG"];
// This number should have the national prefix fixed.
STAssertEqualObjects(@"082749-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AU"], nil);
[alphaNumericNumber setRawInput:@"082749-FLAG"];
STAssertEqualObjects(@"082749-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AU"], nil);
[alphaNumericNumber setNationalNumber:@18007493524];
[alphaNumericNumber setRawInput:@"1-800-SIX-flag"];
// This number should not have the national prefix prefixed, in accordance
// with the override for this specific formatting rule.
STAssertEqualObjects(@"1-800-SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AU"], nil);
// The metadata should not be permanently changed, since we copied it before
// modifying patterns. Here we check this.
[alphaNumericNumber setNationalNumber:@1800749352];
STAssertEqualObjects(@"1800 749 352", [phoneUtil formatOutOfCountryCallingNumber:alphaNumericNumber regionCallingFrom:@"AU"], nil);
// Testing a region with multiple international prefixes.
STAssertEqualObjects(@"+61 1-800-SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"SG"], nil);
// Testing the case of calling from a non-supported region.
STAssertEqualObjects(@"+61 1-800-SIX-FLAG", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AQ"], nil);
// Testing the case with an invalid country calling code.
[alphaNumericNumber setCountryCode:@0];
[alphaNumericNumber setNationalNumber:@18007493524];
[alphaNumericNumber setRawInput:@"1-800-SIX-flag"];
// Uses the raw input only.
STAssertEqualObjects(@"1-800-SIX-flag", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"DE"], nil);
// Testing the case of an invalid alpha number.
[alphaNumericNumber setCountryCode:@1];
[alphaNumericNumber setNationalNumber:@80749];
[alphaNumericNumber setRawInput:@"180-SIX"];
// No country-code stripping can be done.
STAssertEqualObjects(@"00 1 180-SIX", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"DE"], nil);
// Testing the case of calling from a non-supported region.
[alphaNumericNumber setCountryCode:@1];
[alphaNumericNumber setNationalNumber:@80749];
[alphaNumericNumber setRawInput:@"180-SIX"];
// No country-code stripping can be done since the number is invalid.
STAssertEqualObjects(@"+1 180-SIX", [phoneUtil formatOutOfCountryKeepingAlphaChars:alphaNumericNumber regionCallingFrom:@"AQ"], nil);
}
#pragma mark - testFormatWithCarrierCode()
{
// We only support this for AR in our test metadata, and only for mobile
// numbers starting with certain values.
NBPhoneNumber *arMobile = [[NBPhoneNumber alloc] init];
[arMobile setCountryCode:@54];
[arMobile setNationalNumber:@92234654321];
STAssertEqualObjects(@"02234 65-4321", [phoneUtil format:arMobile numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
// Here we force 14 as the carrier code.
STAssertEqualObjects(@"02234 14 65-4321", [phoneUtil formatNationalNumberWithCarrierCode:arMobile carrierCode:@"14"], nil);
// Here we force the number to be shown with no carrier code.
STAssertEqualObjects(@"02234 65-4321", [phoneUtil formatNationalNumberWithCarrierCode:arMobile carrierCode:@""], nil);
// Here the international rule is used, so no carrier code should be present.
STAssertEqualObjects(@"+5492234654321", [phoneUtil format:arMobile numberFormat:NBEPhoneNumberFormatE164], nil);
// We don't support this for the US so there should be no change.
STAssertEqualObjects(@"650 253 0000", [phoneUtil formatNationalNumberWithCarrierCode:US_NUMBER carrierCode:@"15"], nil);
// Invalid country code should just get the NSN.
STAssertEqualObjects(@"12345", [phoneUtil formatNationalNumberWithCarrierCode:UNKNOWN_COUNTRY_CODE_NO_RAW_INPUT carrierCode:@"89"], nil);
}
#pragma mark - testFormatWithPreferredCarrierCode
{
// We only support this for AR in our test metadata.
NBPhoneNumber *arNumber = [[NBPhoneNumber alloc] init];
[arNumber setCountryCode:@54];
[arNumber setNationalNumber:@91234125678];
// Test formatting with no preferred carrier code stored in the number itself.
STAssertEqualObjects(@"01234 15 12-5678", [phoneUtil formatNationalNumberWithPreferredCarrierCode:arNumber fallbackCarrierCode:@"15"], nil);
STAssertEqualObjects(@"01234 12-5678", [phoneUtil formatNationalNumberWithPreferredCarrierCode:arNumber fallbackCarrierCode:@""], nil);
// Test formatting with preferred carrier code present.
[arNumber setPreferredDomesticCarrierCode:@"19"];
STAssertEqualObjects(@"01234 12-5678", [phoneUtil format:arNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"01234 19 12-5678", [phoneUtil formatNationalNumberWithPreferredCarrierCode:arNumber fallbackCarrierCode:@"15"], nil);
STAssertEqualObjects(@"01234 19 12-5678", [phoneUtil formatNationalNumberWithPreferredCarrierCode:arNumber fallbackCarrierCode:@""], nil);
// When the preferred_domestic_carrier_code is present (even when it contains
// an empty string), use it instead of the default carrier code passed in.
[arNumber setPreferredDomesticCarrierCode:@""];
STAssertEqualObjects(@"01234 12-5678", [phoneUtil formatNationalNumberWithPreferredCarrierCode:arNumber fallbackCarrierCode:@"15"], nil);
// We don't support this for the US so there should be no change.
NBPhoneNumber *usNumber = [[NBPhoneNumber alloc] init];
[usNumber setCountryCode:@1];
[usNumber setNationalNumber:@4241231234];
[usNumber setPreferredDomesticCarrierCode:@"99"];
STAssertEqualObjects(@"424 123 1234", [phoneUtil format:usNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEqualObjects(@"424 123 1234", [phoneUtil formatNationalNumberWithPreferredCarrierCode:usNumber fallbackCarrierCode:@"15"], nil);
}
#pragma mark - testFormatNumberForMobileDialing
{
// Numbers are normally dialed in national format in-country, and
// international format from outside the country.
STAssertEqualObjects(@"030123456", [phoneUtil formatNumberForMobileDialing:DE_NUMBER regionCallingFrom:@"DE" withFormatting:NO], nil);
STAssertEqualObjects(@"+4930123456", [phoneUtil formatNumberForMobileDialing:DE_NUMBER regionCallingFrom:@"CH" withFormatting:NO], nil);
id deNumberWithExtn = [DE_NUMBER copy];
[deNumberWithExtn setExtension:@"1234"];
STAssertEqualObjects(@"030123456", [phoneUtil formatNumberForMobileDialing:deNumberWithExtn regionCallingFrom:@"DE" withFormatting:NO], nil);
STAssertEqualObjects(@"+4930123456", [phoneUtil formatNumberForMobileDialing:deNumberWithExtn regionCallingFrom:@"CH" withFormatting:NO], nil);
// US toll free numbers are marked as noInternationalDialling in the test
// metadata for testing purposes.
STAssertEqualObjects(@"800 253 0000", [phoneUtil formatNumberForMobileDialing:US_TOLLFREE regionCallingFrom:@"US" withFormatting:YES], nil);
STAssertEqualObjects(@"", [phoneUtil formatNumberForMobileDialing:US_TOLLFREE regionCallingFrom:@"CN" withFormatting:YES], nil);
STAssertEqualObjects(@"+1 650 253 0000", [phoneUtil formatNumberForMobileDialing:US_NUMBER regionCallingFrom:@"US" withFormatting:YES], nil);
id usNumberWithExtn = [US_NUMBER copy];
[usNumberWithExtn setExtension:@"1234"];
STAssertEqualObjects(@"+1 650 253 0000", [phoneUtil formatNumberForMobileDialing:usNumberWithExtn regionCallingFrom:@"US" withFormatting:YES], nil);
STAssertEqualObjects(@"8002530000", [phoneUtil formatNumberForMobileDialing:US_TOLLFREE regionCallingFrom:@"US" withFormatting:NO], nil);
STAssertEqualObjects(@"", [phoneUtil formatNumberForMobileDialing:US_TOLLFREE regionCallingFrom:@"CN" withFormatting:NO], nil);
STAssertEqualObjects(@"+16502530000", [phoneUtil formatNumberForMobileDialing:US_NUMBER regionCallingFrom:@"US" withFormatting:NO], nil);
STAssertEqualObjects(@"+16502530000", [phoneUtil formatNumberForMobileDialing:usNumberWithExtn regionCallingFrom:@"US" withFormatting:NO], nil);
// An invalid US number, which is one digit too long.
STAssertEqualObjects(@"+165025300001", [phoneUtil formatNumberForMobileDialing:US_LONG_NUMBER regionCallingFrom:@"US" withFormatting:NO], nil);
STAssertEqualObjects(@"+1 65025300001", [phoneUtil formatNumberForMobileDialing:US_LONG_NUMBER regionCallingFrom:@"US" withFormatting:YES], nil);
// Star numbers. In real life they appear in Israel, but we have them in JP
// in our test metadata.
STAssertEqualObjects(@"*2345", [phoneUtil formatNumberForMobileDialing:JP_STAR_NUMBER regionCallingFrom:@"JP" withFormatting:NO], nil);
STAssertEqualObjects(@"*2345", [phoneUtil formatNumberForMobileDialing:JP_STAR_NUMBER regionCallingFrom:@"JP" withFormatting:YES], nil);
STAssertEqualObjects(@"+80012345678", [phoneUtil formatNumberForMobileDialing:INTERNATIONAL_TOLL_FREE regionCallingFrom:@"JP" withFormatting:NO], nil);
STAssertEqualObjects(@"+800 1234 5678", [phoneUtil formatNumberForMobileDialing:INTERNATIONAL_TOLL_FREE regionCallingFrom:@"JP" withFormatting:YES], nil);
// UAE numbers beginning with 600 (classified as UAN) need to be dialled
// without +971 locally.
STAssertEqualObjects(@"+971600123456", [phoneUtil formatNumberForMobileDialing:AE_UAN regionCallingFrom:@"JP" withFormatting:NO], nil);
STAssertEqualObjects(@"600123456", [phoneUtil formatNumberForMobileDialing:AE_UAN regionCallingFrom:@"AE" withFormatting:NO], nil);
STAssertEqualObjects(@"+523312345678",
[phoneUtil formatNumberForMobileDialing:MX_NUMBER1 regionCallingFrom:@"MX" withFormatting:NO], nil);
STAssertEqualObjects(@"+523312345678",
[phoneUtil formatNumberForMobileDialing:MX_NUMBER1 regionCallingFrom:@"US" withFormatting:NO], nil);
// Non-geographical numbers should always be dialed in international format.
STAssertEqualObjects(@"+80012345678", [phoneUtil formatNumberForMobileDialing:INTERNATIONAL_TOLL_FREE regionCallingFrom:@"US" withFormatting:NO], nil);
STAssertEqualObjects(@"+80012345678", [phoneUtil formatNumberForMobileDialing:INTERNATIONAL_TOLL_FREE regionCallingFrom:@"UN001" withFormatting:NO], nil);
}
#pragma mark - testFormatByPattern
{
NBNumberFormat *newNumFormat = [[NBNumberFormat alloc] init];
[newNumFormat setPattern:@"(\\d{3})(\\d{3})(\\d{4})"];
[newNumFormat setFormat:@"($1) $2-$3"];
STAssertEqualObjects(@"(650) 253-0000", [phoneUtil formatByPattern:US_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL userDefinedFormats:@[newNumFormat]], nil);
STAssertEqualObjects(@"+1 (650) 253-0000", [phoneUtil formatByPattern:US_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL userDefinedFormats:@[newNumFormat]], nil);
STAssertEqualObjects(@"tel:+1-650-253-0000", [phoneUtil formatByPattern:US_NUMBER numberFormat:NBEPhoneNumberFormatRFC3966 userDefinedFormats:@[newNumFormat]], nil);
// $NP is set to '1' for the US. Here we check that for other NANPA countries
// the US rules are followed.
[newNumFormat setNationalPrefixFormattingRule:@"$NP ($FG)"];
[newNumFormat setFormat:@"$1 $2-$3"];
STAssertEqualObjects(@"1 (242) 365-1234", [phoneUtil formatByPattern:BS_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL userDefinedFormats:@[newNumFormat]], nil);
STAssertEqualObjects(@"+1 242 365-1234", [phoneUtil formatByPattern:BS_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL userDefinedFormats:@[newNumFormat]], nil);
[newNumFormat setPattern:@"(\\d{2})(\\d{5})(\\d{3})"];
[newNumFormat setFormat:@"$1-$2 $3"];
STAssertEqualObjects(@"02-36618 300", [phoneUtil formatByPattern:IT_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL userDefinedFormats:@[newNumFormat]], nil);
STAssertEqualObjects(@"+39 02-36618 300", [phoneUtil formatByPattern:IT_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL userDefinedFormats:@[newNumFormat]], nil);
[newNumFormat setNationalPrefixFormattingRule:@"$NP$FG"];
[newNumFormat setPattern:@"(\\d{2})(\\d{4})(\\d{4})"];
[newNumFormat setFormat:@"$1 $2 $3"];
STAssertEqualObjects(@"020 7031 3000", [phoneUtil formatByPattern:GB_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL userDefinedFormats:@[newNumFormat]], nil);
[newNumFormat setNationalPrefixFormattingRule:@"($NP$FG)"];
STAssertEqualObjects(@"(020) 7031 3000", [phoneUtil formatByPattern:GB_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL userDefinedFormats:@[newNumFormat]], nil);
[newNumFormat setNationalPrefixFormattingRule:@""];
STAssertEqualObjects(@"20 7031 3000", [phoneUtil formatByPattern:GB_NUMBER numberFormat:NBEPhoneNumberFormatNATIONAL userDefinedFormats:@[newNumFormat]], nil);
STAssertEqualObjects(@"+44 20 7031 3000", [phoneUtil formatByPattern:GB_NUMBER numberFormat:NBEPhoneNumberFormatINTERNATIONAL userDefinedFormats:@[newNumFormat]], nil);
}
#pragma mark - testFormatE164Number
{
STAssertEqualObjects(@"+16502530000", [phoneUtil format:US_NUMBER numberFormat:NBEPhoneNumberFormatE164], nil);
STAssertEqualObjects(@"+4930123456", [phoneUtil format:DE_NUMBER numberFormat:NBEPhoneNumberFormatE164], nil);
STAssertEqualObjects(@"+80012345678", [phoneUtil format:INTERNATIONAL_TOLL_FREE numberFormat:NBEPhoneNumberFormatE164], nil);
}
#pragma mark - testFormatNumberWithExtension
{
id nzNumber = [NZ_NUMBER copy];
[nzNumber setExtension:@"1234"];
// Uses default extension prefix:
STAssertEqualObjects(@"03-331 6005 ext. 1234", [phoneUtil format:nzNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
// Uses RFC 3966 syntax.
STAssertEqualObjects(@"tel:+64-3-331-6005;ext=1234", [phoneUtil format:nzNumber numberFormat:NBEPhoneNumberFormatRFC3966], nil);
// Extension prefix overridden in the territory information for the US:
id usNumberWithExtension = [US_NUMBER copy];
[usNumberWithExtension setExtension:@"4567"];
STAssertEqualObjects(@"650 253 0000 extn. 4567", [phoneUtil format:usNumberWithExtension numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
}
#pragma mark - testFormatInOriginalFormat
{
NBPhoneNumber *number1 = [phoneUtil parseAndKeepRawInput:@"+442087654321" defaultRegion:@"GB"];
STAssertEqualObjects(@"+44 20 8765 4321", [phoneUtil formatInOriginalFormat:number1 regionCallingFrom:@"GB"], nil);
NBPhoneNumber *number2 = [phoneUtil parseAndKeepRawInput:@"02087654321" defaultRegion:@"GB"];
STAssertEqualObjects(@"(020) 8765 4321", [phoneUtil formatInOriginalFormat:number2 regionCallingFrom:@"GB"], nil);
NBPhoneNumber *number3 = [phoneUtil parseAndKeepRawInput:@"011442087654321" defaultRegion:@"US"];
STAssertEqualObjects(@"011 44 20 8765 4321", [phoneUtil formatInOriginalFormat:number3 regionCallingFrom:@"US"], nil);
NBPhoneNumber *number4 = [phoneUtil parseAndKeepRawInput:@"442087654321" defaultRegion:@"GB"];
STAssertEqualObjects(@"44 20 8765 4321", [phoneUtil formatInOriginalFormat:number4 regionCallingFrom:@"GB"], nil);
NBPhoneNumber *number5 = [phoneUtil parse:@"+442087654321" defaultRegion:@"GB"];
STAssertEqualObjects(@"(020) 8765 4321", [phoneUtil formatInOriginalFormat:number5 regionCallingFrom:@"GB"], nil);
// 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.
NBPhoneNumber *number6 = [phoneUtil parseAndKeepRawInput:@"7345678901" defaultRegion:@"US"];
STAssertEqualObjects(@"734 567 8901", [phoneUtil formatInOriginalFormat:number6 regionCallingFrom:@"US"], nil);
// US is not a leading zero country, and the presence of the leading zero
// leads us to format the number using raw_input.
NBPhoneNumber *number7 = [phoneUtil parseAndKeepRawInput:@"0734567 8901" defaultRegion:@"US"];
STAssertEqualObjects(@"0734567 8901", [phoneUtil formatInOriginalFormat:number7 regionCallingFrom:@"US"], nil);
// This number is valid, but we don't have a formatting pattern for it.
// Fall back to the raw input.
NBPhoneNumber *number8 = [phoneUtil parseAndKeepRawInput:@"02-4567-8900" defaultRegion:@"KR"];
STAssertEqualObjects(@"02-4567-8900", [phoneUtil formatInOriginalFormat:number8 regionCallingFrom:@"KR"], nil);
NBPhoneNumber *number9 = [phoneUtil parseAndKeepRawInput:@"01180012345678" defaultRegion:@"US"];
STAssertEqualObjects(@"011 800 1234 5678", [phoneUtil formatInOriginalFormat:number9 regionCallingFrom:@"US"], nil);
NBPhoneNumber *number10 = [phoneUtil parseAndKeepRawInput:@"+80012345678" defaultRegion:@"KR"];
STAssertEqualObjects(@"+800 1234 5678", [phoneUtil formatInOriginalFormat:number10 regionCallingFrom:@"KR"], nil);
// US local numbers are formatted correctly, as we have formatting patterns
// for them.
NBPhoneNumber *localNumberUS = [phoneUtil parseAndKeepRawInput:@"2530000" defaultRegion:@"US"];
STAssertEqualObjects(@"253 0000", [phoneUtil formatInOriginalFormat:localNumberUS regionCallingFrom:@"US"], nil);
NBPhoneNumber *numberWithNationalPrefixUS = [phoneUtil parseAndKeepRawInput:@"18003456789" defaultRegion:@"US"];
STAssertEqualObjects(@"1 800 345 6789", [phoneUtil formatInOriginalFormat:numberWithNationalPrefixUS regionCallingFrom:@"US"], nil);
NBPhoneNumber *numberWithoutNationalPrefixGB = [phoneUtil parseAndKeepRawInput:@"2087654321" defaultRegion:@"GB"];
STAssertEqualObjects(@"20 8765 4321", [phoneUtil formatInOriginalFormat:numberWithoutNationalPrefixGB regionCallingFrom:@"GB"], nil);
// Make sure no metadata is modified as a result of the previous function
// call.
STAssertEqualObjects(@"(020) 8765 4321", [phoneUtil formatInOriginalFormat:number5 regionCallingFrom:@"GB"], nil);
NBPhoneNumber *numberWithNationalPrefixMX = [phoneUtil parseAndKeepRawInput:@"013312345678" defaultRegion:@"MX"];
STAssertEqualObjects(@"01 33 1234 5678", [phoneUtil formatInOriginalFormat:numberWithNationalPrefixMX regionCallingFrom:@"MX"], nil);
NBPhoneNumber *numberWithoutNationalPrefixMX = [phoneUtil parseAndKeepRawInput:@"3312345678" defaultRegion:@"MX"];
STAssertEqualObjects(@"33 1234 5678", [phoneUtil formatInOriginalFormat:numberWithoutNationalPrefixMX regionCallingFrom:@"MX"], nil);
NBPhoneNumber *italianFixedLineNumber = [phoneUtil parseAndKeepRawInput:@"0212345678" defaultRegion:@"IT"];
STAssertEqualObjects(@"02 1234 5678", [phoneUtil formatInOriginalFormat:italianFixedLineNumber regionCallingFrom:@"IT"], nil);
NBPhoneNumber *numberWithNationalPrefixJP = [phoneUtil parseAndKeepRawInput:@"00777012" defaultRegion:@"JP"];
STAssertEqualObjects(@"0077-7012", [phoneUtil formatInOriginalFormat:numberWithNationalPrefixJP regionCallingFrom:@"JP"], nil);
NBPhoneNumber *numberWithoutNationalPrefixJP = [phoneUtil parseAndKeepRawInput:@"0777012" defaultRegion:@"JP"];
STAssertEqualObjects(@"0777012", [phoneUtil formatInOriginalFormat:numberWithoutNationalPrefixJP regionCallingFrom:@"JP"], nil);
NBPhoneNumber *numberWithCarrierCodeBR = [phoneUtil parseAndKeepRawInput:@"012 3121286979" defaultRegion:@"BR"];
STAssertEqualObjects(@"012 3121286979", [phoneUtil formatInOriginalFormat:numberWithCarrierCodeBR regionCallingFrom:@"BR"], nil);
// 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.
NBPhoneNumber *numberWithNationalPrefixMX1 = [phoneUtil parseAndKeepRawInput:@"044(33)1234-5678" defaultRegion:@"MX"];
STAssertEqualObjects(@"044(33)1234-5678", [phoneUtil formatInOriginalFormat:numberWithNationalPrefixMX1 regionCallingFrom:@"MX"], nil);
NBPhoneNumber *numberWithNationalPrefixMX2 = [phoneUtil parseAndKeepRawInput:@"045(33)1234-5678" defaultRegion:@"MX"];
STAssertEqualObjects(@"045 33 1234 5678", [phoneUtil formatInOriginalFormat:numberWithNationalPrefixMX2 regionCallingFrom:@"MX"], nil);
// 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.
id outOfCountryNumberFromAU1 = [phoneUtil parseAndKeepRawInput:@"0012 16502530000" defaultRegion:@"AU"];
STAssertEqualObjects(@"0012 16502530000", [phoneUtil formatInOriginalFormat:outOfCountryNumberFromAU1 regionCallingFrom:@"AU"], nil);
id outOfCountryNumberFromAU2 = [phoneUtil parseAndKeepRawInput:@"0011 16502530000" defaultRegion:@"AU"];
STAssertEqualObjects(@"0011 1 650 253 0000", [phoneUtil formatInOriginalFormat:outOfCountryNumberFromAU2 regionCallingFrom:@"AU"], nil);
// Test the star sign is not removed from or added to the original input by
// this method.
id starNumber = [phoneUtil parseAndKeepRawInput:@"*1234" defaultRegion:@"JP"];
STAssertEqualObjects(@"*1234", [phoneUtil formatInOriginalFormat:starNumber regionCallingFrom:@"JP"], nil);
NBPhoneNumber *numberWithoutStar = [phoneUtil parseAndKeepRawInput:@"1234" defaultRegion:@"JP"];
STAssertEqualObjects(@"1234", [phoneUtil formatInOriginalFormat:numberWithoutStar regionCallingFrom:@"JP"], nil);
// Test an invalid national number without raw input is just formatted as the
// national number.
STAssertEqualObjects(@"650253000", [phoneUtil formatInOriginalFormat:US_SHORT_BY_ONE_NUMBER regionCallingFrom:@"US"], nil);
}
#pragma mark - testIsPremiumRate
{
STAssertEquals(NBEPhoneNumberTypePREMIUM_RATE, [phoneUtil getNumberType:US_PREMIUM], nil);
NBPhoneNumber *premiumRateNumber = [[NBPhoneNumber alloc] init];
premiumRateNumber = [[NBPhoneNumber alloc] init];
[premiumRateNumber setCountryCode:@39];
[premiumRateNumber setNationalNumber:@892123];
STAssertEquals(NBEPhoneNumberTypePREMIUM_RATE, [phoneUtil getNumberType:premiumRateNumber], nil);
premiumRateNumber = [[NBPhoneNumber alloc] init];
[premiumRateNumber setCountryCode:@44];
[premiumRateNumber setNationalNumber:@9187654321];
STAssertEquals(NBEPhoneNumberTypePREMIUM_RATE, [phoneUtil getNumberType:premiumRateNumber], nil);
premiumRateNumber = [[NBPhoneNumber alloc] init];
[premiumRateNumber setCountryCode:@49];
[premiumRateNumber setNationalNumber:@9001654321];
STAssertEquals(NBEPhoneNumberTypePREMIUM_RATE, [phoneUtil getNumberType:premiumRateNumber], nil);
premiumRateNumber = [[NBPhoneNumber alloc] init];
[premiumRateNumber setCountryCode:@49];
[premiumRateNumber setNationalNumber:@90091234567];
STAssertEquals(NBEPhoneNumberTypePREMIUM_RATE, [phoneUtil getNumberType:premiumRateNumber], nil);
STAssertEquals(NBEPhoneNumberTypePREMIUM_RATE, [phoneUtil getNumberType:UNIVERSAL_PREMIUM_RATE], nil);
}
#pragma mark - testIsTollFree
{
NBPhoneNumber *tollFreeNumber = [[NBPhoneNumber alloc] init];
[tollFreeNumber setCountryCode:@1];
[tollFreeNumber setNationalNumber:@8881234567];
STAssertEquals(NBEPhoneNumberTypeTOLL_FREE, [phoneUtil getNumberType:tollFreeNumber], nil);
tollFreeNumber = [[NBPhoneNumber alloc] init];
[tollFreeNumber setCountryCode:@39];
[tollFreeNumber setNationalNumber:@803123];
STAssertEquals(NBEPhoneNumberTypeTOLL_FREE, [phoneUtil getNumberType:tollFreeNumber], nil);
tollFreeNumber = [[NBPhoneNumber alloc] init];
[tollFreeNumber setCountryCode:@44];
[tollFreeNumber setNationalNumber:@8012345678];
STAssertEquals(NBEPhoneNumberTypeTOLL_FREE, [phoneUtil getNumberType:tollFreeNumber], nil);
tollFreeNumber = [[NBPhoneNumber alloc] init];
[tollFreeNumber setCountryCode:@49];
[tollFreeNumber setNationalNumber:@8001234567];
STAssertEquals(NBEPhoneNumberTypeTOLL_FREE, [phoneUtil getNumberType:tollFreeNumber], nil);
STAssertEquals(NBEPhoneNumberTypeTOLL_FREE, [phoneUtil getNumberType:INTERNATIONAL_TOLL_FREE], nil);
}
#pragma mark - testIsMobile
{
STAssertEquals(NBEPhoneNumberTypeMOBILE, [phoneUtil getNumberType:BS_MOBILE], nil);
STAssertEquals(NBEPhoneNumberTypeMOBILE, [phoneUtil getNumberType:GB_MOBILE], nil);
STAssertEquals(NBEPhoneNumberTypeMOBILE, [phoneUtil getNumberType:IT_MOBILE], nil);
STAssertEquals(NBEPhoneNumberTypeMOBILE, [phoneUtil getNumberType:AR_MOBILE], nil);
NBPhoneNumber *mobileNumber = [[NBPhoneNumber alloc] init];
[mobileNumber setCountryCode:@49];
[mobileNumber setNationalNumber:@15123456789];
STAssertEquals(NBEPhoneNumberTypeMOBILE, [phoneUtil getNumberType:mobileNumber], nil);
}
#pragma mark - testIsFixedLine
{
STAssertEquals(NBEPhoneNumberTypeFIXED_LINE, [phoneUtil getNumberType:BS_NUMBER], nil);
STAssertEquals(NBEPhoneNumberTypeFIXED_LINE, [phoneUtil getNumberType:IT_NUMBER], nil);
STAssertEquals(NBEPhoneNumberTypeFIXED_LINE, [phoneUtil getNumberType:GB_NUMBER], nil);
STAssertEquals(NBEPhoneNumberTypeFIXED_LINE, [phoneUtil getNumberType:DE_NUMBER], nil);
}
#pragma mark - testIsFixedLineAndMobile
{
STAssertEquals(NBEPhoneNumberTypeFIXED_LINE_OR_MOBILE, [phoneUtil getNumberType:US_NUMBER], nil);
NBPhoneNumber *fixedLineAndMobileNumber = [[NBPhoneNumber alloc] init];
[fixedLineAndMobileNumber setCountryCode:@54];
[fixedLineAndMobileNumber setNationalNumber:@1987654321];
STAssertEquals(NBEPhoneNumberTypeFIXED_LINE_OR_MOBILE, [phoneUtil getNumberType:fixedLineAndMobileNumber], nil);
}
#pragma mark - testIsSharedCost
{
NBPhoneNumber *gbNumber = [[NBPhoneNumber alloc] init];
[gbNumber setCountryCode:@44];
[gbNumber setNationalNumber:@8431231234];
STAssertEquals(NBEPhoneNumberTypeSHARED_COST, [phoneUtil getNumberType:gbNumber], nil);
}
#pragma mark - testIsVoip
{
NBPhoneNumber *gbNumber = [[NBPhoneNumber alloc] init];
[gbNumber setCountryCode:@44];
[gbNumber setNationalNumber:@5631231234];
STAssertEquals(NBEPhoneNumberTypeVOIP, [phoneUtil getNumberType:gbNumber], nil);
}
#pragma mark - testIsPersonalNumber
{
NBPhoneNumber *gbNumber = [[NBPhoneNumber alloc] init];
[gbNumber setCountryCode:@44];
[gbNumber setNationalNumber:@7031231234];
STAssertEquals(NBEPhoneNumberTypePERSONAL_NUMBER, [phoneUtil getNumberType:gbNumber], nil);
}
#pragma mark - testIsUnknown
{
// Invalid numbers should be of type UNKNOWN.
STAssertEquals(NBEPhoneNumberTypeUNKNOWN, [phoneUtil getNumberType:US_LOCAL_NUMBER], nil);
}
#pragma mark - testisValidNumber
{
STAssertTrue([phoneUtil isValidNumber:US_NUMBER], nil);
STAssertTrue([phoneUtil isValidNumber:IT_NUMBER], nil);
STAssertTrue([phoneUtil isValidNumber:GB_MOBILE], nil);
STAssertTrue([phoneUtil isValidNumber:INTERNATIONAL_TOLL_FREE], nil);
STAssertTrue([phoneUtil isValidNumber:UNIVERSAL_PREMIUM_RATE], nil);
NBPhoneNumber *nzNumber = [[NBPhoneNumber alloc] init];
[nzNumber setCountryCode:@64];
[nzNumber setNationalNumber:@21387835];
STAssertTrue([phoneUtil isValidNumber:nzNumber], nil);
}
#pragma mark - testIsValidForRegion
{
// This number is valid for the Bahamas, but is not a valid US number.
STAssertTrue([phoneUtil isValidNumber:BS_NUMBER], nil);
STAssertTrue([phoneUtil isValidNumberForRegion:BS_NUMBER regionCode:@"BS"], nil);
STAssertFalse([phoneUtil isValidNumberForRegion:BS_NUMBER regionCode:@"US"], nil);
NBPhoneNumber *bsInvalidNumber = [[NBPhoneNumber alloc] init];
[bsInvalidNumber setCountryCode:@1];
[bsInvalidNumber setNationalNumber:@2421232345];
// This number is no longer valid.
STAssertFalse([phoneUtil isValidNumber:bsInvalidNumber], nil);
// La Mayotte and Reunion use 'leadingDigits' to differentiate them.
NBPhoneNumber *reNumber = [[NBPhoneNumber alloc] init];
[reNumber setCountryCode:@262];
[reNumber setNationalNumber:@262123456];
STAssertTrue([phoneUtil isValidNumber:reNumber], nil);
STAssertTrue([phoneUtil isValidNumberForRegion:reNumber regionCode:@"RE"], nil);
STAssertFalse([phoneUtil isValidNumberForRegion:reNumber regionCode:@"YT"], nil);
// Now change the number to be a number for La Mayotte.
[reNumber setNationalNumber:@269601234];
STAssertTrue([phoneUtil isValidNumberForRegion:reNumber regionCode:@"YT"], nil);
STAssertFalse([phoneUtil isValidNumberForRegion:reNumber regionCode:@"RE"], nil);
// This number is no longer valid for La Reunion.
[reNumber setNationalNumber:@269123456];
STAssertFalse([phoneUtil isValidNumberForRegion:reNumber regionCode:@"YT"], nil);
STAssertFalse([phoneUtil isValidNumberForRegion:reNumber regionCode:@"RE"], nil);
STAssertFalse([phoneUtil isValidNumber:reNumber], nil);
// However, it should be recognised as from La Mayotte, since it is valid for
// this region.
STAssertEqualObjects(@"YT", [phoneUtil getRegionCodeForNumber:reNumber], nil);
// This number is valid in both places.
[reNumber setNationalNumber:@800123456];
STAssertTrue([phoneUtil isValidNumberForRegion:reNumber regionCode:@"YT"], nil);
STAssertTrue([phoneUtil isValidNumberForRegion:reNumber regionCode:@"RE"], nil);
STAssertTrue([phoneUtil isValidNumberForRegion:INTERNATIONAL_TOLL_FREE regionCode:@"001"], nil);
STAssertFalse([phoneUtil isValidNumberForRegion:INTERNATIONAL_TOLL_FREE regionCode:@"US"], nil);
STAssertFalse([phoneUtil isValidNumberForRegion:INTERNATIONAL_TOLL_FREE regionCode:@"ZZ"], nil);
NBPhoneNumber *invalidNumber = [[NBPhoneNumber alloc] init];
// Invalid country calling codes.
[invalidNumber setCountryCode:@3923];
[invalidNumber setNationalNumber:@2366];
STAssertFalse([phoneUtil isValidNumberForRegion:invalidNumber regionCode:@"ZZ"], nil);
STAssertFalse([phoneUtil isValidNumberForRegion:invalidNumber regionCode:@"001"], nil);
[invalidNumber setCountryCode:@0];
STAssertFalse([phoneUtil isValidNumberForRegion:invalidNumber regionCode:@"001"], nil);
STAssertFalse([phoneUtil isValidNumberForRegion:invalidNumber regionCode:@"ZZ"], nil);
}
#pragma mark - testIsNotValidNumber
{
STAssertFalse([phoneUtil isValidNumber:US_LOCAL_NUMBER], nil);
NBPhoneNumber *invalidNumber = [[NBPhoneNumber alloc] init];
[invalidNumber setCountryCode:@39];
[invalidNumber setNationalNumber:@23661830000];
[invalidNumber setItalianLeadingZero:YES];
STAssertFalse([phoneUtil isValidNumber:invalidNumber], nil);
invalidNumber = [[NBPhoneNumber alloc] init];
[invalidNumber setCountryCode:@44];
[invalidNumber setNationalNumber:@791234567];
STAssertFalse([phoneUtil isValidNumber:invalidNumber], nil);
invalidNumber = [[NBPhoneNumber alloc] init];
[invalidNumber setCountryCode:@0];
[invalidNumber setNationalNumber:@1234];
STAssertFalse([phoneUtil isValidNumber:invalidNumber], nil);
invalidNumber = [[NBPhoneNumber alloc] init];
[invalidNumber setCountryCode:@64];
[invalidNumber setNationalNumber:@3316005];
STAssertFalse([phoneUtil isValidNumber:invalidNumber], nil);
invalidNumber = [[NBPhoneNumber alloc] init];
// Invalid country calling codes.
[invalidNumber setCountryCode:@3923];
[invalidNumber setNationalNumber:@2366];
STAssertFalse([phoneUtil isValidNumber:invalidNumber], nil);
[invalidNumber setCountryCode:@0];
STAssertFalse([phoneUtil isValidNumber:invalidNumber], nil);
STAssertFalse([phoneUtil isValidNumber:INTERNATIONAL_TOLL_FREE_TOO_LONG], nil);
}
#pragma mark - testgetRegionCodeForCountryCode
{
STAssertEqualObjects(@"US", [phoneUtil getRegionCodeForCountryCode:@1], nil);
STAssertEqualObjects(@"GB", [phoneUtil getRegionCodeForCountryCode:@44], nil);
STAssertEqualObjects(@"DE", [phoneUtil getRegionCodeForCountryCode:@49], nil);
STAssertEqualObjects(@"001", [phoneUtil getRegionCodeForCountryCode:@800], nil);
STAssertEqualObjects(@"001", [phoneUtil getRegionCodeForCountryCode:@979], nil);
}
#pragma mark - testgetRegionCodeForNumber
{
STAssertEqualObjects(@"BS", [phoneUtil getRegionCodeForNumber:BS_NUMBER], nil);
STAssertEqualObjects(@"US", [phoneUtil getRegionCodeForNumber:US_NUMBER], nil);
STAssertEqualObjects(@"GB", [phoneUtil getRegionCodeForNumber:GB_MOBILE], nil);
STAssertEqualObjects(@"001", [phoneUtil getRegionCodeForNumber:INTERNATIONAL_TOLL_FREE], nil);
STAssertEqualObjects(@"001", [phoneUtil getRegionCodeForNumber:UNIVERSAL_PREMIUM_RATE], nil);
}
#pragma mark - testGetRegionCodesForCountryCode
{
NSArray *regionCodesForNANPA = [phoneUtil getRegionCodesForCountryCode:@1];
STAssertTrue([regionCodesForNANPA containsObject:@"US"], nil);
STAssertTrue([regionCodesForNANPA containsObject:@"BS"], nil);
STAssertTrue([[phoneUtil getRegionCodesForCountryCode:@44] containsObject:@"GB"], nil);
STAssertTrue([[phoneUtil getRegionCodesForCountryCode:@49] containsObject:@"DE"], nil);
STAssertTrue([[phoneUtil getRegionCodesForCountryCode:@800] containsObject:@"001"], nil);
// Test with invalid country calling code.
STAssertTrue([[phoneUtil getRegionCodesForCountryCode:@-1] count] == 0, nil);
}
#pragma mark - testGetCountryCodeForRegion
{
STAssertTrue([[phoneUtil getCountryCodeForRegion:@"US"] isEqualToNumber:@1], nil);
STAssertTrue([[phoneUtil getCountryCodeForRegion:@"NZ"] isEqualToNumber:@64], nil);
STAssertTrue([[phoneUtil getCountryCodeForRegion:nil] isEqualToNumber:@0], nil);
STAssertTrue([[phoneUtil getCountryCodeForRegion:@"ZZ"] isEqualToNumber:@0], nil);
STAssertTrue([[phoneUtil getCountryCodeForRegion:@"001"] isEqualToNumber:@0], nil);
STAssertTrue([[phoneUtil getCountryCodeForRegion:@"CS"] isEqualToNumber:@0], nil);
}
#pragma mark - testGetNationalDiallingPrefixForRegion
{
STAssertEqualObjects(@"1", [phoneUtil getNddPrefixForRegion:@"US" stripNonDigits:NO], nil);
// Test non-main country to see it gets the national dialling prefix for the
// main country with that country calling code.
STAssertEqualObjects(@"1", [phoneUtil getNddPrefixForRegion:@"BS" stripNonDigits:NO], nil);
STAssertEqualObjects(@"0", [phoneUtil getNddPrefixForRegion:@"NZ" stripNonDigits:NO], nil);
// Test case with non digit in the national prefix.
STAssertEqualObjects(@"0~0", [phoneUtil getNddPrefixForRegion:@"AO" stripNonDigits:NO], nil);
STAssertEqualObjects(@"00", [phoneUtil getNddPrefixForRegion:@"AO" stripNonDigits:YES], nil);
// Test cases with invalid regions.
STAssertNil([phoneUtil getNddPrefixForRegion:nil stripNonDigits:NO], nil);
STAssertNil([phoneUtil getNddPrefixForRegion:@"ZZ" stripNonDigits:NO], nil);
STAssertNil([phoneUtil getNddPrefixForRegion:@"001" stripNonDigits:NO], nil);
// CS is already deprecated so the library doesn't support it.
STAssertNil([phoneUtil getNddPrefixForRegion:@"CS" stripNonDigits:NO], nil);
}
#pragma mark - testIsNANPACountry
{
STAssertTrue([phoneUtil isNANPACountry:@"US"], nil);
STAssertTrue([phoneUtil isNANPACountry:@"BS"], nil);
STAssertFalse([phoneUtil isNANPACountry:@"DE"], nil);
STAssertFalse([phoneUtil isNANPACountry:@"ZZ"], nil);
STAssertFalse([phoneUtil isNANPACountry:@"001"], nil);
STAssertFalse([phoneUtil isNANPACountry:nil], nil);
}
#pragma mark - testIsPossibleNumber
{
STAssertTrue([phoneUtil isPossibleNumber:US_NUMBER], nil);
STAssertTrue([phoneUtil isPossibleNumber:US_LOCAL_NUMBER], nil);
STAssertTrue([phoneUtil isPossibleNumber:GB_NUMBER], nil);
STAssertTrue([phoneUtil isPossibleNumber:INTERNATIONAL_TOLL_FREE], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"+1 650 253 0000" regionDialingFrom:@"US"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"+1 650 GOO OGLE" regionDialingFrom:@"US"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"(650) 253-0000" regionDialingFrom:@"US"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"253-0000" regionDialingFrom:@"US"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"+1 650 253 0000" regionDialingFrom:@"GB"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"+44 20 7031 3000" regionDialingFrom:@"GB"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"(020) 7031 3000" regionDialingFrom:@"GB"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"7031 3000" regionDialingFrom:@"GB"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"3331 6005" regionDialingFrom:@"NZ"], nil);
STAssertTrue([phoneUtil isPossibleNumberString:@"+800 1234 5678" regionDialingFrom:@"001"], nil);
}
#pragma mark - testIsPossibleNumberWithReason
{
// National numbers for country calling code +1 that are within 7 to 10 digits
// are possible.
STAssertEquals(NBEValidationResultIS_POSSIBLE, [phoneUtil isPossibleNumberWithReason:US_NUMBER], nil);
STAssertEquals(NBEValidationResultIS_POSSIBLE, [phoneUtil isPossibleNumberWithReason:US_LOCAL_NUMBER], nil);
STAssertEquals(NBEValidationResultTOO_LONG, [phoneUtil isPossibleNumberWithReason:US_LONG_NUMBER], nil);
NBPhoneNumber *number = [[NBPhoneNumber alloc] init];
[number setCountryCode:@0];
[number setNationalNumber:@2530000];
STAssertEquals(NBEValidationResultINVALID_COUNTRY_CODE, [phoneUtil isPossibleNumberWithReason:number], nil);
number = [[NBPhoneNumber alloc] init];
[number setCountryCode:@1];
[number setNationalNumber:@253000];
STAssertEquals(NBEValidationResultTOO_SHORT, [phoneUtil isPossibleNumberWithReason:number], nil);
number = [[NBPhoneNumber alloc] init];
[number setCountryCode:@65];
[number setNationalNumber:@1234567890];
STAssertEquals(NBEValidationResultIS_POSSIBLE, [phoneUtil isPossibleNumberWithReason:number], nil);
STAssertEquals(NBEValidationResultTOO_LONG, [phoneUtil isPossibleNumberWithReason:INTERNATIONAL_TOLL_FREE_TOO_LONG], nil);
// Try with number that we don't have metadata for.
NBPhoneNumber *adNumber = [[NBPhoneNumber alloc] init];
[adNumber setCountryCode:@376];
[adNumber setNationalNumber:@12345];
STAssertEquals(NBEValidationResultIS_POSSIBLE, [phoneUtil isPossibleNumberWithReason:adNumber], nil);
[adNumber setCountryCode:@376];
[adNumber setNationalNumber:@1];
STAssertEquals(NBEValidationResultTOO_SHORT, [phoneUtil isPossibleNumberWithReason:adNumber], nil);
[adNumber setCountryCode:@376];
[adNumber setNationalNumber:@12345678901234567];
STAssertEquals(NBEValidationResultTOO_LONG, [phoneUtil isPossibleNumberWithReason:adNumber], nil);
}
#pragma mark - testIsNotPossibleNumber
{
STAssertFalse([phoneUtil isPossibleNumber:US_LONG_NUMBER], nil);
STAssertFalse([phoneUtil isPossibleNumber:INTERNATIONAL_TOLL_FREE_TOO_LONG], nil);
NBPhoneNumber *number = [[NBPhoneNumber alloc] init];
[number setCountryCode:@1];
[number setNationalNumber:@253000];
STAssertFalse([phoneUtil isPossibleNumber:number], nil);
number = [[NBPhoneNumber alloc] init];
[number setCountryCode:@44];
[number setNationalNumber:@300];
STAssertFalse([phoneUtil isPossibleNumber:number], nil);
STAssertFalse([phoneUtil isPossibleNumberString:@"+1 650 253 00000" regionDialingFrom:@"US"], nil);
STAssertFalse([phoneUtil isPossibleNumberString:@"(650) 253-00000" regionDialingFrom:@"US"], nil);
STAssertFalse([phoneUtil isPossibleNumberString:@"I want a Pizza" regionDialingFrom:@"US"], nil);
STAssertFalse([phoneUtil isPossibleNumberString:@"253-000" regionDialingFrom:@"US"], nil);
STAssertFalse([phoneUtil isPossibleNumberString:@"1 3000" regionDialingFrom:@"GB"], nil);
STAssertFalse([phoneUtil isPossibleNumberString:@"+44 300" regionDialingFrom:@"GB"], nil);
STAssertFalse([phoneUtil isPossibleNumberString:@"+800 1234 5678 9" regionDialingFrom:@"001"], nil);
}
#pragma mark - testTruncateTooLongNumber
{
// GB number 080 1234 5678, but entered with 4 extra digits at the end.
NBPhoneNumber *tooLongNumber = [[NBPhoneNumber alloc] init];
[tooLongNumber setCountryCode:@44];
[tooLongNumber setNationalNumber:@80123456780123];
NBPhoneNumber *validNumber = [[NBPhoneNumber alloc] init];
[validNumber setCountryCode:@44];
[validNumber setNationalNumber:@8012345678];
STAssertTrue([phoneUtil truncateTooLongNumber:tooLongNumber], nil);
STAssertTrue([validNumber isEqual:tooLongNumber], nil);
// IT number 022 3456 7890, but entered with 3 extra digits at the end.
tooLongNumber = [[NBPhoneNumber alloc] init];
[tooLongNumber setCountryCode:@39];
[tooLongNumber setNationalNumber:@2234567890123];
[tooLongNumber setItalianLeadingZero:YES];
validNumber = [[NBPhoneNumber alloc] init];
[validNumber setCountryCode:@39];
[validNumber setNationalNumber:@2234567890];
[validNumber setItalianLeadingZero:YES];
STAssertTrue([phoneUtil truncateTooLongNumber:tooLongNumber], nil);
STAssertTrue([validNumber isEqual:tooLongNumber], nil);
// US number 650-253-0000, but entered with one additional digit at the end.
tooLongNumber = [US_LONG_NUMBER copy];
STAssertTrue([phoneUtil truncateTooLongNumber:tooLongNumber], nil);
STAssertTrue([US_NUMBER isEqual:tooLongNumber], nil);
tooLongNumber = [INTERNATIONAL_TOLL_FREE_TOO_LONG copy];
STAssertTrue([phoneUtil truncateTooLongNumber:tooLongNumber], nil);
STAssertTrue([INTERNATIONAL_TOLL_FREE isEqual:tooLongNumber], nil);
// Tests what happens when a valid number is passed in.
NBPhoneNumber *validNumberCopy = [validNumber copy];
STAssertTrue([phoneUtil truncateTooLongNumber:validNumber], nil);
// Tests the number is not modified.
STAssertTrue([validNumber isEqual:validNumberCopy], nil);
// Tests what happens when a number with invalid prefix is passed in.
NBPhoneNumber *numberWithInvalidPrefix = [[NBPhoneNumber alloc] init];
// The test metadata says US numbers cannot have prefix 240.
[numberWithInvalidPrefix setCountryCode:@1];
[numberWithInvalidPrefix setNationalNumber:@2401234567];
NBPhoneNumber *invalidNumberCopy = [numberWithInvalidPrefix copy];
STAssertFalse([phoneUtil truncateTooLongNumber:numberWithInvalidPrefix], nil);
// Tests the number is not modified.
STAssertTrue([numberWithInvalidPrefix isEqual:invalidNumberCopy], nil);
// Tests what happens when a too short number is passed in.
NBPhoneNumber *tooShortNumber = [[NBPhoneNumber alloc] init];
[tooShortNumber setCountryCode:@1];
[tooShortNumber setNationalNumber:@1234];
NBPhoneNumber *tooShortNumberCopy = [tooShortNumber copy];
STAssertFalse([phoneUtil truncateTooLongNumber:tooShortNumber], nil);
// Tests the number is not modified.
STAssertTrue([tooShortNumber isEqual:tooShortNumberCopy], nil);
}
#pragma mark - testIsViablePhoneNumber
{
NSLog(@"-------------- testIsViablePhoneNumber");
STAssertFalse([phoneUtil isViablePhoneNumber:@"1"], nil);
// Only one or two digits before strange non-possible punctuation.
STAssertFalse([phoneUtil isViablePhoneNumber:@"1+1+1"], nil);
STAssertFalse([phoneUtil isViablePhoneNumber:@"80+0"], nil);
// Two digits is viable.
STAssertTrue([phoneUtil isViablePhoneNumber:@"00"], nil);
STAssertTrue([phoneUtil isViablePhoneNumber:@"111"], nil);
// Alpha numbers.
STAssertTrue([phoneUtil isViablePhoneNumber:@"0800-4-pizza"], nil);
STAssertTrue([phoneUtil isViablePhoneNumber:@"0800-4-PIZZA"], nil);
// We need at least three digits before any alpha characters.
STAssertFalse([phoneUtil isViablePhoneNumber:@"08-PIZZA"], nil);
STAssertFalse([phoneUtil isViablePhoneNumber:@"8-PIZZA"], nil);
STAssertFalse([phoneUtil isViablePhoneNumber:@"12. March"], nil);
}
#pragma mark - testIsViablePhoneNumberNonAscii
{
NSLog(@"-------------- testIsViablePhoneNumberNonAscii");
// Only one or two digits before possible punctuation followed by more digits.
STAssertTrue([phoneUtil isViablePhoneNumber:@"1\u300034"], nil);
STAssertFalse([phoneUtil isViablePhoneNumber:@"1\u30003+4"], nil);
// Unicode variants of possible starting character and other allowed
// punctuation/digits.
STAssertTrue([phoneUtil isViablePhoneNumber:@"\uFF081\uFF09\u30003456789"], nil);
// Testing a leading + is okay.
STAssertTrue([phoneUtil isViablePhoneNumber:@"+1\uFF09\u30003456789"], nil);
}
#pragma mark - testExtractPossibleNumber
{
NSLog(@"-------------- testExtractPossibleNumber");
// Removes preceding funky punctuation and letters but leaves the rest
// untouched.
STAssertEqualObjects(@"0800-345-600", [phoneUtil extractPossibleNumber:@"Tel:0800-345-600"], nil);
STAssertEqualObjects(@"0800 FOR PIZZA", [phoneUtil extractPossibleNumber:@"Tel:0800 FOR PIZZA"], nil);
// Should not remove plus sign
STAssertEqualObjects(@"+800-345-600", [phoneUtil extractPossibleNumber:@"Tel:+800-345-600"], nil);
// Should recognise wide digits as possible start values.
STAssertEqualObjects(@"\uFF10\uFF12\uFF13", [phoneUtil extractPossibleNumber:@"\uFF10\uFF12\uFF13"], nil);
// Dashes are not possible start values and should be removed.
STAssertEqualObjects(@"\uFF11\uFF12\uFF13", [phoneUtil extractPossibleNumber:@"Num-\uFF11\uFF12\uFF13"], nil);
// If not possible number present, return empty string.
STAssertEqualObjects(@"", [phoneUtil extractPossibleNumber:@"Num-...."], nil);
// Leading brackets are stripped - these are not used when parsing.
STAssertEqualObjects(@"650) 253-0000", [phoneUtil extractPossibleNumber:@"(650) 253-0000"], nil);
// Trailing non-alpha-numeric characters should be removed.
STAssertEqualObjects(@"650) 253-0000", [phoneUtil extractPossibleNumber:@"(650) 253-0000..- .."], nil);
STAssertEqualObjects(@"650) 253-0000", [phoneUtil extractPossibleNumber:@"(650) 253-0000."], nil);
// This case has a trailing RTL char.
STAssertEqualObjects(@"650) 253-0000", [phoneUtil extractPossibleNumber:@"(650) 253-0000\u200F"], nil);
}
#pragma mark - testMaybeStripNationalPrefix
{
NSLog(@"-------------- testMaybeStripNationalPrefix");
NBPhoneMetaData *metadata = [[NBPhoneMetaData alloc] init];
[metadata setNationalPrefixForParsing:@"34"];
NBPhoneNumberDesc *generalDesc = [[NBPhoneNumberDesc alloc] init];
[generalDesc setNationalNumberPattern:@"\\d{4,8}"];
[metadata setGeneralDesc:generalDesc];
NBPhoneNumber *numberToStrip = [[NBPhoneNumber alloc] init];
[numberToStrip setRawInput:@"34356778"];
NSString *strippedNumber = @"356778";
NSString *rawInput = numberToStrip.rawInput;
STAssertTrue([phoneUtil maybeStripNationalPrefixAndCarrierCode:&rawInput metadata:metadata carrierCode:nil], nil);
STAssertEqualObjects(strippedNumber, rawInput, @"Should have had national prefix stripped.");
// Retry stripping - now the number should not start with the national prefix,
// so no more stripping should occur.
STAssertFalse([phoneUtil maybeStripNationalPrefixAndCarrierCode:&rawInput metadata:metadata carrierCode:nil], nil);
STAssertEqualObjects(strippedNumber, rawInput, @"Should have had no change - no national prefix present.");
// Some countries have no national prefix. Repeat test with none specified.
[metadata setNationalPrefixForParsing:@""];
STAssertFalse([phoneUtil maybeStripNationalPrefixAndCarrierCode:&rawInput metadata:metadata carrierCode:nil], nil);
STAssertEqualObjects(strippedNumber, rawInput, @"Should not strip anything with empty national prefix.");
// If the resultant number doesn't match the national rule, it shouldn't be
// stripped.
[metadata setNationalPrefixForParsing:@"3"];
numberToStrip.rawInput = @"3123";
rawInput = numberToStrip.rawInput;
strippedNumber = @"3123";
STAssertFalse([phoneUtil maybeStripNationalPrefixAndCarrierCode:&rawInput metadata:metadata carrierCode:nil], nil);
STAssertEqualObjects(strippedNumber, rawInput, @"Should have had no change - after stripping, it would not have matched the national rule.");
// Test extracting carrier selection code.
[metadata setNationalPrefixForParsing:@"0(81)?"];
numberToStrip.rawInput = @"08122123456";
strippedNumber = @"22123456";
rawInput = numberToStrip.rawInput;
NSString *carrierCode = @"";
STAssertTrue([phoneUtil maybeStripNationalPrefixAndCarrierCode:&rawInput metadata:metadata carrierCode:&carrierCode], nil);
STAssertEqualObjects(@"81", carrierCode, nil);
STAssertEqualObjects(strippedNumber, rawInput, @"Should have had national prefix and carrier code stripped.");
// If there was a transform rule, check it was applied.
[metadata setNationalPrefixTransformRule:@"5$15"];
// Note that a capturing group is present here.
[metadata setNationalPrefixForParsing:@"0(\\d{2})"];
numberToStrip.rawInput = @"031123";
rawInput = numberToStrip.rawInput;
NSString *transformedNumber = @"5315123";
STAssertTrue([phoneUtil maybeStripNationalPrefixAndCarrierCode:&rawInput metadata:metadata carrierCode:nil], nil);
STAssertEqualObjects(transformedNumber, rawInput, @"Should transform the 031 to a 5315.");
}
#pragma mark - testMaybeStripInternationalPrefix
{
NSLog(@"-------------- testMaybeStripInternationalPrefix");
NSString *internationalPrefix = @"00[39]";
NSString *numberToStripPrefix = @"0034567700-3898003";
// Note the dash is removed as part of the normalization.
NSString *strippedNumberString = @"45677003898003";
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITH_IDD, [phoneUtil maybeStripInternationalPrefixAndNormalize:&numberToStripPrefix
possibleIddPrefix:internationalPrefix], nil);
STAssertEqualObjects(strippedNumberString, numberToStripPrefix, @"The number supplied was not stripped of its international prefix.");
// Now the number no longer starts with an IDD prefix, so it should now report
// FROM_DEFAULT_COUNTRY.
STAssertEquals(NBECountryCodeSourceFROM_DEFAULT_COUNTRY, [phoneUtil maybeStripInternationalPrefixAndNormalize:&numberToStripPrefix
possibleIddPrefix:internationalPrefix], nil);
numberToStripPrefix = @"00945677003898003";
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITH_IDD, [phoneUtil maybeStripInternationalPrefixAndNormalize:&numberToStripPrefix
possibleIddPrefix:internationalPrefix], nil);
STAssertEqualObjects(strippedNumberString, numberToStripPrefix, @"The number supplied was not stripped of its international prefix.");
// Test it works when the international prefix is broken up by spaces.
numberToStripPrefix = @"00 9 45677003898003";
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITH_IDD, [phoneUtil maybeStripInternationalPrefixAndNormalize:&numberToStripPrefix
possibleIddPrefix:internationalPrefix], nil);
STAssertEqualObjects(strippedNumberString, numberToStripPrefix, @"The number supplied was not stripped of its international prefix.");
// Now the number no longer starts with an IDD prefix, so it should now report
// FROM_DEFAULT_COUNTRY.
STAssertEquals(NBECountryCodeSourceFROM_DEFAULT_COUNTRY, [phoneUtil maybeStripInternationalPrefixAndNormalize:&numberToStripPrefix
possibleIddPrefix:internationalPrefix], nil);
// Test the + symbol is also recognised and stripped.
numberToStripPrefix = @"+45677003898003";
strippedNumberString = @"45677003898003";
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN, [phoneUtil maybeStripInternationalPrefixAndNormalize:&numberToStripPrefix
possibleIddPrefix:internationalPrefix], nil);
STAssertEqualObjects(strippedNumberString, numberToStripPrefix, @"The number supplied was not stripped of the plus symbol.");
// If the number afterwards is a zero, we should not strip this - no country
// calling code begins with 0.
numberToStripPrefix = @"0090112-3123";
strippedNumberString = @"00901123123";
STAssertEquals(NBECountryCodeSourceFROM_DEFAULT_COUNTRY, [phoneUtil maybeStripInternationalPrefixAndNormalize:&numberToStripPrefix
possibleIddPrefix:internationalPrefix], nil);
STAssertEqualObjects(strippedNumberString, numberToStripPrefix, @"The number supplied had a 0 after the match so should not be stripped.");
// Here the 0 is separated by a space from the IDD.
numberToStripPrefix = @"009 0-112-3123";
STAssertEquals(NBECountryCodeSourceFROM_DEFAULT_COUNTRY, [phoneUtil maybeStripInternationalPrefixAndNormalize:&numberToStripPrefix
possibleIddPrefix:internationalPrefix], nil);
}
#pragma mark - testMaybeExtractCountryCode
{
NSLog(@"-------------- testMaybeExtractCountryCode");
NBPhoneNumber *number = [[NBPhoneNumber alloc] init];
NBPhoneMetaData *metadata = [phoneUtil getMetadataForRegion:@"US"];
// Note that for the US, the IDD is 011.
NSString *phoneNumber = @"011112-3456789";
NSString *strippedNumber = @"123456789";
NSNumber *countryCallingCode = @1;
NSString *numberToFill = @"";
@try {
STAssertEqualObjects(countryCallingCode, [phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:YES phoneNumber:&number], nil);
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITH_IDD, [number.countryCodeSource intValue], nil);
// Should strip and normalize national significant number.
STAssertEqualObjects(strippedNumber, numberToFill, nil);
}
@catch (NSException *e) {
STFail([@"Should not have thrown an exception: " stringByAppendingString:e.reason]);
}
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITH_IDD, [number.countryCodeSource intValue], @"Did not figure out CountryCodeSource correctly");
// Should strip and normalize national significant number.
STAssertEqualObjects(strippedNumber, numberToFill, @"Did not strip off the country calling code correctly.");
number = [[NBPhoneNumber alloc] init];
phoneNumber = @"+6423456789";
countryCallingCode = @64;
numberToFill = @"";
STAssertEqualObjects(countryCallingCode, [phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:YES phoneNumber:&number], nil);
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN, [number.countryCodeSource intValue], @"Did not figure out CountryCodeSource correctly");
number = [[NBPhoneNumber alloc] init];
phoneNumber = @"+80012345678";
countryCallingCode = @800;
numberToFill = @"";
STAssertEqualObjects(countryCallingCode, [phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:YES phoneNumber:&number], nil);
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN, [number.countryCodeSource intValue], @"Did not figure out CountryCodeSource correctly");
number = [[NBPhoneNumber alloc] init];
phoneNumber = @"2345-6789";
numberToFill = @"";
STAssertEquals(@0, [phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:YES phoneNumber:&number], nil);
STAssertEquals(NBECountryCodeSourceFROM_DEFAULT_COUNTRY, [number.countryCodeSource intValue], @"Did not figure out CountryCodeSource correctly");
number = [[NBPhoneNumber alloc] init];
phoneNumber = @"0119991123456789";
numberToFill = @"";
@try {
[phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:YES phoneNumber:&number];
STFail(@"Should have thrown an exception, no valid country calling code present.");
}
@catch (NSException *exception) {
// Expected.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", exception.name, nil);
}
number = [[NBPhoneNumber alloc] init];
phoneNumber = @"(1 610) 619 4466";
countryCallingCode = @1;
numberToFill = @"";
@try {
STAssertEqualObjects(countryCallingCode, [phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:YES phoneNumber:&number],
@"Should have extracted the country calling code of the region passed in");
STAssertEquals(NBECountryCodeSourceFROM_NUMBER_WITHOUT_PLUS_SIGN, [number.countryCodeSource intValue], @"Did not figure out CountryCodeSource correctly");
}
@catch (NSException *exception) {
NSLog(@"%@", exception.reason);
}
number = [[NBPhoneNumber alloc] init];
phoneNumber = @"(1 610) 619 4466";
countryCallingCode = @1;
numberToFill = @"";
@try {
STAssertEqualObjects(countryCallingCode, [phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:NO phoneNumber:&number], nil);
}
@catch (NSException *exception) {
NSLog(@"%@", exception.reason);
}
number = [[NBPhoneNumber alloc] init];
phoneNumber = @"(1 610) 619 446";
numberToFill = @"";
@try {
STAssertEquals(@0, [phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:NO phoneNumber:&number], nil);
STAssertFalse(number.countryCodeSource != nil, @"Should not contain CountryCodeSource.");
}
@catch (NSException *exception) {
NSLog(@"%@", exception.reason);
}
number = [[NBPhoneNumber alloc] init];
phoneNumber = @"(1 610) 619";
numberToFill = @"";
@try {
STAssertEquals(@0, [phoneUtil maybeExtractCountryCode:phoneNumber metadata:metadata
nationalNumber:&numberToFill keepRawInput:YES phoneNumber:&number], nil);
STAssertEquals(NBECountryCodeSourceFROM_DEFAULT_COUNTRY, [number.countryCodeSource intValue], nil);
}
@catch (NSException *exception) {
NSLog(@"%@", exception.reason);
}
}
#pragma mark - testParseNationalNumber
{
NSLog(@"-------------- testParseNationalNumber");
// National prefix attached.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"033316005" defaultRegion:@"NZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"33316005" defaultRegion:@"NZ"]], nil);
// National prefix attached and some formatting present.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"03-331 6005" defaultRegion:@"NZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"03 331 6005" defaultRegion:@"NZ"]], nil);
// Test parsing RFC3966 format with a phone context.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"tel:03-331-6005;phone-context=+64" defaultRegion:@"NZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"tel:331-6005;phone-context=+64-3" defaultRegion:@"NZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"tel:331-6005;phone-context=+64-3" defaultRegion:@"US"]], nil);
// Test parsing RFC3966 format with optional user-defined parameters. The
// parameters will appear after the context if present.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"tel:03-331-6005;phone-context=+64;a=%A1" defaultRegion:@"NZ"]], nil);
// Test parsing RFC3966 with an ISDN subaddress.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"tel:03-331-6005;isub=12345;phone-context=+64" defaultRegion:@"NZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"tel:+64-3-331-6005;isub=12345" defaultRegion:@"NZ"]], nil);
// Testing international prefixes.
// Should strip country calling code.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"0064 3 331 6005" defaultRegion:@"NZ"]], nil);
// Try again, but this time we have an international number with Region Code
// US. It should recognise the country calling code and parse accordingly.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"01164 3 331 6005" defaultRegion:@"US"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"+64 3 331 6005" defaultRegion:@"US"]], nil);
// 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.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"+01164 3 331 6005" defaultRegion:@"US"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"+0064 3 331 6005" defaultRegion:@"NZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"+ 00 64 3 331 6005" defaultRegion:@"NZ"]], nil);
STAssertTrue([US_LOCAL_NUMBER isEqual:[phoneUtil parse:@"tel:253-0000;phone-context=www.google.com" defaultRegion:@"US"]], nil);
STAssertTrue([US_LOCAL_NUMBER isEqual:[phoneUtil parse:@"tel:253-0000;isub=12345;phone-context=www.google.com" defaultRegion:@"US"]], nil);
// 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.
STAssertTrue([US_LOCAL_NUMBER isEqual:[phoneUtil parse:@"tel:2530000;isub=12345;phone-context=1-650" defaultRegion:@"US"]], nil);
STAssertTrue([US_LOCAL_NUMBER isEqual:[phoneUtil parse:@"tel:2530000;isub=12345;phone-context=1234.com" defaultRegion:@"US"]], nil);
NBPhoneNumber *nzNumber = [[NBPhoneNumber alloc] init];
[nzNumber setCountryCode:@64];
[nzNumber setNationalNumber:@64123456];
STAssertTrue([nzNumber isEqual:[phoneUtil parse:@"64(0)64123456" defaultRegion:@"NZ"]], nil);
// Check that using a '/' is fine in a phone number.
STAssertTrue([DE_NUMBER isEqual:[phoneUtil parse:@"301/23456" defaultRegion:@"DE"]], nil);
NBPhoneNumber *usNumber = [[NBPhoneNumber alloc] init];
// Check it doesn't use the '1' as a country calling code when parsing if the
// phone number was already possible.
[usNumber setCountryCode:@1];
[usNumber setNationalNumber:@1234567890];
STAssertTrue([usNumber isEqual:[phoneUtil parse:@"123-456-7890" defaultRegion:@"US"]], nil);
// 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.
STAssertTrue([JP_STAR_NUMBER isEqual:[phoneUtil parse:@"+81 *2345" defaultRegion:@"JP"]], nil);
NBPhoneNumber *shortNumber = [[NBPhoneNumber alloc] init];
[shortNumber setCountryCode:@64];
[shortNumber setNationalNumber:@12];
STAssertTrue([shortNumber isEqual:[phoneUtil parse:@"12" defaultRegion:@"NZ"]], nil);
}
#pragma mark - testParseNumberWithAlphaCharacters
{
NSLog(@"-------------- testParseNumberWithAlphaCharacters");
// Test case with alpha characters.
NBPhoneNumber *tollfreeNumber = [[NBPhoneNumber alloc] init];
[tollfreeNumber setCountryCode:@64];
[tollfreeNumber setNationalNumber:@800332005];
STAssertTrue([tollfreeNumber isEqual:[phoneUtil parse:@"0800 DDA 005" defaultRegion:@"NZ"]], nil);
NBPhoneNumber *premiumNumber = [[NBPhoneNumber alloc] init];
[premiumNumber setCountryCode:@64];
[premiumNumber setNationalNumber:@9003326005];
STAssertTrue([premiumNumber isEqual:[phoneUtil parse:@"0900 DDA 6005" defaultRegion:@"NZ"]], nil);
// Not enough alpha characters for them to be considered intentional, so they
// are stripped.
STAssertTrue([premiumNumber isEqual:[phoneUtil parse:@"0900 332 6005a" defaultRegion:@"NZ"]], nil);
STAssertTrue([premiumNumber isEqual:[phoneUtil parse:@"0900 332 600a5" defaultRegion:@"NZ"]], nil);
STAssertTrue([premiumNumber isEqual:[phoneUtil parse:@"0900 332 600A5" defaultRegion:@"NZ"]], nil);
STAssertTrue([premiumNumber isEqual:[phoneUtil parse:@"0900 a332 600A5" defaultRegion:@"NZ"]], nil);
}
#pragma mark - testParseMaliciousInput
{
NSLog(@"-------------- testParseMaliciousInput");
// Lots of leading + signs before the possible number.
NSString *maliciousNumber = @"";
for (int i=0; i<6000; i++)
{
maliciousNumber = [maliciousNumber stringByAppendingString:@"+"];
}
maliciousNumber = [maliciousNumber stringByAppendingString:@"12222-33-244 extensioB 343+"];
@try {
[phoneUtil parse:maliciousNumber defaultRegion:@"US"];
STFail([@"This should not parse without throwing an exception " stringByAppendingString:maliciousNumber]);
}
@catch (NSException *e) {
STAssertEqualObjects(@"TOO_LONG", e.name, @"Wrong error type stored in exception.");
}
NSString *maliciousNumberWithAlmostExt = @"";
for (int i=0; i<350; i++)
{
maliciousNumberWithAlmostExt = [maliciousNumberWithAlmostExt stringByAppendingString:@"200"];
}
[maliciousNumberWithAlmostExt stringByAppendingString:@" extensiOB 345"];
@try {
[phoneUtil parse:maliciousNumberWithAlmostExt defaultRegion:@"US"];
STFail([@"This should not parse without throwing an exception " stringByAppendingString:maliciousNumberWithAlmostExt]);
}
@catch (NSException *e) {
STAssertEqualObjects(@"TOO_LONG", e.name, @"Wrong error type stored in exception.");
}
}
#pragma mark - testParseWithInternationalPrefixes
{
NSLog(@"-------------- testParseWithInternationalPrefixes");
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"+1 (650) 253-0000" defaultRegion:@"NZ"]], nil);
STAssertTrue([INTERNATIONAL_TOLL_FREE isEqual:[phoneUtil parse:@"011 800 1234 5678" defaultRegion:@"US"]], nil);
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"1-650-253-0000" defaultRegion:@"US"]], nil);
// Calling the US number from Singapore by using different service providers
// 1st test: calling using SingTel IDD service (IDD is 001)
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"0011-650-253-0000" defaultRegion:@"SG"]], nil);
// 2nd test: calling using StarHub IDD service (IDD is 008)
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"0081-650-253-0000" defaultRegion:@"SG"]], nil);
// 3rd test: calling using SingTel V019 service (IDD is 019)
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"0191-650-253-0000" defaultRegion:@"SG"]], nil);
// Calling the US number from Poland
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"0~01-650-253-0000" defaultRegion:@"PL"]], nil);
// Using '++' at the start.
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"++1 (650) 253-0000" defaultRegion:@"PL"]], nil);
}
#pragma mark - testParseNonAscii
{
NSLog(@"-------------- testParseNonAscii");
// Using a full-width plus sign.
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"\uFF0B1 (650) 253-0000" defaultRegion:@"SG"]], nil);
// Using a soft hyphen U+00AD.
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"1 (650) 253\u00AD-0000" defaultRegion:@"US"]], nil);
// The whole number, including punctuation, is here represented in full-width
// form.
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"\uFF0B\uFF11\u3000\uFF08\uFF16\uFF15\uFF10\uFF09\u3000\uFF12\uFF15\uFF13\uFF0D\uFF10\uFF10\uFF10\uFF10" defaultRegion:@"SG"]], nil);
// Using U+30FC dash instead.
STAssertTrue([US_NUMBER isEqual:[phoneUtil parse:@"\uFF0B\uFF11\u3000\uFF08\uFF16\uFF15\uFF10\uFF09\u3000\uFF12\uFF15\uFF13\u30FC\uFF10\uFF10\uFF10\uFF10" defaultRegion:@"SG"]], nil);
// Using a very strange decimal digit range (Mongolian digits).
// TODO(user): Support Mongolian digits
// STAssertTrue(US_NUMBER isEqual:
// [phoneUtil parse:@"\u1811 \u1816\u1815\u1810 " +
// '\u1812\u1815\u1813 \u1810\u1810\u1810\u1810" defaultRegion:@"US"], nil);
}
#pragma mark - testParseWithLeadingZero
{
NSLog(@"-------------- testParseWithLeadingZero");
STAssertTrue([IT_NUMBER isEqual:[phoneUtil parse:@"+39 02-36618 300" defaultRegion:@"NZ"]], nil);
STAssertTrue([IT_NUMBER isEqual:[phoneUtil parse:@"02-36618 300" defaultRegion:@"IT"]], nil);
STAssertTrue([IT_MOBILE isEqual:[phoneUtil parse:@"345 678 901" defaultRegion:@"IT"]], nil);
}
#pragma mark - testParseNationalNumberArgentina
{
NSLog(@"-------------- testParseNationalNumberArgentina");
// Test parsing mobile numbers of Argentina.
NBPhoneNumber *arNumber = [[NBPhoneNumber alloc] init];
[arNumber setCountryCode:@54];
[arNumber setNationalNumber:@93435551212];
STAssertTrue([arNumber isEqual:[phoneUtil parse:@"+54 9 343 555 1212" defaultRegion:@"AR"]], nil);
STAssertTrue([arNumber isEqual:[phoneUtil parse:@"0343 15 555 1212" defaultRegion:@"AR"]], nil);
arNumber = [[NBPhoneNumber alloc] init];
[arNumber setCountryCode:@54];
[arNumber setNationalNumber:@93715654320];
STAssertTrue([arNumber isEqual:[phoneUtil parse:@"+54 9 3715 65 4320" defaultRegion:@"AR"]], nil);
STAssertTrue([arNumber isEqual:[phoneUtil parse:@"03715 15 65 4320" defaultRegion:@"AR"]], nil);
STAssertTrue([AR_MOBILE isEqual:[phoneUtil parse:@"911 876 54321" defaultRegion:@"AR"]], nil);
// Test parsing fixed-line numbers of Argentina.
STAssertTrue([AR_NUMBER isEqual:[phoneUtil parse:@"+54 11 8765 4321" defaultRegion:@"AR"]], nil);
STAssertTrue([AR_NUMBER isEqual:[phoneUtil parse:@"011 8765 4321" defaultRegion:@"AR"]], nil);
arNumber = [[NBPhoneNumber alloc] init];
[arNumber setCountryCode:@54];
[arNumber setNationalNumber:@3715654321];
STAssertTrue([arNumber isEqual:[phoneUtil parse:@"+54 3715 65 4321" defaultRegion:@"AR"]], nil);
STAssertTrue([arNumber isEqual:[phoneUtil parse:@"03715 65 4321" defaultRegion:@"AR"]], nil);
arNumber = [[NBPhoneNumber alloc] init];
[arNumber setCountryCode:@54];
[arNumber setNationalNumber:@2312340000];
STAssertTrue([arNumber isEqual:[phoneUtil parse:@"+54 23 1234 0000" defaultRegion:@"AR"]], nil);
STAssertTrue([arNumber isEqual:[phoneUtil parse:@"023 1234 0000" defaultRegion:@"AR"]], nil);
}
#pragma mark - testParseWithXInNumber
{
NSLog(@"-------------- testParseWithXInNumber");
// Test that having an 'x' in the phone number at the start is ok and that it
// just gets removed.
STAssertTrue([AR_NUMBER isEqual:[phoneUtil parse:@"01187654321" defaultRegion:@"AR"]], nil);
STAssertTrue([AR_NUMBER isEqual:[phoneUtil parse:@"(0) 1187654321" defaultRegion:@"AR"]], nil);
STAssertTrue([AR_NUMBER isEqual:[phoneUtil parse:@"0 1187654321" defaultRegion:@"AR"]], nil);
STAssertTrue([AR_NUMBER isEqual:[phoneUtil parse:@"(0xx) 1187654321" defaultRegion:@"AR"]], nil);
id arFromUs = [[NBPhoneNumber alloc] init];
[arFromUs setCountryCode:@54];
[arFromUs setNationalNumber:@81429712];
// This test is intentionally constructed such that the number of digit after
// xx is larger than 7, so that the number won't be mistakenly treated as an
// 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.
STAssertTrue([arFromUs isEqual:[phoneUtil parse:@"011xx5481429712" defaultRegion:@"US"]], nil);
}
#pragma mark - testParseNumbersMexico
{
NSLog(@"-------------- testParseNumbersMexico");
// Test parsing fixed-line numbers of Mexico.
id mxNumber = [[NBPhoneNumber alloc] init];
[mxNumber setCountryCode:@52];
[mxNumber setNationalNumber:@4499780001];
STAssertTrue([mxNumber isEqual:[phoneUtil parse:@"+52 (449)978-0001" defaultRegion:@"MX"]], nil);
STAssertTrue([mxNumber isEqual:[phoneUtil parse:@"01 (449)978-0001" defaultRegion:@"MX"]], nil);
STAssertTrue([mxNumber isEqual:[phoneUtil parse:@"(449)978-0001" defaultRegion:@"MX"]], nil);
// Test parsing mobile numbers of Mexico.
mxNumber = [[NBPhoneNumber alloc] init];
[mxNumber setCountryCode:@52];
[mxNumber setNationalNumber:@13312345678];
STAssertTrue([mxNumber isEqual:[phoneUtil parse:@"+52 1 33 1234-5678" defaultRegion:@"MX"]], nil);
STAssertTrue([mxNumber isEqual:[phoneUtil parse:@"044 (33) 1234-5678" defaultRegion:@"MX"]], nil);
STAssertTrue([mxNumber isEqual:[phoneUtil parse:@"045 33 1234-5678" defaultRegion:@"MX"]], nil);
}
#pragma mark - testFailedParseOnInvalidNumbers
{
NSLog(@"-------------- testFailedParseOnInvalidNumbers");
@try {
NSString *sentencePhoneNumber = @"This is not a phone number";
[phoneUtil parse:sentencePhoneNumber defaultRegion:@"NZ"];
STFail([@"This should not parse without throwing an exception " stringByAppendingString:sentencePhoneNumber]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name ,@"Wrong error type stored in exception.");
}
@try {
NSString *sentencePhoneNumber = @"1 Still not a number";
[phoneUtil parse:sentencePhoneNumber defaultRegion:@"NZ"];
STFail([@"This should not parse without throwing an exception " stringByAppendingString:sentencePhoneNumber]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *sentencePhoneNumber = @"1 MICROSOFT";
[phoneUtil parse:sentencePhoneNumber defaultRegion:@"NZ"];
STFail([@"This should not parse without throwing an exception " stringByAppendingString:sentencePhoneNumber]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *sentencePhoneNumber = @"12 MICROSOFT";
[phoneUtil parse:sentencePhoneNumber defaultRegion:@"NZ"];
STFail([@"This should not parse without throwing an exception " stringByAppendingString:sentencePhoneNumber]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *tooLongPhoneNumber = @"01495 72553301873 810104";
[phoneUtil parse:tooLongPhoneNumber defaultRegion:@"GB"];
STFail([@"This should not parse without throwing an exception " stringByAppendingString:tooLongPhoneNumber]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"TOO_LONG", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *plusMinusPhoneNumber = @"+---";
[phoneUtil parse:plusMinusPhoneNumber defaultRegion:@"DE"];
STFail([@"This should not parse without throwing an exception "stringByAppendingString:plusMinusPhoneNumber]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *plusStar = @"+***";
[phoneUtil parse:plusStar defaultRegion:@"DE"];
STFail([@"This should not parse without throwing an exception "stringByAppendingString:plusStar]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *plusStarPhoneNumber = @"+*******91";
[phoneUtil parse:plusStarPhoneNumber defaultRegion:@"DE"];
STFail([@"This should not parse without throwing an exception "stringByAppendingString:plusStarPhoneNumber]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *tooShortPhoneNumber = @"+49 0";
[phoneUtil parse:tooShortPhoneNumber defaultRegion:@"DE"];
STFail([@"This should not parse without throwing an exception "stringByAppendingString:tooShortPhoneNumber]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"TOO_SHORT_NSN", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *invalidcountryCode = @"+210 3456 56789";
[phoneUtil parse:invalidcountryCode defaultRegion:@"NZ"];
STFail([@"This is not a recognised region code: should fail: " stringByAppendingString:invalidcountryCode]);
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *plusAndIddAndInvalidcountryCode = @"+ 00 210 3 331 6005";
[phoneUtil parse:plusAndIddAndInvalidcountryCode defaultRegion:@"NZ"];
STFail(@"This should not parse without throwing an exception.");
} @catch (NSException *e) {
// Expected this exception. 00 is a correct IDD, but 210 is not a valid
// country code.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *someNumber = @"123 456 7890";
[phoneUtil parse:someNumber defaultRegion:@"ZZ"];
STFail(@"Unknown region code not allowed: should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *someNumber = @"123 456 7890";
[phoneUtil parse:someNumber defaultRegion:@"CS"];
STFail(@"Deprecated region code not allowed: should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *someNumber = @"123 456 7890";
[phoneUtil parse:someNumber defaultRegion:nil];
STFail(@"nil region code not allowed: should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *someNumber = @"0044------";
[phoneUtil parse:someNumber defaultRegion:@"GB"];
STFail(@"No number provided, only region code: should fail");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"TOO_SHORT_AFTER_IDD", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *someNumber = @"0044";
[phoneUtil parse:someNumber defaultRegion:@"GB"];
STFail(@"No number provided, only region code: should fail");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"TOO_SHORT_AFTER_IDD", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *someNumber = @"011";
[phoneUtil parse:someNumber defaultRegion:@"US"];
STFail(@"Only IDD provided - should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"TOO_SHORT_AFTER_IDD", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *someNumber = @"0119";
[phoneUtil parse:someNumber defaultRegion:@"US"];
STFail(@"Only IDD provided and then 9 - should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"TOO_SHORT_AFTER_IDD", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *emptyNumber = @"";
// Invalid region.
[phoneUtil parse:emptyNumber defaultRegion:@"ZZ"];
STFail(@"Empty string - should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
// Invalid region.
[phoneUtil parse:nil defaultRegion:@"ZZ"];
STFail(@"nil string - should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
[phoneUtil parse:nil defaultRegion:@"US"];
STFail(@"nil string - should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"NOT_A_NUMBER", e.name, @"Wrong error type stored in exception.");
}
@try {
NSString *domainRfcPhoneContext = @"tel:555-1234;phone-context=www.google.com";
[phoneUtil parse:domainRfcPhoneContext defaultRegion:@"ZZ"];
STFail(@"Unknown region code not allowed: should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", e.name, @"Wrong error type stored in exception.");
}
@try {
// This is invalid because no '+' sign is present as part of phone-context.
// This should not succeed in being parsed.
NSString *invalidRfcPhoneContext = @"tel:555-1234;phone-context=1-331";
[phoneUtil parse:invalidRfcPhoneContext defaultRegion:@"ZZ"];
STFail(@"Unknown region code not allowed: should fail.");
} @catch (NSException *e) {
// Expected this exception.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", e.name, @"Wrong error type stored in exception.");
}
}
#pragma mark - testParseNumbersWithPlusWithNoRegion
{
NSLog(@"-------------- testParseNumbersWithPlusWithNoRegion");
// @"ZZ is allowed only if the number starts with a '+' - then the
// country calling code can be calculated.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"+64 3 331 6005" defaultRegion:@"ZZ"]], nil);
// Test with full-width plus.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"\uFF0B64 3 331 6005" defaultRegion:@"ZZ"]], nil);
// Test with normal plus but leading characters that need to be stripped.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"Tel: +64 3 331 6005" defaultRegion:@"ZZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"+64 3 331 6005" defaultRegion:nil]], nil);
STAssertTrue([INTERNATIONAL_TOLL_FREE isEqual:[phoneUtil parse:@"+800 1234 5678" defaultRegion:nil]], nil);
STAssertTrue([UNIVERSAL_PREMIUM_RATE isEqual:[phoneUtil parse:@"+979 123 456 789" defaultRegion:nil]], nil);
// Test parsing RFC3966 format with a phone context.
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"tel:03-331-6005;phone-context=+64" defaultRegion:@"ZZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@" tel:03-331-6005;phone-context=+64" defaultRegion:@"ZZ"]], nil);
STAssertTrue([NZ_NUMBER isEqual:[phoneUtil parse:@"tel:03-331-6005;isub=12345;phone-context=+64" defaultRegion:@"ZZ"]], nil);
// It is important that we set the carrier code to an empty string, since we
// used ParseAndKeepRawInput and no carrier code was found.
id nzNumberWithRawInput = [NZ_NUMBER copy];
[nzNumberWithRawInput setRawInput:@"+64 3 331 6005"];
[nzNumberWithRawInput setCountryCodeSource:[NSNumber numberWithInt:NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN]];
[nzNumberWithRawInput setPreferredDomesticCarrierCode:@""];
STAssertTrue([nzNumberWithRawInput isEqual:[phoneUtil parseAndKeepRawInput:@"+64 3 331 6005" defaultRegion:@"ZZ"]], nil);
// nil is also allowed for the region code in these cases.
STAssertTrue([nzNumberWithRawInput isEqual:[phoneUtil parseAndKeepRawInput:@"+64 3 331 6005" defaultRegion:nil]], nil);
}
#pragma mark - testParseExtensions
{
NSLog(@"-------------- testParseExtensions");
NBPhoneNumber *nzNumber = [[NBPhoneNumber alloc] init];
[nzNumber setCountryCode:@64];
[nzNumber setNationalNumber:@33316005];
[nzNumber setExtension:@"3456"];
STAssertTrue([nzNumber isEqual:[phoneUtil parse:@"03 331 6005 ext 3456" defaultRegion:@"NZ"]], nil);
STAssertTrue([nzNumber isEqual:[phoneUtil parse:@"03-3316005x3456" defaultRegion:@"NZ"]], nil);
STAssertTrue([nzNumber isEqual:[phoneUtil parse:@"03-3316005 int.3456" defaultRegion:@"NZ"]], nil);
STAssertTrue([nzNumber isEqual:[phoneUtil parse:@"03 3316005 #3456" defaultRegion:@"NZ"]], nil);
// Test the following do not extract extensions:
STAssertTrue([ALPHA_NUMERIC_NUMBER isEqual:[phoneUtil parse:@"1800 six-flags" defaultRegion:@"US"]], nil);
STAssertTrue([ALPHA_NUMERIC_NUMBER isEqual:[phoneUtil parse:@"1800 SIX FLAGS" defaultRegion:@"US"]], nil);
STAssertTrue([ALPHA_NUMERIC_NUMBER isEqual:[phoneUtil parse:@"0~0 1800 7493 5247" defaultRegion:@"PL"]], nil);
STAssertTrue([ALPHA_NUMERIC_NUMBER isEqual:[phoneUtil parse:@"(1800) 7493.5247" defaultRegion:@"US"]], nil);
// Check that the last instance of an extension token is matched.
id extnNumber = [ALPHA_NUMERIC_NUMBER copy];
[extnNumber setExtension:@"1234"];
STAssertTrue([extnNumber isEqual:[phoneUtil parse:@"0~0 1800 7493 5247 ~1234" defaultRegion:@"PL"]], nil);
// Verifying bug-fix where the last digit of a number was previously omitted
// if it was a 0 when extracting the extension. Also verifying a few different
// cases of extensions.
id ukNumber = [[NBPhoneNumber alloc] init];
[ukNumber setCountryCode:@44];
[ukNumber setNationalNumber:@2034567890];
[ukNumber setExtension:@"456"];
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44 2034567890x456" defaultRegion:@"NZ"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44 2034567890x456" defaultRegion:@"GB"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44 2034567890 x456" defaultRegion:@"GB"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44 2034567890 X456" defaultRegion:@"GB"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44 2034567890 X 456" defaultRegion:@"GB"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44 2034567890 X 456" defaultRegion:@"GB"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44 2034567890 x 456 " defaultRegion:@"GB"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44 2034567890 X 456" defaultRegion:@"GB"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+44-2034567890;ext=456" defaultRegion:@"GB"]], nil);
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"tel:2034567890;ext=456;phone-context=+44" defaultRegion:@"ZZ"]], nil);
// Full-width extension, @"extn' only.
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+442034567890\uFF45\uFF58\uFF54\uFF4E456" defaultRegion:@"GB"]], nil);
// 'xtn' only.
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+442034567890\uFF58\uFF54\uFF4E456" defaultRegion:@"GB"]], nil);
// 'xt' only.
STAssertTrue([ukNumber isEqual:[phoneUtil parse:@"+442034567890\uFF58\uFF54456" defaultRegion:@"GB"]], nil);
id usWithExtension = [[NBPhoneNumber alloc] init];
[usWithExtension setCountryCode:@1];
[usWithExtension setNationalNumber:@8009013355];
[usWithExtension setExtension:@"7246433"];
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"(800) 901-3355 x 7246433" defaultRegion:@"US"]], nil);
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"(800) 901-3355 , ext 7246433" defaultRegion:@"US"]], nil);
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"(800) 901-3355 ,extension 7246433" defaultRegion:@"US"]], nil);
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"(800) 901-3355 ,extensi\u00F3n 7246433" defaultRegion:@"US"]], nil);
// Repeat with the small letter o with acute accent created by combining
// characters.
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"(800) 901-3355 ,extensio\u0301n 7246433" defaultRegion:@"US"]], nil);
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"(800) 901-3355 , 7246433" defaultRegion:@"US"]], nil);
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"(800) 901-3355 ext: 7246433" defaultRegion:@"US"]], nil);
// Test that if a number has two extensions specified, we ignore the second.
id usWithTwoExtensionsNumber = [[NBPhoneNumber alloc] init];
[usWithTwoExtensionsNumber setCountryCode:@1];
[usWithTwoExtensionsNumber setNationalNumber:@2121231234];
[usWithTwoExtensionsNumber setExtension:@"508"];
STAssertTrue([usWithTwoExtensionsNumber isEqual:[phoneUtil parse:@"(212)123-1234 x508/x1234" defaultRegion:@"US"]], nil);
STAssertTrue([usWithTwoExtensionsNumber isEqual:[phoneUtil parse:@"(212)123-1234 x508/ x1234" defaultRegion:@"US"]], nil);
STAssertTrue([usWithTwoExtensionsNumber isEqual:[phoneUtil parse:@"(212)123-1234 x508\\x1234" defaultRegion:@"US"]], nil);
// Test parsing numbers in the form (645) 123-1234-910# works, where the last
// 3 digits before the # are an extension.
usWithExtension = [[NBPhoneNumber alloc] init];
[usWithExtension setCountryCode:@1];
[usWithExtension setNationalNumber:@6451231234];
[usWithExtension setExtension:@"910"];
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"+1 (645) 123 1234-910#" defaultRegion:@"US"]], nil);
// Retry with the same number in a slightly different format.
STAssertTrue([usWithExtension isEqual:[phoneUtil parse:@"+1 (645) 123 1234 ext. 910#" defaultRegion:@"US"]], nil);
}
#pragma mark - testParseAndKeepRaw
{
NSLog(@"-------------- testParseAndKeepRaw");
NBPhoneNumber *alphaNumericNumber = [ALPHA_NUMERIC_NUMBER copy];
[alphaNumericNumber setRawInput:@"800 six-flags"];
[alphaNumericNumber setCountryCodeSource:[NSNumber numberWithInt:NBECountryCodeSourceFROM_DEFAULT_COUNTRY]];
[alphaNumericNumber setPreferredDomesticCarrierCode:@""];
STAssertTrue([alphaNumericNumber isEqual:[phoneUtil parseAndKeepRawInput:@"800 six-flags" defaultRegion:@"US"]], nil);
id shorterAlphaNumber = [[NBPhoneNumber alloc] init];
[shorterAlphaNumber setCountryCode:@1];
[shorterAlphaNumber setNationalNumber:@8007493524];
[shorterAlphaNumber setRawInput:@"1800 six-flag"];
[shorterAlphaNumber setCountryCodeSource:[NSNumber numberWithInt:NBECountryCodeSourceFROM_NUMBER_WITHOUT_PLUS_SIGN]];
[shorterAlphaNumber setPreferredDomesticCarrierCode:@""];
STAssertTrue([shorterAlphaNumber isEqual:[phoneUtil parseAndKeepRawInput:@"1800 six-flag" defaultRegion:@"US"]], nil);
[shorterAlphaNumber setRawInput:@"+1800 six-flag"];
[shorterAlphaNumber setCountryCodeSource:[NSNumber numberWithInt:NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN]];
STAssertTrue([shorterAlphaNumber isEqual:[phoneUtil parseAndKeepRawInput:@"+1800 six-flag" defaultRegion:@"NZ"]], nil);
[alphaNumericNumber setCountryCode:@1];
[alphaNumericNumber setNationalNumber:@8007493524];
[alphaNumericNumber setRawInput:@"001800 six-flag"];
[alphaNumericNumber setCountryCodeSource:[NSNumber numberWithInt:NBECountryCodeSourceFROM_NUMBER_WITH_IDD]];
STAssertTrue([alphaNumericNumber isEqual:[phoneUtil parseAndKeepRawInput:@"001800 six-flag" defaultRegion:@"NZ"]], nil);
// Invalid region code supplied.
@try
{
[phoneUtil parseAndKeepRawInput:@"123 456 7890" defaultRegion:@"CS"];
STFail(@"Deprecated region code not allowed: should fail.");
} @catch (NSException *e)
{
// Expected this exception.
STAssertEqualObjects(@"INVALID_COUNTRY_CODE", e.name, @"Wrong error type stored in exception.");
}
id koreanNumber = [[NBPhoneNumber alloc] init];
[koreanNumber setCountryCode:@82];
[koreanNumber setNationalNumber:@22123456];
[koreanNumber setRawInput:@"08122123456"];
[koreanNumber setCountryCodeSource:[NSNumber numberWithInt:NBECountryCodeSourceFROM_DEFAULT_COUNTRY]];
[koreanNumber setPreferredDomesticCarrierCode:@"81"];
STAssertTrue([koreanNumber isEqual:[phoneUtil parseAndKeepRawInput:@"08122123456" defaultRegion:@"KR"]], nil);
}
#pragma mark - testCountryWithNoNumberDesc
{
NSLog(@"-------------- testCountryWithNoNumberDesc");
// Andorra is a country where we don't have PhoneNumberDesc info in the
// metadata.
NBPhoneNumber *adNumber = [[NBPhoneNumber alloc] init];
[adNumber setCountryCode:@376];
[adNumber setNationalNumber:@12345];
STAssertEqualObjects(@"+376 12345", [phoneUtil format:adNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL], nil);
STAssertEqualObjects(@"+37612345", [phoneUtil format:adNumber numberFormat:NBEPhoneNumberFormatE164], nil);
STAssertEqualObjects(@"12345", [phoneUtil format:adNumber numberFormat:NBEPhoneNumberFormatNATIONAL], nil);
STAssertEquals(NBEPhoneNumberTypeUNKNOWN, [phoneUtil getNumberType:adNumber], nil);
STAssertTrue([phoneUtil isValidNumber:adNumber], nil);
// Test dialing a US number from within Andorra.
STAssertEqualObjects(@"00 1 650 253 0000", [phoneUtil formatOutOfCountryCallingNumber:US_NUMBER regionCallingFrom:@"AD"], nil);
}
#pragma mark - testUnknownCountryCallingCode
{
NSLog(@"-------------- testUnknownCountryCallingCode");
STAssertFalse([phoneUtil isValidNumber:UNKNOWN_COUNTRY_CODE_NO_RAW_INPUT], nil);
// 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.
STAssertEqualObjects(@"+212345", [phoneUtil format:UNKNOWN_COUNTRY_CODE_NO_RAW_INPUT numberFormat:NBEPhoneNumberFormatE164], nil);
}
#pragma mark - testIsNumberMatchMatches
{
NSLog(@"-------------- testIsNumberMatchMatches");
// Test simple matches where formatting is different, or leading zeroes,
// or country calling code has been specified.
NBPhoneNumber *num1 = [phoneUtil parse:@"+64 3 331 6005" defaultRegion:@"NZ"];
NBPhoneNumber *num2 = [phoneUtil parse:@"+64 03 331 6005" defaultRegion:@"NZ"];
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:num1 second:num2], nil);
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+64 3 331 6005" second:@"+64 03 331 6005"], nil);
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+800 1234 5678" second:@"+80012345678"], nil);
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+64 03 331-6005" second:@"+64 03331 6005"], nil);
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+643 331-6005" second:@"+64033316005"], nil);
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+643 331-6005" second:@"+6433316005"], nil);
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"+6433316005"], nil);
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"tel:+64-3-331-6005;isub=123"], nil);
// Test alpha numbers.
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+1800 siX-Flags" second:@"+1 800 7493 5247"], nil);
// Test numbers with extensions.
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005 extn 1234" second:@"+6433316005#1234"], nil);
// Test proto buffers.
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:NZ_NUMBER second:@"+6403 331 6005"], nil);
NBPhoneNumber *nzNumber = [NZ_NUMBER copy];
[nzNumber setExtension:@"3456"];
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:nzNumber second:@"+643 331 6005 ext 3456"], nil);
// Check empty extensions are ignored.
[nzNumber setExtension:@""];
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:nzNumber second:@"+6403 331 6005"], nil);
// Check variant with two proto buffers.
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:nzNumber second:NZ_NUMBER], @"Numbers did not match");
// Check raw_input, country_code_source and preferred_domestic_carrier_code
// are ignored.
NBPhoneNumber *brNumberOne = [[NBPhoneNumber alloc] init];
NBPhoneNumber *brNumberTwo = [[NBPhoneNumber alloc] init];
[brNumberOne setCountryCode:@55];
[brNumberOne setNationalNumber:@3121286979];
[brNumberOne setCountryCodeSource:[NSNumber numberWithInt:NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN]];
[brNumberOne setPreferredDomesticCarrierCode:@"12"];
[brNumberOne setRawInput:@"012 3121286979"];
[brNumberTwo setCountryCode:@55];
[brNumberTwo setNationalNumber:@3121286979];
[brNumberTwo setCountryCodeSource:[NSNumber numberWithInt:NBECountryCodeSourceFROM_DEFAULT_COUNTRY]];
[brNumberTwo setPreferredDomesticCarrierCode:@"14"];
[brNumberTwo setRawInput:@"143121286979"];
STAssertEquals(NBEMatchTypeEXACT_MATCH, [phoneUtil isNumberMatch:brNumberOne second:brNumberTwo], nil);
}
#pragma mark - testIsNumberMatchNonMatches
{
NSLog(@"-------------- testIsNumberMatchNonMatches");
// Non-matches.
STAssertEquals(NBEMatchTypeNO_MATCH, [phoneUtil isNumberMatch:@"03 331 6005" second:@"03 331 6006"], nil);
STAssertEquals(NBEMatchTypeNO_MATCH, [phoneUtil isNumberMatch:@"+800 1234 5678" second:@"+1 800 1234 5678"], nil);
// Different country calling code, partial number match.
STAssertEquals(NBEMatchTypeNO_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"+16433316005"], nil);
// Different country calling code, same number.
STAssertEquals(NBEMatchTypeNO_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"+6133316005"], nil);
// Extension different, all else the same.
STAssertEquals(NBEMatchTypeNO_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005 extn 1234" second:@"0116433316005#1235"], nil);
STAssertEquals(NBEMatchTypeNO_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005 extn 1234" second:@"tel:+64-3-331-6005;ext=1235"], nil);
// NSN matches, but extension is different - not the same number.
STAssertEquals(NBEMatchTypeNO_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005 ext.1235" second:@"3 331 6005#1234"], nil);
// Invalid numbers that can't be parsed.
STAssertEquals(NBEMatchTypeNOT_A_NUMBER, [phoneUtil isNumberMatch:@"4" second:@"3 331 6043"], nil);
STAssertEquals(NBEMatchTypeNOT_A_NUMBER, [phoneUtil isNumberMatch:@"+43" second:@"+64 3 331 6005"], nil);
STAssertEquals(NBEMatchTypeNOT_A_NUMBER, [phoneUtil isNumberMatch:@"+43" second:@"64 3 331 6005"], nil);
STAssertEquals(NBEMatchTypeNOT_A_NUMBER, [phoneUtil isNumberMatch:@"Dog" second:@"64 3 331 6005"], nil);
}
#pragma mark - testIsNumberMatchNsnMatches
{
NSLog(@"-------------- testIsNumberMatchNsnMatches");
// NSN matches.
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"03 331 6005"], nil);
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"tel:03-331-6005;isub=1234;phone-context=abc.nz"], nil);
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:NZ_NUMBER second:@"03 331 6005"], nil);
// Here the second number possibly starts with the country calling code for
// New Zealand, although we are unsure.
NBPhoneNumber *unchangedNzNumber = [NZ_NUMBER copy];
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:unchangedNzNumber second:@"(64-3) 331 6005"], nil);
// Check the phone number proto was not edited during the method call.
STAssertTrue([NZ_NUMBER isEqual:unchangedNzNumber], nil);
// Here, the 1 might be a national prefix, if we compare it to the US number,
// so the resultant match is an NSN match.
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:US_NUMBER second:@"1-650-253-0000"], nil);
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:US_NUMBER second:@"6502530000"], nil);
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:@"+1 650-253 0000" second:@"1 650 253 0000"], nil);
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:@"1 650-253 0000" second:@"1 650 253 0000"], nil);
STAssertEquals(NBEMatchTypeNSN_MATCH, [phoneUtil isNumberMatch:@"1 650-253 0000" second:@"+1 650 253 0000"], nil);
// For this case, the match will be a short NSN match, because we cannot
// assume that the 1 might be a national prefix, so don't remove it when
// parsing.
NBPhoneNumber *randomNumber = [[NBPhoneNumber alloc] init];
[randomNumber setCountryCode:@41];
[randomNumber setNationalNumber:@6502530000];
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:randomNumber second:@"1-650-253-0000"], nil);
}
#pragma mark - testIsNumberMatchShortNsnMatches
{
NSLog(@"-------------- testIsNumberMatchShortNsnMatches");
// Short NSN matches with the country not specified for either one or both
// numbers.
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"331 6005"], nil);
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"tel:331-6005;phone-context=abc.nz"], nil);
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"tel:331-6005;isub=1234;phone-context=abc.nz"], nil);
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"tel:331-6005;isub=1234;phone-context=abc.nz;a=%A1"], nil);
// 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.
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"3 331-6005" second:@"03 331 6005"], nil);
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"3 331-6005" second:@"331 6005"], nil);
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"3 331-6005" second:@"tel:331-6005;phone-context=abc.nz"], nil);
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"3 331-6005" second:@"+64 331 6005"], nil);
// Short NSN match with the country specified.
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"03 331-6005" second:@"331 6005"], nil);
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"1 234 345 6789" second:@"345 6789"], nil);
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"+1 (234) 345 6789" second:@"345 6789"], nil);
// NSN matches, country calling code omitted for one number, extension missing
// for one.
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:@"+64 3 331-6005" second:@"3 331 6005#1234"], nil);
// One has Italian leading zero, one does not.
NBPhoneNumber *italianNumberOne = [[NBPhoneNumber alloc] init];
[italianNumberOne setCountryCode:@39];
[italianNumberOne setNationalNumber:@1234];
[italianNumberOne setItalianLeadingZero:YES];
NBPhoneNumber *italianNumberTwo = [[NBPhoneNumber alloc] init];
[italianNumberTwo setCountryCode:@39];
[italianNumberTwo setNationalNumber:@1234];
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:italianNumberOne second:italianNumberTwo], nil);
// One has an extension, the other has an extension of ''.
[italianNumberOne setExtension:@"1234"];
italianNumberOne.italianLeadingZero = NO;
[italianNumberTwo setExtension:@""];
STAssertEquals(NBEMatchTypeSHORT_NSN_MATCH, [phoneUtil isNumberMatch:italianNumberOne second:italianNumberTwo], nil);
}
#pragma mark - testCanBeInternationallyDialled
{
NSLog(@"-------------- testCanBeInternationallyDialled");
// We have no-international-dialling rules for the US in our test metadata
// that say that toll-free numbers cannot be dialled internationally.
STAssertFalse([phoneUtil canBeInternationallyDialled:US_TOLLFREE], nil);
// Normal US numbers can be internationally dialled.
STAssertTrue([phoneUtil canBeInternationallyDialled:US_NUMBER], nil);
// Invalid number.
STAssertTrue([phoneUtil canBeInternationallyDialled:US_LOCAL_NUMBER], nil);
// We have no data for NZ - should return true.
STAssertTrue([phoneUtil canBeInternationallyDialled:NZ_NUMBER], nil);
STAssertTrue([phoneUtil canBeInternationallyDialled:INTERNATIONAL_TOLL_FREE], nil);
}
#pragma mark - testIsAlphaNumber
{
NSLog(@"-------------- testIsAlphaNumber");
STAssertTrue([phoneUtil isAlphaNumber:@"1800 six-flags"], nil);
STAssertTrue([phoneUtil isAlphaNumber:@"1800 six-flags ext. 1234"], nil);
STAssertTrue([phoneUtil isAlphaNumber:@"+800 six-flags"], nil);
STAssertTrue([phoneUtil isAlphaNumber:@"180 six-flags"], nil);
STAssertFalse([phoneUtil isAlphaNumber:@"1800 123-1234"], nil);
STAssertFalse([phoneUtil isAlphaNumber:@"1 six-flags"], nil);
STAssertFalse([phoneUtil isAlphaNumber:@"18 six-flags"], nil);
STAssertFalse([phoneUtil isAlphaNumber:@"1800 123-1234 extension: 1234"], nil);
STAssertFalse([phoneUtil isAlphaNumber:@"+800 1234-1234"], nil);
}
}
@end