private BuildEventArgs ReadBuildStartedEventArgs()
{
var fields = ReadBuildEventArgsFields();
var environment = ReadStringDictionary();
var e = new BuildStartedEventArgs(
fields.Message,
fields.HelpKeyword,
environment);
SetCommonFields(e, fields);
return(e);
}
/// <summary>
/// Note with msbuild:
/// Be careful - the onBuildStarted(i.e. all before onTargetStarted) is not safe for any unhandled exceptions!
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void onBuildStarted(object sender, BuildStartedEventArgs e)
{
try {
ptargets.Clear();
// yes, we're ready
onPre(initializer.Properties.Targets);
}
catch (Exception ex) {
debug("Error onBuildStarted: '{0}'", ex.Message);
abort = true;
}
}
protected override void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
try
{
base.BuildStartedHandler(sender, buildEvent);
errorlistManager.ClearBuildErrors();
errors = warnings = 0;
didCompile = false;
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
}
}
// BuildStartedEventArgs => BuildStartedEvent
private Event BuildStartedEvent(BuildEventArgs buildEvent)
{
BuildStartedEventArgs e = buildEvent as BuildStartedEventArgs;
Debug.Assert(e != null);
Debug.Assert(e.BuildEventContext == null);
return(new BuildStartedEvent()
{
Context = null,
Message = e.Message,
Timestamp = e.Timestamp,
});
}
protected override void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
try
{
base.BuildStartedHandler(sender, buildEvent);
errorlistManager.ClearBuildErrors();
errors = warnings = 0;
didCompile = false;
Logger.Debug("Build Started");
}
catch (Exception e)
{
Logger.Exception(e, "BuildStartedHandler");
}
}
public void BuildStarted(object sender, BuildStartedEventArgs args)
{
try
{
lock (syncLock)
{
Build.StartTime = args.Timestamp;
var properties = Build.GetOrCreateNodeWithName <Folder>("Environment");
AddProperties(properties, args.BuildEnvironment);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
void BuildStarted(object sender, BuildStartedEventArgs e)
{
AppendLine(string.Format("#Build Started {0}", e.Timestamp));
var r = from be in e.BuildEnvironment.Keys
select new {
Name = be,
Value = e.BuildEnvironment[be]
};
AppendLine(r.ToMarkdownTable().ToMarkdown());
if (IsVerbosityAtLeast(LoggerVerbosity.Detailed))
{
AppendLine(e.ToPropertyValues().ToMarkdownTable().ToMarkdown());
}
}
public void ForwardEvents()
{
BuildStartedEventArgs buildStarted = new BuildStartedEventArgs("Message", "Help");
BuildFinishedEventArgs buildFinished = new BuildFinishedEventArgs("Message", "Keyword", true);
BuildMessageEventArgs normalMessage = new BuildMessageEventArgs("Message2", "help", "sender", MessageImportance.Normal);
EventSourceSink loggerSource = AttachForwardingLoggerAndRedirector(buildStarted);
loggerSource.Consume(buildStarted);
loggerSource = AttachForwardingLoggerAndRedirector(buildFinished);
loggerSource.Consume(buildFinished);
loggerSource = AttachForwardingLoggerAndRedirector(normalMessage);
loggerSource.Consume(normalMessage);
}
public void TestConsumeBuildStartedEvent()
{
bool wentInHandler = false;
BuildStartedEventArgs buildStarted = new BuildStartedEventArgs("Start", "Help");
SendDataDelegate transportDelegate = delegate(INodePacket packet)
{
wentInHandler = true;
};
BuildEventArgTransportSink transportSink = new BuildEventArgTransportSink(transportDelegate);
transportSink.Consume(buildStarted, 0);
Assert.IsTrue(transportSink.HaveLoggedBuildStartedEvent);
Assert.IsFalse(transportSink.HaveLoggedBuildFinishedEvent);
Assert.IsFalse(wentInHandler, "Expected not to go into transport delegate");
}
public void BuildStarted(object sender, BuildStartedEventArgs args)
{
try
{
lock (syncLock)
{
Build.StartTime = args.Timestamp;
var properties = Build.GetOrCreateNodeWithName <Folder>(Intern(Strings.Environment));
AddProperties(properties, args.BuildEnvironment);
// realize the evaluation folder now so it is ordered before the main solution node
_ = EvaluationFolder;
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
/// <summary>
/// Logs that the build has finished with all loggers, except for forwarding loggers.
/// </summary>
virtual internal void LogBuildStarted(int loggerId)
{
// If we're only logging critical events, don't risk causing all the resources to load by formatting
// a string that won't get emitted anyway.
string message = String.Empty;
if (!OnlyLogCriticalEvents)
{
message = ResourceUtilities.FormatResourceString("BuildStarted");
}
BuildStartedEventArgs e = new BuildStartedEventArgs(message, null /* no help keyword */);
// Wrap the BuildStarted event so it is only sent to the loggers to
// the specified logger id
NodeLoggingEventWithLoggerId nodeEvent =
new NodeLoggingEventWithLoggerId(e, loggerId);
PostLoggingEvent(nodeEvent);
}
/// <summary>
/// This is the delegate for BuildStartedHandler events.
/// </summary>
private void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
try
{
this.haveCachedRegistry = false;
if (LogAtImportance(MessageImportance.Low))
{
LogEvent(sender, buildEvent);
}
}
catch (Exception e)
{
Debug.Assert(false, "Problem logging buildstarted event: " + e.Message + " at " + e.TargetSite);
// swallow the exception
}
finally
{
// remove all Project System tasks from the task list, add everything else to the task set
taskReporter.ClearAllTasks();
}
}
/**************************************************************************************************************************
* WARNING: Do not add overloads that allow raising events without specifying a file. In general ALL events should have a
* file associated with them. We've received a LOT of feedback from dogfooders about the lack of information in our
* events. If an event TRULY does not have an associated file, then String.Empty can be passed in for the file. However,
* that burden should lie on the caller -- these wrapper methods should NOT make it easy to skip the filename.
*************************************************************************************************************************/
/// <summary>
/// Logs that the build has started with all loggers (only called on the main node)
/// </summary>
virtual internal void LogBuildStarted()
{
// If we're only logging critical events, don't risk causing all the resources to load by formatting
// a string that won't get emitted anyway.
string message = String.Empty;
if (!OnlyLogCriticalEvents)
{
message = ResourceUtilities.FormatResourceString("BuildStarted");
}
BuildStartedEventArgs e = new BuildStartedEventArgs(message, null /* no help keyword */);
PostLoggingEvent(e);
// Wrap the event to be sent to central loggers
NodeLoggingEventWithLoggerId nodeEventToCentralLoggers =
new NodeLoggingEventWithLoggerId(e, EngineLoggingServicesInProc.ALL_PRIVATE_EVENTSOURCES);
PostLoggingEvent(nodeEventToCentralLoggers);
}
public void VerifyEventType()
{
BuildFinishedEventArgs buildFinished = new BuildFinishedEventArgs("Message", "Keyword", true);
BuildStartedEventArgs buildStarted = new BuildStartedEventArgs("Message", "Help");
BuildMessageEventArgs lowMessage = new BuildMessageEventArgs("Message", "help", "sender", MessageImportance.Low);
TaskStartedEventArgs taskStarted = new TaskStartedEventArgs("message", "help", "projectFile", "taskFile", "taskName");
TaskFinishedEventArgs taskFinished = new TaskFinishedEventArgs("message", "help", "projectFile", "taskFile", "taskName", true);
TaskCommandLineEventArgs commandLine = new TaskCommandLineEventArgs("commandLine", "taskName", MessageImportance.Low);
TaskParameterEventArgs taskParameter = CreateTaskParameter();
BuildWarningEventArgs warning = new BuildWarningEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender");
BuildErrorEventArgs error = new BuildErrorEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender");
TargetStartedEventArgs targetStarted = new TargetStartedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile");
TargetFinishedEventArgs targetFinished = new TargetFinishedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile", true);
TargetSkippedEventArgs targetSkipped = CreateTargetSkipped();
ProjectStartedEventArgs projectStarted = new ProjectStartedEventArgs(-1, "message", "help", "ProjectFile", "targetNames", null, null, null);
ProjectFinishedEventArgs projectFinished = new ProjectFinishedEventArgs("message", "help", "ProjectFile", true);
ExternalProjectStartedEventArgs externalStartedEvent = new ExternalProjectStartedEventArgs("message", "help", "senderName", "projectFile", "targetNames");
ProjectEvaluationStartedEventArgs evaluationStarted = new ProjectEvaluationStartedEventArgs();
ProjectEvaluationFinishedEventArgs evaluationFinished = new ProjectEvaluationFinishedEventArgs();
VerifyLoggingPacket(buildFinished, LoggingEventType.BuildFinishedEvent);
VerifyLoggingPacket(buildStarted, LoggingEventType.BuildStartedEvent);
VerifyLoggingPacket(lowMessage, LoggingEventType.BuildMessageEvent);
VerifyLoggingPacket(taskStarted, LoggingEventType.TaskStartedEvent);
VerifyLoggingPacket(taskFinished, LoggingEventType.TaskFinishedEvent);
VerifyLoggingPacket(commandLine, LoggingEventType.TaskCommandLineEvent);
VerifyLoggingPacket(taskParameter, LoggingEventType.TaskParameterEvent);
VerifyLoggingPacket(warning, LoggingEventType.BuildWarningEvent);
VerifyLoggingPacket(error, LoggingEventType.BuildErrorEvent);
VerifyLoggingPacket(targetStarted, LoggingEventType.TargetStartedEvent);
VerifyLoggingPacket(targetFinished, LoggingEventType.TargetFinishedEvent);
VerifyLoggingPacket(targetSkipped, LoggingEventType.TargetSkipped);
VerifyLoggingPacket(projectStarted, LoggingEventType.ProjectStartedEvent);
VerifyLoggingPacket(projectFinished, LoggingEventType.ProjectFinishedEvent);
VerifyLoggingPacket(evaluationStarted, LoggingEventType.ProjectEvaluationStartedEvent);
VerifyLoggingPacket(evaluationFinished, LoggingEventType.ProjectEvaluationFinishedEvent);
VerifyLoggingPacket(externalStartedEvent, LoggingEventType.CustomEvent);
}
/// <summary>
/// This is the delegate for BuildStartedHandler events.
/// </summary>
private void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
try
{
this.haveCachedRegistry = false;
if (LogAtImportance(MessageImportance.Normal))
{
LogEvent(sender, buildEvent);
}
}
catch (Exception e)
{
Debug.Assert(false, "Problem logging buildstarted event: " + e.Message + " at " + e.TargetSite);
// swallow the exception
}
finally
{
if (errorReporter != null)
{
errorReporter.ClearErrors();
}
}
}
private void EventSource_BuildStarted(object sender, BuildStartedEventArgs e)
{
Log.Debug("Build Started");
_buildSpan = _tracer.StartSpan(BuildTags.BuildOperationName);
_buildSpan.SetMetric(Tags.Analytics, 1.0d);
_buildSpan.SetTraceSamplingPriority(SamplingPriority.UserKeep);
_buildSpan.Type = SpanTypes.Build;
_buildSpan.SetTag(BuildTags.BuildName, e.SenderName);
foreach (KeyValuePair <string, string> envValue in e.BuildEnvironment)
{
_buildSpan.SetTag($"{BuildTags.BuildEnvironment}.{envValue.Key}", envValue.Value);
}
_buildSpan.SetTag(BuildTags.BuildCommand, Environment.CommandLine);
_buildSpan.SetTag(BuildTags.BuildWorkingFolder, Environment.CurrentDirectory);
_buildSpan.SetTag(BuildTags.BuildStartMessage, e.Message);
_buildSpan.SetTag(CommonTags.RuntimeOSArchitecture, Environment.Is64BitOperatingSystem ? "x64" : "x86");
_buildSpan.SetTag(CommonTags.RuntimeProcessArchitecture, Environment.Is64BitProcess ? "x64" : "x86");
CIEnvironmentValues.DecorateSpan(_buildSpan);
}
public abstract void BuildStartedHandler(object sender, BuildStartedEventArgs e);
/// <summary>
/// Build Started Event handler, logs to build log file.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void eventSource_BuildStartedEvent(object sender, BuildStartedEventArgs e)
{
//MSBuildEngineCommonHelper.Log = "************Starting Build " + e.Code;
LogToBuildLog(e.Message + "\t" + e.Timestamp.ToString() + ".");
LogToBuildLog(@"________________________________________________");
}
private void Write(BuildStartedEventArgs e)
{
Write(BinaryLogRecordKind.BuildStarted);
WriteBuildEventArgsFields(e);
Write(e.BuildEnvironment);
}
private void BuildStarted(object sender, BuildStartedEventArgs e)
{
this.startTime = DateTime.Now;
this.WriteToSql("BuildStarted", e.Message);
}
/// <summary>
/// Handler for build started events
/// </summary>
/// <param name="sender">sender (should be null)</param>
/// <param name="e">event arguments</param>
public void BuildStartedHandler(object sender, BuildStartedEventArgs e)
{
InitializeBaseConsoleLogger(); // for compat: see DDB#136924
_consoleLogger.BuildStartedHandler(sender, e);
}
/// <summary>
/// This is the delegate for BuildStartedHandler events.
/// </summary>
protected override void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
base.BuildStartedHandler(sender, buildEvent);
_timer = Stopwatch.StartNew();
}
// ReSharper disable once UnusedMember.Local
private void OnBuildStarted(BuildStartedEventArgs e)
{
BuildStarted?.Invoke(this, e);
}
/// <summary>
/// Handle a build started event
/// </summary>
/// <param name="sender">Who sent the event</param>
/// <param name="e">Event raised on the event source</param>
private void Source_BuildStarted(object sender, BuildStartedEventArgs e)
{
HandleEvent(e);
}
void HandleBuildStarted(object sender, BuildStartedEventArgs args)
{
CreateWriter(true);
}
private void BuildStarted(object sender, BuildStartedEventArgs e)
{
SendMessage(FormatMessage(e));
}
public void BuildStartedHandler(object sender, BuildStartedEventArgs args)
{
GetBuildRecord(sender).BuildStartedHandler(sender, args);
}
void BuildStarted(object sender, BuildStartedEventArgs e)
{
writer.WriteLine(GetLogMessage("BuildStarted", e));
}
void BuildStarted(object sender, BuildStartedEventArgs e)
{
string indentStr = new string('\t', currentIndent++);
AppendLine(string.Format("{0}BuildStarted:{1}", indentStr, e.Message));
}
private void eventSource_BuildStartedHandler(object sender, BuildStartedEventArgs e)
{
LogStageStarted(XmlLoggerElements.Build, "", "", e.Timestamp);
}
/// <summary>
/// Compares two LogMessagePacket objects for equivalence.
/// </summary>
private void CompareLogMessagePackets(LogMessagePacket left, LogMessagePacket right)
{
Assert.AreEqual(left.EventType, right.EventType);
Assert.AreEqual(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.IsNotNull(leftError);
Assert.IsNotNull(rightError);
Assert.AreEqual(leftError.Code, rightError.Code);
Assert.AreEqual(leftError.ColumnNumber, rightError.ColumnNumber);
Assert.AreEqual(leftError.EndColumnNumber, rightError.EndColumnNumber);
Assert.AreEqual(leftError.EndLineNumber, rightError.EndLineNumber);
Assert.AreEqual(leftError.File, rightError.File);
Assert.AreEqual(leftError.LineNumber, rightError.LineNumber);
Assert.AreEqual(leftError.Message, rightError.Message);
Assert.AreEqual(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.IsNotNull(leftFinished);
Assert.IsNotNull(rightFinished);
Assert.AreEqual(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.IsNotNull(leftMessage);
Assert.IsNotNull(rightMessage);
Assert.AreEqual(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.IsNotNull(leftBuildStart);
Assert.IsNotNull(rightBuildStart);
break;
case LoggingEventType.BuildWarningEvent:
BuildWarningEventArgs leftBuildWarn = left.NodeBuildEvent.Value.Value as BuildWarningEventArgs;
BuildWarningEventArgs rightBuildWarn = right.NodeBuildEvent.Value.Value as BuildWarningEventArgs;
Assert.IsNotNull(leftBuildWarn);
Assert.IsNotNull(rightBuildWarn);
Assert.AreEqual(leftBuildWarn.Code, rightBuildWarn.Code);
Assert.AreEqual(leftBuildWarn.ColumnNumber, rightBuildWarn.ColumnNumber);
Assert.AreEqual(leftBuildWarn.EndColumnNumber, rightBuildWarn.EndColumnNumber);
Assert.AreEqual(leftBuildWarn.EndLineNumber, rightBuildWarn.EndLineNumber);
Assert.AreEqual(leftBuildWarn.File, rightBuildWarn.File);
Assert.AreEqual(leftBuildWarn.LineNumber, rightBuildWarn.LineNumber);
Assert.AreEqual(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.IsNotNull(leftCustom);
Assert.IsNotNull(rightCustom);
Assert.AreEqual(leftCustom.ProjectFile, rightCustom.ProjectFile);
Assert.AreEqual(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.IsNotNull(leftProjectFinished);
Assert.IsNotNull(rightProjectFinished);
Assert.AreEqual(leftProjectFinished.ProjectFile, rightProjectFinished.ProjectFile);
Assert.AreEqual(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.IsNotNull(leftProjectStarted);
Assert.IsNotNull(rightProjectStarted);
Assert.AreEqual(leftProjectStarted.ParentProjectBuildEventContext, rightProjectStarted.ParentProjectBuildEventContext);
Assert.AreEqual(leftProjectStarted.ProjectFile, rightProjectStarted.ProjectFile);
Assert.AreEqual(leftProjectStarted.ProjectId, rightProjectStarted.ProjectId);
Assert.AreEqual(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.IsNotNull(leftTargetFinished);
Assert.IsNotNull(rightTargetFinished);
Assert.AreEqual(leftTargetFinished.ProjectFile, rightTargetFinished.ProjectFile);
Assert.AreEqual(leftTargetFinished.Succeeded, rightTargetFinished.Succeeded);
Assert.AreEqual(leftTargetFinished.TargetFile, rightTargetFinished.TargetFile);
Assert.AreEqual(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.IsNotNull(leftTargetStarted);
Assert.IsNotNull(rightTargetStarted);
Assert.AreEqual(leftTargetStarted.ProjectFile, rightTargetStarted.ProjectFile);
Assert.AreEqual(leftTargetStarted.TargetFile, rightTargetStarted.TargetFile);
Assert.AreEqual(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.IsNotNull(leftCommand);
Assert.IsNotNull(rightCommand);
Assert.AreEqual(leftCommand.CommandLine, rightCommand.CommandLine);
Assert.AreEqual(leftCommand.Importance, rightCommand.Importance);
Assert.AreEqual(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.IsNotNull(leftTaskFinished);
Assert.IsNotNull(rightTaskFinished);
Assert.AreEqual(leftTaskFinished.ProjectFile, rightTaskFinished.ProjectFile);
Assert.AreEqual(leftTaskFinished.Succeeded, rightTaskFinished.Succeeded);
Assert.AreEqual(leftTaskFinished.TaskFile, rightTaskFinished.TaskFile);
Assert.AreEqual(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.IsNotNull(leftTaskStarted);
Assert.IsNotNull(rightTaskStarted);
Assert.AreEqual(leftTaskStarted.ProjectFile, rightTaskStarted.ProjectFile);
Assert.AreEqual(leftTaskStarted.TaskFile, rightTaskStarted.TaskFile);
Assert.AreEqual(leftTaskStarted.TaskName, rightTaskStarted.TaskName);
break;
default:
Assert.Fail("Unexpected logging event type {0}", left.EventType);
break;
}
}
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.ProjectEvaluationStartedEvent:
ProjectEvaluationStartedEventArgs leftEvaluationStarted = left.NodeBuildEvent.Value.Value as ProjectEvaluationStartedEventArgs;
ProjectEvaluationStartedEventArgs rightEvaluationStarted = right.NodeBuildEvent.Value.Value as ProjectEvaluationStartedEventArgs;
Assert.NotNull(leftEvaluationStarted);
Assert.NotNull(rightEvaluationStarted);
Assert.Equal(leftEvaluationStarted.ProjectFile, rightEvaluationStarted.ProjectFile);
break;
case LoggingEventType.ProjectEvaluationFinishedEvent:
ProjectEvaluationFinishedEventArgs leftEvaluationFinished = left.NodeBuildEvent.Value.Value as ProjectEvaluationFinishedEventArgs;
ProjectEvaluationFinishedEventArgs rightEvaluationFinished = right.NodeBuildEvent.Value.Value as ProjectEvaluationFinishedEventArgs;
Assert.NotNull(leftEvaluationFinished);
Assert.NotNull(rightEvaluationFinished);
Assert.Equal(leftEvaluationFinished.ProjectFile, rightEvaluationFinished.ProjectFile);
Assert.Equal(leftEvaluationFinished.ProfilerResult, rightEvaluationFinished.ProfilerResult);
Assert.Equal(
TranslationHelpers.GetPropertiesString(leftEvaluationFinished.GlobalProperties),
TranslationHelpers.GetPropertiesString(rightEvaluationFinished.GlobalProperties));
Assert.Equal(
TranslationHelpers.GetPropertiesString(leftEvaluationFinished.Properties),
TranslationHelpers.GetPropertiesString(rightEvaluationFinished.Properties));
Assert.Equal(
TranslationHelpers.GetMultiItemsString(leftEvaluationFinished.Items),
TranslationHelpers.GetMultiItemsString(rightEvaluationFinished.Items));
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);
// TODO: target output translation is a special case and is done in TranslateTargetFinishedEvent
// Assert.Equal(leftTargetFinished.TargetOutputs, rightTargetFinished.TargetOutputs);
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.TargetSkipped:
TargetSkippedEventArgs leftTargetSkipped = left.NodeBuildEvent.Value.Value as TargetSkippedEventArgs;
TargetSkippedEventArgs rightTargetSkipped = right.NodeBuildEvent.Value.Value as TargetSkippedEventArgs;
Assert.Equal(leftTargetSkipped.BuildReason, rightTargetSkipped.BuildReason);
Assert.Equal(leftTargetSkipped.SkipReason, rightTargetSkipped.SkipReason);
Assert.Equal(leftTargetSkipped.BuildEventContext, rightTargetSkipped.BuildEventContext);
Assert.Equal(leftTargetSkipped.OriginalBuildEventContext, rightTargetSkipped.OriginalBuildEventContext);
Assert.Equal(leftTargetSkipped.Condition, rightTargetSkipped.Condition);
Assert.Equal(leftTargetSkipped.EvaluatedCondition, rightTargetSkipped.EvaluatedCondition);
Assert.Equal(leftTargetSkipped.Importance, rightTargetSkipped.Importance);
Assert.Equal(leftTargetSkipped.OriginallySucceeded, rightTargetSkipped.OriginallySucceeded);
Assert.Equal(leftTargetSkipped.ProjectFile, rightTargetSkipped.ProjectFile);
Assert.Equal(leftTargetSkipped.TargetFile, rightTargetSkipped.TargetFile);
Assert.Equal(leftTargetSkipped.TargetName, rightTargetSkipped.TargetName);
Assert.Equal(leftTargetSkipped.ParentTarget, rightTargetSkipped.ParentTarget);
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.TaskParameterEvent:
var leftTaskParameter = left.NodeBuildEvent.Value.Value as TaskParameterEventArgs;
var rightTaskParameter = right.NodeBuildEvent.Value.Value as TaskParameterEventArgs;
Assert.NotNull(leftTaskParameter);
Assert.NotNull(rightTaskParameter);
Assert.Equal(leftTaskParameter.Kind, rightTaskParameter.Kind);
Assert.Equal(leftTaskParameter.ItemType, rightTaskParameter.ItemType);
Assert.Equal(leftTaskParameter.Items.Count, rightTaskParameter.Items.Count);
Assert.Equal(leftTaskParameter.Message, rightTaskParameter.Message);
Assert.Equal(leftTaskParameter.BuildEventContext, rightTaskParameter.BuildEventContext);
Assert.Equal(leftTaskParameter.Timestamp, rightTaskParameter.Timestamp);
Assert.Equal(leftTaskParameter.LineNumber, rightTaskParameter.LineNumber);
Assert.Equal(leftTaskParameter.ColumnNumber, rightTaskParameter.ColumnNumber);
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);
Assert.Equal(leftTaskStarted.LineNumber, rightTaskStarted.LineNumber);
Assert.Equal(leftTaskStarted.ColumnNumber, rightTaskStarted.ColumnNumber);
break;
default:
Assert.True(false, string.Format("Unexpected logging event type {0}", left.EventType));
break;
}
}
