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