public static void EvaluateParseTree(Block actualRoot, Block expectedRoot)
{
// Evaluate the result
var collector = new ErrorCollector();
if (expectedRoot == null)
{
Assert.Null(actualRoot);
}
else
{
// Link all the nodes
expectedRoot.LinkNodes();
Assert.NotNull(actualRoot);
EvaluateSyntaxTreeNode(collector, actualRoot, expectedRoot);
if (collector.Success)
{
WriteTraceLine("Parse Tree Validation Succeeded:" + Environment.NewLine + collector.Message);
}
else
{
Assert.True(false, Environment.NewLine + collector.Message);
}
}
}
private static void EvaluateBlock(ErrorCollector collector, Block actual, Block expected)
{
if (actual.Type != expected.Type || !expected.ChunkGenerator.Equals(actual.ChunkGenerator))
{
AddMismatchError(collector, actual, expected);
}
else
{
if (actual is TagHelperBlock)
{
EvaluateTagHelperBlock(collector, actual as TagHelperBlock, expected as TagHelperBlock);
}
AddPassedMessage(collector, expected);
using (collector.Indent())
{
var expectedNodes = expected.Children.GetEnumerator();
var actualNodes = actual.Children.GetEnumerator();
while (expectedNodes.MoveNext())
{
if (!actualNodes.MoveNext())
{
collector.AddError("{0} - FAILED :: No more elements at this node", expectedNodes.Current);
}
else
{
EvaluateSyntaxTreeNode(collector, actualNodes.Current, expectedNodes.Current);
}
}
while (actualNodes.MoveNext())
{
collector.AddError("End of Node - FAILED :: Found Node: {0}", actualNodes.Current);
}
}
}
}
private static void EvaluateSyntaxTreeNode(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
{
if (actual == null)
{
AddNullActualError(collector, actual, expected);
return;
}
if (actual.IsBlock != expected.IsBlock)
{
AddMismatchError(collector, actual, expected);
}
else
{
if (expected.IsBlock)
{
EvaluateBlock(collector, (Block)actual, (Block)expected);
}
else
{
EvaluateSpan(collector, (Span)actual, (Span)expected);
}
}
}
private static void AddNullActualError(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
{
collector.AddError("{0} - FAILED :: Actual: << Null >>", expected);
}
private static void AddMismatchError(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
{
collector.AddError("{0} - FAILED :: Actual: {1}", expected, actual);
}
private static void AddPassedMessage(ErrorCollector collector, SyntaxTreeNode expected)
{
collector.AddMessage("{0} - PASSED", expected);
}
private static void EvaluateTagHelperBlock(ErrorCollector collector, TagHelperBlock actual, TagHelperBlock expected)
{
if (expected == null)
{
AddMismatchError(collector, actual, expected);
}
else
{
if (!string.Equals(expected.TagName, actual.TagName, StringComparison.Ordinal))
{
collector.AddError(
"{0} - FAILED :: TagName mismatch for TagHelperBlock :: ACTUAL: {1}",
expected.TagName,
actual.TagName);
}
if (expected.TagMode != actual.TagMode)
{
collector.AddError(
$"{expected.TagMode} - FAILED :: {nameof(TagMode)} for {nameof(TagHelperBlock)} " +
$"{actual.TagName} :: ACTUAL: {actual.TagMode}");
}
var expectedAttributes = expected.Attributes.GetEnumerator();
var actualAttributes = actual.Attributes.GetEnumerator();
while (expectedAttributes.MoveNext())
{
if (!actualAttributes.MoveNext())
{
collector.AddError("{0} - FAILED :: No more attributes on this node", expectedAttributes.Current);
}
else
{
EvaluateTagHelperAttribute(collector, actualAttributes.Current, expectedAttributes.Current);
}
}
while (actualAttributes.MoveNext())
{
collector.AddError("End of Attributes - FAILED :: Found Attribute: {0}", actualAttributes.Current.Key);
}
}
}
private static void EvaluateBlock(ErrorCollector collector, Block actual, Block expected)
{
if (actual.Type != expected.Type || !expected.ChunkGenerator.Equals(actual.ChunkGenerator))
{
AddMismatchError(collector, actual, expected);
}
else
{
if (actual is TagHelperBlock)
{
EvaluateTagHelperBlock(collector, actual as TagHelperBlock, expected as TagHelperBlock);
}
AddPassedMessage(collector, expected);
using (collector.Indent())
{
var expectedNodes = expected.Children.GetEnumerator();
var actualNodes = actual.Children.GetEnumerator();
while (expectedNodes.MoveNext())
{
if (!actualNodes.MoveNext())
{
collector.AddError("{0} - FAILED :: No more elements at this node", expectedNodes.Current);
}
else
{
EvaluateSyntaxTreeNode(collector, actualNodes.Current, expectedNodes.Current);
}
}
while (actualNodes.MoveNext())
{
collector.AddError("End of Node - FAILED :: Found Node: {0}", actualNodes.Current);
}
}
}
}
private static void EvaluateSpan(ErrorCollector collector, Span actual, Span expected)
{
if (!Equals(expected, actual))
{
AddMismatchError(collector, actual, expected);
}
else
{
AddPassedMessage(collector, expected);
}
}
private static void EvaluateTagHelperAttribute(ErrorCollector collector,
KeyValuePair<string, SyntaxTreeNode> actual,
KeyValuePair<string, SyntaxTreeNode> expected)
{
if (actual.Key != expected.Key)
{
collector.AddError("{0} - FAILED :: Attribute names do not match", expected.Key);
}
else
{
collector.AddMessage("{0} - PASSED :: Attribute names match", expected.Key);
}
if (actual.Value == null && expected.Value == null)
{
collector.AddMessage("{0} - PASSED :: Minimized attribute values match", expected.Key);
}
else
{
EvaluateSyntaxTreeNode(collector, actual.Value, expected.Value);
}
}
private static void EvaluateSyntaxTreeNode(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
{
if (actual == null)
{
AddNullActualError(collector, actual, expected);
return;
}
if (actual.IsBlock != expected.IsBlock)
{
AddMismatchError(collector, actual, expected);
}
else
{
if (expected.IsBlock)
{
EvaluateBlock(collector, (Block)actual, (Block)expected);
}
else
{
EvaluateSpan(collector, (Span)actual, (Span)expected);
}
}
}
private static void AddNullActualError(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
{
collector.AddError("{0} - FAILED :: Actual: << Null >>", expected);
}
private static void AddMismatchError(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
{
collector.AddError("{0} - FAILED :: Actual: {1}", expected, actual);
}
private static void AddPassedMessage(ErrorCollector collector, SyntaxTreeNode expected)
{
collector.AddMessage("{0} - PASSED", expected);
}
private static void EvaluateTagHelperAttribute(
ErrorCollector collector,
TagHelperAttributeNode actual,
TagHelperAttributeNode expected)
{
if (actual.Name != expected.Name)
{
collector.AddError("{0} - FAILED :: Attribute names do not match", expected.Name);
}
else
{
collector.AddMessage("{0} - PASSED :: Attribute names match", expected.Name);
}
if (actual.ValueStyle != expected.ValueStyle)
{
collector.AddError("{0} - FAILED :: Attribute value styles do not match", expected.ValueStyle.ToString());
}
else
{
collector.AddMessage("{0} - PASSED :: Attribute value style match", expected.ValueStyle);
}
if (actual.ValueStyle != HtmlAttributeValueStyle.Minimized)
{
EvaluateSyntaxTreeNode(collector, actual.Value, expected.Value);
}
}