public bool Execute()
{
var message = string.Format("Costura.EmbedTask v{0} Executing (Change MessageImportance to get more or less info)", version);
var buildMessageEventArgs = new BuildMessageEventArgs(message, "", "EmbedTask", Microsoft.Build.Framework.MessageImportance.High);
BuildEngine.LogMessageEvent(buildMessageEventArgs);
var stopwatch = Stopwatch.StartNew();
try
{
logger = new Logger
{
BuildEngine = BuildEngine,
};
logger.Initialise(MessageImportance);
Inner();
}
catch (Exception exception)
{
HandleException(exception);
}
finally
{
stopwatch.Stop();
logger.Flush();
BuildEngine.LogMessageEvent(new BuildMessageEventArgs(string.Format("\tFinished ({0}ms)", stopwatch.ElapsedMilliseconds), "", "Costura.EmbedTask", Microsoft.Build.Framework.MessageImportance.High));
}
return !logger.ErrorHasBeenRaised;
}
/// <summary>
/// Raises the given event to all registered loggers. This method up-cast the events
/// extracted from the queue.
/// </summary>
public void Consume(BuildEventArgs buildEvent)
{
// FXCop may complain that there are unecessary casts here, and there are, but
// using "as" and allocating another variable for each event is extremely costly
// and is much slower then this approach even with the additional casts
if (buildEvent is BuildMessageEventArgs)
{
this.RaiseMessageEvent(null, (BuildMessageEventArgs)buildEvent);
}
else if (buildEvent is TaskStartedEventArgs)
{
this.RaiseTaskStartedEvent(null, (TaskStartedEventArgs)buildEvent);
}
else if (buildEvent is TaskFinishedEventArgs)
{
this.RaiseTaskFinishedEvent(null, (TaskFinishedEventArgs)buildEvent);
}
else if (buildEvent is TargetStartedEventArgs)
{
this.RaiseTargetStartedEvent(null, (TargetStartedEventArgs)buildEvent);
}
else if (buildEvent is TargetFinishedEventArgs)
{
this.RaiseTargetFinishedEvent(null, (TargetFinishedEventArgs)buildEvent);
}
else if (buildEvent is ProjectStartedEventArgs)
{
this.RaiseProjectStartedEvent(null, (ProjectStartedEventArgs)buildEvent);
}
else if (buildEvent is ProjectFinishedEventArgs)
{
this.RaiseProjectFinishedEvent(null, (ProjectFinishedEventArgs)buildEvent);
if (buildEvent.BuildEventContext != null && buildEvent.BuildEventContext.ProjectInstanceId != BuildEventContext.InvalidProjectInstanceId)
{
WarningsAsErrorsByProject?.Remove(buildEvent.BuildEventContext.ProjectInstanceId);
WarningsAsMessagesByProject?.Remove(buildEvent.BuildEventContext.ProjectInstanceId);
}
}
else if (buildEvent is BuildStartedEventArgs)
{
HaveLoggedBuildStartedEvent = true;
this.RaiseBuildStartedEvent(null, (BuildStartedEventArgs)buildEvent);
}
else if (buildEvent is BuildFinishedEventArgs)
{
HaveLoggedBuildFinishedEvent = true;
this.RaiseBuildFinishedEvent(null, (BuildFinishedEventArgs)buildEvent);
}
else if (buildEvent is CustomBuildEventArgs)
{
this.RaiseCustomEvent(null, (CustomBuildEventArgs)buildEvent);
}
else if (buildEvent is BuildStatusEventArgs)
{
this.RaiseStatusEvent(null, (BuildStatusEventArgs)buildEvent);
}
else if (buildEvent is BuildWarningEventArgs)
{
BuildWarningEventArgs warningEvent = (BuildWarningEventArgs)buildEvent;
if (ShouldTreatWarningAsMessage(warningEvent))
{
// Treat this warning as a message with low importance if its in the list
BuildMessageEventArgs errorEvent = new BuildMessageEventArgs(
warningEvent.Subcategory,
warningEvent.Code,
warningEvent.File,
warningEvent.LineNumber,
warningEvent.ColumnNumber,
warningEvent.EndLineNumber,
warningEvent.EndColumnNumber,
warningEvent.Message,
warningEvent.HelpKeyword,
warningEvent.SenderName,
MessageImportance.Low,
warningEvent.Timestamp)
{
BuildEventContext = warningEvent.BuildEventContext,
ProjectFile = warningEvent.ProjectFile,
};
this.RaiseMessageEvent(null, errorEvent);
}
else if (ShouldTreatWarningAsError(warningEvent))
{
// Treat this warning as an error if an empty set of warnings was specified or this code was specified
BuildErrorEventArgs errorEvent = new BuildErrorEventArgs(
warningEvent.Subcategory,
warningEvent.Code,
warningEvent.File,
warningEvent.LineNumber,
warningEvent.ColumnNumber,
warningEvent.EndLineNumber,
warningEvent.EndColumnNumber,
warningEvent.Message,
warningEvent.HelpKeyword,
warningEvent.SenderName,
warningEvent.Timestamp)
{
BuildEventContext = warningEvent.BuildEventContext,
ProjectFile = warningEvent.ProjectFile,
};
this.RaiseErrorEvent(null, errorEvent);
}
else
{
this.RaiseWarningEvent(null, warningEvent);
}
}
else if (buildEvent is BuildErrorEventArgs)
{
this.RaiseErrorEvent(null, (BuildErrorEventArgs)buildEvent);
}
else if (buildEvent is TelemetryEventArgs)
{
this.RaiseTelemetryEvent(null, (TelemetryEventArgs)buildEvent);
}
else
{
ErrorUtilities.VerifyThrow(false, "Unknown event args type.");
}
}
/// <summary>
/// Write a provided instance of BuildEventArgs to the BinaryWriter
/// </summary>
public void Write(BuildEventArgs e)
{
// the cases are ordered by most used first for performance
if (e is BuildMessageEventArgs && e.GetType().Name != "ProjectImportedEventArgs")
{
Write((BuildMessageEventArgs)e);
}
else if (e is TaskStartedEventArgs)
{
Write((TaskStartedEventArgs)e);
}
else if (e is TaskFinishedEventArgs)
{
Write((TaskFinishedEventArgs)e);
}
else if (e is TargetStartedEventArgs)
{
Write((TargetStartedEventArgs)e);
}
else if (e is TargetFinishedEventArgs)
{
Write((TargetFinishedEventArgs)e);
}
else if (e is BuildErrorEventArgs)
{
Write((BuildErrorEventArgs)e);
}
else if (e is BuildWarningEventArgs)
{
Write((BuildWarningEventArgs)e);
}
else if (e is ProjectStartedEventArgs)
{
Write((ProjectStartedEventArgs)e);
}
else if (e is ProjectFinishedEventArgs)
{
Write((ProjectFinishedEventArgs)e);
}
else if (e is BuildStartedEventArgs)
{
Write((BuildStartedEventArgs)e);
}
else if (e is BuildFinishedEventArgs)
{
Write((BuildFinishedEventArgs)e);
}
else if (e is ProjectEvaluationStartedEventArgs)
{
Write((ProjectEvaluationStartedEventArgs)e);
}
else if (e is ProjectEvaluationFinishedEventArgs)
{
Write((ProjectEvaluationFinishedEventArgs)e);
}
// The following cases are due to the fact that StructuredLogger.dll
// only references MSBuild 14.0 .dlls. The following BuildEventArgs types
// were only introduced in MSBuild 15.3 so we can't refer to them statically.
// To still provide a good experience to those who are using the BinaryLogger
// from StructuredLogger.dll against MSBuild 15.3 or later we need to preserve
// these new events, so use reflection to create our "equivalents" of those
// and populate them to be binary identical to the originals. Then serialize
// our copies so that it's impossible to tell what wrote these.
else if (e.GetType().Name == "ProjectEvaluationStartedEventArgs")
{
var evaluationStarted = new ProjectEvaluationStartedEventArgs(e.Message);
evaluationStarted.BuildEventContext = e.BuildEventContext;
evaluationStarted.ProjectFile = Reflector.GetProjectFileFromEvaluationStarted(e);
Write(evaluationStarted);
}
else if (e.GetType().Name == "ProjectEvaluationFinishedEventArgs")
{
var evaluationFinished = new ProjectEvaluationFinishedEventArgs(e.Message);
evaluationFinished.BuildEventContext = e.BuildEventContext;
evaluationFinished.ProjectFile = Reflector.GetProjectFileFromEvaluationFinished(e);
Write(evaluationFinished);
}
else if (e.GetType().Name == "ProjectImportedEventArgs")
{
var message = e as BuildMessageEventArgs;
var projectImported = new ProjectImportedEventArgs(message.LineNumber, message.ColumnNumber, e.Message);
projectImported.BuildEventContext = e.BuildEventContext;
projectImported.ProjectFile = message.ProjectFile;
projectImported.ImportedProjectFile = Reflector.GetImportedProjectFile(e);
projectImported.UnexpandedProject = Reflector.GetUnexpandedProject(e);
Write(projectImported);
}
else
{
// convert all unrecognized objects to message
// and just preserve the message
var buildMessageEventArgs = new BuildMessageEventArgs(
e.Message,
e.HelpKeyword,
e.SenderName,
MessageImportance.Normal,
e.Timestamp);
buildMessageEventArgs.BuildEventContext = e.BuildEventContext ?? BuildEventContext.Invalid;
Write(buildMessageEventArgs);
}
}
/// <summary>
/// This is the delegate for Message event types
/// </summary>
protected virtual void MessageHandler(object sender, BuildMessageEventArgs messageEvent)
{
// NOTE: This may run on a background thread!
QueueOutputEvent(messageEvent.Importance, messageEvent);
}
public void EventsOutOfSequence()
{
// Make sure that the registry key is no present so that we can set the verbosity.
DeleteVerbosityKey();
using (OleServiceProvider provider = new OleServiceProvider())
{
using (TaskProvider task = new TaskProvider(new ServiceProvider(provider)))
{
IVsHierarchy hierarchy = MockFactories.HierarchyForLogger(provider);
IVsOutputWindowPane output = MockFactories.OutputPaneWithStringFunctions();
BaseMock mockOutput = (BaseMock)output;
// Create the logger and make sure that it points to the verbosity
IDELoggerProxy logger = new IDELoggerProxy(output, task, hierarchy);
logger.SetBuildVerbosityRegistryRoot(TestVerbosityRoot);
// Create the IEventSource that will be used to send messages to the logger
BaseMock mockSource = MockFactories.CreateMSBuildEventSource();
// Now initialize the logger.
logger.Initialize(mockSource as IEventSource);
// Verify that the logger has installed an event handler for messages and
// build events.
Assert.IsNotNull(mockSource["MessageRaised"]);
BuildMessageEventHandler messageHandler = (BuildMessageEventHandler)mockSource["MessageRaised"];
Assert.IsNotNull(mockSource["BuildStarted"]);
BuildStartedEventHandler buildStartedHandler = (BuildStartedEventHandler)mockSource["BuildStarted"];
Assert.IsNotNull(mockSource["BuildFinished"]);
BuildFinishedEventHandler buildFinishedHandler = (BuildFinishedEventHandler)mockSource["BuildFinished"];
Assert.IsNotNull(mockSource["TaskStarted"]);
TaskStartedEventHandler taskStartedHandler = (TaskStartedEventHandler)mockSource["TaskStarted"];
Assert.IsNotNull(mockSource["TaskFinished"]);
TaskFinishedEventHandler taskFinishedHandler = (TaskFinishedEventHandler)mockSource["TaskFinished"];
// Create the arguments for the events and the delegates.
BuildMessageEventArgs messageArgs = new BuildMessageEventArgs("Message", "help", "sender", MessageImportance.Normal);
SendEventFunction sendMessage = delegate { messageHandler.Invoke(mockSource, messageArgs); };
//
BuildStartedEventArgs startBuildArgs = new BuildStartedEventArgs("Start Build", "help");
SendEventFunction sendStartBuild = delegate { buildStartedHandler.Invoke(mockSource, startBuildArgs); };
//
BuildFinishedEventArgs finishBuildArgs = new BuildFinishedEventArgs("End Build", "help", true);
SendEventFunction sendEndBuild = delegate { buildFinishedHandler.Invoke(mockSource, finishBuildArgs); };
//
TaskStartedEventArgs startTaskArgs = new TaskStartedEventArgs("Start Task", null, null, null, null);
SendEventFunction sendStartTask = delegate { taskStartedHandler.Invoke(mockSource, startTaskArgs); };
//
TaskFinishedEventArgs endTaskArgs = new TaskFinishedEventArgs("End Task", null, null, null, null, true);
SendEventFunction sendEndTask = delegate { taskFinishedHandler.Invoke(mockSource, endTaskArgs); };
// Set the verbosity to Diagnostic so that all the messages are written.
logger.Verbosity = LoggerVerbosity.Diagnostic;
List <SendEventFunction>[] events = new List <SendEventFunction>[] {
new List <SendEventFunction>(new SendEventFunction[] { sendMessage, sendEndBuild, sendStartBuild }),
new List <SendEventFunction>(new SendEventFunction[] { sendStartBuild, sendEndTask, sendEndBuild, sendStartTask }),
new List <SendEventFunction>(new SendEventFunction[] { sendStartTask, sendStartBuild, sendEndTask, sendEndBuild }),
new List <SendEventFunction>(new SendEventFunction[] { sendEndBuild, sendStartTask, sendEndTask, sendStartBuild }),
new List <SendEventFunction>(new SendEventFunction[] { sendEndBuild, sendEndTask, sendStartTask, sendStartBuild }),
new List <SendEventFunction>(new SendEventFunction[] { sendEndTask, sendEndBuild, sendStartTask, sendStartBuild }),
};
// Call the functions. Note that here we don't check for the actual text printed on the output,
// but we simply verify that the logger can handle the events without exceptions.
foreach (List <SendEventFunction> sendFunctions in events)
{
output.Clear();
foreach (SendEventFunction func in sendFunctions)
{
func();
}
}
}
}
}
public void LogMessageEvent(BuildMessageEventArgs eventArgs)
{
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
LogMessageEvents.Add(e);
}
private void eventSource_MessageHandler(object sender, BuildMessageEventArgs e)
{
LogMessage(XmlLoggerElements.Message, e.Message, e.Importance, e.Timestamp);
}
/// <inheritdoc cref="IBuildEngine.LogMessageEvent" /> public void LogMessageEvent(BuildMessageEventArgs e) => Add(e);
private void EventSource_MessageRaised(object sender, BuildMessageEventArgs e)
{
_logger
.WithStack(_frameStack)
.Information("{MessageImportance} message: {MessageText}", e.Importance, e.Message);
}
/// <summary>
/// Prints a message event
/// </summary>
public void MessageHandler(object sender, BuildMessageEventArgs e)
{
InitializeBaseConsoleLogger(); // for compat: see DDB#136924
_consoleLogger.MessageHandler(sender, e);
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
_logger.LogInformation("{Message}", e.Message);
}
void eventSource_MessageHandler(object sender, BuildMessageEventArgs e)
{
LogMessage(XmlLoggerElements.Message, e.Message, e.Importance, e.Timestamp);
}
public virtual void LogMessageEvent(BuildMessageEventArgs eventArgs)
{
this.messages.Add(eventArgs);
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
this.ConsoleLogger.LogMessage(e.Message);
}
void IBuildEngine.LogMessageEvent(BuildMessageEventArgs e)
{
Console.WriteLine("BuildEngine: MESSAGE: {0}", e.Message);
this.messages.Add(e);
}
private void BuildMessage(object sender, BuildMessageEventArgs e)
{
SendMessage(FormatMessage(e));
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
Console.WriteLine($"MESSAGE: {e.Code} {e.Message} in {e.File} {e.LineNumber}:{e.ColumnNumber}-{e.EndLineNumber}:{e.EndColumnNumber}");
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
}
/// <summary>
/// Handle a message event
/// </summary>
/// <param name="sender">Who sent the event</param>
/// <param name="e">Event raised on the event source</param>
private void Source_MessageRaised(object sender, BuildMessageEventArgs e)
{
HandleEvent(e);
}
/// <summary>
/// Compares two LogMessagePacket objects for equivalence.
/// </summary>
private void CompareLogMessagePackets(LogMessagePacket left, LogMessagePacket right)
{
Assert.Equal(left.EventType, right.EventType);
Assert.Equal(left.NodeBuildEvent.Value.Value.GetType(), right.NodeBuildEvent.Value.Value.GetType());
CompareNodeBuildEventArgs(left.NodeBuildEvent.Value, right.NodeBuildEvent.Value, left.EventType == LoggingEventType.CustomEvent /* expectInvalidBuildEventContext */);
switch (left.EventType)
{
case LoggingEventType.BuildErrorEvent:
BuildErrorEventArgs leftError = left.NodeBuildEvent.Value.Value as BuildErrorEventArgs;
BuildErrorEventArgs rightError = right.NodeBuildEvent.Value.Value as BuildErrorEventArgs;
Assert.NotNull(leftError);
Assert.NotNull(rightError);
Assert.Equal(leftError.Code, rightError.Code);
Assert.Equal(leftError.ColumnNumber, rightError.ColumnNumber);
Assert.Equal(leftError.EndColumnNumber, rightError.EndColumnNumber);
Assert.Equal(leftError.EndLineNumber, rightError.EndLineNumber);
Assert.Equal(leftError.File, rightError.File);
Assert.Equal(leftError.LineNumber, rightError.LineNumber);
Assert.Equal(leftError.Message, rightError.Message);
Assert.Equal(leftError.Subcategory, rightError.Subcategory);
break;
case LoggingEventType.BuildFinishedEvent:
BuildFinishedEventArgs leftFinished = left.NodeBuildEvent.Value.Value as BuildFinishedEventArgs;
BuildFinishedEventArgs rightFinished = right.NodeBuildEvent.Value.Value as BuildFinishedEventArgs;
Assert.NotNull(leftFinished);
Assert.NotNull(rightFinished);
Assert.Equal(leftFinished.Succeeded, rightFinished.Succeeded);
break;
case LoggingEventType.BuildMessageEvent:
BuildMessageEventArgs leftMessage = left.NodeBuildEvent.Value.Value as BuildMessageEventArgs;
BuildMessageEventArgs rightMessage = right.NodeBuildEvent.Value.Value as BuildMessageEventArgs;
Assert.NotNull(leftMessage);
Assert.NotNull(rightMessage);
Assert.Equal(leftMessage.Importance, rightMessage.Importance);
break;
case LoggingEventType.BuildStartedEvent:
BuildStartedEventArgs leftBuildStart = left.NodeBuildEvent.Value.Value as BuildStartedEventArgs;
BuildStartedEventArgs rightBuildStart = right.NodeBuildEvent.Value.Value as BuildStartedEventArgs;
Assert.NotNull(leftBuildStart);
Assert.NotNull(rightBuildStart);
break;
case LoggingEventType.BuildWarningEvent:
BuildWarningEventArgs leftBuildWarn = left.NodeBuildEvent.Value.Value as BuildWarningEventArgs;
BuildWarningEventArgs rightBuildWarn = right.NodeBuildEvent.Value.Value as BuildWarningEventArgs;
Assert.NotNull(leftBuildWarn);
Assert.NotNull(rightBuildWarn);
Assert.Equal(leftBuildWarn.Code, rightBuildWarn.Code);
Assert.Equal(leftBuildWarn.ColumnNumber, rightBuildWarn.ColumnNumber);
Assert.Equal(leftBuildWarn.EndColumnNumber, rightBuildWarn.EndColumnNumber);
Assert.Equal(leftBuildWarn.EndLineNumber, rightBuildWarn.EndLineNumber);
Assert.Equal(leftBuildWarn.File, rightBuildWarn.File);
Assert.Equal(leftBuildWarn.LineNumber, rightBuildWarn.LineNumber);
Assert.Equal(leftBuildWarn.Subcategory, rightBuildWarn.Subcategory);
break;
case LoggingEventType.CustomEvent:
ExternalProjectStartedEventArgs leftCustom = left.NodeBuildEvent.Value.Value as ExternalProjectStartedEventArgs;
ExternalProjectStartedEventArgs rightCustom = right.NodeBuildEvent.Value.Value as ExternalProjectStartedEventArgs;
Assert.NotNull(leftCustom);
Assert.NotNull(rightCustom);
Assert.Equal(leftCustom.ProjectFile, rightCustom.ProjectFile);
Assert.Equal(leftCustom.TargetNames, rightCustom.TargetNames);
break;
case LoggingEventType.ProjectFinishedEvent:
ProjectFinishedEventArgs leftProjectFinished = left.NodeBuildEvent.Value.Value as ProjectFinishedEventArgs;
ProjectFinishedEventArgs rightProjectFinished = right.NodeBuildEvent.Value.Value as ProjectFinishedEventArgs;
Assert.NotNull(leftProjectFinished);
Assert.NotNull(rightProjectFinished);
Assert.Equal(leftProjectFinished.ProjectFile, rightProjectFinished.ProjectFile);
Assert.Equal(leftProjectFinished.Succeeded, rightProjectFinished.Succeeded);
break;
case LoggingEventType.ProjectStartedEvent:
ProjectStartedEventArgs leftProjectStarted = left.NodeBuildEvent.Value.Value as ProjectStartedEventArgs;
ProjectStartedEventArgs rightProjectStarted = right.NodeBuildEvent.Value.Value as ProjectStartedEventArgs;
Assert.NotNull(leftProjectStarted);
Assert.NotNull(rightProjectStarted);
Assert.Equal(leftProjectStarted.ParentProjectBuildEventContext, rightProjectStarted.ParentProjectBuildEventContext);
Assert.Equal(leftProjectStarted.ProjectFile, rightProjectStarted.ProjectFile);
Assert.Equal(leftProjectStarted.ProjectId, rightProjectStarted.ProjectId);
Assert.Equal(leftProjectStarted.TargetNames, rightProjectStarted.TargetNames);
// UNDONE: (Serialization.) We don't actually serialize the items at this time.
// Assert.AreEqual(leftProjectStarted.Items, rightProjectStarted.Items);
// UNDONE: (Serialization.) We don't actually serialize properties at this time.
// Assert.AreEqual(leftProjectStarted.Properties, rightProjectStarted.Properties);
break;
case LoggingEventType.TargetFinishedEvent:
TargetFinishedEventArgs leftTargetFinished = left.NodeBuildEvent.Value.Value as TargetFinishedEventArgs;
TargetFinishedEventArgs rightTargetFinished = right.NodeBuildEvent.Value.Value as TargetFinishedEventArgs;
Assert.NotNull(leftTargetFinished);
Assert.NotNull(rightTargetFinished);
Assert.Equal(leftTargetFinished.ProjectFile, rightTargetFinished.ProjectFile);
Assert.Equal(leftTargetFinished.Succeeded, rightTargetFinished.Succeeded);
Assert.Equal(leftTargetFinished.TargetFile, rightTargetFinished.TargetFile);
Assert.Equal(leftTargetFinished.TargetName, rightTargetFinished.TargetName);
break;
case LoggingEventType.TargetStartedEvent:
TargetStartedEventArgs leftTargetStarted = left.NodeBuildEvent.Value.Value as TargetStartedEventArgs;
TargetStartedEventArgs rightTargetStarted = right.NodeBuildEvent.Value.Value as TargetStartedEventArgs;
Assert.NotNull(leftTargetStarted);
Assert.NotNull(rightTargetStarted);
Assert.Equal(leftTargetStarted.ProjectFile, rightTargetStarted.ProjectFile);
Assert.Equal(leftTargetStarted.TargetFile, rightTargetStarted.TargetFile);
Assert.Equal(leftTargetStarted.TargetName, rightTargetStarted.TargetName);
break;
case LoggingEventType.TaskCommandLineEvent:
TaskCommandLineEventArgs leftCommand = left.NodeBuildEvent.Value.Value as TaskCommandLineEventArgs;
TaskCommandLineEventArgs rightCommand = right.NodeBuildEvent.Value.Value as TaskCommandLineEventArgs;
Assert.NotNull(leftCommand);
Assert.NotNull(rightCommand);
Assert.Equal(leftCommand.CommandLine, rightCommand.CommandLine);
Assert.Equal(leftCommand.Importance, rightCommand.Importance);
Assert.Equal(leftCommand.TaskName, rightCommand.TaskName);
break;
case LoggingEventType.TaskFinishedEvent:
TaskFinishedEventArgs leftTaskFinished = left.NodeBuildEvent.Value.Value as TaskFinishedEventArgs;
TaskFinishedEventArgs rightTaskFinished = right.NodeBuildEvent.Value.Value as TaskFinishedEventArgs;
Assert.NotNull(leftTaskFinished);
Assert.NotNull(rightTaskFinished);
Assert.Equal(leftTaskFinished.ProjectFile, rightTaskFinished.ProjectFile);
Assert.Equal(leftTaskFinished.Succeeded, rightTaskFinished.Succeeded);
Assert.Equal(leftTaskFinished.TaskFile, rightTaskFinished.TaskFile);
Assert.Equal(leftTaskFinished.TaskName, rightTaskFinished.TaskName);
break;
case LoggingEventType.TaskStartedEvent:
TaskStartedEventArgs leftTaskStarted = left.NodeBuildEvent.Value.Value as TaskStartedEventArgs;
TaskStartedEventArgs rightTaskStarted = right.NodeBuildEvent.Value.Value as TaskStartedEventArgs;
Assert.NotNull(leftTaskStarted);
Assert.NotNull(rightTaskStarted);
Assert.Equal(leftTaskStarted.ProjectFile, rightTaskStarted.ProjectFile);
Assert.Equal(leftTaskStarted.TaskFile, rightTaskStarted.TaskFile);
Assert.Equal(leftTaskStarted.TaskName, rightTaskStarted.TaskName);
break;
default:
Assert.True(false, string.Format("Unexpected logging event type {0}", left.EventType));
break;
}
}
public virtual void LogMessageEvent(BuildMessageEventArgs e)
{
throw new Exception("The method or operation is not implemented.");
}
public void MessageFormattingTest()
{
// Make sure that the registry key is no present so that we can set the verbosity.
DeleteVerbosityKey();
using (OleServiceProvider provider = new OleServiceProvider())
{
using (TaskProvider task = new TaskProvider(new ServiceProvider(provider)))
{
IVsHierarchy hierarchy = MockFactories.HierarchyForLogger(provider);
IVsOutputWindowPane output = MockFactories.OutputPaneWithStringFunctions();
BaseMock mockOutput = (BaseMock)output;
// Create the logger and make sure that it points to the verbosity
IDELoggerProxy logger = new IDELoggerProxy(output, task, hierarchy);
logger.SetBuildVerbosityRegistryRoot(TestVerbosityRoot);
// Create the IEventSource that will be used to send messages to the logger
BaseMock mockSource = MockFactories.CreateMSBuildEventSource();
// Now initialize the logger.
logger.Initialize(mockSource as IEventSource);
// Verify that the logger has installed an event handler for messages and
// build events.
Assert.IsNotNull(mockSource["MessageRaised"]);
BuildMessageEventHandler messageHandler = (BuildMessageEventHandler)mockSource["MessageRaised"];
Assert.IsNotNull(mockSource["BuildStarted"]);
BuildStartedEventHandler buildStartedHandler = (BuildStartedEventHandler)mockSource["BuildStarted"];
Assert.IsNotNull(mockSource["BuildFinished"]);
BuildFinishedEventHandler buildFinishedHandler = (BuildFinishedEventHandler)mockSource["BuildFinished"];
Assert.IsNotNull(mockSource["TaskStarted"]);
TaskStartedEventHandler taskStartedHandler = (TaskStartedEventHandler)mockSource["TaskStarted"];
Assert.IsNotNull(mockSource["TaskFinished"]);
TaskFinishedEventHandler taskFinishedHandler = (TaskFinishedEventHandler)mockSource["TaskFinished"];
// Set the verbosity to Diagnostic so that all the messages are written.
logger.Verbosity = LoggerVerbosity.Diagnostic;
// Create a message of the expected importance.
BuildMessageEventArgs message = new BuildMessageEventArgs("message", "help", "sender", MessageImportance.Normal);
messageHandler.Invoke(mockSource, message);
// Add a second message with null text.
message = new BuildMessageEventArgs(null, "help", "sender", MessageImportance.Normal);
messageHandler.Invoke(mockSource, message);
// Add another message with emty text.
message = new BuildMessageEventArgs(string.Empty, "help", "sender", MessageImportance.Normal);
messageHandler.Invoke(mockSource, message);
System.Windows.Forms.Application.DoEvents();
string expected = "message" + Environment.NewLine;
System.Text.StringBuilder builder = (System.Text.StringBuilder)mockOutput["StringBuilder"];
Assert.AreEqual(expected, builder.ToString(), false);
// Clean up the text.
output.Clear();
// Now verify the identation in case of start and end build events.
string startText = "Test Started";
string messageText = "build message";
string endText = "Test Finished";
BuildStartedEventArgs startBuildArgs = new BuildStartedEventArgs(startText, "help");
buildStartedHandler.Invoke(mockSource, startBuildArgs);
message = new BuildMessageEventArgs(messageText, "help", "sender", MessageImportance.Normal);
messageHandler.Invoke(mockSource, message);
BuildFinishedEventArgs finishBuildArgs = new BuildFinishedEventArgs(endText, "help", true);
buildFinishedHandler.Invoke(mockSource, finishBuildArgs);
System.Windows.Forms.Application.DoEvents();
// Get the text in the output pane.
builder = (System.Text.StringBuilder)mockOutput["StringBuilder"];
expected = string.Format("{0}{1}{2}{1}{1}{3}{1}", startText, Environment.NewLine, messageText, endText);
Assert.AreEqual(expected, builder.ToString(), false);
// Clear the output and test the identation in case of start and end task.
output.Clear();
TaskStartedEventArgs startTaskArgs = new TaskStartedEventArgs(startText, null, null, null, null);
taskStartedHandler.Invoke(mockSource, startTaskArgs);
message = new BuildMessageEventArgs(messageText, "help", "sender", MessageImportance.Normal);
messageHandler.Invoke(mockSource, message);
TaskFinishedEventArgs endTaskArgs = new TaskFinishedEventArgs(endText, null, null, null, null, true);
taskFinishedHandler.Invoke(mockSource, endTaskArgs);
System.Windows.Forms.Application.DoEvents();
// Verify the text in the output pane.
expected = string.Format("{0}{1}\t{2}{1}{3}{1}", startText, Environment.NewLine, messageText, endText);
builder = (System.Text.StringBuilder)mockOutput["StringBuilder"];
Assert.AreEqual(expected, builder.ToString(), false);
}
}
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
Console.WriteLine($"{e.File} ({e.LineNumber},{e.ColumnNumber},{e.EndLineNumber},{e.EndColumnNumber}): XAMLIL MESSAGE {e.Code}: {e.Message}");
}
public abstract void MessageHandler(object sender, BuildMessageEventArgs e);
private void Log(BuildMessageEventArgs eventArgs)
{
Messages.Add(String.Format("MESSAGE[{0}]: {1}", eventArgs.Importance, eventArgs.Message));
}
private void WriteMessageFields(BuildMessageEventArgs e, bool writeMessage = true, bool writeImportance = false)
{
var flags = GetBuildEventArgsFieldFlags(e, writeMessage);
flags = GetMessageFlags(e, flags, writeMessage, writeImportance);
Write((int)flags);
WriteBaseFields(e, flags);
if ((flags & BuildEventArgsFieldFlags.Subcategory) != 0)
{
WriteDeduplicatedString(e.Subcategory);
}
if ((flags & BuildEventArgsFieldFlags.Code) != 0)
{
WriteDeduplicatedString(e.Code);
}
if ((flags & BuildEventArgsFieldFlags.File) != 0)
{
WriteDeduplicatedString(e.File);
}
if ((flags & BuildEventArgsFieldFlags.ProjectFile) != 0)
{
WriteDeduplicatedString(e.ProjectFile);
}
if ((flags & BuildEventArgsFieldFlags.LineNumber) != 0)
{
Write(e.LineNumber);
}
if ((flags & BuildEventArgsFieldFlags.ColumnNumber) != 0)
{
Write(e.ColumnNumber);
}
if ((flags & BuildEventArgsFieldFlags.EndLineNumber) != 0)
{
Write(e.EndLineNumber);
}
if ((flags & BuildEventArgsFieldFlags.EndColumnNumber) != 0)
{
Write(e.EndColumnNumber);
}
if ((flags & BuildEventArgsFieldFlags.Arguments) != 0)
{
Write(e.RawArguments.Length);
for (int i = 0; i < e.RawArguments.Length; i++)
{
string argument = Convert.ToString(e.RawArguments[i], CultureInfo.CurrentCulture);
WriteDeduplicatedString(argument);
}
}
if ((flags & BuildEventArgsFieldFlags.Importance) != 0)
{
Write((int)e.Importance);
}
}
public void LogMessageEvent(BuildMessageEventArgs e) => Console.WriteLine(e.Message);
public void LogMessageEvent(BuildMessageEventArgs e) => this.buildEvents.Add(e);
/// <summary>
/// Write a provided instance of BuildEventArgs to the BinaryWriter
/// </summary>
public void Write(BuildEventArgs e)
{
switch (e)
{
// the cases are ordered by most used first for performance
case BuildMessageEventArgs args:
Write(args);
break;
case TaskStartedEventArgs eventArgs:
Write(eventArgs);
break;
case TaskFinishedEventArgs finishedEventArgs:
Write(finishedEventArgs);
break;
case TargetStartedEventArgs startedEventArgs:
Write(startedEventArgs);
break;
case TargetFinishedEventArgs targetFinishedEventArgs:
Write(targetFinishedEventArgs);
break;
case BuildErrorEventArgs errorEventArgs:
Write(errorEventArgs);
break;
case BuildWarningEventArgs warningEventArgs:
Write(warningEventArgs);
break;
case ProjectStartedEventArgs projectStartedEventArgs:
Write(projectStartedEventArgs);
break;
case ProjectFinishedEventArgs projectFinishedEventArgs:
Write(projectFinishedEventArgs);
break;
case BuildStartedEventArgs buildStartedEventArgs:
Write(buildStartedEventArgs);
break;
case BuildFinishedEventArgs buildFinishedEventArgs:
Write(buildFinishedEventArgs);
break;
case ProjectEvaluationStartedEventArgs evaluationStartedEventArgs:
Write(evaluationStartedEventArgs);
break;
case ProjectEvaluationFinishedEventArgs evaluationFinishedEventArgs:
Write(evaluationFinishedEventArgs);
break;
default:
// convert all unrecognized objects to message
// and just preserve the message
BuildMessageEventArgs buildMessageEventArgs = new BuildMessageEventArgs(
e.Message,
e.HelpKeyword,
e.SenderName,
MessageImportance.Normal,
e.Timestamp)
{
BuildEventContext = e.BuildEventContext ?? BuildEventContext.Invalid
};
Write(buildMessageEventArgs);
break;
}
}
public void OnMessageRaised([NotNull] BuildMessageEventArgs e)
{
Logger.Update(e.BuildEventContext);
}
void EventSourceMessageRaised(object sender, BuildMessageEventArgs e)
{
events.Add(new EventMessages {
Matched = false, BuildEventArgs = e
});
}
private void Log(BuildMessageEventArgs eventArgs)
{
Messages.Add($"MESSAGE[{eventArgs.Importance}]: {eventArgs.Message}");
}
public void Process(BuildMessageEventArgs args)
{
if (args == null)
{
return;
}
var message = args.Message;
if (string.IsNullOrEmpty(message))
{
return;
}
if (args.SenderName == "BinaryLogger")
{
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, string.Empty, stringTable);
construction.Build.AddChild(parameter);
return;
}
if (message.StartsWith(Strings.ItemGroupIncludeMessagePrefix))
{
AddItemGroup(args, Strings.ItemGroupIncludeMessagePrefix, new AddItem());
return;
}
if (message.StartsWith(Strings.OutputItemsMessagePrefix))
{
var task = GetTask(args);
//this.construction.Build.Statistics.ReportOutputItemMessage(task, message);
var folder = task.GetOrCreateNodeWithName <Folder>("OutputItems");
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.OutputItemsMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
if (message.StartsWith(Strings.OutputPropertyMessagePrefix))
{
var task = GetTask(args);
var folder = task.GetOrCreateNodeWithName <Folder>("OutputProperties");
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.OutputPropertyMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
if (message.StartsWith(Strings.ItemGroupRemoveMessagePrefix))
{
AddItemGroup(args, Strings.ItemGroupRemoveMessagePrefix, new RemoveItem());
return;
}
if (message.StartsWith(Strings.PropertyGroupMessagePrefix))
{
AddPropertyGroup(args, Strings.PropertyGroupMessagePrefix);
return;
}
if (message.StartsWith(Strings.TaskParameterMessagePrefix))
{
var task = GetTask(args);
if (IgnoreParameters(task))
{
return;
}
//this.construction.Build.Statistics.ReportTaskParameterMessage(task, message);
var folder = task.GetOrCreateNodeWithName <Folder>(Strings.Parameters);
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.TaskParameterMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
// A task from assembly message (parses out the task name and assembly path).
var match = Strings.UsingTask(message);
if (match.Success)
{
construction.SetTaskAssembly(
stringTable.Intern(match.Groups["task"].Value),
stringTable.Intern(match.Groups["assembly"].Value));
return;
}
if (args is TaskCommandLineEventArgs taskArgs)
{
if (AddCommandLine(taskArgs))
{
return;
}
}
// Just the generic log message or something we currently don't handle in the object model.
AddMessage(args, message);
}
void IBuildEngine.LogMessageEvent(BuildMessageEventArgs e)
{
this.Output.WriteLine($"Message: {e.Message}");
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
_output?.WriteLine($"{e.Importance} : {e.Message}");
Messages.Add(e);
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
LogMessageEvents.Add(e);
Console.WriteLine(e.Message);
}
public void LogMessageEvent(BuildMessageEventArgs e)
{
_log.LogMessage((LogImportance)e.Importance, e.Message);
}
private static bool ValidateWelcomeBanner(BuildMessageEventArgs eventArgs)
{
Assert.Equal(string.Format("xUnit.net MSBuild runner ({0}-bit .NET {1})", IntPtr.Size * 8, Environment.Version), eventArgs.Message);
Assert.Equal(MessageImportance.High, eventArgs.Importance);
return true;
}
private bool ValidateAssemblyBanner(BuildMessageEventArgs eventArgs)
{
Assert.Equal("Test assembly: assemblyFilename", eventArgs.Message);
Assert.Equal(MessageImportance.High, eventArgs.Importance);
return true;
}
