protected void AssertCompilerReturnsMessage(
string input,
CompilerMessageId messageId,
CompilerMessageType messageType,
string[] messageParameters)
{
// Arrange
var compiler = new ThriftCompiler();
var parserInput = ParserInput.FromString(input);
// Act
var result = compiler.Compile(parserInput.GetStream());
// Assert
var message = result.Messages.FirstOrDefault(
m => m.MessageType == messageType && m.MessageId == messageId);
Assert.True(message != null, $"No {messageType.ToString().ToLower()} messages were returned from the compiler");
if (parserInput.LineNumber != null)
{
Assert.Equal(parserInput.LineNumber, message.LineNumber);
Assert.Equal(parserInput.StartPosition, message.StartPosition);
Assert.Equal(parserInput.EndPosition, message.EndPosition);
}
if (messageParameters?.Length > 0)
{
var expectedMessage = string.Format(
CompilerMessages.Get(messageId), messageParameters);
Assert.Equal(expectedMessage, message.Message);
}
}
protected void AssertCompilerReturnsWarningMessage(
string input, CompilerMessageId messageId, params string[] messageParameters)
{
this.AssertCompilerReturnsMessage(
input,
messageId,
CompilerMessageType.Warning,
messageParameters);
}
public void GetMessage_ForAllMessageIds_ReturnsMessage(CompilerMessageId messageId)
{
// Arrange
var messageKey = CompilerMessages.FormatMessageId(messageId);
var expectedMessage = this.resourceManager.GetString(messageKey);
// Act
var actualMessage = CompilerMessages.Get(messageId);
// Assert
Assert.True(!string.IsNullOrEmpty(expectedMessage), $"Compiler message missing for {messageKey}");
Assert.Equal(expectedMessage, actualMessage);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompilationMessage" /> class.
/// </summary>
/// <param name="messageId">The compiler message Id.</param>
/// <param name="messageType">The type of message being reported.</param>
/// <param name="lineNumber">The 1-based line number in the document.</param>
/// <param name="startPosition">
/// The 1-based starting position of the message on the line.
/// </param>
/// <param name="endPosition">
/// The 1-based ending position of the message on the line.
/// </param>
/// <param name="message">
/// The user-friendly compiler message.
/// </param>
public CompilationMessage(
CompilerMessageId messageId,
CompilerMessageType messageType,
int lineNumber,
int startPosition,
int endPosition,
string message)
{
this.MessageId = messageId;
this.MessageType = messageType;
this.LineNumber = lineNumber;
this.StartPosition = startPosition;
this.EndPosition = endPosition;
this.Message = message;
}
/// <summary>
/// Creates a warning message, specifying the tokens to highlight.
/// </summary>
/// <param name="messageId">The compiler message Id.</param>
/// <param name="startToken">
/// The starting token that the warning should be placed against.
/// </param>
/// <param name="endToken">
/// The end token that the warning should be placed against.
/// </param>
/// <param name="messageParameters">
/// Any parameters to include when formatting the compiler message.
/// </param>
/// <returns>The warning message.</returns>
public static CompilationMessage CreateWarning(
CompilerMessageId messageId,
IToken startToken,
IToken endToken,
string[] messageParameters)
{
string formattedMessage = string.Format(
CompilerMessages.Get(messageId), messageParameters);
return(new CompilationMessage(
messageId,
CompilerMessageType.Warning,
startToken.Line,
startToken.Column + 1,
endToken.Column + endToken.Text.Length,
formattedMessage));
}
protected void AssertCompilerDoesNotReturnMessage(
string input,
CompilerMessageId messageId)
{
// Arrange
var compiler = new ThriftCompiler();
var parserInput = ParserInput.FromString(input);
// Act
var result = compiler.Compile(parserInput.GetStream());
// Assert
var message = result.Messages.FirstOrDefault(m => m.MessageId == messageId);
Assert.True(
message == null,
$"Message Id '{messageId}' should not have been reported");
}
protected void AssertCompilerReturnsMessage(
string input,
CompilerMessageId messageId,
CompilerMessageType messageType,
string[] messageParameters)
{
// Arrange
var compiler = new ThriftCompiler();
var parserInput = ParserInput.FromString(input);
// Act
var result = compiler.Compile(parserInput.GetStream());
// Assert
var message = result.Messages.FirstOrDefault(
m => m.MessageType == messageType && m.MessageId == messageId);
Assert.True(message != null, $"No {messageType.ToString().ToLower()} messages were returned from the compiler");
// Although we know that message cannot be null because of the assert on
// the previous line, check for null here because the lgtm check isn't
// smart enough to realise that
if (message != null)
{
if (parserInput.LineNumber != null)
{
Assert.Equal(parserInput.LineNumber, message.LineNumber);
Assert.Equal(parserInput.StartPosition, message.StartPosition);
Assert.Equal(parserInput.EndPosition, message.EndPosition);
}
if (messageParameters?.Length > 0)
{
var expectedMessage = string.Format(
CompilerMessages.Get(messageId), messageParameters);
Assert.Equal(expectedMessage, message.Message);
}
}
}
private void AddWarning(CompilerMessageId messageId, IToken token, params string[] messageParameters)
{
this.messages.Add(CompilationMessage.CreateWarning(
messageId, token, token, messageParameters));
}
private void AddError(CompilerMessageId messageId, IToken startToken, IToken endToken, params string[] messageParameters)
{
this.messages.Add(CompilationMessage.CreateError(
messageId, startToken, endToken, messageParameters));
}
/// <summary>
/// Gets the content of the specified message Id.
/// </summary>
/// <param name="messageId">The Id of the message to get.</param>
/// <returns>The content of the message.</returns>
public static string Get(CompilerMessageId messageId)
{
return(Manager.GetString(FormatMessageId(messageId)));
}
/// <summary>
/// Formats the specified compiler message Id as a string.
/// </summary>
/// <param name="messageId">The message Id.</param>
/// <returns>The formatted message Id.</returns>
public static string FormatMessageId(CompilerMessageId messageId)
{
return($"TC{(int)messageId:0000}");
}
