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