public void Equals_False_WhenExpected(AutoCompleteEditHandler leftObject, object rightObject)
{
// Arrange & Act
var result = leftObject.Equals(rightObject);
// Assert
Assert.False(result);
}
public override bool Equals(object obj)
{
AutoCompleteEditHandler other = obj as AutoCompleteEditHandler;
return(base.Equals(obj) &&
other != null &&
String.Equals(other.AutoCompleteString, AutoCompleteString, StringComparison.Ordinal) &&
AutoCompleteAtEndOfSpan == other.AutoCompleteAtEndOfSpan);
}
public void GetHashCode_ReturnsSameValue_WhenEqual(
AutoCompleteEditHandler leftObject,
AutoCompleteEditHandler rightObject)
{
// Arrange & Act
var leftResult = leftObject.GetHashCode();
var rightResult = rightObject.GetHashCode();
// Assert
Assert.Equal(leftResult, rightResult);
}
protected virtual void SectionDirective()
{
var nested = Context.IsWithin(BlockType.Section);
var errorReported = false;
// Set the block and span type
Context.CurrentBlock.Type = BlockType.Section;
// Verify we're on "section" and accept
AssertDirective(SyntaxConstants.CSharp.SectionKeyword);
var startLocation = CurrentLocation;
AcceptAndMoveNext();
if (nested)
{
Context.OnError(
startLocation,
RazorResources.FormatParseError_Sections_Cannot_Be_Nested(RazorResources.SectionExample_CS),
Span.GetContent().Value.Length);
errorReported = true;
}
var whitespace = ReadWhile(IsSpacingToken(includeNewLines: true, includeComments: false));
// Get the section name
var sectionName = string.Empty;
if (!Required(CSharpSymbolType.Identifier,
errorIfNotFound: true,
errorBase: RazorResources.FormatParseError_Unexpected_Character_At_Section_Name_Start))
{
if (!errorReported)
{
errorReported = true;
}
PutCurrentBack();
PutBack(whitespace);
AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: false));
}
else
{
Accept(whitespace);
sectionName = CurrentSymbol.Content;
AcceptAndMoveNext();
}
Context.CurrentBlock.CodeGenerator = new SectionCodeGenerator(sectionName);
var errorLocation = CurrentLocation;
whitespace = ReadWhile(IsSpacingToken(includeNewLines: true, includeComments: false));
// Get the starting brace
var sawStartingBrace = At(CSharpSymbolType.LeftBrace);
if (!sawStartingBrace)
{
if (!errorReported)
{
errorReported = true;
Context.OnError(errorLocation, RazorResources.ParseError_MissingOpenBraceAfterSection);
}
PutCurrentBack();
PutBack(whitespace);
AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: false));
Optional(CSharpSymbolType.NewLine);
Output(SpanKind.MetaCode);
CompleteBlock();
return;
}
else
{
Accept(whitespace);
}
// Set up edit handler
var editHandler = new AutoCompleteEditHandler(Language.TokenizeString, autoCompleteAtEndOfSpan: true);
Span.EditHandler = editHandler;
Span.Accept(CurrentSymbol);
// Output Metacode then switch to section parser
Output(SpanKind.MetaCode);
SectionBlock("{", "}", caseSensitive: true);
Span.CodeGenerator = SpanCodeGenerator.Null;
// Check for the terminating "}"
if (!Optional(CSharpSymbolType.RightBrace))
{
editHandler.AutoCompleteString = "}";
Context.OnError(CurrentLocation,
RazorResources.FormatParseError_Expected_X(
Language.GetSample(CSharpSymbolType.RightBrace)));
}
else
{
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
}
CompleteBlock(insertMarkerIfNecessary: false, captureWhitespaceToEndOfLine: true);
Output(SpanKind.MetaCode);
return;
}
protected virtual void FunctionsDirective()
{
// Set the block type
Context.CurrentBlock.Type = BlockType.Functions;
// Verify we're on "functions" and accept
AssertDirective(SyntaxConstants.CSharp.FunctionsKeyword);
var block = new Block(CurrentSymbol);
AcceptAndMoveNext();
AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: false));
if (!At(CSharpSymbolType.LeftBrace))
{
Context.OnError(CurrentLocation,
RazorResources.FormatParseError_Expected_X(Language.GetSample(CSharpSymbolType.LeftBrace)));
CompleteBlock();
Output(SpanKind.MetaCode);
return;
}
else
{
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
}
// Capture start point and continue
var blockStart = CurrentLocation;
AcceptAndMoveNext();
// Output what we've seen and continue
Output(SpanKind.MetaCode);
var editHandler = new AutoCompleteEditHandler(Language.TokenizeString);
Span.EditHandler = editHandler;
Balance(BalancingModes.NoErrorOnFailure, CSharpSymbolType.LeftBrace, CSharpSymbolType.RightBrace, blockStart);
Span.CodeGenerator = new TypeMemberCodeGenerator();
if (!At(CSharpSymbolType.RightBrace))
{
editHandler.AutoCompleteString = "}";
Context.OnError(blockStart, RazorResources.FormatParseError_Expected_EndOfBlock_Before_EOF(block.Name, "}", "{"));
CompleteBlock();
Output(SpanKind.Code);
}
else
{
Output(SpanKind.Code);
Assert(CSharpSymbolType.RightBrace);
Span.CodeGenerator = SpanCodeGenerator.Null;
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
AcceptAndMoveNext();
CompleteBlock();
Output(SpanKind.MetaCode);
}
}
protected virtual void HelperDirective()
{
bool nested = Context.IsWithin(BlockType.Helper);
// Set the block and span type
Context.CurrentBlock.Type = BlockType.Helper;
// Verify we're on "helper" and accept
AssertDirective(SyntaxConstants.CSharp.HelperKeyword);
Block block = new Block(CurrentSymbol.Content.ToString().ToLowerInvariant(), CurrentLocation);
AcceptAndMoveNext();
if (nested)
{
Context.OnError(CurrentLocation, RazorResources.ParseError_Helpers_Cannot_Be_Nested);
}
// Accept a single whitespace character if present, if not, we should stop now
if (!At(CSharpSymbolType.WhiteSpace))
{
string error;
if (At(CSharpSymbolType.NewLine))
{
error = RazorResources.ErrorComponent_Newline;
}
else if (EndOfFile)
{
error = RazorResources.ErrorComponent_EndOfFile;
}
else
{
error = String.Format(CultureInfo.CurrentCulture, RazorResources.ErrorComponent_Character, CurrentSymbol.Content);
}
Context.OnError(
CurrentLocation,
RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
error);
PutCurrentBack();
Output(SpanKind.MetaCode);
return;
}
CSharpSymbol remainingWs = AcceptSingleWhiteSpaceCharacter();
// Output metacode and continue
Output(SpanKind.MetaCode);
if (remainingWs != null)
{
Accept(remainingWs);
}
AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true)); // Don't accept newlines.
// Expecting an identifier (helper name)
bool errorReported = !Required(CSharpSymbolType.Identifier, errorIfNotFound: true, errorBase: RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start);
if (!errorReported)
{
Assert(CSharpSymbolType.Identifier);
AcceptAndMoveNext();
}
AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true));
// Expecting parameter list start: "("
SourceLocation bracketErrorPos = CurrentLocation;
if (!Optional(CSharpSymbolType.LeftParenthesis))
{
if (!errorReported)
{
errorReported = true;
Context.OnError(
CurrentLocation,
RazorResources.ParseError_MissingCharAfterHelperName,
"(");
}
}
else
{
SourceLocation bracketStart = CurrentLocation;
if (!Balance(BalancingModes.NoErrorOnFailure,
CSharpSymbolType.LeftParenthesis,
CSharpSymbolType.RightParenthesis,
bracketStart))
{
errorReported = true;
Context.OnError(
bracketErrorPos,
RazorResources.ParseError_UnterminatedHelperParameterList);
}
Optional(CSharpSymbolType.RightParenthesis);
}
int bookmark = CurrentLocation.AbsoluteIndex;
IEnumerable<CSharpSymbol> ws = ReadWhile(IsSpacingToken(includeNewLines: true, includeComments: true));
// Expecting a "{"
SourceLocation errorLocation = CurrentLocation;
bool headerComplete = At(CSharpSymbolType.LeftBrace);
if (headerComplete)
{
Accept(ws);
AcceptAndMoveNext();
}
else
{
Context.Source.Position = bookmark;
NextToken();
AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true));
if (!errorReported)
{
Context.OnError(
errorLocation,
RazorResources.ParseError_MissingCharAfterHelperParameters,
Language.GetSample(CSharpSymbolType.LeftBrace));
}
}
// Grab the signature and build the code generator
AddMarkerSymbolIfNecessary();
LocationTagged<string> signature = Span.GetContent();
HelperCodeGenerator blockGen = new HelperCodeGenerator(signature, headerComplete);
Context.CurrentBlock.CodeGenerator = blockGen;
// The block will generate appropriate code,
Span.CodeGenerator = SpanCodeGenerator.Null;
if (!headerComplete)
{
CompleteBlock();
Output(SpanKind.Code);
return;
}
else
{
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
Output(SpanKind.Code);
}
// We're valid, so parse the nested block
AutoCompleteEditHandler bodyEditHandler = new AutoCompleteEditHandler(Language.TokenizeString);
using (PushSpanConfig(DefaultSpanConfig))
{
using (Context.StartBlock(BlockType.Statement))
{
Span.EditHandler = bodyEditHandler;
CodeBlock(false, block);
CompleteBlock(insertMarkerIfNecessary: true);
Output(SpanKind.Code);
}
}
Initialize(Span);
EnsureCurrent();
Span.CodeGenerator = SpanCodeGenerator.Null; // The block will generate the footer code.
if (!Optional(CSharpSymbolType.RightBrace))
{
// The } is missing, so set the initial signature span to use it as an autocomplete string
bodyEditHandler.AutoCompleteString = "}";
// Need to be able to accept anything to properly handle the autocomplete
bodyEditHandler.AcceptedCharacters = AcceptedCharacters.Any;
}
else
{
blockGen.Footer = Span.GetContent();
Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
}
CompleteBlock();
Output(SpanKind.Code);
}
public void GetHashCode_ReturnsSameValue_WhenEqual(
AutoCompleteEditHandler leftObject,
AutoCompleteEditHandler rightObject)
{
// Arrange & Act
var leftResult = leftObject.GetHashCode();
var rightResult = rightObject.GetHashCode();
// Assert
Assert.Equal(leftResult, rightResult);
}
public void Equals_False_WhenExpected(AutoCompleteEditHandler leftObject, object rightObject)
{
// Arrange & Act
var result = leftObject.Equals(rightObject);
// Assert
Assert.False(result);
}