public void TestComplexArgs()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"I don't {a,plural,other{w'{'on't #'#'}} and " +
"{b,select,other{shan't'}'}} '{'''know'''}' and " +
"{c,choice,0#can't'|'}" +
"{z,number,#'#'###.00'}'}.");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectTextThatContains("I don't ").
ExpectPluralArg("a").
ExpectVariant("other").
ExpectTextThatContains("w{on't ").ExpectReplaceNumber().
ExpectTextThatContains("#").FinishVariant().
finishComplexArg().
ExpectTextThatContains(" and ").
ExpectSelectArg("b").
ExpectVariant("other").ExpectTextThatContains("shan't}").FinishVariant().
finishComplexArg().
ExpectTextThatContains(" {'know'} and ").
ExpectChoiceArg("c").
ExpectVariant("#", 0).ExpectTextThatContains("can't|").FinishVariant().
finishComplexArg().
ExpectSimpleArg("z", "number", "#'#'###.00'}'").
ExpectTextThatContains(".");
expect.CheckMatches(msg);
}
public void TestSimpleArg()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode("a'{bc''de'f{0,number,g'hi''jk'l#}");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectTextThatContains("a{bc'def").ExpectSimpleArg(0, "number", "g'hi''jk'l#");
expect.CheckMatches(msg);
}
public void TestHelloWithApos()
{
// Literal ASCII apostrophe.
MessageNode msg = MessagePatternUtil.BuildMessageNode("Hel'lo!");
ExpectMessageNode expect = new ExpectMessageNode().ExpectTextThatContains("Hel'lo");
expect.CheckMatches(msg);
}
public void TestHello()
{
// No syntax.
MessageNode msg = MessagePatternUtil.BuildMessageNode("Hello!");
ExpectMessageNode expect = new ExpectMessageNode().ExpectTextThatContains("Hello");
expect.CheckMatches(msg);
}
public void TestPluralArg()
{
// Plural with only keywords.
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"abc{num_people, plural, offset:17 few{fff} other {oooo}}xyz");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectTextThatContains("abc").
ExpectPluralArg("num_people").
ExpectOffset(17).
ExpectVariant("few").ExpectTextThatContains("fff").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("oooo").FinishVariant().
finishComplexArg().
ExpectTextThatContains("xyz");
expect.CheckMatches(msg);
// Plural with explicit-value selectors.
msg = MessagePatternUtil.BuildMessageNode(
"abc{ num , plural , offset: 2 =1 {1} =-1 {-1} =3.14 {3.14} other {oo} }xyz");
expect = new ExpectMessageNode().
ExpectTextThatContains("abc").
ExpectPluralArg("num").
ExpectOffset(2).
ExpectVariant("=1", 1).ExpectTextThatContains("1").FinishVariant().
ExpectVariant("=-1", -1).ExpectTextThatContains("-1").FinishVariant().
ExpectVariant("=3.14", 3.14).ExpectTextThatContains("3.14").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("oo").FinishVariant().
finishComplexArg().
ExpectTextThatContains("xyz");
expect.CheckMatches(msg);
// Plural with number replacement.
msg = MessagePatternUtil.BuildMessageNode(
"a_{0,plural,other{num=#'#'=#'#'={1,number,##}!}}_z");
expect = new ExpectMessageNode().
ExpectTextThatContains("a_").
ExpectPluralArg(0).
ExpectVariant("other").
ExpectTextThatContains("num=").ExpectReplaceNumber().
ExpectTextThatContains("#=").ExpectReplaceNumber().
ExpectTextThatContains("#=").ExpectSimpleArg(1, "number", "##").
ExpectTextThatContains("!").FinishVariant().
finishComplexArg().
ExpectTextThatContains("_z");
expect.CheckMatches(msg);
// Plural with explicit offset:0.
msg = MessagePatternUtil.BuildMessageNode(
"a_{0,plural,offset:0 other{num=#!}}_z");
expect = new ExpectMessageNode().
ExpectTextThatContains("a_").
ExpectPluralArg(0).
ExpectOffset(0).
ExpectVariant("other").
ExpectTextThatContains("num=").ExpectReplaceNumber().
ExpectTextThatContains("!").FinishVariant().
finishComplexArg().
ExpectTextThatContains("_z");
expect.CheckMatches(msg);
}
public void TestSelectArg()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"abc{2, number}ghi{3, select, xx {xxx} other {ooo}} xyz");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectTextThatContains("abc").ExpectSimpleArg(2, "number").
ExpectTextThatContains("ghi").
ExpectSelectArg(3).
ExpectVariant("xx").ExpectTextThatContains("xxx").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("ooo").FinishVariant().
finishComplexArg().
ExpectTextThatContains(" xyz");
expect.CheckMatches(msg);
}
public void TestHelloWithQuote()
{
// Apostrophe starts quoted literal text.
MessageNode msg = MessagePatternUtil.BuildMessageNode("Hel'{o!");
ExpectMessageNode expect = new ExpectMessageNode().ExpectTextThatContains("Hel{o");
expect.CheckMatches(msg);
// Terminating the quote should yield the same result.
msg = MessagePatternUtil.BuildMessageNode("Hel'{'o!");
expect.CheckMatches(msg);
// Double apostrophe inside quoted literal text still encodes a single apostrophe.
msg = MessagePatternUtil.BuildMessageNode("a'{bc''de'f");
expect = new ExpectMessageNode().ExpectTextThatContains("a{bc'def");
expect.CheckMatches(msg);
}
public void TestPluralVariantsByType()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"{p,plural,a{A}other{O}=4{iv}b{B}other{U}=2{ii}}");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectPluralArg("p").
ExpectVariant("a").ExpectTextThatContains("A").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("O").FinishVariant().
ExpectVariant("=4", 4).ExpectTextThatContains("iv").FinishVariant().
ExpectVariant("b").ExpectTextThatContains("B").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("U").FinishVariant().
ExpectVariant("=2", 2).ExpectTextThatContains("ii").FinishVariant().
finishComplexArg();
if (!expect.Matches(msg))
{
return;
}
List <VariantNode> numericVariants = new List <VariantNode>();
List <VariantNode> keywordVariants = new List <VariantNode>();
VariantNode other =
((ArgNode)msg.GetContents()[0]).ComplexStyle.
GetVariantsByType(numericVariants, keywordVariants);
assertEquals("'other' selector", "other", other.Selector);
assertEquals("message string of first 'other'", "O", VariantText(other));
assertEquals("numericVariants.size()", 2, numericVariants.Count);
VariantNode v = numericVariants[0];
assertEquals("numericVariants[0] selector", "=4", v.Selector);
assertEquals("numericVariants[0] selector value", 4.0, v.SelectorValue);
assertEquals("numericVariants[0] text", "iv", VariantText(v));
v = numericVariants[1];
assertEquals("numericVariants[1] selector", "=2", v.Selector);
assertEquals("numericVariants[1] selector value", 2.0, v.SelectorValue);
assertEquals("numericVariants[1] text", "ii", VariantText(v));
assertEquals("keywordVariants.size()", 2, keywordVariants.Count);
v = keywordVariants[0];
assertEquals("keywordVariants[0] selector", "a", v.Selector);
assertFalse("keywordVariants[0].isSelectorNumeric()", v.IsSelectorNumeric);
assertEquals("keywordVariants[0] text", "A", VariantText(v));
v = keywordVariants[1];
assertEquals("keywordVariants[1] selector", "b", v.Selector);
assertFalse("keywordVariants[1].isSelectorNumeric()", v.IsSelectorNumeric);
assertEquals("keywordVariants[1] text", "B", VariantText(v));
}
public void TestChoiceArg()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"a_{0,choice,-∞ #-inf| 5≤ five | 99 # ninety'|'nine }_z");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectTextThatContains("a_").
ExpectChoiceArg(0).
ExpectVariant("#", double.NegativeInfinity).
ExpectTextThatContains("-inf").FinishVariant().
ExpectVariant("≤", 5).ExpectTextThatContains(" five ").FinishVariant().
ExpectVariant("#", 99).ExpectTextThatContains(" ninety|nine ").FinishVariant().
finishComplexArg().
ExpectTextThatContains("_z");
expect.CheckMatches(msg);
}
public void TestSelectOrdinalArg()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"abc{num, selectordinal, offset:17 =0{null} few{fff} other {oooo}}xyz");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectTextThatContains("abc").
ExpectSelectOrdinalArg("num").
ExpectOffset(17).
ExpectVariant("=0", 0).ExpectTextThatContains("null").FinishVariant().
ExpectVariant("few").ExpectTextThatContains("fff").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("oooo").FinishVariant().
finishComplexArg().
ExpectTextThatContains("xyz");
expect.CheckMatches(msg);
}
public void TestNoneArg()
{
// Numbered argument.
MessageNode msg = MessagePatternUtil.BuildMessageNode("abc{0}def");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectTextThatContains("abc").ExpectNoneArg(0).ExpectTextThatContains("def");
expect.CheckMatches(msg);
// Named argument.
msg = MessagePatternUtil.BuildMessageNode("abc{ arg }def");
expect = new ExpectMessageNode().
ExpectTextThatContains("abc").ExpectNoneArg("arg").ExpectTextThatContains("def");
expect.CheckMatches(msg);
// Numbered and named arguments.
msg = MessagePatternUtil.BuildMessageNode("abc{1}def{arg}ghi");
expect = new ExpectMessageNode().
ExpectTextThatContains("abc").ExpectNoneArg(1).ExpectTextThatContains("def").
ExpectNoneArg("arg").ExpectTextThatContains("ghi");
expect.CheckMatches(msg);
}
public void TestSelectVariantsByType()
{
MessageNode msg = MessagePatternUtil.BuildMessageNode(
"{s,select,a{A}other{O}b{B}other{U}}");
ExpectMessageNode expect = new ExpectMessageNode().
ExpectSelectArg("s").
ExpectVariant("a").ExpectTextThatContains("A").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("O").FinishVariant().
ExpectVariant("b").ExpectTextThatContains("B").FinishVariant().
ExpectVariant("other").ExpectTextThatContains("U").FinishVariant().
finishComplexArg();
if (!expect.Matches(msg))
{
return;
}
// Check that we can use numericVariants = null.
IList <VariantNode> keywordVariants = new List <VariantNode>();
VariantNode other =
((ArgNode)msg.GetContents()[0]).ComplexStyle.
GetVariantsByType(null, keywordVariants);
assertEquals("'other' selector", "other", other.Selector);
assertEquals("message string of first 'other'", "O", VariantText(other));
assertEquals("keywordVariants.size()", 2, keywordVariants.Count);
VariantNode v = keywordVariants[0];
assertEquals("keywordVariants[0] selector", "a", v.Selector);
assertFalse("keywordVariants[0].isSelectorNumeric()", v.IsSelectorNumeric);
assertEquals("keywordVariants[0] text", "A", VariantText(v));
v = keywordVariants[1];
assertEquals("keywordVariants[1] selector", "b", v.Selector);
assertFalse("keywordVariants[1].isSelectorNumeric()", v.IsSelectorNumeric);
assertEquals("keywordVariants[1] text", "B", VariantText(v));
}
