public void TestLoadNationalFormatRequiresFormat()
{
String xmlInput = "<numberFormat></numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
NumberFormat.Builder numberFormat = new NumberFormat.Builder();
try
{
BuildMetadataFromXml.LoadNationalFormat(metadata, numberFormatElement, numberFormat);
Assert.Fail();
}
catch (Exception)
{
// Test passed.
}
}
public void TestLoadInternationalFormatExpectsOnlyOnePattern()
{
String xmlInput = "<numberFormat><intlFormat/><intlFormat/></numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
// Should throw an exception as multiple intlFormats are provided.
try
{
BuildMetadataFromXml.LoadInternationalFormat(metadata, numberFormatElement, "");
Assert.Fail();
}
catch (Exception)
{
// Test passed.
}
}
[TestMethod] public void testLoadNationalFormatExpectsExactlyOneFormat()
{
String xmlInput = "<numberFormat><format/><format/></numberFormat>";
XmlElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
NumberFormat.Builder numberFormat = NumberFormat.newBuilder();
try
{
BuildMetadataFromXml.loadNationalFormat(metadata, numberFormatElement, numberFormat);
Assert.Fail();
}
catch (Exception)
{
// Test passed.
}
}
/**
* Extracts the pattern for the national format.
*
* @throws RuntimeException if multiple or no formats have been encountered.
*/
// @VisibleForTesting
internal static void loadNationalFormat(PhoneMetadata.Builder metadata, XmlElement numberFormatXmlElement,
NumberFormat.Builder format)
{
setLeadingDigitsPatterns(numberFormatXmlElement, format);
format.setPattern(validateRE(numberFormatXmlElement.GetAttribute(PATTERN)));
var formatPattern = numberFormatXmlElement.GetElementsByTagName(FORMAT);
int numFormatPatterns = formatPattern.Count;
if (numFormatPatterns != 1)
{
// LOGGER.log(Level.SEVERE, "One format pattern for a numberFormat element should be defined.");
String countryId = metadata.getId().Length > 0 ?
metadata.getId() : metadata.getCountryCode().ToString();
throw new Exception("Invalid number of format patterns (" + numFormatPatterns +
") for country: " + countryId);
}
format.setFormat(formatPattern.Item(0).FirstChild.Value);
}
public void TestLoadAvailableFormatsPropagatesCarrierCodeFormattingRule()
{
String xmlInput =
"<territory carrierCodeFormattingRule='$NP $CC ($FG)'>" +
" <availableFormats>" +
" <numberFormat nationalPrefixFormattingRule='($FG)'>" +
" <format>$1 $2 $3</format>" +
" </numberFormat>" +
" </availableFormats>" +
"</territory>";
XElement element = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
BuildMetadataFromXml.LoadAvailableFormats(
metadata, element, "0", "", false /* NP not optional */);
Assert.Equal("(${1})", metadata.NumberFormatList[0].NationalPrefixFormattingRule);
Assert.Equal("0 $CC (${1})", metadata.NumberFormatList[0].DomesticCarrierCodeFormattingRule);
Assert.Equal("$1 $2 $3", metadata.NumberFormatList[0].Format);
}
[TestMethod] public void testLoadAvailableFormatsPropagatesCarrierCodeFormattingRule()
{
String xmlInput =
"<territory carrierCodeFormattingRule='$NP $CC ($FG)'>" +
" <availableFormats>" +
" <numberFormat nationalPrefixFormattingRule='($FG)'>" +
" <format>$1 $2 $3</format>" +
" </numberFormat>" +
" </availableFormats>" +
"</territory>";
XmlElement element = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
BuildMetadataFromXml.loadAvailableFormats(
metadata, element, "0", "", false /* NP not optional */);
Assert.AreEqual("($1)", metadata.getNumberFormat(0).getNationalPrefixFormattingRule());
Assert.AreEqual("0 $CC ($1)", metadata.getNumberFormat(0).getDomesticCarrierCodeFormattingRule());
Assert.AreEqual("$1 $2 $3", metadata.getNumberFormat(0).getFormat());
}
// @VisibleForTesting
internal static PhoneMetadata loadCountryMetadata(String regionCode, XmlElement element, bool liteBuild,
bool isShortNumberMetadata, bool isAlternateFormatsMetadata)
{
String nationalPrefix = getNationalPrefix(element);
PhoneMetadata.Builder metadata =
loadTerritoryTagMetadata(regionCode, element, nationalPrefix);
String nationalPrefixFormattingRule =
getNationalPrefixFormattingRuleFromXmlElement(element, nationalPrefix);
loadAvailableFormats(metadata, element, nationalPrefix.ToString(),
nationalPrefixFormattingRule.ToString(),
element.HasAttribute(NATIONAL_PREFIX_OPTIONAL_WHEN_FORMATTING));
if (!isAlternateFormatsMetadata)
{
// The alternate formats metadata does not need most of the patterns to be set.
setRelevantDescPatterns(metadata, element, liteBuild, isShortNumberMetadata);
}
return(metadata.build());
}
/**
* Extracts the pattern for the national format.
*
* @throws RuntimeException if multiple or no formats have been encountered.
* @return the national format string.
*/
// @VisibleForTesting
public static String LoadNationalFormat(PhoneMetadata.Builder metadata, XElement numberFormatElement,
NumberFormat.Builder format)
{
SetLeadingDigitsPatterns(numberFormatElement, format);
format.SetPattern(ValidateRE(numberFormatElement.GetAttribute(PATTERN)));
var formatPattern = numberFormatElement.Elements(FORMAT).ToArray();
if (formatPattern.Count() != 1)
{
//LOGGER.log(Level.SEVERE,
// "Only one format pattern for a numberFormat element should be defined.");
throw new Exception("Invalid number of format patterns for country: " +
metadata.Id);
}
String nationalFormat = formatPattern[0].Value;
format.SetFormat(nationalFormat);
return(nationalFormat);
}
/**
* Extracts the pattern for international format. If there is no intlFormat, default to using the
* national format. If the intlFormat is set to "NA" the intlFormat should be ignored.
*
* @throws RuntimeException if multiple intlFormats have been encountered.
* @return whether an international number format is defined.
*/
// @VisibleForTesting
internal static bool loadInternationalFormat(PhoneMetadata.Builder metadata,
XmlElement numberFormatXmlElement,
NumberFormat nationalFormat)
{
NumberFormat.Builder intlFormat = NumberFormat.newBuilder();
var intlFormatPattern = numberFormatXmlElement.GetElementsByTagName(INTL_FORMAT);
var hasExplicitIntlFormatDefined = false;
if (intlFormatPattern.Count > 1)
{
// LOGGER.log(Level.SEVERE,
// "A maximum of one intlFormat pattern for a numberFormat element should be " +
// "defined.");
String countryId = metadata.getId().Length > 0 ?
metadata.getId() : metadata.getCountryCode().ToString();
throw new Exception("Invalid number of intlFormat patterns for country: " + countryId);
}
else if (intlFormatPattern.Count == 0)
{
// Default to use the same as the national pattern if none is defined.
intlFormat.mergeFrom(nationalFormat);
}
else
{
intlFormat.setPattern(numberFormatXmlElement.GetAttribute(PATTERN));
setLeadingDigitsPatterns(numberFormatXmlElement, intlFormat);
String intlFormatPatternValue = intlFormatPattern.Item(0).FirstChild.Value;
if (!intlFormatPatternValue.Equals("NA"))
{
intlFormat.setFormat(intlFormatPatternValue);
}
hasExplicitIntlFormatDefined = true;
}
if (intlFormat.HasFormat())
{
metadata.addIntlNumberFormat(intlFormat);
}
return(hasExplicitIntlFormatDefined);
}
/**
* Extracts the pattern for international format. If there is no intlFormat, default to using the
* national format. If the intlFormat is set to "NA" the intlFormat should be ignored.
*
* @throws RuntimeException if multiple intlFormats have been encountered.
* @return whether an international number format is defined.
*/
// @VisibleForTesting
public static bool LoadInternationalFormat(PhoneMetadata.Builder metadata,
XElement numberFormatElement,
String nationalFormat)
{
var intlFormat = new NumberFormat.Builder();
SetLeadingDigitsPatterns(numberFormatElement, intlFormat);
intlFormat.SetPattern(numberFormatElement.GetAttribute(PATTERN));
var intlFormatPattern = numberFormatElement.GetElementsByTagName(INTL_FORMAT);
bool hasExplicitIntlFormatDefined = false;
if (intlFormatPattern.Length > 1)
{
//LOGGER.log(Level.SEVERE,
// "A maximum of one intlFormat pattern for a numberFormat element should be " +
// "defined.");
throw new Exception("Invalid number of intlFormat patterns for country: " +
metadata.Id);
}
if (intlFormatPattern.Length == 0)
{
// Default to use the same as the national pattern if none is defined.
intlFormat.SetFormat(nationalFormat);
}
else
{
String intlFormatPatternValue = intlFormatPattern[0].Value;
if (!intlFormatPatternValue.Equals("NA"))
{
intlFormat.SetFormat(intlFormatPatternValue);
}
hasExplicitIntlFormatDefined = true;
}
if (intlFormat.HasFormat)
{
metadata.AddIntlNumberFormat(intlFormat);
}
return(hasExplicitIntlFormatDefined);
}
// @VisibleForTesting
public static void LoadGeneralDesc(PhoneMetadata.Builder metadata, XElement element)
{
var generalDescBuilder = ProcessPhoneNumberDescElement(null, element, GENERAL_DESC);
SetPossibleLengthsGeneralDesc(generalDescBuilder, metadata.Id, element, false);
var generalDesc = generalDescBuilder.Build();
metadata.SetFixedLine(ProcessPhoneNumberDescElement(generalDesc, element, FIXED_LINE));
metadata.SetMobile(ProcessPhoneNumberDescElement(generalDesc, element, MOBILE));
metadata.SetTollFree(ProcessPhoneNumberDescElement(generalDesc, element, TOLL_FREE));
metadata.SetPremiumRate(ProcessPhoneNumberDescElement(generalDesc, element, PREMIUM_RATE));
metadata.SetSharedCost(ProcessPhoneNumberDescElement(generalDesc, element, SHARED_COST));
metadata.SetVoip(ProcessPhoneNumberDescElement(generalDesc, element, VOIP));
metadata.SetPersonalNumber(ProcessPhoneNumberDescElement(generalDesc, element, PERSONAL_NUMBER));
metadata.SetPager(ProcessPhoneNumberDescElement(generalDesc, element, PAGER));
metadata.SetUan(ProcessPhoneNumberDescElement(generalDesc, element, UAN));
metadata.SetVoicemail(ProcessPhoneNumberDescElement(generalDesc, element, VOICEMAIL));
metadata.SetEmergency(ProcessPhoneNumberDescElement(generalDesc, element, EMERGENCY));
metadata.SetNoInternationalDialling(ProcessPhoneNumberDescElement(generalDesc, element, NO_INTERNATIONAL_DIALLING));
metadata.SetSameMobileAndFixedLinePattern(
metadata.Mobile.NationalNumberPattern.Equals(
metadata.FixedLine.NationalNumberPattern));
}
[TestMethod] public void testSetRelevantDescPatternsSetsAllDescriptionsForShortNumbers()
{
String xmlInput =
"<territory ID=\"FR\">" +
" <tollFree><nationalNumberPattern>\\d{1}</nationalNumberPattern></tollFree>" +
" <standardRate><nationalNumberPattern>\\d{2}</nationalNumberPattern></standardRate>" +
" <premiumRate><nationalNumberPattern>\\d{3}</nationalNumberPattern></premiumRate>" +
" <shortCode><nationalNumberPattern>\\d{4}</nationalNumberPattern></shortCode>" +
" <carrierSpecific>" +
" <nationalNumberPattern>\\d{5}</nationalNumberPattern>" +
" </carrierSpecific>" +
"</territory>";
XmlElement territoryElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
BuildMetadataFromXml.setRelevantDescPatterns(metadata, territoryElement, false /* liteBuild */,
true /* isShortNumberMetadata */);
Assert.AreEqual("\\d{1}", metadata.getTollFree().getNationalNumberPattern());
Assert.AreEqual("\\d{2}", metadata.getStandardRate().getNationalNumberPattern());
Assert.AreEqual("\\d{3}", metadata.getPremiumRate().getNationalNumberPattern());
Assert.AreEqual("\\d{4}", metadata.getShortCode().getNationalNumberPattern());
Assert.AreEqual("\\d{5}", metadata.getCarrierSpecific().getNationalNumberPattern());
}
public static PhoneMetadata.Builder LoadTerritoryTagMetadata(string regionCode, XElement element,
string nationalPrefix)
{
var metadata = new PhoneMetadata.Builder();
metadata.SetId(regionCode);
if (element.HasAttribute(COUNTRY_CODE))
metadata.SetCountryCode(int.Parse(element.GetAttribute(COUNTRY_CODE)));
if (element.HasAttribute(LEADING_DIGITS))
metadata.SetLeadingDigits(ValidateRE(element.GetAttribute(LEADING_DIGITS)));
if (element.HasAttribute(INTERNATIONAL_PREFIX))
metadata.SetInternationalPrefix(ValidateRE(element.GetAttribute(INTERNATIONAL_PREFIX)));
if (element.HasAttribute(PREFERRED_INTERNATIONAL_PREFIX))
metadata.SetPreferredInternationalPrefix(
element.GetAttribute(PREFERRED_INTERNATIONAL_PREFIX));
if (element.HasAttribute(NATIONAL_PREFIX_FOR_PARSING))
{
metadata.SetNationalPrefixForParsing(
ValidateRE(element.GetAttribute(NATIONAL_PREFIX_FOR_PARSING), true));
if (element.HasAttribute(NATIONAL_PREFIX_TRANSFORM_RULE))
metadata.SetNationalPrefixTransformRule(
ValidateRE(element.GetAttribute(NATIONAL_PREFIX_TRANSFORM_RULE)));
}
if (!string.IsNullOrEmpty(nationalPrefix))
{
metadata.SetNationalPrefix(nationalPrefix);
if (!metadata.HasNationalPrefixForParsing)
metadata.SetNationalPrefixForParsing(nationalPrefix);
}
if (element.HasAttribute(PREFERRED_EXTN_PREFIX))
metadata.SetPreferredExtnPrefix(element.GetAttribute(PREFERRED_EXTN_PREFIX));
if (element.HasAttribute(MAIN_COUNTRY_FOR_CODE))
metadata.SetMainCountryForCode(true);
if (element.HasAttribute(MOBILE_NUMBER_PORTABLE_REGION))
metadata.SetMobileNumberPortableRegion(true);
return metadata;
}
public void TestLoadTerritoryTagMetadata()
{
String xmlInput =
"<territory countryCode='33' leadingDigits='2' internationalPrefix='00'" +
" preferredInternationalPrefix='0011' nationalPrefixForParsing='0'" +
" nationalPrefixTransformRule='9$1'" + // nationalPrefix manually injected.
" preferredExtnPrefix=' x' mainCountryForCode='true'" +
" leadingZeroPossible='true'>" +
"</territory>";
XElement territoryElement = parseXmlString(xmlInput);
PhoneMetadata.Builder phoneMetadata =
BuildMetadataFromXml.LoadTerritoryTagMetadata("33", territoryElement, "0");
Assert.Equal(33, phoneMetadata.CountryCode);
Assert.Equal("2", phoneMetadata.LeadingDigits);
Assert.Equal("00", phoneMetadata.InternationalPrefix);
Assert.Equal("0011", phoneMetadata.PreferredInternationalPrefix);
Assert.Equal("0", phoneMetadata.NationalPrefixForParsing);
Assert.Equal("9$1", phoneMetadata.NationalPrefixTransformRule);
Assert.Equal("0", phoneMetadata.NationalPrefix);
Assert.Equal(" x", phoneMetadata.PreferredExtnPrefix);
Assert.True(phoneMetadata.MainCountryForCode);
Assert.True(phoneMetadata.LeadingZeroPossible);
}
// @VisibleForTesting
public static void LoadGeneralDesc(PhoneMetadata.Builder metadata, XElement element, bool liteBuild)
{
var generalDesc = ProcessPhoneNumberDescElement(null, element, GENERAL_DESC, liteBuild);
metadata.SetGeneralDesc(generalDesc);
metadata.SetFixedLine(ProcessPhoneNumberDescElement(generalDesc, element, FIXED_LINE, liteBuild));
metadata.SetMobile(ProcessPhoneNumberDescElement(generalDesc, element, MOBILE, liteBuild));
metadata.SetTollFree(ProcessPhoneNumberDescElement(generalDesc, element, TOLL_FREE, liteBuild));
metadata.SetPremiumRate(ProcessPhoneNumberDescElement(generalDesc, element, PREMIUM_RATE, liteBuild));
metadata.SetSharedCost(ProcessPhoneNumberDescElement(generalDesc, element, SHARED_COST, liteBuild));
metadata.SetVoip(ProcessPhoneNumberDescElement(generalDesc, element, VOIP, liteBuild));
metadata.SetPersonalNumber(ProcessPhoneNumberDescElement(generalDesc, element,
PERSONAL_NUMBER, liteBuild));
metadata.SetPager(ProcessPhoneNumberDescElement(generalDesc, element, PAGER, liteBuild));
metadata.SetUan(ProcessPhoneNumberDescElement(generalDesc, element, UAN, liteBuild));
metadata.SetVoicemail(ProcessPhoneNumberDescElement(generalDesc, element, VOICEMAIL, liteBuild));
metadata.SetEmergency(ProcessPhoneNumberDescElement(generalDesc, element, EMERGENCY, liteBuild));
metadata.SetNoInternationalDialling(ProcessPhoneNumberDescElement(generalDesc, element,
NO_INTERNATIONAL_DIALLING, liteBuild));
metadata.SetSameMobileAndFixedLinePattern(
metadata.Mobile.NationalNumberPattern.Equals(
metadata.FixedLine.NationalNumberPattern));
}
public void TestMaybeStripNationalPrefix()
{
PhoneMetadata metadata = new PhoneMetadata.Builder()
.SetNationalPrefixForParsing("34")
.SetGeneralDesc(new PhoneNumberDesc.Builder().SetNationalNumberPattern("\\d{4,8}").Build())
.BuildPartial();
StringBuilder numberToStrip = new StringBuilder("34356778");
String strippedNumber = "356778";
Assert.True(phoneUtil.MaybeStripNationalPrefixAndCarrierCode(numberToStrip, metadata, null));
Assert.AreEqual(strippedNumber, numberToStrip.ToString(),
"Should have had national prefix stripped.");
// Retry stripping - now the number should not start with the national prefix, so no more
// stripping should occur.
Assert.False(phoneUtil.MaybeStripNationalPrefixAndCarrierCode(numberToStrip, metadata, null));
Assert.AreEqual(strippedNumber, numberToStrip.ToString(),
"Should have had no change - no national prefix present.");
// Some countries have no national prefix. Repeat test with none specified.
metadata = Update(metadata).SetNationalPrefixForParsing("").BuildPartial();
Assert.False(phoneUtil.MaybeStripNationalPrefixAndCarrierCode(numberToStrip, metadata, null));
Assert.AreEqual(strippedNumber, numberToStrip.ToString(),
"Should not strip anything with empty national prefix.");
// If the resultant number doesn't match the national rule, it shouldn't be stripped.
metadata = Update(metadata).SetNationalPrefixForParsing("3").BuildPartial();
numberToStrip = new StringBuilder("3123");
strippedNumber = "3123";
Assert.False(phoneUtil.MaybeStripNationalPrefixAndCarrierCode(numberToStrip, metadata, null));
Assert.AreEqual(strippedNumber, numberToStrip.ToString(),
"Should have had no change - after stripping, it wouldn't have matched " +
"the national rule.");
// Test extracting carrier selection code.
metadata = Update(metadata).SetNationalPrefixForParsing("0(81)?").BuildPartial();
numberToStrip = new StringBuilder("08122123456");
strippedNumber = "22123456";
StringBuilder carrierCode = new StringBuilder();
Assert.True(phoneUtil.MaybeStripNationalPrefixAndCarrierCode(
numberToStrip, metadata, carrierCode));
Assert.AreEqual("81", carrierCode.ToString());
Assert.AreEqual(strippedNumber, numberToStrip.ToString(),
"Should have had national prefix and carrier code stripped.");
// If there was a transform rule, check it was applied.
// Note that a capturing group is present here.
metadata = Update(metadata).SetNationalPrefixTransformRule("5${1}5")
.SetNationalPrefixForParsing("0(\\d{2})").BuildPartial();
numberToStrip = new StringBuilder("031123");
String transformedNumber = "5315123";
Assert.True(phoneUtil.MaybeStripNationalPrefixAndCarrierCode(numberToStrip, metadata, null));
Assert.AreEqual(transformedNumber, numberToStrip.ToString(),
"Should transform the 031 to a 5315.");
}
/**
* Extracts the available formats from the provided DOM element. If it does not contain any
* nationalPrefixFormattingRule, the one passed-in is retained. The nationalPrefix,
* nationalPrefixFormattingRule and nationalPrefixOptionalWhenFormatting values are provided from
* the parent (territory) element.
*/
public static void LoadAvailableFormats(PhoneMetadata.Builder metadata,
XElement element, string nationalPrefix,
string nationalPrefixFormattingRule,
bool nationalPrefixOptionalWhenFormatting)
{
var carrierCodeFormattingRule = "";
if (element.HasAttribute(CARRIER_CODE_FORMATTING_RULE))
{
carrierCodeFormattingRule = ValidateRE(
GetDomesticCarrierCodeFormattingRuleFromElement(element, nationalPrefix));
}
var availableFormats = element.Element("availableFormats");
var hasExplicitIntlFormatDefined = false;
if (availableFormats != null && availableFormats.HasElements)
{
foreach (var numberFormatElement in availableFormats.Elements())
{
var format = new NumberFormat.Builder();
if (numberFormatElement.HasAttribute(NATIONAL_PREFIX_FORMATTING_RULE))
{
format.SetNationalPrefixFormattingRule(
GetNationalPrefixFormattingRuleFromElement(numberFormatElement, nationalPrefix));
}
else if (!nationalPrefixFormattingRule.Equals(""))
{
format.SetNationalPrefixFormattingRule(nationalPrefixFormattingRule);
}
if (numberFormatElement.HasAttribute(NATIONAL_PREFIX_OPTIONAL_WHEN_FORMATTING))
{
format.SetNationalPrefixOptionalWhenFormatting(
bool.Parse(numberFormatElement.Attribute(NATIONAL_PREFIX_OPTIONAL_WHEN_FORMATTING).Value));
}
else if (format.NationalPrefixOptionalWhenFormatting
!= nationalPrefixOptionalWhenFormatting)
{
// Inherit from the parent field if it is not already the same as the default.
format.SetNationalPrefixOptionalWhenFormatting(nationalPrefixOptionalWhenFormatting);
}
if (numberFormatElement.HasAttribute("carrierCodeFormattingRule"))
{
format.SetDomesticCarrierCodeFormattingRule(ValidateRE(
GetDomesticCarrierCodeFormattingRuleFromElement(
numberFormatElement, nationalPrefix)));
}
else if (!carrierCodeFormattingRule.Equals(""))
{
format.SetDomesticCarrierCodeFormattingRule(carrierCodeFormattingRule);
}
// Extract the pattern for the national format.
var nationalFormat =
LoadNationalFormat(metadata, numberFormatElement, format);
metadata.AddNumberFormat(format);
if (LoadInternationalFormat(metadata, numberFormatElement, nationalFormat))
{
hasExplicitIntlFormatDefined = true;
}
}
// Only a small number of regions need to specify the intlFormats in the xml. For the majority
// of countries the intlNumberFormat metadata is an exact copy of the national NumberFormat
// metadata. To minimize the size of the metadata file, we only keep intlNumberFormats that
// actually differ in some way to the national formats.
if (!hasExplicitIntlFormatDefined)
{
metadata.ClearIntlNumberFormat();
}
}
}
/**
* Extracts the available formats from the provided DOM element. If it does not contain any
* nationalPrefixFormattingRule, the one passed-in is retained. The nationalPrefix,
* nationalPrefixFormattingRule and nationalPrefixOptionalWhenFormatting values are provided from
* the parent (territory) element.
*/
// @VisibleForTesting
internal static void loadAvailableFormats(PhoneMetadata.Builder metadata,
XmlElement element, String nationalPrefix,
String nationalPrefixFormattingRule,
bool nationalPrefixOptionalWhenFormatting)
{
String carrierCodeFormattingRule = "";
if (element.HasAttribute(CARRIER_CODE_FORMATTING_RULE))
{
carrierCodeFormattingRule = validateRE(
getDomesticCarrierCodeFormattingRuleFromXmlElement(element, nationalPrefix));
}
var numberFormatXmlElements = element.GetElementsByTagName(NUMBER_FORMAT);
bool hasExplicitIntlFormatDefined = false;
int numOfFormatXmlElements = numberFormatXmlElements.Count;
if (numOfFormatXmlElements > 0)
{
for (int i = 0; i < numOfFormatXmlElements; i++)
{
XmlElement numberFormatXmlElement = (XmlElement)numberFormatXmlElements.Item(i);
NumberFormat.Builder format = NumberFormat.newBuilder();
if (numberFormatXmlElement.HasAttribute(NATIONAL_PREFIX_FORMATTING_RULE))
{
format.setNationalPrefixFormattingRule(
getNationalPrefixFormattingRuleFromXmlElement(numberFormatXmlElement, nationalPrefix));
}
else
{
format.setNationalPrefixFormattingRule(nationalPrefixFormattingRule);
}
if (format.HasNationalPrefixFormattingRule())
{
if (numberFormatXmlElement.HasAttribute(NATIONAL_PREFIX_OPTIONAL_WHEN_FORMATTING))
{
format.setNationalPrefixOptionalWhenFormatting(
Boolean.Parse(numberFormatXmlElement.GetAttribute(
NATIONAL_PREFIX_OPTIONAL_WHEN_FORMATTING)));
}
else
{
format.setNationalPrefixOptionalWhenFormatting(nationalPrefixOptionalWhenFormatting);
}
}
if (numberFormatXmlElement.HasAttribute(CARRIER_CODE_FORMATTING_RULE))
{
format.setDomesticCarrierCodeFormattingRule(validateRE(
getDomesticCarrierCodeFormattingRuleFromXmlElement(numberFormatXmlElement,
nationalPrefix)));
}
else
{
format.setDomesticCarrierCodeFormattingRule(carrierCodeFormattingRule);
}
loadNationalFormat(metadata, numberFormatXmlElement, format);
metadata.addNumberFormat(format);
if (loadInternationalFormat(metadata, numberFormatXmlElement, format.build()))
{
hasExplicitIntlFormatDefined = true;
}
}
// Only a small number of regions need to specify the intlFormats in the xml. For the majority
// of countries the intlNumberFormat metadata is an exact copy of the national NumberFormat
// metadata. To minimize the size of the metadata file, we only keep intlNumberFormats that
// actually differ in some way to the national formats.
if (!hasExplicitIntlFormatDefined)
{
metadata.clearIntlNumberFormat();
}
}
}
/**
* Clears certain fields in {@code metadata} as defined by the {@code MetadataFilter} instance.
* Note that this changes the mutable {@code metadata} object, and is not thread-safe. If this
* method does not return successfully, do not assume {@code metadata} has not changed.
*
* @param metadata The {@code PhoneMetadata} object to be filtered
*/
internal void FilterMetadata(PhoneMetadata.Builder metadata)
{
// TODO: Consider clearing if the filtered PhoneNumberDesc is empty.
if (metadata.HasFixedLine)
{
metadata.SetFixedLine(GetFiltered("fixedLine", metadata.FixedLine));
}
if (metadata.HasMobile)
{
metadata.SetMobile(GetFiltered("mobile", metadata.Mobile));
}
if (metadata.HasTollFree)
{
metadata.SetTollFree(GetFiltered("tollFree", metadata.TollFree));
}
if (metadata.HasPremiumRate)
{
metadata.SetPremiumRate(GetFiltered("premiumRate", metadata.PremiumRate));
}
if (metadata.HasSharedCost)
{
metadata.SetSharedCost(GetFiltered("sharedCost", metadata.SharedCost));
}
if (metadata.HasPersonalNumber)
{
metadata.SetPersonalNumber(GetFiltered("personalNumber", metadata.PersonalNumber));
}
if (metadata.HasVoip)
{
metadata.SetVoip(GetFiltered("voip", metadata.Voip));
}
if (metadata.HasPager)
{
metadata.SetPager(GetFiltered("pager", metadata.Pager));
}
if (metadata.HasUan)
{
metadata.SetUan(GetFiltered("uan", metadata.Uan));
}
if (metadata.HasEmergency)
{
metadata.SetEmergency(GetFiltered("emergency", metadata.Emergency));
}
if (metadata.HasVoicemail)
{
metadata.SetVoicemail(GetFiltered("voicemail", metadata.Voicemail));
}
if (metadata.HasShortCode)
{
metadata.SetShortCode(GetFiltered("shortCode", metadata.ShortCode));
}
if (metadata.HasStandardRate)
{
metadata.SetStandardRate(GetFiltered("standardRate", metadata.StandardRate));
}
if (metadata.HasCarrierSpecific)
{
metadata.SetCarrierSpecific(GetFiltered("carrierSpecific", metadata.CarrierSpecific));
}
if (metadata.HasSmsServices)
{
metadata.SetSmsServices(GetFiltered("smsServices", metadata.SmsServices));
}
if (metadata.HasNoInternationalDialling)
{
metadata.SetNoInternationalDialling(GetFiltered("noInternationalDialling",
metadata.NoInternationalDialling));
}
if (ShouldDrop("preferredInternationalPrefix"))
{
metadata.ClearPreferredInternationalPrefix();
}
if (ShouldDrop("nationalPrefix"))
{
metadata.ClearNationalPrefix();
}
if (ShouldDrop("preferredExtnPrefix"))
{
metadata.ClearPreferredExtnPrefix();
}
if (ShouldDrop("nationalPrefixTransformRule"))
{
metadata.ClearNationalPrefixTransformRule();
}
if (ShouldDrop("sameMobileAndFixedLinePattern"))
{
metadata.ClearSameMobileAndFixedLinePattern();
}
if (ShouldDrop("mainCountryForCode"))
{
metadata.ClearMainCountryForCode();
}
if (ShouldDrop("leadingZeroPossible"))
{
metadata.ClearLeadingZeroPossible();
}
if (ShouldDrop("mobileNumberPortableRegion"))
{
metadata.ClearMobileNumberPortableRegion();
}
}
public void TestLoadInternationalFormatExpectsOnlyOnePattern()
{
String xmlInput = "<numberFormat><intlFormat/><intlFormat/></numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
// Should throw an exception as multiple intlFormats are provided.
try
{
BuildMetadataFromXml.LoadInternationalFormat(metadata, numberFormatElement, "");
Assert.Fail();
}
catch (Exception)
{
// Test passed.
}
}
public void TestLoadInternationalFormatWithBothNationalAndIntlFormatsDefined()
{
String intlFormat = "$1 $2";
String xmlInput = "<numberFormat><intlFormat>" + intlFormat + "</intlFormat></numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
String nationalFormat = "$1";
Assert.True(BuildMetadataFromXml.LoadInternationalFormat(metadata, numberFormatElement,
nationalFormat));
Assert.AreEqual(intlFormat, metadata.IntlNumberFormatList[0].Format);
}
public void TestLoadGeneralDescSetsSameMobileAndFixedLinePattern()
{
String xmlInput =
"<territory countryCode=\"33\">" +
" <fixedLine><nationalNumberPattern>\\d{6}</nationalNumberPattern></fixedLine>" +
" <mobile><nationalNumberPattern>\\d{6}</nationalNumberPattern></mobile>" +
"</territory>";
XElement territoryElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
// Should set sameMobileAndFixedPattern to true.
BuildMetadataFromXml.LoadGeneralDesc(metadata, territoryElement, false);
Assert.True(metadata.SameMobileAndFixedLinePattern);
}
public void TestLoadInternationalFormatUsesNationalFormatByDefault()
{
String xmlInput = "<numberFormat></numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
String nationalFormat = "$1 $2 $3";
Assert.False(BuildMetadataFromXml.LoadInternationalFormat(metadata, numberFormatElement,
nationalFormat));
Assert.AreEqual(nationalFormat, metadata.IntlNumberFormatList[0].Format);
}
public void TestLoadAvailableFormatsHandlesMultipleNumberFormats()
{
String xmlInput =
"<territory>" +
" <availableFormats>" +
" <numberFormat><format>$1 $2 $3</format></numberFormat>" +
" <numberFormat><format>$1-$2</format></numberFormat>" +
" </availableFormats>" +
"</territory>";
XElement element = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
BuildMetadataFromXml.LoadAvailableFormats(
metadata, element, "0", "($1)", false /* NP not optional */);
Assert.AreEqual("$1 $2 $3", metadata.NumberFormatList[0].Format);
Assert.AreEqual("$1-$2", metadata.NumberFormatList[1].Format);
}
public void TestLoadInternationalFormatDoesNotSetIntlFormatWhenNA()
{
String xmlInput = "<numberFormat><intlFormat>NA</intlFormat></numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
String nationalFormat = "$1 $2";
BuildMetadataFromXml.LoadInternationalFormat(metadata, numberFormatElement, nationalFormat);
Assert.AreEqual(0, metadata.IntlNumberFormatCount);
}
public void TestLoadAvailableFormatsClearsIntlFormat()
{
String xmlInput =
"<territory>" +
" <availableFormats>" +
" <numberFormat><format>$1 $2 $3</format></numberFormat>" +
" </availableFormats>" +
"</territory>";
XElement element = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
BuildMetadataFromXml.LoadAvailableFormats(
metadata, element, "0", "($1)", false /* NP not optional */);
Assert.AreEqual(0, metadata.IntlNumberFormatCount);
}
public void TestLoadAvailableFormatsSetsProvidedNationalPrefixFormattingRule()
{
String xmlInput =
"<territory>" +
" <availableFormats>" +
" <numberFormat><format>$1 $2 $3</format></numberFormat>" +
" </availableFormats>" +
"</territory>";
XElement element = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
BuildMetadataFromXml.LoadAvailableFormats(
metadata, element, "0", "($1)", false /* NP not optional */);
Assert.AreEqual("($1)", metadata.NumberFormatList[0].NationalPrefixFormattingRule);
}
public void TestLoadAvailableFormatsPropagatesCarrierCodeFormattingRule()
{
String xmlInput =
"<territory carrierCodeFormattingRule='$NP $CC ($FG)'>" +
" <availableFormats>" +
" <numberFormat nationalPrefixFormattingRule='($FG)'>" +
" <format>$1 $2 $3</format>" +
" </numberFormat>" +
" </availableFormats>" +
"</territory>";
XElement element = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
BuildMetadataFromXml.LoadAvailableFormats(
metadata, element, "0", "", false /* NP not optional */);
Assert.AreEqual("(${1})", metadata.NumberFormatList[0].NationalPrefixFormattingRule);
Assert.AreEqual("0 $CC (${1})", metadata.NumberFormatList[0].DomesticCarrierCodeFormattingRule);
Assert.AreEqual("$1 $2 $3", metadata.NumberFormatList[0].Format);
}
/**
* Extracts the available formats from the provided DOM element. If it does not contain any
* nationalPrefixFormattingRule, the one passed-in is retained. The nationalPrefix,
* nationalPrefixFormattingRule and nationalPrefixOptionalWhenFormatting values are provided from
* the parent (territory) element.
*/
// @VisibleForTesting
public static void LoadAvailableFormats(PhoneMetadata.Builder metadata,
XElement element, String nationalPrefix,
String nationalPrefixFormattingRule,
bool nationalPrefixOptionalWhenFormatting)
{
String carrierCodeFormattingRule = "";
if (element.HasAttribute(CARRIER_CODE_FORMATTING_RULE))
{
carrierCodeFormattingRule = ValidateRE(
GetDomesticCarrierCodeFormattingRuleFromElement(element, nationalPrefix));
}
var numberFormatElements = element.GetElementsByTagName(NUMBER_FORMAT);
bool hasExplicitIntlFormatDefined = false;
int numOfFormatElements = numberFormatElements.Length;
if (numOfFormatElements > 0)
{
foreach (XElement numberFormatElement in numberFormatElements)
{
var format = new NumberFormat.Builder();
if (numberFormatElement.HasAttribute(NATIONAL_PREFIX_FORMATTING_RULE))
{
format.SetNationalPrefixFormattingRule(
GetNationalPrefixFormattingRuleFromElement(numberFormatElement, nationalPrefix));
format.SetNationalPrefixOptionalWhenFormatting(
numberFormatElement.HasAttribute(NATIONAL_PREFIX_OPTIONAL_WHEN_FORMATTING));
}
else
{
format.SetNationalPrefixFormattingRule(nationalPrefixFormattingRule);
format.SetNationalPrefixOptionalWhenFormatting(nationalPrefixOptionalWhenFormatting);
}
if (numberFormatElement.HasAttribute("carrierCodeFormattingRule"))
{
format.SetDomesticCarrierCodeFormattingRule(ValidateRE(
GetDomesticCarrierCodeFormattingRuleFromElement(
numberFormatElement, nationalPrefix)));
}
else
{
format.SetDomesticCarrierCodeFormattingRule(carrierCodeFormattingRule);
}
// Extract the pattern for the national format.
String nationalFormat =
LoadNationalFormat(metadata, numberFormatElement, format);
metadata.AddNumberFormat(format);
if (LoadInternationalFormat(metadata, numberFormatElement, nationalFormat))
{
hasExplicitIntlFormatDefined = true;
}
}
// Only a small number of regions need to specify the intlFormats in the xml. For the majority
// of countries the intlNumberFormat metadata is an exact copy of the national NumberFormat
// metadata. To minimize the size of the metadata file, we only keep intlNumberFormats that
// actually differ in some way to the national formats.
if (!hasExplicitIntlFormatDefined)
{
metadata.ClearIntlNumberFormat();
}
}
}
public void TestLoadGeneralDescSetsAllDescriptions()
{
String xmlInput =
"<territory countryCode=\"33\">" +
" <fixedLine><nationalNumberPattern>\\d{1}</nationalNumberPattern></fixedLine>" +
" <mobile><nationalNumberPattern>\\d{2}</nationalNumberPattern></mobile>" +
" <pager><nationalNumberPattern>\\d{3}</nationalNumberPattern></pager>" +
" <tollFree><nationalNumberPattern>\\d{4}</nationalNumberPattern></tollFree>" +
" <premiumRate><nationalNumberPattern>\\d{5}</nationalNumberPattern></premiumRate>" +
" <sharedCost><nationalNumberPattern>\\d{6}</nationalNumberPattern></sharedCost>" +
" <personalNumber><nationalNumberPattern>\\d{7}</nationalNumberPattern></personalNumber>" +
" <voip><nationalNumberPattern>\\d{8}</nationalNumberPattern></voip>" +
" <uan><nationalNumberPattern>\\d{9}</nationalNumberPattern></uan>" +
" <shortCode><nationalNumberPattern>\\d{10}</nationalNumberPattern></shortCode>" +
"</territory>";
XElement territoryElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
BuildMetadataFromXml.LoadGeneralDesc(metadata, territoryElement, false);
Assert.AreEqual("\\d{1}", metadata.FixedLine.NationalNumberPattern);
Assert.AreEqual("\\d{2}", metadata.Mobile.NationalNumberPattern);
Assert.AreEqual("\\d{3}", metadata.Pager.NationalNumberPattern);
Assert.AreEqual("\\d{4}", metadata.TollFree.NationalNumberPattern);
Assert.AreEqual("\\d{5}", metadata.PremiumRate.NationalNumberPattern);
Assert.AreEqual("\\d{6}", metadata.SharedCost.NationalNumberPattern);
Assert.AreEqual("\\d{7}", metadata.PersonalNumber.NationalNumberPattern);
Assert.AreEqual("\\d{8}", metadata.Voip.NationalNumberPattern);
Assert.AreEqual("\\d{9}", metadata.Uan.NationalNumberPattern);
}
public void TestLoadNationalFormatExpectsExactlyOneFormat()
{
String xmlInput = "<numberFormat><format/><format/></numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
NumberFormat.Builder numberFormat = new NumberFormat.Builder();
try
{
BuildMetadataFromXml.LoadNationalFormat(metadata, numberFormatElement, numberFormat);
Assert.Fail();
}
catch (Exception)
{
// Test passed.
}
}
public void TestLoadNationalFormat()
{
String nationalFormat = "$1 $2";
String xmlInput = String.Format("<numberFormat><format>{0}</format></numberFormat>",
nationalFormat);
XElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = new PhoneMetadata.Builder();
NumberFormat.Builder numberFormat = new NumberFormat.Builder();
Assert.AreEqual(nationalFormat,
BuildMetadataFromXml.LoadNationalFormat(metadata, numberFormatElement,
numberFormat));
}
