public void ParseMethodCallsParseDocumentOnMarkupParserAndReturnsResults()
{
// Arrange
var parser = new RazorParser();
var expected =
@"RazorDocument - [0..12)::12 - [foo @bar baz]
MarkupBlock - [0..12)::12
MarkupTextLiteral - [0..4)::4 - [foo ] - Gen<Markup> - SpanEditHandler;Accepts:Any
Text;[foo];
Whitespace;[ ];
CSharpCodeBlock - [4..8)::4
CSharpImplicitExpression - [4..8)::4
CSharpTransition - [4..5)::1 - Gen<None> - SpanEditHandler;Accepts:None
Transition;[@];
CSharpImplicitExpressionBody - [5..8)::3
CSharpCodeBlock - [5..8)::3
CSharpExpressionLiteral - [5..8)::3 - [bar] - Gen<Expr> - ImplicitExpressionEditHandler;Accepts:NonWhitespace;ImplicitExpression[RTD];K14
Identifier;[bar];
MarkupTextLiteral - [8..12)::4 - [ baz] - Gen<Markup> - SpanEditHandler;Accepts:Any
Whitespace;[ ];
Text;[baz];
";
// Act
var syntaxTree = parser.Parse(TestRazorSourceDocument.Create("foo @bar baz"));
// Assert
var actual = SyntaxNodeSerializer.Serialize(syntaxTree.Root);
Assert.Equal(expected, actual);
}
internal virtual void AssertSyntaxTreeNodeMatchesBaseline(RazorSyntaxTree syntaxTree)
{
var root = syntaxTree.Root;
var diagnostics = syntaxTree.Diagnostics;
var filePath = syntaxTree.Source.FilePath;
if (FileName == null)
{
var message = $"{nameof(AssertSyntaxTreeNodeMatchesBaseline)} should only be called from a parser test ({nameof(FileName)} is null).";
throw new InvalidOperationException(message);
}
if (IsTheory)
{
var message = $"{nameof(AssertSyntaxTreeNodeMatchesBaseline)} should not be called from a [Theory] test.";
throw new InvalidOperationException(message);
}
var fileName = BaselineTestCount > 0 ? FileName + $"_{BaselineTestCount}" : FileName;
var baselineFileName = Path.ChangeExtension(fileName, ".stree.txt");
var baselineDiagnosticsFileName = Path.ChangeExtension(fileName, ".diag.txt");
var baselineClassifiedSpansFileName = Path.ChangeExtension(fileName, ".cspans.txt");
var baselineTagHelperSpansFileName = Path.ChangeExtension(fileName, ".tspans.txt");
BaselineTestCount++;
if (GenerateBaselines)
{
// Write syntax tree baseline
var baselineFullPath = Path.Combine(TestProjectRoot, baselineFileName);
File.WriteAllText(baselineFullPath, SyntaxNodeSerializer.Serialize(root));
// Write diagnostics baseline
var baselineDiagnosticsFullPath = Path.Combine(TestProjectRoot, baselineDiagnosticsFileName);
var lines = diagnostics.Select(SerializeDiagnostic).ToArray();
if (lines.Any())
{
File.WriteAllLines(baselineDiagnosticsFullPath, lines);
}
else if (File.Exists(baselineDiagnosticsFullPath))
{
File.Delete(baselineDiagnosticsFullPath);
}
// Write classified spans baseline
var classifiedSpansBaselineFullPath = Path.Combine(TestProjectRoot, baselineClassifiedSpansFileName);
File.WriteAllText(classifiedSpansBaselineFullPath, ClassifiedSpanSerializer.Serialize(syntaxTree));
// Write tag helper spans baseline
var tagHelperSpansBaselineFullPath = Path.Combine(TestProjectRoot, baselineTagHelperSpansFileName);
var serializedTagHelperSpans = TagHelperSpanSerializer.Serialize(syntaxTree);
if (!string.IsNullOrEmpty(serializedTagHelperSpans))
{
File.WriteAllText(tagHelperSpansBaselineFullPath, serializedTagHelperSpans);
}
else if (File.Exists(tagHelperSpansBaselineFullPath))
{
File.Delete(tagHelperSpansBaselineFullPath);
}
return;
}
// Verify syntax tree
var stFile = TestFile.Create(baselineFileName, GetType().GetTypeInfo().Assembly);
if (!stFile.Exists())
{
throw new XunitException($"The resource {baselineFileName} was not found.");
}
var baseline = stFile.ReadAllText().Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
SyntaxNodeVerifier.Verify(root, baseline);
// Verify diagnostics
var baselineDiagnostics = string.Empty;
var diagnosticsFile = TestFile.Create(baselineDiagnosticsFileName, GetType().GetTypeInfo().Assembly);
if (diagnosticsFile.Exists())
{
baselineDiagnostics = diagnosticsFile.ReadAllText();
}
var actualDiagnostics = string.Concat(diagnostics.Select(d => SerializeDiagnostic(d) + "\r\n"));
Assert.Equal(baselineDiagnostics, actualDiagnostics);
// Verify classified spans
var classifiedSpanFile = TestFile.Create(baselineClassifiedSpansFileName, GetType().GetTypeInfo().Assembly);
if (!classifiedSpanFile.Exists())
{
throw new XunitException($"The resource {baselineClassifiedSpansFileName} was not found.");
}
else
{
var classifiedSpanBaseline = Array.Empty <string>();
classifiedSpanBaseline = classifiedSpanFile.ReadAllText().Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
ClassifiedSpanVerifier.Verify(syntaxTree, classifiedSpanBaseline);
}
// Verify tag helper spans
var tagHelperSpanFile = TestFile.Create(baselineTagHelperSpansFileName, GetType().GetTypeInfo().Assembly);
var tagHelperSpanBaseline = Array.Empty <string>();
if (tagHelperSpanFile.Exists())
{
tagHelperSpanBaseline = tagHelperSpanFile.ReadAllText().Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
TagHelperSpanVerifier.Verify(syntaxTree, tagHelperSpanBaseline);
}
}
