public void TestConditionalMatchNodeRendering()
{
RegexNodeLiteral condition = new RegexNodeLiteral(@"\w\s");
RegexNodeLiteral trueMatch = new RegexNodeLiteral(@"\w\s\d{5}-[^\u005c]+");
RegexNodeLiteral falseMatch = new RegexNodeLiteral(@"\d{5,}\u005d");
RegexNodeConditionalMatch conditionalMatch1 = new RegexNodeConditionalMatch(condition, trueMatch, falseMatch);
Assert.AreEqual(@"(?(\w\s)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)", conditionalMatch1.ToRegexPattern());
conditionalMatch1.Quantifier = RegexQuantifier.OneOrMore;
Assert.AreEqual(@"(?(\w\s)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)+", conditionalMatch1.ToRegexPattern());
RegexNodeConditionalMatch conditionalMatch2 = new RegexNodeConditionalMatch("SomeGroup", trueMatch, falseMatch);
Assert.AreEqual(@"(?(SomeGroup)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)", conditionalMatch2.ToRegexPattern());
conditionalMatch2.Quantifier = RegexQuantifier.OneOrMore;
Assert.AreEqual(@"(?(SomeGroup)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)+", conditionalMatch2.ToRegexPattern());
RegexNodeConditionalMatch conditionalMatch3 = RegexBuilder.ConditionalMatch(condition, trueMatch, falseMatch);
Assert.AreEqual(@"(?(\w\s)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)", conditionalMatch3.ToRegexPattern());
conditionalMatch3 = RegexBuilder.ConditionalMatch(condition, trueMatch, falseMatch, RegexQuantifier.OneOrMore);
Assert.AreEqual(@"(?(\w\s)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)+", conditionalMatch3.ToRegexPattern());
RegexNodeConditionalMatch conditionalMatch4 = RegexBuilder.ConditionalMatch("SomeGroup", trueMatch, falseMatch);
Assert.AreEqual(@"(?(SomeGroup)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)", conditionalMatch4.ToRegexPattern());
conditionalMatch4 = RegexBuilder.ConditionalMatch("SomeGroup", trueMatch, falseMatch, RegexQuantifier.OneOrMore);
Assert.AreEqual(@"(?(SomeGroup)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)+", conditionalMatch4.ToRegexPattern());
}
public void TestRegexNodeAdditionOperator6()
{
RegexNodeLiteral literal = new RegexNodeLiteral("\\w*");
RegexNode sum = null + literal;
Assert.IsNull(sum);
}
public void TestAlternationNodeRendering()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral(@"\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral(@"\d+");
RegexNodeLiteral literal3 = new RegexNodeLiteral(@"\s?");
RegexNodeAlternation alternation1 = new RegexNodeAlternation(literal1, literal2);
Assert.AreEqual(@"(?:\w*|\d+)", alternation1.ToRegexPattern());
RegexNodeAlternation alternation2 = new RegexNodeAlternation(literal1, literal2, literal3);
Assert.AreEqual(@"(?:\w*|\d+|\s?)", alternation2.ToRegexPattern());
RegexNodeAlternation alternation3 = RegexBuilder.Alternate(literal1, literal2);
Assert.AreEqual(@"(?:\w*|\d+)", alternation3.ToRegexPattern());
RegexNodeAlternation alternation4 = RegexBuilder.Alternate(new RegexNode[] { literal1, literal2, literal3 });
Assert.AreEqual(@"(?:\w*|\d+|\s?)", alternation4.ToRegexPattern());
RegexNodeAlternation alternation5 = new RegexNodeAlternation(literal1, literal2);
alternation5.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\w*|\d+)*", alternation5.ToRegexPattern());
RegexNodeAlternation alternation6 = new RegexNodeAlternation(literal1, literal2, literal3);
alternation6.Quantifier = RegexQuantifier.OneOrMore;
Assert.AreEqual(@"(?:\w*|\d+|\s?)+", alternation6.ToRegexPattern());
RegexNodeAlternation alternation7 = RegexBuilder.Alternate(literal1, literal2, RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"(?:\w*|\d+)?", alternation7.ToRegexPattern());
RegexNodeAlternation alternation8 = RegexBuilder.Alternate(new RegexNode[] { literal1, literal2, literal3 }, RegexQuantifier.AtLeast(5));
Assert.AreEqual(@"(?:\w*|\d+|\s?){5,}", alternation8.ToRegexPattern());
}
public void TestLiteralNodeRendering()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral(@"\w\b.353\s");
Assert.AreEqual(@"\w\b.353\s", literal1.ToRegexPattern());
literal1.Quantifier = RegexQuantifier.ZeroOrOne;
Assert.AreEqual(@"(?:\w\b.353\s)?", literal1.ToRegexPattern());
RegexNodeLiteral literal2 = RegexBuilder.NonEscapedLiteral(@"\w\b.353\s");
Assert.AreEqual(@"\w\b.353\s", literal2.ToRegexPattern());
RegexNodeLiteral literal3 = RegexBuilder.NonEscapedLiteral(@"\w\b.353\s", RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"(?:\w\b.353\s)?", literal3.ToRegexPattern());
RegexNodeLiteral literal4 = RegexBuilder.NonEscapedLiteral(@"\w", RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"\w?", literal4.ToRegexPattern());
RegexNodeLiteral literal5 = RegexBuilder.NonEscapedLiteral(@"a", RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"a*", literal5.ToRegexPattern());
}
public void TestQuantifierSetterForNodesWithQuantifierAllowed()
{
RegexNode node = new RegexNodeLiteral("Value");
RegexQuantifier quantifier = RegexQuantifier.OneOrMore;
node.Quantifier = quantifier;
Assert.AreEqual(quantifier, node.Quantifier);
}
public void TestConditionalMatchNodeNullAssignment1()
{
RegexNodeLiteral condition = new RegexNodeLiteral("a");
RegexNodeLiteral trueMatch = new RegexNodeLiteral("b");
RegexNodeConditionalMatch conditionalMatch = new RegexNodeConditionalMatch(condition, trueMatch, null);
Assert.IsNull(conditionalMatch);
}
public void TestConditionalMatchNodeNullAssignment2()
{
RegexNodeLiteral condition = new RegexNodeLiteral("a");
RegexNodeLiteral falseMatch = new RegexNodeLiteral("c");
RegexNodeConditionalMatch conditionalMatch = new RegexNodeConditionalMatch(condition, null, falseMatch);
Assert.IsNull(conditionalMatch);
}
public void TestConditionalMatchNodeNullAssignment3()
{
RegexNodeLiteral condition = new RegexNodeLiteral("a");
RegexNodeLiteral trueMatch = new RegexNodeLiteral("b");
RegexNodeLiteral falseMatch = new RegexNodeLiteral("c");
RegexNodeConditionalMatch conditionalMatch = new RegexNodeConditionalMatch(condition, trueMatch, falseMatch);
conditionalMatch.TrueMatchExpression = null;
conditionalMatch.FalseMatchExpression = null;
Assert.IsNull(conditionalMatch);
}
public void TestRegexNodeAdditionOperator1()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("\\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral("\\d+");
RegexNode sum = literal1 + literal2;
Assert.IsInstanceOfType(sum, typeof(RegexNodeConcatenation));
Assert.AreEqual(literal1, ((RegexNodeConcatenation)sum).ChildNodes[0]);
Assert.AreEqual(literal2, ((RegexNodeConcatenation)sum).ChildNodes[1]);
}
public void TestAlternationNodeConstruction()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("a");
RegexNodeLiteral literal2 = new RegexNodeLiteral("b");
RegexNodeAlternation alternation = new RegexNodeAlternation(literal1, literal2);
List<RegexNode> expressions = new List<RegexNode>(alternation.Expressions);
Assert.AreEqual(expressions.Count, 2);
Assert.AreEqual(expressions[0], literal1);
Assert.AreEqual(expressions[1], literal2);
}
public void TestAlternationNodeConstruction()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("a");
RegexNodeLiteral literal2 = new RegexNodeLiteral("b");
RegexNodeAlternation alternation = new RegexNodeAlternation(literal1, literal2);
List <RegexNode> expressions = new List <RegexNode>(alternation.Expressions);
Assert.AreEqual(expressions.Count, 2);
Assert.AreEqual(expressions[0], literal1);
Assert.AreEqual(expressions[1], literal2);
}
public void TestLookAroundNodeRendering()
{
RegexNodeLiteral lookupExpression = new RegexNodeLiteral(@"a\bc");
RegexNodeLiteral matchExpression = new RegexNodeLiteral(@"\w+");
RegexNodeLookAround positiveLookAhead = new RegexNodeLookAround(RegexLookAround.PositiveLookAhead, lookupExpression, matchExpression);
Assert.AreEqual(@"(?:\w+(?=a\bc))", positiveLookAhead.ToRegexPattern());
positiveLookAhead.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\w+(?=a\bc))*", positiveLookAhead.ToRegexPattern());
RegexNodeLookAround positiveLookBehind = new RegexNodeLookAround(RegexLookAround.PositiveLookBehind, lookupExpression, matchExpression);
Assert.AreEqual(@"(?:(?<=a\bc)\w+)", positiveLookBehind.ToRegexPattern());
positiveLookBehind.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:(?<=a\bc)\w+)*", positiveLookBehind.ToRegexPattern());
RegexNodeLookAround negativeLookAhead = new RegexNodeLookAround(RegexLookAround.NegativeLookAhead, lookupExpression, matchExpression);
Assert.AreEqual(@"(?:\w+(?!a\bc))", negativeLookAhead.ToRegexPattern());
negativeLookAhead.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\w+(?!a\bc))*", negativeLookAhead.ToRegexPattern());
RegexNodeLookAround negativeLookBehind = new RegexNodeLookAround(RegexLookAround.NegativeLookBehind, lookupExpression, matchExpression);
Assert.AreEqual(@"(?:(?<!a\bc)\w+)", negativeLookBehind.ToRegexPattern());
negativeLookBehind.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:(?<!a\bc)\w+)*", negativeLookBehind.ToRegexPattern());
RegexNodeLookAround positiveLookAhead2 = RegexBuilder.PositiveLookAhead(lookupExpression, matchExpression);
Assert.AreEqual(@"(?:\w+(?=a\bc))", positiveLookAhead2.ToRegexPattern());
positiveLookAhead2 = RegexBuilder.PositiveLookAhead(lookupExpression, matchExpression, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:\w+(?=a\bc))*", positiveLookAhead2.ToRegexPattern());
RegexNodeLookAround positiveLookBehind2 = RegexBuilder.PositiveLookBehind(lookupExpression, matchExpression);
Assert.AreEqual(@"(?:(?<=a\bc)\w+)", positiveLookBehind2.ToRegexPattern());
positiveLookBehind2 = RegexBuilder.PositiveLookBehind(lookupExpression, matchExpression, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:(?<=a\bc)\w+)*", positiveLookBehind2.ToRegexPattern());
RegexNodeLookAround negativeLookAhead2 = RegexBuilder.NegativeLookAhead(lookupExpression, matchExpression);
Assert.AreEqual(@"(?:\w+(?!a\bc))", negativeLookAhead2.ToRegexPattern());
negativeLookAhead2 = RegexBuilder.NegativeLookAhead(lookupExpression, matchExpression, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:\w+(?!a\bc))*", negativeLookAhead2.ToRegexPattern());
RegexNodeLookAround negativeLookBehind2 = RegexBuilder.NegativeLookBehind(lookupExpression, matchExpression);
Assert.AreEqual(@"(?:(?<!a\bc)\w+)", negativeLookBehind2.ToRegexPattern());
negativeLookBehind2 = RegexBuilder.NegativeLookBehind(lookupExpression, matchExpression, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:(?<!a\bc)\w+)*", negativeLookBehind2.ToRegexPattern());
}
public void TestConcatenationNodeNullChildAssignment2()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("a");
RegexNodeLiteral literal2 = new RegexNodeLiteral("b");
RegexNodeConcatenation concatenation = new RegexNodeConcatenation(literal1, literal2);
Assert.AreEqual(2, concatenation.ChildNodes.Count);
// ReSharper disable RedundantAssignment
// -- This line is expected to cause an exception.
concatenation = new RegexNodeConcatenation(null);
// ReSharper restore RedundantAssignment
}
public void TestConcatenationNodeRendering()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral(@"\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral(@"\d+");
RegexNodeLiteral literal3 = new RegexNodeLiteral(@"\s?");
RegexNodeLiteral literal4 = new RegexNodeLiteral(@"\t");
RegexNodeConcatenation concatenation1 = new RegexNodeConcatenation(literal1, literal2);
Assert.AreEqual(@"\w*\d+", concatenation1.ToRegexPattern());
RegexNodeConcatenation concatenation2 = new RegexNodeConcatenation(new List <RegexNode>(new[] { literal1, literal2 }));
Assert.AreEqual(@"\w*\d+", concatenation2.ToRegexPattern());
RegexNodeConcatenation concatenation3 = new RegexNodeConcatenation(literal1, literal2);
concatenation3.ChildNodes.Add(literal3);
Assert.AreEqual(@"\w*\d+\s?", concatenation3.ToRegexPattern());
concatenation3.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\w*\d+\s?)*", concatenation3.ToRegexPattern());
concatenation3 = new RegexNodeConcatenation(new List <RegexNode>(new[] { literal4, literal2, literal3, literal1 }));
concatenation3.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\t\d+\s?\w*)*", concatenation3.ToRegexPattern());
RegexNodeConcatenation concatenation4 = RegexBuilder.Concatenate(literal1, literal2);
Assert.AreEqual(@"\w*\d+", concatenation4.ToRegexPattern());
RegexNodeConcatenation concatenation5 = RegexBuilder.Concatenate(literal1, literal2, RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"(?:\w*\d+)?", concatenation5.ToRegexPattern());
RegexNodeConcatenation concatenation6 = RegexBuilder.Concatenate(literal1, literal2, literal3);
Assert.AreEqual(@"\w*\d+\s?", concatenation6.ToRegexPattern());
RegexNodeConcatenation concatenation7 = RegexBuilder.Concatenate(literal1, literal2, literal3, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:\w*\d+\s?)*", concatenation7.ToRegexPattern());
RegexNodeConcatenation concatenation8 = RegexBuilder.Concatenate(literal1, literal2, literal3, literal4);
Assert.AreEqual(@"\w*\d+\s?\t", concatenation8.ToRegexPattern());
RegexNodeConcatenation concatenation9 = RegexBuilder.Concatenate(literal1, literal2, literal3, literal4, RegexQuantifier.OneOrMore);
Assert.AreEqual(@"(?:\w*\d+\s?\t)+", concatenation9.ToRegexPattern());
}
public void TestRegexNodeAdditionOperator3()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("\\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral("\\d+");
RegexNodeConcatenation concatenation = new RegexNodeConcatenation(literal1, literal2);
RegexNodeLiteral literal3 = new RegexNodeLiteral("\\s?");
RegexNode sum = literal3 + concatenation;
Assert.IsInstanceOfType(sum, typeof(RegexNodeConcatenation));
Assert.AreNotSame(concatenation, sum);
Assert.AreEqual(literal3, ((RegexNodeConcatenation)sum).ChildNodes[0]);
Assert.AreEqual(literal1, ((RegexNodeConcatenation)sum).ChildNodes[1]);
Assert.AreEqual(literal2, ((RegexNodeConcatenation)sum).ChildNodes[2]);
}
public void TestBacktrackingSuppressionNodeRendering()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("\\w*");
RegexNodeBacktrackingSuppression suppression1 = new RegexNodeBacktrackingSuppression(literal1);
Assert.AreEqual("(?>\\w*)", suppression1.ToRegexPattern());
RegexNodeBacktrackingSuppression suppression2 = new RegexNodeBacktrackingSuppression(literal1);
suppression2.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(?>\\w*)*", suppression2.ToRegexPattern());
RegexNodeBacktrackingSuppression suppression3 = RegexBuilder.BacktrackingSuppression(literal1);
Assert.AreEqual("(?>\\w*)", suppression3.ToRegexPattern());
RegexNodeBacktrackingSuppression suppression4 = RegexBuilder.BacktrackingSuppression(literal1, RegexQuantifier.ZeroOrMore);
suppression4.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(?>\\w*)*", suppression2.ToRegexPattern());
}
public void TestInlineOptionNodeRendering()
{
RegexNodeLiteral literal = new RegexNodeLiteral(@"ab\wc{0}");
RegexNodeInlineOption option1 = new RegexNodeInlineOption(RegexOptions.IgnoreCase, literal);
Assert.AreEqual(@"(?i:ab\wc{0})", option1.ToRegexPattern());
RegexNodeInlineOption option2 = new RegexNodeInlineOption(RegexOptions.Singleline | RegexOptions.IgnoreCase, literal);
Assert.AreEqual(@"(?is:ab\wc{0})", option2.ToRegexPattern());
RegexNodeInlineOption option3 = new RegexNodeInlineOption(RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace, literal);
Assert.AreEqual(@"(?mx:ab\wc{0})", option3.ToRegexPattern());
RegexNodeInlineOption option4 = new RegexNodeInlineOption(RegexOptions.ExplicitCapture | RegexOptions.IgnorePatternWhitespace, literal);
Assert.AreEqual(@"(?nx:ab\wc{0})", option4.ToRegexPattern());
}
public void TestRegexNodeAdditionOperator4()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("\\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral("\\d+");
RegexNodeConcatenation concatenation1 = new RegexNodeConcatenation(literal1, literal2);
RegexNodeLiteral literal3 = new RegexNodeLiteral("\\W*");
RegexNodeLiteral literal4 = new RegexNodeLiteral("\\t+");
RegexNodeConcatenation concatenation2 = new RegexNodeConcatenation(literal3, literal4);
RegexNode sum = concatenation1 + concatenation2;
Assert.IsInstanceOfType(sum, typeof(RegexNodeConcatenation));
Assert.AreNotSame(concatenation1, sum);
Assert.AreNotSame(concatenation2, sum);
Assert.AreEqual(literal1, ((RegexNodeConcatenation)sum).ChildNodes[0]);
Assert.AreEqual(literal2, ((RegexNodeConcatenation)sum).ChildNodes[1]);
Assert.AreEqual(literal3, ((RegexNodeConcatenation)sum).ChildNodes[2]);
Assert.AreEqual(literal4, ((RegexNodeConcatenation)sum).ChildNodes[3]);
}
public void TestAlternationNodeRendering()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral(@"\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral(@"\d+");
RegexNodeLiteral literal3 = new RegexNodeLiteral(@"\s?");
RegexNodeAlternation alternation1 = new RegexNodeAlternation(literal1, literal2);
Assert.AreEqual(@"(?:\w*|\d+)", alternation1.ToRegexPattern());
RegexNodeAlternation alternation2 = new RegexNodeAlternation(literal1, literal2, literal3);
Assert.AreEqual(@"(?:\w*|\d+|\s?)", alternation2.ToRegexPattern());
RegexNodeAlternation alternation3 = RegexBuilder.Alternate(literal1, literal2);
Assert.AreEqual(@"(?:\w*|\d+)", alternation3.ToRegexPattern());
RegexNodeAlternation alternation4 = RegexBuilder.Alternate(new RegexNode[] { literal1, literal2, literal3 });
Assert.AreEqual(@"(?:\w*|\d+|\s?)", alternation4.ToRegexPattern());
RegexNodeAlternation alternation5 = new RegexNodeAlternation(literal1, literal2);
alternation5.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\w*|\d+)*", alternation5.ToRegexPattern());
RegexNodeAlternation alternation6 = new RegexNodeAlternation(literal1, literal2, literal3);
alternation6.Quantifier = RegexQuantifier.OneOrMore;
Assert.AreEqual(@"(?:\w*|\d+|\s?)+", alternation6.ToRegexPattern());
RegexNodeAlternation alternation7 = RegexBuilder.Alternate(literal1, literal2, RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"(?:\w*|\d+)?", alternation7.ToRegexPattern());
RegexNodeAlternation alternation8 = RegexBuilder.Alternate(new RegexNode[] { literal1, literal2, literal3 }, RegexQuantifier.AtLeast(5));
Assert.AreEqual(@"(?:\w*|\d+|\s?){5,}", alternation8.ToRegexPattern());
}
public void TestGroupNodeRendering()
{
RegexNodeLiteral literal = new RegexNodeLiteral("abc");
RegexNodeGroup group1 = new RegexNodeGroup(literal);
Assert.AreEqual("(abc)", group1.ToRegexPattern());
group1.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(abc)*", group1.ToRegexPattern());
RegexNodeGroup group2 = new RegexNodeGroup(literal, false);
Assert.AreEqual("(?:abc)", group2.ToRegexPattern());
group2.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(?:abc)*", group2.ToRegexPattern());
RegexNodeGroup group3 = new RegexNodeGroup(literal, "SomeGroup");
Assert.AreEqual("(?<SomeGroup>abc)", group3.ToRegexPattern());
group3.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(?<SomeGroup>abc)*", group3.ToRegexPattern());
RegexNodeGroup group4 = RegexBuilder.Group(literal);
Assert.AreEqual("(abc)", group4.ToRegexPattern());
group4 = RegexBuilder.Group(literal, RegexQuantifier.ZeroOrMore);
Assert.AreEqual("(abc)*", group4.ToRegexPattern());
RegexNodeGroup group5 = RegexBuilder.NonCapturingGroup(literal);
Assert.AreEqual("(?:abc)", group5.ToRegexPattern());
group5 = RegexBuilder.NonCapturingGroup(literal, RegexQuantifier.ZeroOrMore);
Assert.AreEqual("(?:abc)*", group5.ToRegexPattern());
RegexNodeGroup group6 = RegexBuilder.Group("SomeGroup", literal);
Assert.AreEqual("(?<SomeGroup>abc)", group6.ToRegexPattern());
group6 = RegexBuilder.Group("SomeGroup", literal, RegexQuantifier.ZeroOrMore);
Assert.AreEqual("(?<SomeGroup>abc)*", group6.ToRegexPattern());
}
public void TestBacktrackingSuppressionNodeRendering()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("\\w*");
RegexNodeBacktrackingSuppression suppression1 = new RegexNodeBacktrackingSuppression(literal1);
Assert.AreEqual("(?>\\w*)", suppression1.ToRegexPattern());
RegexNodeBacktrackingSuppression suppression2 = new RegexNodeBacktrackingSuppression(literal1);
suppression2.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(?>\\w*)*", suppression2.ToRegexPattern());
RegexNodeBacktrackingSuppression suppression3 = RegexBuilder.BacktrackingSuppression(literal1);
Assert.AreEqual("(?>\\w*)", suppression3.ToRegexPattern());
RegexNodeBacktrackingSuppression suppression4 = RegexBuilder.BacktrackingSuppression(literal1, RegexQuantifier.ZeroOrMore);
suppression4.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(?>\\w*)*", suppression2.ToRegexPattern());
}
public void TestRegexNodeAdditionOperator6()
{
RegexNodeLiteral literal = new RegexNodeLiteral("\\w*");
RegexNode sum = null + literal;
Assert.IsNull(sum);
}
public void TestRegexNodeAdditionOperator4()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("\\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral("\\d+");
RegexNodeConcatenation concatenation1 = new RegexNodeConcatenation(literal1, literal2);
RegexNodeLiteral literal3 = new RegexNodeLiteral("\\W*");
RegexNodeLiteral literal4 = new RegexNodeLiteral("\\t+");
RegexNodeConcatenation concatenation2 = new RegexNodeConcatenation(literal3, literal4);
RegexNode sum = concatenation1 + concatenation2;
Assert.IsInstanceOfType(sum, typeof(RegexNodeConcatenation));
Assert.AreNotSame(concatenation1, sum);
Assert.AreNotSame(concatenation2, sum);
Assert.AreEqual(literal1, ((RegexNodeConcatenation)sum).ChildNodes[0]);
Assert.AreEqual(literal2, ((RegexNodeConcatenation)sum).ChildNodes[1]);
Assert.AreEqual(literal3, ((RegexNodeConcatenation)sum).ChildNodes[2]);
Assert.AreEqual(literal4, ((RegexNodeConcatenation)sum).ChildNodes[3]);
}
public void TestRegexNodeAdditionOperator3()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("\\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral("\\d+");
RegexNodeConcatenation concatenation = new RegexNodeConcatenation(literal1, literal2);
RegexNodeLiteral literal3 = new RegexNodeLiteral("\\s?");
RegexNode sum = literal3 + concatenation;
Assert.IsInstanceOfType(sum, typeof(RegexNodeConcatenation));
Assert.AreNotSame(concatenation, sum);
Assert.AreEqual(literal3, ((RegexNodeConcatenation)sum).ChildNodes[0]);
Assert.AreEqual(literal1, ((RegexNodeConcatenation)sum).ChildNodes[1]);
Assert.AreEqual(literal2, ((RegexNodeConcatenation)sum).ChildNodes[2]);
}
public void TestRegexNodeAdditionOperator1()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("\\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral("\\d+");
RegexNode sum = literal1 + literal2;
Assert.IsInstanceOfType(sum, typeof(RegexNodeConcatenation));
Assert.AreEqual(literal1, ((RegexNodeConcatenation)sum).ChildNodes[0]);
Assert.AreEqual(literal2, ((RegexNodeConcatenation)sum).ChildNodes[1]);
}
public void TestQuantifierSetterForNodesWithQuantifierAllowed()
{
RegexNode node = new RegexNodeLiteral("Value");
RegexQuantifier quantifier = RegexQuantifier.OneOrMore;
node.Quantifier = quantifier;
Assert.AreEqual(quantifier, node.Quantifier);
}
public void TestConditionalMatchNodeNullAssignment3()
{
RegexNodeLiteral condition = new RegexNodeLiteral("a");
RegexNodeLiteral trueMatch = new RegexNodeLiteral("b");
RegexNodeLiteral falseMatch = new RegexNodeLiteral("c");
RegexNodeConditionalMatch conditionalMatch = new RegexNodeConditionalMatch(condition, trueMatch, falseMatch);
conditionalMatch.TrueMatchExpression = null;
conditionalMatch.FalseMatchExpression = null;
Assert.IsNull(conditionalMatch);
}
public void TestConditionalMatchNodeNullAssignment2()
{
RegexNodeLiteral condition = new RegexNodeLiteral("a");
RegexNodeLiteral falseMatch = new RegexNodeLiteral("c");
RegexNodeConditionalMatch conditionalMatch = new RegexNodeConditionalMatch(condition, null, falseMatch);
Assert.IsNull(conditionalMatch);
}
public void TestConditionalMatchNodeRendering()
{
RegexNodeLiteral condition = new RegexNodeLiteral(@"\w\s");
RegexNodeLiteral trueMatch = new RegexNodeLiteral(@"\w\s\d{5}-[^\u005c]+");
RegexNodeLiteral falseMatch = new RegexNodeLiteral(@"\d{5,}\u005d");
RegexNodeConditionalMatch conditionalMatch1 = new RegexNodeConditionalMatch(condition, trueMatch, falseMatch);
Assert.AreEqual(@"(?(\w\s)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)", conditionalMatch1.ToRegexPattern());
conditionalMatch1.Quantifier = RegexQuantifier.OneOrMore;
Assert.AreEqual(@"(?(\w\s)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)+", conditionalMatch1.ToRegexPattern());
RegexNodeConditionalMatch conditionalMatch2 = new RegexNodeConditionalMatch("SomeGroup", trueMatch, falseMatch);
Assert.AreEqual(@"(?(SomeGroup)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)", conditionalMatch2.ToRegexPattern());
conditionalMatch2.Quantifier = RegexQuantifier.OneOrMore;
Assert.AreEqual(@"(?(SomeGroup)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)+", conditionalMatch2.ToRegexPattern());
RegexNodeConditionalMatch conditionalMatch3 = RegexBuilder.ConditionalMatch(condition, trueMatch, falseMatch);
Assert.AreEqual(@"(?(\w\s)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)", conditionalMatch3.ToRegexPattern());
conditionalMatch3 = RegexBuilder.ConditionalMatch(condition, trueMatch, falseMatch, RegexQuantifier.OneOrMore);
Assert.AreEqual(@"(?(\w\s)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)+", conditionalMatch3.ToRegexPattern());
RegexNodeConditionalMatch conditionalMatch4 = RegexBuilder.ConditionalMatch("SomeGroup", trueMatch, falseMatch);
Assert.AreEqual(@"(?(SomeGroup)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)", conditionalMatch4.ToRegexPattern());
conditionalMatch4 = RegexBuilder.ConditionalMatch("SomeGroup", trueMatch, falseMatch, RegexQuantifier.OneOrMore);
Assert.AreEqual(@"(?(SomeGroup)\w\s\d{5}-[^\u005c]+|\d{5,}\u005d)+", conditionalMatch4.ToRegexPattern());
}
public void TestConditionalMatchNodeNullAssignment1()
{
RegexNodeLiteral condition = new RegexNodeLiteral("a");
RegexNodeLiteral trueMatch = new RegexNodeLiteral("b");
RegexNodeConditionalMatch conditionalMatch = new RegexNodeConditionalMatch(condition, trueMatch, null);
Assert.IsNull(conditionalMatch);
}
public void TestConcatenationNodeNullChildAssignment2()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral("a");
RegexNodeLiteral literal2 = new RegexNodeLiteral("b");
RegexNodeConcatenation concatenation = new RegexNodeConcatenation(literal1, literal2);
Assert.AreEqual(2, concatenation.ChildNodes.Count);
// ReSharper disable RedundantAssignment
// -- This line is expected to cause an exception.
concatenation = new RegexNodeConcatenation(null);
// ReSharper restore RedundantAssignment
}
public void TestConcatenationNodeRendering()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral(@"\w*");
RegexNodeLiteral literal2 = new RegexNodeLiteral(@"\d+");
RegexNodeLiteral literal3 = new RegexNodeLiteral(@"\s?");
RegexNodeLiteral literal4 = new RegexNodeLiteral(@"\t");
RegexNodeConcatenation concatenation1 = new RegexNodeConcatenation(literal1, literal2);
Assert.AreEqual(@"\w*\d+", concatenation1.ToRegexPattern());
RegexNodeConcatenation concatenation2 = new RegexNodeConcatenation(new List<RegexNode>(new[] { literal1, literal2 }));
Assert.AreEqual(@"\w*\d+", concatenation2.ToRegexPattern());
RegexNodeConcatenation concatenation3 = new RegexNodeConcatenation(literal1, literal2);
concatenation3.ChildNodes.Add(literal3);
Assert.AreEqual(@"\w*\d+\s?", concatenation3.ToRegexPattern());
concatenation3.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\w*\d+\s?)*", concatenation3.ToRegexPattern());
concatenation3 = new RegexNodeConcatenation(new List<RegexNode>(new[] { literal4, literal2, literal3, literal1 }));
concatenation3.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\t\d+\s?\w*)*", concatenation3.ToRegexPattern());
RegexNodeConcatenation concatenation4 = RegexBuilder.Concatenate(literal1, literal2);
Assert.AreEqual(@"\w*\d+", concatenation4.ToRegexPattern());
RegexNodeConcatenation concatenation5 = RegexBuilder.Concatenate(literal1, literal2, RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"(?:\w*\d+)?", concatenation5.ToRegexPattern());
RegexNodeConcatenation concatenation6 = RegexBuilder.Concatenate(literal1, literal2, literal3);
Assert.AreEqual(@"\w*\d+\s?", concatenation6.ToRegexPattern());
RegexNodeConcatenation concatenation7 = RegexBuilder.Concatenate(literal1, literal2, literal3, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:\w*\d+\s?)*", concatenation7.ToRegexPattern());
RegexNodeConcatenation concatenation8 = RegexBuilder.Concatenate(literal1, literal2, literal3, literal4);
Assert.AreEqual(@"\w*\d+\s?\t", concatenation8.ToRegexPattern());
RegexNodeConcatenation concatenation9 = RegexBuilder.Concatenate(literal1, literal2, literal3, literal4, RegexQuantifier.OneOrMore);
Assert.AreEqual(@"(?:\w*\d+\s?\t)+", concatenation9.ToRegexPattern());
}
public void TestGroupNodeRendering()
{
RegexNodeLiteral literal = new RegexNodeLiteral("abc");
RegexNodeGroup group1 = new RegexNodeGroup(literal);
Assert.AreEqual("(abc)", group1.ToRegexPattern());
group1.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(abc)*", group1.ToRegexPattern());
RegexNodeGroup group2 = new RegexNodeGroup(literal, false);
Assert.AreEqual("(?:abc)", group2.ToRegexPattern());
group2.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(?:abc)*", group2.ToRegexPattern());
RegexNodeGroup group3 = new RegexNodeGroup(literal, "SomeGroup");
Assert.AreEqual("(?<SomeGroup>abc)", group3.ToRegexPattern());
group3.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual("(?<SomeGroup>abc)*", group3.ToRegexPattern());
RegexNodeGroup group4 = RegexBuilder.Group(literal);
Assert.AreEqual("(abc)", group4.ToRegexPattern());
group4 = RegexBuilder.Group(literal, RegexQuantifier.ZeroOrMore);
Assert.AreEqual("(abc)*", group4.ToRegexPattern());
RegexNodeGroup group5 = RegexBuilder.NonCapturingGroup(literal);
Assert.AreEqual("(?:abc)", group5.ToRegexPattern());
group5 = RegexBuilder.NonCapturingGroup(literal, RegexQuantifier.ZeroOrMore);
Assert.AreEqual("(?:abc)*", group5.ToRegexPattern());
RegexNodeGroup group6 = RegexBuilder.Group("SomeGroup", literal);
Assert.AreEqual("(?<SomeGroup>abc)", group6.ToRegexPattern());
group6 = RegexBuilder.Group("SomeGroup", literal, RegexQuantifier.ZeroOrMore);
Assert.AreEqual("(?<SomeGroup>abc)*", group6.ToRegexPattern());
}
public void TestInlineOptionNodeRendering()
{
RegexNodeLiteral literal = new RegexNodeLiteral(@"ab\wc{0}");
RegexNodeInlineOption option1 = new RegexNodeInlineOption(RegexOptions.IgnoreCase, literal);
Assert.AreEqual(@"(?i:ab\wc{0})", option1.ToRegexPattern());
RegexNodeInlineOption option2 = new RegexNodeInlineOption(RegexOptions.Singleline | RegexOptions.IgnoreCase, literal);
Assert.AreEqual(@"(?is:ab\wc{0})", option2.ToRegexPattern());
RegexNodeInlineOption option3 = new RegexNodeInlineOption(RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace, literal);
Assert.AreEqual(@"(?mx:ab\wc{0})", option3.ToRegexPattern());
RegexNodeInlineOption option4 = new RegexNodeInlineOption(RegexOptions.ExplicitCapture | RegexOptions.IgnorePatternWhitespace, literal);
Assert.AreEqual(@"(?nx:ab\wc{0})", option4.ToRegexPattern());
}
public void TestLiteralNodeRendering()
{
RegexNodeLiteral literal1 = new RegexNodeLiteral(@"\w\b.353\s");
Assert.AreEqual(@"\w\b.353\s", literal1.ToRegexPattern());
literal1.Quantifier = RegexQuantifier.ZeroOrOne;
Assert.AreEqual(@"(?:\w\b.353\s)?", literal1.ToRegexPattern());
RegexNodeLiteral literal2 = RegexBuilder.NonEscapedLiteral(@"\w\b.353\s");
Assert.AreEqual(@"\w\b.353\s", literal2.ToRegexPattern());
RegexNodeLiteral literal3 = RegexBuilder.NonEscapedLiteral(@"\w\b.353\s", RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"(?:\w\b.353\s)?", literal3.ToRegexPattern());
RegexNodeLiteral literal4 = RegexBuilder.NonEscapedLiteral(@"\w", RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"\w?", literal4.ToRegexPattern());
RegexNodeLiteral literal5 = RegexBuilder.NonEscapedLiteral(@"a", RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"a*", literal5.ToRegexPattern());
}
public void TestLookAroundNodeRendering()
{
RegexNodeLiteral lookupExpression = new RegexNodeLiteral(@"a\bc");
RegexNodeLiteral matchExpression = new RegexNodeLiteral(@"\w+");
RegexNodeLookAround positiveLookAhead = new RegexNodeLookAround(RegexLookAround.PositiveLookAhead, lookupExpression, matchExpression);
Assert.AreEqual(@"(?:\w+(?=a\bc))", positiveLookAhead.ToRegexPattern());
positiveLookAhead.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\w+(?=a\bc))*", positiveLookAhead.ToRegexPattern());
RegexNodeLookAround positiveLookBehind = new RegexNodeLookAround(RegexLookAround.PositiveLookBehind, lookupExpression, matchExpression);
Assert.AreEqual(@"(?:(?<=a\bc)\w+)", positiveLookBehind.ToRegexPattern());
positiveLookBehind.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:(?<=a\bc)\w+)*", positiveLookBehind.ToRegexPattern());
RegexNodeLookAround negativeLookAhead = new RegexNodeLookAround(RegexLookAround.NegativeLookAhead, lookupExpression, matchExpression);
Assert.AreEqual(@"(?:\w+(?!a\bc))", negativeLookAhead.ToRegexPattern());
negativeLookAhead.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:\w+(?!a\bc))*", negativeLookAhead.ToRegexPattern());
RegexNodeLookAround negativeLookBehind = new RegexNodeLookAround(RegexLookAround.NegativeLookBehind, lookupExpression, matchExpression);
Assert.AreEqual(@"(?:(?<!a\bc)\w+)", negativeLookBehind.ToRegexPattern());
negativeLookBehind.Quantifier = RegexQuantifier.ZeroOrMore;
Assert.AreEqual(@"(?:(?<!a\bc)\w+)*", negativeLookBehind.ToRegexPattern());
RegexNodeLookAround positiveLookAhead2 = RegexBuilder.PositiveLookAhead(lookupExpression, matchExpression);
Assert.AreEqual(@"(?:\w+(?=a\bc))", positiveLookAhead2.ToRegexPattern());
positiveLookAhead2 = RegexBuilder.PositiveLookAhead(lookupExpression, matchExpression, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:\w+(?=a\bc))*", positiveLookAhead2.ToRegexPattern());
RegexNodeLookAround positiveLookBehind2 = RegexBuilder.PositiveLookBehind(lookupExpression, matchExpression);
Assert.AreEqual(@"(?:(?<=a\bc)\w+)", positiveLookBehind2.ToRegexPattern());
positiveLookBehind2 = RegexBuilder.PositiveLookBehind(lookupExpression, matchExpression, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:(?<=a\bc)\w+)*", positiveLookBehind2.ToRegexPattern());
RegexNodeLookAround negativeLookAhead2 = RegexBuilder.NegativeLookAhead(lookupExpression, matchExpression);
Assert.AreEqual(@"(?:\w+(?!a\bc))", negativeLookAhead2.ToRegexPattern());
negativeLookAhead2 = RegexBuilder.NegativeLookAhead(lookupExpression, matchExpression, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:\w+(?!a\bc))*", negativeLookAhead2.ToRegexPattern());
RegexNodeLookAround negativeLookBehind2 = RegexBuilder.NegativeLookBehind(lookupExpression, matchExpression);
Assert.AreEqual(@"(?:(?<!a\bc)\w+)", negativeLookBehind2.ToRegexPattern());
negativeLookBehind2 = RegexBuilder.NegativeLookBehind(lookupExpression, matchExpression, RegexQuantifier.ZeroOrMore);
Assert.AreEqual(@"(?:(?<!a\bc)\w+)*", negativeLookBehind2.ToRegexPattern());
}
