public void MultipleNamedCaptureParseCorrectly(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(2));
Assert.That(nodes[0], Is.InstanceOf<NamedCapture>());
Assert.That(nodes[1], Is.InstanceOf<NamedCapture>());
var namedCapture1 = (NamedCapture)nodes[0];
Assert.That(namedCapture1.Number, Is.EqualTo(1));
Assert.That(namedCapture1.Name, Is.EqualTo("foo"));
var children1 = namedCapture1.Children.ToList();
Assert.That(children1.Count, Is.EqualTo(3));
Assert.That(children1[0], Is.InstanceOf<CharacterLiteral>());
Assert.That(children1[1], Is.InstanceOf<CharacterLiteral>());
Assert.That(children1[2], Is.InstanceOf<CharacterLiteral>());
var namedCapture2 = (NamedCapture)nodes[1];
Assert.That(namedCapture2.Number, Is.EqualTo(2));
Assert.That(namedCapture2.Name, Is.EqualTo("bar"));
var children2 = namedCapture2.Children.ToList();
Assert.That(children2.Count, Is.EqualTo(3));
Assert.That(children2[0], Is.InstanceOf<CharacterLiteral>());
Assert.That(children2[1], Is.InstanceOf<CharacterLiteral>());
Assert.That(children2[2], Is.InstanceOf<CharacterLiteral>());
}
public void AnAlternationWithAllCharacterNodesChoicesParsesCorrectly()
{
const string pattern = @"abc|[0-9]|\s|.";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf<Alternation>());
var alternation = (Alternation) nodes[0];
var choices = alternation.Choices.ToList();
Assert.That(choices.Count, Is.EqualTo(4));
Assert.That(choices[0], Is.InstanceOf<AlternationChoice>());
Assert.That(choices[1], Is.InstanceOf<AlternationChoice>());
Assert.That(choices[2], Is.InstanceOf<AlternationChoice>());
Assert.That(choices[3], Is.InstanceOf<AlternationChoice>());
Assert.That(choices[0].Children.Count, Is.EqualTo(3));
Assert.That(choices[1].Children.Count, Is.EqualTo(1));
Assert.That(choices[2].Children.Count, Is.EqualTo(1));
Assert.That(choices[3].Children.Count, Is.EqualTo(1));
Assert.That(choices[0].Children[0], Is.InstanceOf<CharacterLiteral>());
Assert.That(choices[0].Children[1], Is.InstanceOf<CharacterLiteral>());
Assert.That(choices[0].Children[2], Is.InstanceOf<CharacterLiteral>());
Assert.That(choices[1].Children[0], Is.InstanceOf<CharacterClass>());
Assert.That(choices[2].Children[0], Is.InstanceOf<CharacterClassShorthand>());
Assert.That(choices[3].Children[0], Is.InstanceOf<Dot>());
}
public void Build()
{
RegexCompiler task = new RegexCompiler();
task.BuildEngine = new MockBuild();
task.OutputDirectory = TaskUtility.TestDirectory;
task.AssemblyName = "MSBuild.Community.RegularExpressions.dll";
task.AssemblyTitle = "MSBuild.Community.RegularExpressions";
task.AssemblyDescription = "MSBuild Community Tasks Regular Expressions";
task.AssemblyCompany = "MSBuildTasks";
task.AssemblyProduct = "MSBuildTasks";
task.AssemblyCopyright = "Copyright (c) MSBuildTasks 2008";
task.AssemblyVersion = "1.0.0.0";
task.AssemblyFileVersion = "1.0.0.0";
task.AssemblyInformationalVersion = "1.0.0.0";
task.AssemblyKeyFile = @"..\..\..\MSBuild.Community.Tasks\MSBuild.Community.Tasks.snk";
List<ITaskItem> expressions = new List<ITaskItem>();
TaskItem item1 = new TaskItem("TextRegex");
item1.SetMetadata("Pattern", @"\G[^<]+");
item1.SetMetadata("Options", "RegexOptions.Singleline | RegexOptions.Multiline");
item1.SetMetadata("IsPublic", "true");
TaskItem item2 = new TaskItem("CommentRegex");
item2.SetMetadata("Pattern", @"\G<%--(([^-]*)-)*?-%>");
item2.SetMetadata("Options", "RegexOptions.Singleline | RegexOptions.Multiline");
item2.SetMetadata("IsPublic", "true");
task.RegularExpressions = new ITaskItem[] {item1, item2};
bool result = task.Execute();
Assert.IsTrue(result);
}
public void NestedNamedCaptureParseCorrectly(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf <NamedCapture>());
var namedCapture1 = (NamedCapture)nodes[0];
Assert.That(namedCapture1.Number, Is.EqualTo(1));
Assert.That(namedCapture1.Name, Is.EqualTo("foo"));
var children1 = namedCapture1.Children;
Assert.That(children1.Count, Is.EqualTo(4));
Assert.That(children1[0], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[1], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[2], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[3], Is.InstanceOf <NamedCapture>());
var namedCapture2 = (NamedCapture)children1[3];
Assert.That(namedCapture2.Number, Is.EqualTo(2));
Assert.That(namedCapture2.Name, Is.EqualTo("bar"));
var children2 = namedCapture2.Children;
Assert.That(children2.Count, Is.EqualTo(3));
Assert.That(children2[0], Is.InstanceOf <CharacterLiteral>());
Assert.That(children2[1], Is.InstanceOf <CharacterLiteral>());
Assert.That(children2[2], Is.InstanceOf <CharacterLiteral>());
}
public object Any(StructureRequest request)
{
var compiler = new RegexCompiler();
StructureResponse response;
try
{
var regex = compiler.Compile(request.Pattern);
var regexDto = DtoMapper.Map <RegexNodeDto>(regex);
response = new StructureResponse {
Regex = regexDto
};
}
catch (Exception ex)
{
response = new StructureResponse {
ResponseStatus = new ResponseStatus(ex.GetType().Name, ex.Message)
{
StackTrace = ex.StackTrace
}
};
}
return(new HttpResult(response, ContentType.Json));
}
public void AnAlternationWithAllCharacterNodesChoicesParsesCorrectly()
{
const string pattern = @"abc|[0-9]|\s|.";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf <Alternation>());
var alternation = (Alternation)nodes[0];
var choices = alternation.Choices.ToList();
Assert.That(choices.Count, Is.EqualTo(4));
Assert.That(choices[0], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[1], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[2], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[3], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[0].Children.Count, Is.EqualTo(3));
Assert.That(choices[1].Children.Count, Is.EqualTo(1));
Assert.That(choices[2].Children.Count, Is.EqualTo(1));
Assert.That(choices[3].Children.Count, Is.EqualTo(1));
Assert.That(choices[0].Children[0], Is.InstanceOf <CharacterLiteral>());
Assert.That(choices[0].Children[1], Is.InstanceOf <CharacterLiteral>());
Assert.That(choices[0].Children[2], Is.InstanceOf <CharacterLiteral>());
Assert.That(choices[1].Children[0], Is.InstanceOf <CharacterClass>());
Assert.That(choices[2].Children[0], Is.InstanceOf <CharacterClassShorthand>());
Assert.That(choices[3].Children[0], Is.InstanceOf <Dot>());
}
public void CapturedAlternation()
{
const string pattern = @"(a|b)";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf <CapturingParens>());
var parens = (CapturingParens)nodes[0];
var parensChildren = parens.Children.ToList();
Assert.That(parensChildren.Count, Is.EqualTo(1));
Assert.That(parensChildren[0], Is.InstanceOf <Alternation>());
var alternation = (Alternation)parensChildren[0];
var choices = alternation.Choices.ToList();
Assert.That(choices.Count, Is.EqualTo(2));
Assert.That(choices[0], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[1], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[0].Children.Count, Is.EqualTo(1));
Assert.That(choices[1].Children.Count, Is.EqualTo(1));
Assert.That(choices[0].Children[0], Is.InstanceOf <CharacterLiteral>());
Assert.That(choices[1].Children[0], Is.InstanceOf <CharacterLiteral>());
}
public void CapturedChoices()
{
const string pattern = @"(a)(b)|(c)(d)|(e)(f)";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf <Alternation>());
var alternation = (Alternation)nodes[0];
var choices = alternation.Choices.ToList();
Assert.That(choices.Count, Is.EqualTo(3));
Assert.That(choices[0], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[1], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[2], Is.InstanceOf <AlternationChoice>());
Assert.That(choices[0].Children.Count, Is.EqualTo(2));
Assert.That(choices[1].Children.Count, Is.EqualTo(2));
Assert.That(choices[2].Children.Count, Is.EqualTo(2));
Assert.That(choices[0].Children[0], Is.InstanceOf <CapturingParens>());
Assert.That(((CapturingParens)choices[0].Children[0]).Number, Is.EqualTo(1));
Assert.That(choices[0].Children[1], Is.InstanceOf <CapturingParens>());
Assert.That(((CapturingParens)choices[0].Children[1]).Number, Is.EqualTo(2));
Assert.That(choices[1].Children[0], Is.InstanceOf <CapturingParens>());
Assert.That(((CapturingParens)choices[1].Children[0]).Number, Is.EqualTo(3));
Assert.That(choices[1].Children[1], Is.InstanceOf <CapturingParens>());
Assert.That(((CapturingParens)choices[1].Children[1]).Number, Is.EqualTo(4));
Assert.That(choices[2].Children[0], Is.InstanceOf <CapturingParens>());
Assert.That(((CapturingParens)choices[2].Children[0]).Number, Is.EqualTo(5));
Assert.That(choices[2].Children[1], Is.InstanceOf <CapturingParens>());
Assert.That(((CapturingParens)choices[2].Children[1]).Number, Is.EqualTo(6));
}
public void NestedCapturingParensParseCorrectly()
{
const string pattern = @"(abc(123))";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf <CapturingParens>());
var capturingParens1 = (CapturingParens)nodes[0];
Assert.That(capturingParens1.Number, Is.EqualTo(1));
var children1 = capturingParens1.Children;
Assert.That(children1.Count, Is.EqualTo(4));
Assert.That(children1[0], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[1], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[2], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[3], Is.InstanceOf <CapturingParens>());
var capturingParens2 = (CapturingParens)children1[3];
Assert.That(capturingParens2.Number, Is.EqualTo(2));
var children2 = capturingParens2.Children;
Assert.That(children2.Count, Is.EqualTo(3));
Assert.That(children2[0], Is.InstanceOf <CharacterLiteral>());
Assert.That(children2[1], Is.InstanceOf <CharacterLiteral>());
Assert.That(children2[2], Is.InstanceOf <CharacterLiteral>());
}
public void NestedQuantifierParensParseCorrectly()
{
const string pattern = @"(ab(12)?xy)";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf <CapturingParens>());
var capturingParens1 = (CapturingParens)nodes[0];
Assert.That(capturingParens1.Number, Is.EqualTo(1));
var children1 = capturingParens1.Children;
Assert.That(children1.Count, Is.EqualTo(5));
Assert.That(children1[0], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[1], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[2], Is.InstanceOf <GreedyQuestionMark>());
Assert.That(children1[3], Is.InstanceOf <CharacterLiteral>());
Assert.That(children1[4], Is.InstanceOf <CharacterLiteral>());
var greedyQuestionMark = (GreedyQuestionMark)children1[2];
Assert.That(greedyQuestionMark.Child, Is.InstanceOf <CapturingParens>());
var children2 = ((CapturingParens)greedyQuestionMark.Child).Children;
Assert.That(children2.Count, Is.EqualTo(2));
Assert.That(children2[0], Is.InstanceOf <CharacterLiteral>());
Assert.That(children2[1], Is.InstanceOf <CharacterLiteral>());
}
public void NestedCapturingParensParseCorrectly()
{
const string pattern = @"(abc(123))";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf<CapturingParens>());
var capturingParens1 = (CapturingParens) nodes[0];
Assert.That(capturingParens1.Number, Is.EqualTo(1));
var children1 = capturingParens1.Children;
Assert.That(children1.Count, Is.EqualTo(4));
Assert.That(children1[0], Is.InstanceOf<CharacterLiteral>());
Assert.That(children1[1], Is.InstanceOf<CharacterLiteral>());
Assert.That(children1[2], Is.InstanceOf<CharacterLiteral>());
Assert.That(children1[3], Is.InstanceOf<CapturingParens>());
var capturingParens2 = (CapturingParens) children1[3];
Assert.That(capturingParens2.Number, Is.EqualTo(2));
var children2 = capturingParens2.Children;
Assert.That(children2.Count, Is.EqualTo(3));
Assert.That(children2[0], Is.InstanceOf<CharacterLiteral>());
Assert.That(children2[1], Is.InstanceOf<CharacterLiteral>());
Assert.That(children2[2], Is.InstanceOf<CharacterLiteral>());
}
public void ParseEscapedSpecialCharacterIntoCharacterLiteralCaseInsensitive(string pattern)
{
var sut = new RegexCompiler(true);
var result = sut.Compile(pattern);
AssertResult(result, pattern);
}
public void ParseEscapedSpecialCharacterIntoCharacterLiteralCaseInsensitive(string pattern)
{
var sut = new RegexCompiler(true);
var result = sut.Compile(pattern);
AssertResult(result, pattern);
}
public void ParseDigitIntoDigitShorthand()
{
const string pattern = @"\d";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult(result, Shorthand.Digit);
}
public void ParseNonWhitespaceIntoNonWhitespaceShorthand()
{
const string pattern = @"\S";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult(result, Shorthand.NonWhitespace);
}
public void ParseNonWordCharacterIntoNonWordCharacterShorthand()
{
const string pattern = @"\W";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult(result, Shorthand.NonWordCharacter);
}
public void ParseWordCharacterIntoWordCharacterShorthand()
{
const string pattern = @"\w";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult(result, Shorthand.WordCharacter);
}
public void ParseWhitespaceIntoWhitespaceShorthand()
{
const string pattern = @"\s";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult(result, Shorthand.Whitespace);
}
public void ParseNonDigitIntoNonDigitShorthand()
{
const string pattern = @"\D";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult(result, Shorthand.NonDigit);
}
public void DotIsParsedIntoDotWhenSingleLineIsFalse()
{
const string pattern = ".";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult(result, false);
}
public void GreedyQuantifierMinAndMaxSpecified(string characterNode)
{
var pattern = characterNode + "{2,4}";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult <GreedyQuantifier>(result, 2, 4);
}
public void GreedyQuantifierMaxOmittedCommaOmitted(string characterNode)
{
var pattern = characterNode + "{2}";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult <GreedyQuantifier>(result, 2, 2);
}
private static BaseLexerRule CreateRegexDfa(string pattern)
{
var regexParser = new RegexParser();
var regex = regexParser.Parse(pattern);
var regexCompiler = new RegexCompiler();
var dfa = regexCompiler.Compile(regex);
return(new DfaLexerRule(dfa, pattern));
}
public void PossessiveQuantifierMaxOmittedWithComma(string characterNode)
{
var pattern = characterNode + "{2,}+";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult <PossessiveQuantifier>(result, 2, null);
}
public void ParseSingleCharacterIntoCharacterLiteralCaseInsensitive()
{
const string pattern = @"a";
var sut = new RegexCompiler(true);
var result = sut.Compile(pattern);
AssertResult(result, pattern);
}
public void ParseSingleCharacterIntoCharacterLiteralCaseInsensitive()
{
const string pattern = @"a";
var sut = new RegexCompiler(true);
var result = sut.Compile(pattern);
AssertResult(result, pattern);
}
public void LazyPlus(string characterNode)
{
var pattern = characterNode + "+?";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult <LazyPlus>(result, 1, null);
}
public void DotIsParsedIntoDotWhenSingleLineIsTrue()
{
const string pattern = ".";
var sut = new RegexCompiler(singleLine:true);
var result = sut.Compile(pattern);
AssertResult(result, true);
}
public void GreedyQuestionMark(string characterNode)
{
var pattern = characterNode + "?";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult <GreedyQuestionMark>(result, 0, 1);
}
public void GreedyStar(string characterNode)
{
var pattern = characterNode + "*";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
AssertResult <GreedyStar>(result, 0, null);
}
public void DotIsParsedIntoDotWhenSingleLineIsFalse()
{
const string pattern = "abcd";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
Assert.That(result, Is.InstanceOf <Regex>());
Assert.That(result.Children, Is.Not.Empty);
}
public void CaretInNegatedCharacterClassAfterFirstPositionIsAcceptedUnescaped(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, false, true);
var parts = AssertPartsCount(characterClass, 1);
AssertCharacterClassLiteralCharacters(parts[0], pattern.Substring(2, pattern.Length - 3), false);
}
public void DotIsParsedIntoDotWhenSingleLineIsFalse()
{
const string pattern = "abcd";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
Assert.That(result, Is.InstanceOf<Regex>());
Assert.That(result.Children, Is.Not.Empty);
}
public void CaretInNegatedCharacterClassAfterFirstPositionIsAcceptedUnescaped(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, false, true);
var parts = AssertPartsCount(characterClass, 1);
AssertCharacterClassLiteralCharacters(parts[0], pattern.Substring(2, pattern.Length - 3), false);
}
public void ParseSingleDashInCharacterClassIntoCharacterClass(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, false, pattern[1] == '^');
var parts = AssertPartsCount(characterClass, 1);
AssertCharacterClassLiteralCharacters(parts[0], "-", false);
}
public void ParseCharacterClassWithBeginningOrEndDashIntoCharacterClass(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, false, false);
var parts = AssertPartsCount(characterClass, 2);
AssertCharacterClassLiteralCharacters(parts[0], pattern.Substring(1, 1), false);
AssertCharacterClassLiteralCharacters(parts[1], pattern.Substring(2, 1), false);
}
/// <summary>Executes a task.</summary>
/// <returns>True if the task executed successfully; otherwise, false.</returns>
public override bool Execute()
{
ErrorCount = 0;
WarningCount = 0;
var c = new RegexCompiler(settings);
c.Compile();
return(ErrorCount == 0);
}
protected static void PerformTest(string input, string pattern, RegexOptions options)
{
var compiler = new RegexCompiler(
(options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase,
(options & RegexOptions.Singleline) == RegexOptions.Singleline,
(options & RegexOptions.Multiline) == RegexOptions.Multiline);
var engine = compiler.Compile(pattern).Parse(input);
var matchesEnumerator = engine.GetMatches().GetEnumerator();
var netMatchesEnumerator = System.Text.RegularExpressions.Regex.Matches(input, pattern, options)
.Cast <System.Text.RegularExpressions.Match>().GetEnumerator();
while (true)
{
var matchesHasNext = matchesEnumerator.MoveNext();
var netMatchesHasNext = netMatchesEnumerator.MoveNext();
var match = matchesEnumerator.Current;
var netMatch = netMatchesEnumerator.Current;
object un = match == null ? "un" : "";
Debug.WriteLine("Match was {0}successful.", un);
Debug.WriteLine("");
DumpParseSteps(engine, pattern);
Assert.That(matchesHasNext, Is.EqualTo(netMatchesHasNext));
if (!matchesHasNext || !netMatchesHasNext)
{
break;
}
Assert.That(match != null, Is.EqualTo(netMatch.Success));
if (match != null)
{
Assert.That(match.Value, Is.EqualTo(netMatch.Value));
Assert.That(match.Groups.Count, Is.EqualTo(netMatch.Groups.Count));
foreach (var @group in match.Groups)
{
var netGroup = netMatch.Groups[@group.Number];
Assert.That(@group.Value, Is.EqualTo(netGroup.Value));
Assert.That(@group.Captures.Count, Is.EqualTo(netGroup.Captures.Count), "Unequal Capture count in Group");
for (int i = 0; i < @group.Captures.Count; i++)
{
Assert.That(@group.Captures[i].Value, Is.EqualTo(netGroup.Captures[i].Value));
}
}
}
}
}
public void ParseSimpleCharacterClassIntoNegatedCharacterClass()
{
const string pattern = @"[^a1]";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, false, true);
var parts = AssertPartsCount(characterClass, 1);
AssertCharacterClassLiteralCharacters(parts[0], "a1", false);
}
public void ParseSimpleCharacterClassIntoCharacterClassCaseInsensitive()
{
const string pattern = @"[a1]";
var sut = new RegexCompiler(true);
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, true, false);
var parts = AssertPartsCount(characterClass, 1);
AssertCharacterClassLiteralCharacters(parts[0], "a1", true);
}
private static void CompileToAssemblyInternal(RegexCompilationInfo[] regexinfos, AssemblyName assemblyname, CustomAttributeBuilder[] attributes, string resourceFile)
{
if (assemblyname == null)
{
throw new ArgumentNullException("assemblyname");
}
if (regexinfos == null)
{
throw new ArgumentNullException("regexinfos");
}
RegexCompiler.CompileToAssembly(regexinfos, assemblyname, attributes, resourceFile);
}
public void ParseNegatedCharacterClassWithBeginningOrEndDashIntoCharacterClass(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, false, true);
var parts = AssertPartsCount(characterClass, 2);
AssertCharacterClassLiteralCharacters(parts[0], pattern.Substring(2, 1), false);
AssertCharacterClassLiteralCharacters(parts[1], pattern.Substring(3, 1), false);
}
public void ParseSingleRangedCharacterClassIntoCharacterClassCaseInsensitive()
{
const string pattern = @"[a-z]";
var sut = new RegexCompiler(true);
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, true, false);
var parts = AssertPartsCount(characterClass, 1);
AssertCharacterClassRange(parts[0], "a", "z", true);
}
public void Test(string pattern, bool ignoreCase, bool singleLine, bool multiLine, int testNumber)
{
var sut = new RegexCompiler(ignoreCase, singleLine, multiLine);
var result = sut.Compile(pattern);
switch (testNumber)
{
case 1:
Test1(result);
break;
}
}
public void EndOfStringAnchorParsesToEndOfString(string pattern, bool expectedMatchedFinalNewLine)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
Assert.That(result.Children.Count, Is.EqualTo(1));
Assert.That(result.Children[0], Is.InstanceOf<EndOfString>());
var endOfString = (EndOfString) result.Children[0];
Assert.That(endOfString.Index, Is.EqualTo(0));
Assert.That(endOfString.Pattern, Is.EqualTo(pattern));
Assert.That(endOfString.MatchesFinalNewLine, Is.EqualTo(expectedMatchedFinalNewLine));
}
public void ParseMixedPartsCharacterClassIntoCharacterClassCaseInsentive()
{
const string pattern = @"[a-f!@#g-m]";
var sut = new RegexCompiler(true);
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, true, false);
var parts = AssertPartsCount(characterClass, 3);
AssertCharacterClassRange(parts[0], "a", "f", true);
AssertCharacterClassLiteralCharacters(parts[1], "!@#", true);
AssertCharacterClassRange(parts[2], "g", "m", true);
}
public void ParseMixedPartsCharacterClassIntoCharacterClass()
{
const string pattern = @"[a-m!@#A-M]";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var characterClass = AssertCharacterClass(result.Children, pattern, false, false);
var parts = AssertPartsCount(characterClass, 3);
AssertCharacterClassRange(parts[0], "a", "m", false);
AssertCharacterClassLiteralCharacters(parts[1], "!@#", false);
AssertCharacterClassRange(parts[2], "A", "M", false);
}
public void WordBoundryParsesToWordBoundry()
{
const string pattern = @"\b";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
Assert.That(result.Children.Count, Is.EqualTo(1));
Assert.That(result.Children[0], Is.InstanceOf<WordBoundry>());
var wordBoundry = (WordBoundry) result.Children[0];
Assert.That(wordBoundry.Index, Is.EqualTo(0));
Assert.That(wordBoundry.Pattern, Is.EqualTo(pattern));
}
public void CaretParsesAsDollarWithMultilineSetToTrue()
{
const string pattern = "^";
var sut = new RegexCompiler(multiLine:true);
var result = sut.Compile(pattern);
Assert.That(result.Children.Count, Is.EqualTo(1));
Assert.That(result.Children[0], Is.InstanceOf<Caret>());
var caret = (Caret) result.Children[0];
Assert.That(caret.Index, Is.EqualTo(0));
Assert.That(caret.Pattern, Is.EqualTo(pattern));
Assert.That(caret.MultiLine, Is.EqualTo(true));
}
public void DollarParsesAsDollarWithMultilineSetToTrue()
{
const string pattern = "$";
var sut = new RegexCompiler(multiLine:true);
var result = sut.Compile(pattern);
Assert.That(result.Children.Count, Is.EqualTo(1));
Assert.That(result.Children[0], Is.InstanceOf<Dollar>());
var dollar = (Dollar) result.Children[0];
Assert.That(dollar.Index, Is.EqualTo(0));
Assert.That(dollar.Pattern, Is.EqualTo(pattern));
Assert.That(dollar.MultiLine, Is.EqualTo(true));
}
public void TickNamedBackreferencesAreParsedCorrectly(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(2));
Assert.That(nodes[0], Is.InstanceOf<NamedBackreference>());
Assert.That(((NamedBackreference)nodes[0]).Name, Is.EqualTo("foo"));
Assert.That(nodes[0].Index, Is.EqualTo(0));
Assert.That(nodes[1], Is.InstanceOf<NamedBackreference>());
Assert.That(((NamedBackreference)nodes[1]).Name, Is.EqualTo("bar"));
Assert.That(nodes[1].Index, Is.EqualTo(7));
}
public void BackreferencesAreParsedCorrectly(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(3));
Assert.That(nodes[0], Is.InstanceOf<Backreference>());
Assert.That(((Backreference)nodes[0]).Number, Is.EqualTo(1));
Assert.That(nodes[1], Is.InstanceOf<Backreference>());
Assert.That(((Backreference)nodes[1]).Number, Is.EqualTo(2));
Assert.That(nodes[2], Is.InstanceOf<Backreference>());
Assert.That(((Backreference)nodes[2]).Number, Is.EqualTo(3));
}
public void ANamedCaptureWithOneCharacterLiteralChildParsesCorrectly(string pattern)
{
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf<NamedCapture>());
var namedCapture = (NamedCapture)nodes[0];
Assert.That(namedCapture.Number, Is.EqualTo(1));
Assert.That(namedCapture.Name, Is.EqualTo("foo"));
var children = namedCapture.Children.ToList();
Assert.That(children.Count, Is.EqualTo(1));
Assert.That(children[0], Is.InstanceOf<CharacterLiteral>());
}
public void ACapturingParensWithOneCharacterLiteralChildParsesCorrectly()
{
const string pattern = @"(a)";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf<CapturingParens>());
var capturingParens = (CapturingParens) nodes[0];
Assert.That(capturingParens.Number, Is.EqualTo(1));
var children = capturingParens.Children.ToList();
Assert.That(children.Count, Is.EqualTo(1));
Assert.That(children[0], Is.InstanceOf<CharacterLiteral>());
}
public object Any(StructureRequest request)
{
var compiler = new RegexCompiler();
StructureResponse response;
try
{
var regex = compiler.Compile(request.Pattern);
var regexDto = DtoMapper.Map<RegexNodeDto>(regex);
response = new StructureResponse { Regex = regexDto };
}
catch (Exception ex)
{
response = new StructureResponse { ResponseStatus = new ResponseStatus(ex.GetType().Name, ex.Message) { StackTrace = ex.StackTrace } };
}
return new HttpResult(response, ContentType.Json);
}
public void ACapturingParensWithMultipleCharacterNodesParsesCorrectly()
{
const string pattern = @"(a[0-9]\d.)";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf<CapturingParens>());
var capturingParens = (CapturingParens) nodes[0];
Assert.That(capturingParens.Number, Is.EqualTo(1));
var children = capturingParens.Children.ToList();
Assert.That(children.Count, Is.EqualTo(4));
Assert.That(children[0], Is.InstanceOf<CharacterLiteral>());
Assert.That(children[1], Is.InstanceOf<CharacterClass>());
Assert.That(children[2], Is.InstanceOf<CharacterClassShorthand>());
Assert.That(children[3], Is.InstanceOf<Dot>());
}
public void AnAlternationWithTwoCharacterLiteralChoicesParsesCorrectly()
{
const string pattern = @"a|b";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf<Alternation>());
var alternation = (Alternation) nodes[0];
var choices = alternation.Choices.ToList();
Assert.That(choices.Count, Is.EqualTo(2));
Assert.That(choices[0], Is.InstanceOf<AlternationChoice>());
Assert.That(choices[1], Is.InstanceOf<AlternationChoice>());
Assert.That(choices[0].Children.Count, Is.EqualTo(1));
Assert.That(choices[1].Children.Count, Is.EqualTo(1));
Assert.That(choices[0].Children[0], Is.InstanceOf<CharacterLiteral>());
Assert.That(choices[1].Children[0], Is.InstanceOf<CharacterLiteral>());
}
public void BuildFile()
{
RegexCompiler task = new RegexCompiler();
task.BuildEngine = new MockBuild();
task.OutputDirectory = TaskUtility.TestDirectory;
task.AssemblyName = "MSBuild.Community.RegularExpressions.dll";
task.AssemblyTitle = "MSBuild.Community.RegularExpressions";
task.AssemblyDescription = "MSBuild Community Tasks Regular Expressions";
task.AssemblyCompany = "MSBuildTasks";
task.AssemblyProduct = "MSBuildTasks";
task.AssemblyCopyright = "Copyright (c) MSBuildTasks 2008";
task.AssemblyVersion = "1.0.0.0";
task.AssemblyFileVersion = "1.0.0.0";
task.AssemblyInformationalVersion = "1.0.0.0";
task.AssemblyKeyFile = @"..\..\..\MSBuild.Community.Tasks\MSBuild.Community.Tasks.snk";
task.RegularExpressionsFile = new TaskItem(@"..\..\..\RegularExpressions.xml");
bool result = task.Execute();
Assert.IsTrue(result);
}
public object Any(ParseStepsRequest request)
{
var skip = request.Skip.HasValue ? Math.Max(0, request.Skip.Value) : 0;
var take = request.Take.HasValue ? Math.Min(MaxStepCountPerRequest, request.Take.Value) : MaxStepCountPerRequest;
var compiler = new RegexCompiler(request.IgnoreCase, request.SingleLine, request.MultiLine);
ParseStepsResponse response;
try
{
var regex = compiler.Compile(request.Pattern);
var engine = regex.Parse(request.Input);
var parseSteps =
engine.GetParseSteps()
.Select((parseStep, stepIndex) =>
{
var parseStepDto = DtoMapper.Map<ParseStepDto>(parseStep);
parseStepDto.StepIndex = stepIndex;
return parseStepDto;
})
.Skip(skip)
.Take(take);
var regexDto = DtoMapper.Map<RegexNodeDto>(regex);
response = new ParseStepsResponse
{
Regex = regexDto,
ParseSteps = parseSteps.ToList()
};
}
catch (Exception ex)
{
response = new ParseStepsResponse { ResponseStatus = new ResponseStatus(ex.GetType().Name, ex.Message) { StackTrace = ex.StackTrace } };
}
return new HttpResult(response, ContentType.Json);
}
public void CapturedAlternation()
{
const string pattern = @"(a|b)";
var sut = new RegexCompiler();
var result = sut.Compile(pattern);
var nodes = result.Children.ToList();
Assert.That(nodes.Count, Is.EqualTo(1));
Assert.That(nodes[0], Is.InstanceOf<CapturingParens>());
var parens = (CapturingParens)nodes[0];
var parensChildren = parens.Children.ToList();
Assert.That(parensChildren.Count, Is.EqualTo(1));
Assert.That(parensChildren[0], Is.InstanceOf<Alternation>());
var alternation = (Alternation)parensChildren[0];
var choices = alternation.Choices.ToList();
Assert.That(choices.Count, Is.EqualTo(2));
Assert.That(choices[0], Is.InstanceOf<AlternationChoice>());
Assert.That(choices[1], Is.InstanceOf<AlternationChoice>());
Assert.That(choices[0].Children.Count, Is.EqualTo(1));
Assert.That(choices[1].Children.Count, Is.EqualTo(1));
Assert.That(choices[0].Children[0], Is.InstanceOf<CharacterLiteral>());
Assert.That(choices[1].Children[0], Is.InstanceOf<CharacterLiteral>());
}
