[TestMethod] public void testLoadNationalFormat()
{
String nationalFormat = "$1 $2";
String xmlInput = String.Format("<numberFormat><format>{0}</format></numberFormat>",
nationalFormat);
XmlElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
NumberFormat.Builder numberFormat = NumberFormat.newBuilder();
BuildMetadataFromXml.loadNationalFormat(metadata, numberFormatElement, numberFormat);
Assert.AreEqual(nationalFormat, numberFormat.getFormat());
}
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();
Assert.ThrowsAny <Exception>(() =>
{
BuildMetadataFromXml.LoadNationalFormat(metadata, numberFormatElement, numberFormat);
});
}
public void TestLoadNationalFormat()
{
var nationalFormat = "$1 $2";
var xmlInput = string.Format("<numberFormat><format>{0}</format></numberFormat>",
nationalFormat);
var numberFormatElement = ParseXmlString(xmlInput);
var metadata = new PhoneMetadata.Builder();
var numberFormat = new NumberFormat.Builder();
Assert.Equal(nationalFormat,
BuildMetadataFromXml.LoadNationalFormat(metadata, numberFormatElement,
numberFormat));
}
[TestMethod] public void testLoadInternationalFormatDoesNotSetIntlFormatWhenNA()
{
String xmlInput = "<numberFormat><intlFormat>NA</intlFormat></numberFormat>";
XmlElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
NumberFormat.Builder nationalFormat = NumberFormat.newBuilder();
nationalFormat.setFormat("$1 $2");
BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
nationalFormat.build());
Assert.AreEqual(0, metadata.IntlNumberFormatSize());
}
// Tests setLeadingDigitsPatterns().
[TestMethod] public void testSetLeadingDigitsPatterns()
{
String xmlInput =
"<numberFormat>" +
"<leadingDigits>1</leadingDigits><leadingDigits>2</leadingDigits>" +
"</numberFormat>";
XmlElement numberFormatElement = parseXmlString(xmlInput);
NumberFormat.Builder numberFormat = NumberFormat.newBuilder();
BuildMetadataFromXml.setLeadingDigitsPatterns(numberFormatElement, numberFormat);
Assert.AreEqual("1", numberFormat.getLeadingDigitsPattern(0));
Assert.AreEqual("2", numberFormat.getLeadingDigitsPattern(1));
}
public void TestSetLeadingDigitsPatterns()
{
String xmlInput =
"<numberFormat>" +
"<leadingDigits>1</leadingDigits><leadingDigits>2</leadingDigits>" +
"</numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
NumberFormat.Builder numberFormat = new NumberFormat.Builder();
BuildMetadataFromXml.SetLeadingDigitsPatterns(numberFormatElement, numberFormat);
Assert.Equal("1", numberFormat.LeadingDigitsPatternList[0]);
Assert.Equal("2", numberFormat.LeadingDigitsPatternList[1]);
}
[TestMethod] public void testLoadInternationalFormatCopiesNationalFormatData()
{
String xmlInput = "<numberFormat></numberFormat>";
XmlElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
NumberFormat.Builder nationalFormat = NumberFormat.newBuilder();
nationalFormat.setFormat("$1-$2");
nationalFormat.setNationalPrefixOptionalWhenFormatting(true);
Assert.IsFalse(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
nationalFormat.build()));
Assert.IsTrue(metadata.getIntlNumberFormat(0).isNationalPrefixOptionalWhenFormatting());
}
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));
}
[TestMethod] public void testLoadInternationalFormatWithBothNationalAndIntlFormatsDefined()
{
String intlFormat = "$1 $2";
String xmlInput = "<numberFormat><intlFormat>" + intlFormat + "</intlFormat></numberFormat>";
XmlElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
NumberFormat.Builder nationalFormat = NumberFormat.newBuilder();
nationalFormat.setFormat("$1");
Assert.IsTrue(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
nationalFormat.build()));
Assert.AreEqual(intlFormat, metadata.getIntlNumberFormat(0).getFormat());
}
[TestMethod] public void testLoadInternationalFormatUsesNationalFormatByDefault()
{
String xmlInput = "<numberFormat></numberFormat>";
XmlElement numberFormatElement = parseXmlString(xmlInput);
PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
NumberFormat.Builder nationalFormat = NumberFormat.newBuilder();
String nationalPattern = "$1 $2 $3";
nationalFormat.setFormat(nationalPattern);
Assert.IsFalse(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
nationalFormat.build()));
Assert.AreEqual(nationalPattern, metadata.getIntlNumberFormat(0).getFormat());
}
public void TestLoadNationalFormatRequiresFormat()
{
var xmlInput = "<numberFormat></numberFormat>";
var numberFormatElement = parseXmlString(xmlInput);
var metadata = new PhoneMetadata.Builder();
var numberFormat = new NumberFormat.Builder();
try
{
BuildMetadataFromXml.LoadNationalFormat(metadata, numberFormatElement, numberFormat);
Assert.Fail();
}
catch (Exception)
{
// Test passed.
}
}
public void TestLoadNationalFormatExpectsExactlyOneFormat()
{
var xmlInput = "<numberFormat><format/><format/></numberFormat>";
var numberFormatElement = ParseXmlString(xmlInput);
var metadata = new PhoneMetadata.Builder();
var numberFormat = new NumberFormat.Builder();
try
{
BuildMetadataFromXml.LoadNationalFormat(metadata, numberFormatElement, numberFormat);
Assert.True(false);
}
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);
}
/**
* 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);
}
public void TestSetLeadingDigitsPatterns()
{
String xmlInput =
"<numberFormat>" +
"<leadingDigits>1</leadingDigits><leadingDigits>2</leadingDigits>" +
"</numberFormat>";
XElement numberFormatElement = parseXmlString(xmlInput);
NumberFormat.Builder numberFormat = new NumberFormat.Builder();
BuildMetadataFromXml.SetLeadingDigitsPatterns(numberFormatElement, numberFormat);
Assert.AreEqual("1", numberFormat.LeadingDigitsPatternList[0]);
Assert.AreEqual("2", numberFormat.LeadingDigitsPatternList[1]);
}
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));
}
/**
* 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();
}
}
}
// @VisibleForTesting
internal static void setLeadingDigitsPatterns(XmlElement numberFormatXmlElement, NumberFormat.Builder format)
{
var leadingDigitsPatternNodes = numberFormatXmlElement.GetElementsByTagName(LEADING_DIGITS);
int numOfLeadingDigitsPatterns = leadingDigitsPatternNodes.Count;
if (numOfLeadingDigitsPatterns > 0)
{
for (int i = 0; i < numOfLeadingDigitsPatterns; i++)
{
format.addLeadingDigitsPattern(
validateRE((leadingDigitsPatternNodes.Item(i)).FirstChild.Value, true));
}
}
}
public void TestFormatByPattern()
{
NumberFormat newNumFormat = new NumberFormat.Builder()
.SetPattern("(\\d{3})(\\d{3})(\\d{4})")
.SetFormat("($1) $2-$3").Build();
List<NumberFormat> newNumberFormats = new List<NumberFormat>();
newNumberFormats.Add(newNumFormat);
Assert.AreEqual("(650) 253-0000", phoneUtil.FormatByPattern(US_NUMBER, PhoneNumberFormat.NATIONAL,
newNumberFormats));
Assert.AreEqual("+1 (650) 253-0000", phoneUtil.FormatByPattern(US_NUMBER,
PhoneNumberFormat.INTERNATIONAL,
newNumberFormats));
Assert.AreEqual("tel:+1-650-253-0000", phoneUtil.FormatByPattern(US_NUMBER,
PhoneNumberFormat.RFC3966, newNumberFormats));
// $NP is set to '1' for the US. Here we check that for other NANPA countries the US rules are
// followed.
newNumberFormats[0] = Update(newNumberFormats[0])
.SetNationalPrefixFormattingRule("$NP ($FG)")
.SetFormat("$1 $2-$3").Build();
Assert.AreEqual("1 (242) 365-1234",
phoneUtil.FormatByPattern(BS_NUMBER, PhoneNumberFormat.NATIONAL,
newNumberFormats));
Assert.AreEqual("+1 242 365-1234",
phoneUtil.FormatByPattern(BS_NUMBER, PhoneNumberFormat.INTERNATIONAL,
newNumberFormats));
newNumberFormats[0] = Update(newNumberFormats[0])
.SetPattern("(\\d{2})(\\d{5})(\\d{3})")
.SetFormat("$1-$2 $3").Build();
Assert.AreEqual("02-36618 300",
phoneUtil.FormatByPattern(IT_NUMBER, PhoneNumberFormat.NATIONAL,
newNumberFormats));
Assert.AreEqual("+39 02-36618 300",
phoneUtil.FormatByPattern(IT_NUMBER, PhoneNumberFormat.INTERNATIONAL,
newNumberFormats));
newNumberFormats[0] = Update(newNumberFormats[0]).SetNationalPrefixFormattingRule("$NP$FG")
.SetPattern("(\\d{2})(\\d{4})(\\d{4})")
.SetFormat("$1 $2 $3").Build();
Assert.AreEqual("020 7031 3000",
phoneUtil.FormatByPattern(GB_NUMBER, PhoneNumberFormat.NATIONAL,
newNumberFormats));
newNumberFormats[0] = Update(newNumberFormats[0]).SetNationalPrefixFormattingRule("($NP$FG)").Build();
Assert.AreEqual("(020) 7031 3000",
phoneUtil.FormatByPattern(GB_NUMBER, PhoneNumberFormat.NATIONAL,
newNumberFormats));
newNumberFormats[0] = Update(newNumberFormats[0]).SetNationalPrefixFormattingRule("").Build();
Assert.AreEqual("20 7031 3000",
phoneUtil.FormatByPattern(GB_NUMBER, PhoneNumberFormat.NATIONAL,
newNumberFormats));
Assert.AreEqual("+44 20 7031 3000",
phoneUtil.FormatByPattern(GB_NUMBER, PhoneNumberFormat.INTERNATIONAL,
newNumberFormats));
}
