public static RegexBuilder WrapInNamedGroup(this RegexBuilder builder, string groupName)
{
return(new RegexBuilder()
.BeginNamedGroup(groupName)
.Concat(builder)
.EndNamedGroup());
}
public void Init()
{
var rMock = new Mock <IRegex>();
var rMock1 = new Mock <IRegex>();
rMock.Setup(x => x.Name).Returns("Test1");
rMock.Setup(x => x.Regex).Returns(@"\d{2}");
rMock1.Setup(x => x.Name).Returns("Test2");
rMock1.Setup(x => x.Regex).Returns(@"[a-z]");
var v = new Run("w").ContentStart;
var a = new RegexBuilder(new List <IRegex>()
{
rMock.Object, rMock1.Object
});
var b = new ExtendText()
{
StartText = v, Text = "Rest"
};
var c = new ExtendText()
{
StartText = v, Text = "123123"
};
_d = new MatchFinder(new List <ExtendText>()
{
b, c
}, a);
}
public void TestEscapingLiteralNodeRendering()
{
RegexNodeEscapingLiteral literal1 = new RegexNodeEscapingLiteral(@"\w\b.353\s");
Assert.AreEqual(@"\\w\\b\.353\\s", literal1.ToRegexPattern());
literal1.Quantifier = RegexQuantifier.ZeroOrOne;
Assert.AreEqual(@"(?:\\w\\b\.353\\s)?", literal1.ToRegexPattern());
RegexNodeEscapingLiteral literal2 = RegexBuilder.Literal(@"\w\b.353\s");
Assert.AreEqual(@"\\w\\b\.353\\s", literal2.ToRegexPattern());
RegexNodeEscapingLiteral literal3 = RegexBuilder.Literal(@"\w\b.353\s", RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"(?:\\w\\b\.353\\s)?", literal3.ToRegexPattern());
RegexNodeEscapingLiteral literal4 = RegexBuilder.Literal(@"a", RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"a?", literal4.ToRegexPattern());
RegexNodeEscapingLiteral literal5 = RegexBuilder.Literal(@"\", RegexQuantifier.ZeroOrOne);
Assert.AreEqual(@"\\?", literal5.ToRegexPattern());
}
public bool InitalizeFromCriteria(int numLetters, int minValid, int maxValid, RegexBuilderOptions regexOptions)
{
foundWords = new List <string>();
correctWords = new List <string>();
int attempts = 0;
while (true)
{
string word = dictionary.RandomWord(numLetters);
string regex = RegexBuilder.GetRegex(word, regexOptions);
List <char> listWord = new List <char>(word.ToCharArray());
constraint = new Constraint(regex, listWord);
correctWords = dictionary.GetMatchingConstraint(constraint);
if (correctWords.Count >= minValid && correctWords.Count <= maxValid)
{
break;
}
// Failsafe to prevent infinite loops
if (attempts > 100)
{
return(false);
}
attempts++;
}
return(true);
}
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 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 TestAnyOfWithSingleSubRegexBuilderArgument()
{
var regex = new RegexBuilder()
.AnyOf(r => r.Text("a"))
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"(?:a)"));
}
public void TestAnyCharacterWithQuantifier()
{
var regex = new RegexBuilder()
.AnyCharacter(OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@".+"));
}
public void TestAnyOfWithMultipleStringArguments()
{
var regex = new RegexBuilder()
.AnyOf("a", "b")
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"(?:a|b)"));
}
public void TestRegexText()
{
var regex = new RegexBuilder()
.RegexText("a*b")
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"a*b"));
}
private static RegexBuilder HtmlTag(RegexBuilder regexBuilder, string tagName, bool opening) =>
regexBuilder
.Text(opening ? "<" : "</")
.PossibleWhitespace()
.Text(tagName)
.WordBoundary()
.AnyCharacterExcept(">", ZeroOrMore)
.Text(">");
public void TestLowercaseLetterWithQuantifier()
{
var regex = new RegexBuilder()
.LowercaseLetter(OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"\p{Ll}+"));
}
public void TestNonHexDigitWithQuantifier()
{
var regex = new RegexBuilder()
.NonHexDigit(OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[^0-9A-Fa-f]+"));
}
public void TestNonHexDigit()
{
var regex = new RegexBuilder()
.NonHexDigit()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[^0-9A-Fa-f]"));
}
public void TestLowercaseHexDigitWithQuantifier()
{
var regex = new RegexBuilder()
.LowercaseHexDigit(OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[0-9a-f]+"));
}
public void TestLowercaseHexDigit()
{
var regex = new RegexBuilder()
.LowercaseHexDigit()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[0-9a-f]"));
}
public void TestRegexTextWithQuantifier()
{
var regex = new RegexBuilder()
.RegexText("a*b", OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"(?:a*b)+"));
}
public void TesNonLetterOrDigitWithQuantifier()
{
var regex = new RegexBuilder()
.NonLetterOrDigit(OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[^\p{L}0-9]+"));
}
public void TestNonLetterOrDigit()
{
var regex = new RegexBuilder()
.NonLetterOrDigit()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[^\p{L}0-9]"));
}
public void TestWhitespaceWithQuantifier()
{
var regex = new RegexBuilder()
.Whitespace(OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"\s+"));
}
public void TestNonWhitespace()
{
var regex = new RegexBuilder()
.NonWhitespace()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"\S"));
}
public void TestStartOfString()
{
var regex = new RegexBuilder()
.StartOfString()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"^"));
}
public void TestNonWordCharacter()
{
var regex = new RegexBuilder()
.NonWordCharacter()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[^\p{L}0-9_]"));
}
public void TestLowercaseLetter()
{
var regex = new RegexBuilder()
.LowercaseLetter()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"\p{Ll}"));
}
public void TestWordBoundary()
{
var regex = new RegexBuilder()
.WordBoundary()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"\b"));
}
public void TestNonWordCharacterWithQuantifier()
{
var regex = new RegexBuilder()
.NonWordCharacter(OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[^\p{L}0-9_]+"));
}
public void TestNonLetter()
{
var regex = new RegexBuilder()
.NonLetter()
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"\P{L}"));
}
public void TestAnyCharacterExceptWithQuantifier()
{
var regex = new RegexBuilder()
.AnyCharacterExcept("^]", OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[^\^\]]+"));
}
public void TestAnyCharacterExcept()
{
var regex = new RegexBuilder()
.AnyCharacterExcept("^]")
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"[^\^\]]"));
}
public void TestNonLetterWithQuantifier()
{
var regex = new RegexBuilder()
.NonLetter(OneOrMore)
.BuildRegex();
Assert.That(regex.ToString(), Is.EqualTo(@"\P{L}+"));
}
