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); }
internal ExpectVariantNode(ExpectComplexArgNode parent, String selector, double value) { this.selector = selector; numericValue = value; msg = new ExpectMessageNode(); msg.parent = parent; }
internal ExpectComplexArgNode(ExpectMessageNode parent, Object name, MessagePatternArgType argType) : base(name, argType.ToString().ToLowerInvariant()) { this.argType = argType; this.parent = parent; }
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)); }