public void InnerImplicitExpressionDoesNotAcceptDotAfterAt()
{
ParseBlockTest("{@.}",
new StatementBlock(
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.EmptyCSharp().AsStatement(),
new ExpressionBlock(
Factory.CodeTransition(),
Factory.EmptyCSharp().AsImplicitExpression(KeywordSet, acceptTrailingDot: true).Accepts(AcceptedCharacters.NonWhiteSpace)
),
Factory.Code(".").AsStatement(),
Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
designTimeParser: true,
expectedErrors: new[]
{
new RazorError(RazorResources.FormatParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS("."), new SourceLocation(2, 0, 2))
});
}
public void TagHelperPrefixDirective_StartQuoteRequiresDoubleQuotesAroundValue()
{
ParseBlockTest("@tagHelperPrefix \"Foo",
new DirectiveBlock(
Factory.CodeTransition(),
Factory
.MetaCode(SyntaxConstants.CSharp.TagHelperPrefixKeyword + " ")
.Accepts(AcceptedCharacters.None),
Factory.Code("\"Foo")
.AsTagHelperPrefixDirective("Foo")),
new RazorError(
RazorResources.ParseError_Unterminated_String_Literal,
absoluteIndex: 17, lineIndex: 0, columnIndex: 17, length: 1),
new RazorError(
RazorResources.FormatParseError_DirectiveMustBeSurroundedByQuotes(
SyntaxConstants.CSharp.TagHelperPrefixKeyword),
absoluteIndex: 17, lineIndex: 0, columnIndex: 17, length: 4));
}
public void ParseBlockCorrectlyRecoversFromMissingCloseParenInExpressionWithinCode()
{
ParseBlockTest(@"{String.Format(<html></html>}",
new StatementBlock(
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.Code("String.Format(")
.AsStatement(),
new MarkupBlock(
BlockFactory.MarkupTagBlock("<html>", AcceptedCharacters.None),
BlockFactory.MarkupTagBlock("</html>", AcceptedCharacters.None)),
Factory.EmptyCSharp().AsStatement(),
Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
expectedErrors: new[] {
new RazorError(
RazorResources.FormatParseError_Expected_CloseBracket_Before_EOF("(", ")"),
14, 0, 14)
});
}
public void ParseBlockResumesIfStatementAfterOpenParen()
{
ParseBlockTest("if(" + Environment.NewLine
+ "else { <p>Foo</p> }",
new StatementBlock(
Factory.Code("if(\r\nelse {").AsStatement(),
new MarkupBlock(
Factory.Markup(" "),
BlockFactory.MarkupTagBlock("<p>", AcceptedCharacters.None),
Factory.Markup("Foo"),
BlockFactory.MarkupTagBlock("</p>", AcceptedCharacters.None),
Factory.Markup(" ").Accepts(AcceptedCharacters.None)),
Factory.Code("}").AsStatement().Accepts(AcceptedCharacters.None)
),
new RazorError(
RazorResources.FormatParseError_Expected_CloseBracket_Before_EOF("(", ")"),
new SourceLocation(2, 0, 2)));
}
/// <summary>
/// Subtracts two <see cref="SourceLocation"/>s.
/// </summary>
/// <param name="left">The left operand.</param>
/// <param name="right">The right operand.</param>
/// <returns>A <see cref="SourceLocation"/> that is the difference of the left and right operands.</returns>
/// <exception cref="ArgumentException">if the <see cref="FilePath"/> of the left and right operands
/// are different.</exception>
public static SourceLocation operator -(SourceLocation left, SourceLocation right)
{
if (!string.Equals(left.FilePath, right.FilePath, StringComparison.Ordinal))
{
throw new ArgumentException(
RazorResources.FormatSourceLocationFilePathDoesNotMatch(nameof(SourceLocation), "-"),
nameof(right));
}
var characterIndex = left.LineIndex != right.LineIndex ?
left.CharacterIndex : left.CharacterIndex - right.CharacterIndex;
return(new SourceLocation(
filePath: null,
absoluteIndex: left.AbsoluteIndex - right.AbsoluteIndex,
lineIndex: left.LineIndex - right.LineIndex,
characterIndex: characterIndex));
}
public void FunctionsDirectiveAutoCompleteAtStartOfFile()
{
ParseBlockTest("@functions{" + Environment.NewLine
+ "foo",
new FunctionsBlock(
Factory.CodeTransition("@")
.Accepts(AcceptedCharacters.None),
Factory.MetaCode("functions{")
.Accepts(AcceptedCharacters.None),
Factory.Code("\r\nfoo")
.AsFunctionsBody()
.With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)
{
AutoCompleteString = "}"
})),
new RazorError(RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF("functions", "}", "{"),
1, 0, 1));
}
public void RemoveTagHelperDirective_EndQuoteRequiresDoubleQuotesAroundValue()
{
ParseBlockTest("@removeTagHelper Foo\"",
new DirectiveBlock(
Factory.CodeTransition(),
Factory.MetaCode(SyntaxConstants.CSharp.RemoveTagHelperKeyword + " ")
.Accepts(AcceptedCharacters.None),
Factory.Code("Foo\"")
.AsStatement()
.Accepts(AcceptedCharacters.AnyExceptNewline)),
new RazorError(
RazorResources.ParseError_Unterminated_String_Literal,
absoluteIndex: 20, lineIndex: 0, columnIndex: 20, length: 1),
new RazorError(
RazorResources.FormatParseError_DirectiveMustBeSurroundedByQuotes(
SyntaxConstants.CSharp.RemoveTagHelperKeyword),
absoluteIndex: 17, lineIndex: 0, columnIndex: 17, length: 4));
}
public void AddTagHelperDirective_EndQuoteRequiresDoubleQuotesAroundValue()
{
ParseBlockTest("@addTagHelper Foo\"",
new DirectiveBlock(
Factory.CodeTransition(),
Factory.MetaCode(SyntaxConstants.CSharp.AddTagHelperKeyword + " ")
.Accepts(AcceptedCharacters.None),
Factory.Code("Foo\"")
.AsAddTagHelper("Foo")
.Accepts(AcceptedCharacters.AnyExceptNewline)),
new RazorError(
RazorResources.ParseError_Unterminated_String_Literal,
absoluteIndex: 17, lineIndex: 0, columnIndex: 17, length: 1),
new RazorError(
RazorResources.FormatParseError_IncompleteQuotesAroundDirective(
SyntaxConstants.CSharp.AddTagHelperKeyword),
absoluteIndex: 14, lineIndex: 0, columnIndex: 14, length: 4));
}
private void ExpectCodeBlock(Block block)
{
if (!EndOfFile)
{
// Check for "{" to make sure we're at a block
if (!At(CSharpSymbolType.LeftBrace))
{
Context.OnError(
CurrentLocation,
RazorResources.FormatParseError_SingleLine_ControlFlowStatements_Not_Allowed(
Language.GetSample(CSharpSymbolType.LeftBrace),
CurrentSymbol.Content),
CurrentSymbol.Content.Length);
}
// Parse the statement and then we're done
Statement(block);
}
}
protected internal bool Balance(BalancingModes mode)
{
var left = CurrentSymbol.Type;
var right = Language.FlipBracket(left);
var start = CurrentLocation;
AcceptAndMoveNext();
if (EndOfFile && ((mode & BalancingModes.NoErrorOnFailure) != BalancingModes.NoErrorOnFailure))
{
Context.OnError(
start,
RazorResources.FormatParseError_Expected_CloseBracket_Before_EOF(
Language.GetSample(left),
Language.GetSample(right)),
length: 1 /* { OR } */);
}
return(Balance(mode, left, right, start));
}
public void SectionDirectiveAutoCompleteAtStartOfFile()
{
ParseBlockTest("@section Header {" + Environment.NewLine
+ "<p>Foo</p>",
new SectionBlock(new SectionCodeGenerator("Header"),
Factory.CodeTransition(),
Factory.MetaCode("section Header {")
.AutoCompleteWith("}", atEndOfSpan: true)
.Accepts(AcceptedCharacters.Any),
new MarkupBlock(
Factory.Markup("\r\n"),
new MarkupTagBlock(
Factory.Markup("<p>")),
Factory.Markup("Foo"),
new MarkupTagBlock(
Factory.Markup("</p>")))),
new RazorError(RazorResources.FormatParseError_Expected_X("}"),
29, 1, 10));
}
public void ParseSectionBlockReportsErrorAndTerminatesSectionBlockIfKeywordNotFollowedByIdentifierStartCharacter()
{
ParseDocumentTest("@section 9 { <p>Foo</p> }",
new MarkupBlock(
Factory.EmptyHtml(),
new SectionBlock(new SectionChunkGenerator(string.Empty),
Factory.CodeTransition(),
Factory.MetaCode("section ")),
Factory.Markup("9 { "),
new MarkupTagBlock(
Factory.Markup("<p>")),
Factory.Markup("Foo"),
new MarkupTagBlock(
Factory.Markup("</p>")),
Factory.Markup(" }")),
new RazorError(
RazorResources.FormatParseError_Unexpected_Character_At_Section_Name_Start(RazorResources.FormatErrorComponent_Character("9")),
9, 0, 9));
}
public void ParseBlockMethodProducesErrorIfEOFAfterTransitionInEmbeddedExpression()
{
ParseBlockTest("{" + Environment.NewLine
+ " @",
new StatementBlock(
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.Code("\r\n ").AsStatement(),
new ExpressionBlock(
Factory.CodeTransition(),
Factory.EmptyCSharp()
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
.Accepts(AcceptedCharacters.NonWhiteSpace)),
Factory.EmptyCSharp().AsStatement()
),
new RazorError(RazorResources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock, 8, 1, 5),
new RazorError(
RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF(RazorResources.BlockName_Code, "}", "{"),
SourceLocation.Zero));
}
public void VerbatimBlockAutoCompleteAtEOF()
{
ParseBlockTest("@{",
new StatementBlock(
Factory.CodeTransition(),
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.EmptyCSharp()
.AsStatement()
.With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)
{
AutoCompleteString = "}"
})
),
new RazorError(
RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF(
RazorResources.BlockName_Code, "}", "{"),
new SourceLocation(1, 0, 1),
length: 1));
}
public void ParseBlockHandlesOpenAngleAtEof()
{
ParseDocumentTest("@{" + Environment.NewLine
+ "<",
new MarkupBlock(
Factory.EmptyHtml(),
new StatementBlock(
Factory.CodeTransition(),
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.Code(Environment.NewLine)
.AsStatement()
.AutoCompleteWith("}"),
new MarkupBlock(
new MarkupTagBlock(
Factory.Markup("<"))))),
new RazorError(
RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF(RazorResources.BlockName_Code, "}", "{"),
1, 0, 1));
}
private void ExplicitExpression()
{
var block = new Block(RazorResources.BlockName_ExplicitExpression, CurrentLocation);
Assert(CSharpSymbolType.LeftParenthesis);
AcceptAndMoveNext();
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
Span.ChunkGenerator = SpanChunkGenerator.Null;
Output(SpanKind.MetaCode);
using (PushSpanConfig(ConfigureExplicitExpressionSpan))
{
var success = Balance(
BalancingModes.BacktrackOnFailure | BalancingModes.NoErrorOnFailure | BalancingModes.AllowCommentsAndTemplates,
CSharpSymbolType.LeftParenthesis,
CSharpSymbolType.RightParenthesis,
block.Start);
if (!success)
{
AcceptUntil(CSharpSymbolType.LessThan);
Context.OnError(block.Start, RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF(block.Name, ")", "("));
}
// If necessary, put an empty-content marker symbol here
if (Span.Symbols.Count == 0)
{
Accept(new CSharpSymbol(CurrentLocation, string.Empty, CSharpSymbolType.Unknown));
}
// Output the content span and then capture the ")"
Output(SpanKind.Code);
}
Optional(CSharpSymbolType.RightParenthesis);
if (!EndOfFile)
{
PutCurrentBack();
}
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
Span.ChunkGenerator = SpanChunkGenerator.Null;
CompleteBlock(insertMarkerIfNecessary: false);
Output(SpanKind.MetaCode);
}
public void ParseHelperCorrectlyParsesIncompleteHelperPreceedingCodeBlock()
{
ParseDocumentTest("@helper" + Environment.NewLine
+ "@{}",
new MarkupBlock(
Factory.EmptyHtml(),
new HelperBlock(
Factory.CodeTransition(),
Factory.MetaCode("helper")),
Factory.Markup("\r\n"),
new StatementBlock(
Factory.CodeTransition(),
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.EmptyCSharp().AsStatement(),
Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
Factory.EmptyHtml()),
new RazorError(
RazorResources.FormatParseError_Unexpected_Character_At_Helper_Name_Start(RazorResources.ErrorComponent_Newline),
7, 0, 7));
}
public void ParseHelperOutputsErrorButContinuesIfLParenFoundAfterHelperKeyword()
{
ParseDocumentTest("@helper () {",
new MarkupBlock(
Factory.EmptyHtml(),
new HelperBlock(new HelperCodeGenerator(new LocationTagged <string>("() {", 8, 0, 8), headerComplete: true),
Factory.CodeTransition(),
Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
Factory.Code("() {").Hidden().Accepts(AcceptedCharacters.None),
new StatementBlock(
Factory.EmptyCSharp()
.AsStatement()
.AutoCompleteWith("}")))),
new RazorError(
RazorResources.FormatParseError_Unexpected_Character_At_Helper_Name_Start(RazorResources.FormatErrorComponent_Character("(")),
8, 0, 8),
new RazorError(
RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF("helper", "}", "{"),
1, 0, 1));
}
public void InnerImplicitExpressionWithOnlySingleAtOutputsZeroLengthCodeSpan()
{
ParseBlockTest("{@}",
new StatementBlock(
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.EmptyCSharp()
.AsStatement()
.AutoCompleteWith(autoCompleteString: null),
new ExpressionBlock(
Factory.CodeTransition(),
Factory.EmptyCSharp().AsImplicitExpression(KeywordSet, acceptTrailingDot: true).Accepts(AcceptedCharacters.NonWhiteSpace)
),
Factory.EmptyCSharp().AsStatement(),
Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
designTimeParser: true,
expectedErrors: new[]
{
new RazorError(RazorResources.FormatParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS("}"), new SourceLocation(2, 0, 2))
});
}
public void FunctionsDirectiveAutoCompleteAtEOF()
{
ParseBlockTest(
"@functions{",
new FunctionsBlock(
Factory.CodeTransition("@")
.Accepts(AcceptedCharacters.None),
Factory.MetaCode("functions{")
.Accepts(AcceptedCharacters.None),
Factory.EmptyCSharp()
.AsFunctionsBody()
.With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)
{
AutoCompleteString = "}"
})),
new RazorError(
RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF("functions", "}", "{"),
new SourceLocation(10, 0, 10),
length: 1));
}
public void SectionDirectiveAutoCompleteAtStartOfFile()
{
ParseBlockTest("@section Header {" + Environment.NewLine
+ "<p>Foo</p>",
new SectionBlock(new SectionChunkGenerator("Header"),
Factory.CodeTransition(),
Factory.MetaCode("section Header {")
.AutoCompleteWith("}", atEndOfSpan: true)
.Accepts(AcceptedCharacters.Any),
new MarkupBlock(
Factory.Markup(Environment.NewLine),
new MarkupTagBlock(
Factory.Markup("<p>")),
Factory.Markup("Foo"),
new MarkupTagBlock(
Factory.Markup("</p>")))),
new RazorError(
RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF("section", "}", "{"),
new SourceLocation(16, 0, 16),
length: 1));
}
private void CodeBlock(bool acceptTerminatingBrace, Block block)
{
EnsureCurrent();
while (!EndOfFile && !At(CSharpSymbolType.RightBrace))
{
// Parse a statement, then return here
Statement();
EnsureCurrent();
}
if (EndOfFile)
{
Context.OnError(block.Start, RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF(block.Name, '}', '{'));
}
else if (acceptTerminatingBrace)
{
Assert(CSharpSymbolType.RightBrace);
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
AcceptAndMoveNext();
}
}
public void ParseSectionBlockHandlesUnterminatedSection()
{
ParseDocumentTest("@section foo { <p>Foo{}</p>",
new MarkupBlock(
Factory.EmptyHtml(),
new SectionBlock(new SectionChunkGenerator("foo"),
Factory.CodeTransition(),
Factory.MetaCode("section foo {")
.AutoCompleteWith("}", atEndOfSpan: true),
new MarkupBlock(
Factory.Markup(" "),
new MarkupTagBlock(
Factory.Markup("<p>")),
// Need to provide the markup span as fragments, since the parser will split the {} into separate symbols.
Factory.Markup("Foo", "{", "}"),
new MarkupTagBlock(
Factory.Markup("</p>"))))),
new RazorError(
RazorResources.FormatParseError_Expected_X("}"),
27, 0, 27));
}
public void UnterminatedRazorCommentInImplicitExpressionMethodCall()
{
ParseDocumentTest("@foo(@*",
new MarkupBlock(
Factory.EmptyHtml(),
new ExpressionBlock(
Factory.CodeTransition(),
Factory.Code("foo(")
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
new CommentBlock(
Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
.Accepts(AcceptedCharacters.None),
Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar)
.Accepts(AcceptedCharacters.None),
Factory.Span(SpanKind.Comment, new CSharpSymbol(
Factory.LocationTracker.CurrentLocation,
string.Empty,
CSharpSymbolType.Unknown))
.Accepts(AcceptedCharacters.Any)))),
new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, 5, 0, 5),
new RazorError(RazorResources.FormatParseError_Expected_CloseBracket_Before_EOF("(", ")"), 4, 0, 4));
}
public void RazorCommentInVerbatimBlock()
{
ParseDocumentTest("@{" + Environment.NewLine
+ " <text" + Environment.NewLine
+ " @**@" + Environment.NewLine
+ "}",
new MarkupBlock(
Factory.EmptyHtml(),
new StatementBlock(
Factory.CodeTransition(),
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.Code(Environment.NewLine)
.AsStatement()
.AutoCompleteWith("}"),
new MarkupBlock(
new MarkupTagBlock(
Factory.MarkupTransition("<text").Accepts(AcceptedCharacters.Any)),
Factory.Markup(Environment.NewLine).Accepts(AcceptedCharacters.None),
Factory.Markup(" ").With(SpanChunkGenerator.Null),
new CommentBlock(
Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
.Accepts(AcceptedCharacters.None),
Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
.Accepts(AcceptedCharacters.None),
Factory.Span(SpanKind.Comment, new HtmlSymbol(
Factory.LocationTracker.CurrentLocation,
string.Empty,
HtmlSymbolType.Unknown))
.Accepts(AcceptedCharacters.Any),
Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
.Accepts(AcceptedCharacters.None),
Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
.Accepts(AcceptedCharacters.None)),
Factory.Markup(Environment.NewLine).With(SpanChunkGenerator.Null),
Factory.Markup("}")))),
new RazorError(RazorResources.ParseError_TextTagCannotContainAttributes, 6 + Environment.NewLine.Length, 1, 4),
new RazorError(RazorResources.FormatParseError_MissingEndTag("text"), 6 + Environment.NewLine.Length, 1, 4),
new RazorError(RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF(RazorResources.BlockName_Code, "}", "{"), 1, 0, 1));
}
private void ValidateParentAllowsContent(Span child, ErrorSink errorSink)
{
if (HasAllowedChildren())
{
var content = child.Content;
if (!string.IsNullOrWhiteSpace(content))
{
var trimmedStart = content.TrimStart();
var whitespace = content.Substring(0, content.Length - trimmedStart.Length);
var errorStart = SourceLocation.Advance(child.Start, whitespace);
var length = trimmedStart.TrimEnd().Length;
var allowedChildren = _currentTagHelperTracker.AllowedChildren;
var allowedChildrenString = string.Join(", ", allowedChildren);
errorSink.OnError(
errorStart,
RazorResources.FormatTagHelperParseTreeRewriter_CannotHaveNonTagContent(
_currentTagHelperTracker.TagName,
allowedChildrenString),
length);
}
}
}
public void ParseHelperStatementGivesWhitespaceAfterOpenBraceToMarkupInDesignMode()
{
ParseDocumentTest("@helper Foo(string foo) { " + Environment.NewLine
+ " ",
new MarkupBlock(
Factory.EmptyHtml(),
new HelperBlock(new HelperCodeGenerator(new LocationTagged <string>("Foo(string foo) {", 8, 0, 8), headerComplete: true),
Factory.CodeTransition(),
Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
Factory.Code(@"Foo(string foo) {").Hidden().Accepts(AcceptedCharacters.None),
new StatementBlock(
Factory.Code(" \r\n ")
.AsStatement()
.AutoCompleteWith("}")))),
designTimeParser: true,
expectedErrors: new[]
{
new RazorError(
RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF("helper", "}", "{"),
new SourceLocation(1, 0, 1))
});
}
private static bool IsEnabled()
{
if (_enabled == null)
{
bool enabled;
if (Boolean.TryParse(Environment.GetEnvironmentVariable("RAZOR_EDITOR_TRACE"), out enabled))
{
#if NET451
// No Trace in CoreCLR
Trace.WriteLine(RazorResources.FormatTrace_Startup(
enabled ? RazorResources.Trace_Enabled : RazorResources.Trace_Disabled));
#endif
_enabled = enabled;
}
else
{
_enabled = false;
}
}
return(_enabled.Value);
}
public void HelperDirectiveAutoCompleteAtEOF()
{
ParseBlockTest("@helper Strong(string value) {",
new HelperBlock(new HelperCodeGenerator(new LocationTagged <string>("Strong(string value) {", 8, 0, 8), headerComplete: true),
Factory.CodeTransition(),
Factory.MetaCode("helper ")
.Accepts(AcceptedCharacters.None),
Factory.Code("Strong(string value) {")
.Hidden()
.Accepts(AcceptedCharacters.None),
new StatementBlock(
Factory.EmptyCSharp()
.AsStatement()
.With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)
{
AutoCompleteString = "}"
})
)
),
new RazorError(RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF("helper", "}", "{"),
1, 0, 1));
}
public void UnterminatedRazorCommentInVerbatimBlock()
{
ParseDocumentTest("@{@*",
new MarkupBlock(
Factory.EmptyHtml(),
new StatementBlock(
Factory.CodeTransition(),
Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
Factory.EmptyCSharp()
.AsStatement(),
new CommentBlock(
Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
.Accepts(AcceptedCharacters.None),
Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar)
.Accepts(AcceptedCharacters.None),
Factory.Span(SpanKind.Comment, new CSharpSymbol(Factory.LocationTracker.CurrentLocation,
String.Empty,
CSharpSymbolType.Unknown))
.Accepts(AcceptedCharacters.Any)))),
new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, 2, 0, 2),
new RazorError(RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF(RazorResources.BlockName_Code, "}", "{"), 1, 0, 1));
}
