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 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 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); } }