private void TargetStarted(object sender, TargetStartedEventArgs e)
{
SendMessage(FormatMessage(e));
}
public abstract void TargetStartedHandler(object sender, TargetStartedEventArgs e);
private void TargetStarted(object sender, TargetStartedEventArgs e)
{
_targets[e.BuildEventContext.TargetId] = new TargetRecord(e.TargetName, e.Timestamp);
}
void eventSource_TargetStartedHandler(object sender, TargetStartedEventArgs e)
{
LogStageStarted(XmlLoggerElements.Target, e.TargetName, "", e.Timestamp);
}
/// <summary>
/// Handle a target started event
/// </summary>
/// <param name="sender">Who sent the event</param>
/// <param name="e">Event raised on the event source</param>
private void Source_TargetStarted(object sender, TargetStartedEventArgs e)
{
HandleEvent(e);
}
private void EventSource_TargetStarted(object sender, TargetStartedEventArgs e)
{
log.Targets.Add(e.TargetName);
}
private void TargetStarted(object sender, TargetStartedEventArgs e)
{
LogStarted("target", e.TargetName, string.Empty);
}
void TargetStarted(object sender, TargetStartedEventArgs e)
{
writer.WriteLine(GetLogMessage("TargetStarted", e));
}
private void TargetStarted(object sender, TargetStartedEventArgs e)
{
this.WriteToSql("TargetStarted", e.Message);
}
private void EventSourceOnTargetStarted(object sender, TargetStartedEventArgs e)
{
TargetStarted?.Invoke(sender, e);
}
public static void EncodeEvent(BinaryWriter writer, BuildEventArgs e)
{
EventTypes type = GetEventType(e);
writer.WriteInt32((int)type);
writer.WriteNullableString(e.Message);
writer.WriteNullableString(e.HelpKeyword);
writer.WriteNullableString(e.SenderName);
writer.WriteDateTime(e.Timestamp);
switch (type)
{
case EventTypes.Error:
BuildErrorEventArgs error = (BuildErrorEventArgs)e;
writer.WriteNullableString(error.Subcategory);
writer.WriteNullableString(error.Code);
writer.WriteNullableString(error.File);
writer.WriteInt32(error.LineNumber);
writer.WriteInt32(error.ColumnNumber);
writer.WriteInt32(error.EndLineNumber);
writer.WriteInt32(error.EndColumnNumber);
break;
case EventTypes.Warning:
BuildWarningEventArgs warning = (BuildWarningEventArgs)e;
writer.WriteNullableString(warning.Subcategory);
writer.WriteNullableString(warning.Code);
writer.WriteNullableString(warning.File);
writer.WriteInt32(warning.LineNumber);
writer.WriteInt32(warning.ColumnNumber);
writer.WriteInt32(warning.EndLineNumber);
writer.WriteInt32(warning.EndColumnNumber);
break;
case EventTypes.Message:
BuildMessageEventArgs message = (BuildMessageEventArgs)e;
writer.WriteInt32((int)message.Importance);
break;
case EventTypes.BuildFinished:
BuildFinishedEventArgs buildFinished = (BuildFinishedEventArgs)e;
writer.Write(buildFinished.Succeeded);
break;
case EventTypes.BuildStarted:
break;
case EventTypes.ProjectFinished:
ProjectFinishedEventArgs projectFinished = (ProjectFinishedEventArgs)e;
writer.WriteNullableString(projectFinished.ProjectFile);
writer.Write(projectFinished.Succeeded);
break;
case EventTypes.ProjectStarted:
ProjectStartedEventArgs projectStarted = (ProjectStartedEventArgs)e;
writer.WriteNullableString(projectStarted.ProjectFile);
writer.WriteNullableString(projectStarted.TargetNames);
break;
case EventTypes.TargetFinished:
TargetFinishedEventArgs targetFinished = (TargetFinishedEventArgs)e;
writer.WriteNullableString(targetFinished.TargetName);
writer.WriteNullableString(targetFinished.ProjectFile);
writer.WriteNullableString(targetFinished.TargetFile);
writer.Write(targetFinished.Succeeded);
break;
case EventTypes.TargetStarted:
TargetStartedEventArgs targetStarted = (TargetStartedEventArgs)e;
writer.WriteNullableString(targetStarted.TargetName);
writer.WriteNullableString(targetStarted.ProjectFile);
writer.WriteNullableString(targetStarted.TargetFile);
#if MSBUILD35
writer.WriteNullableString(null);
#else
writer.WriteNullableString(targetStarted.ParentTarget);
#endif
break;
case EventTypes.TaskFinished:
TaskFinishedEventArgs taskFinished = (TaskFinishedEventArgs)e;
writer.WriteNullableString(taskFinished.ProjectFile);
writer.WriteNullableString(taskFinished.TaskFile);
writer.WriteNullableString(taskFinished.TaskName);
writer.Write(taskFinished.Succeeded);
break;
case EventTypes.TaskStarted:
TaskStartedEventArgs taskStarted = (TaskStartedEventArgs)e;
writer.WriteNullableString(taskStarted.ProjectFile);
writer.WriteNullableString(taskStarted.TaskFile);
writer.WriteNullableString(taskStarted.TaskName);
break;
default: // unknown etc.
break;
}
}
/// <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.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;
}
}
private void TargetStarted(object sender, TargetStartedEventArgs e)
{
_targetStack.Push(e);
}
public async void OnTargetStarted(SolutionItem solutionItem, TargetStartedEventArgs e)
{
await MessageSinks[0].AddMessage(e);
}
private void OnTargetStarted(object sender, TargetStartedEventArgs eventArgs)
{
}
void EventSource_TargetStarted(object sender, TargetStartedEventArgs e)
{
Log(MSBuildEvent.TargetStarted, e.Message);
}
/// <summary>
/// Handler for a TargetStarted log event. Adds the target to the object structure.
/// </summary>
/// <param name="targetStartedEventArgs">The <see cref="TargetStartedEventArgs"/> instance containing the event data.</param>
public void AddTarget(TargetStartedEventArgs targetStartedEventArgs)
{
var project = GetOrAddProject(targetStartedEventArgs.BuildEventContext.ProjectContextId);
project.AddTarget(targetStartedEventArgs);
}
public void AssertTargetNotExecuted(string targetName)
{
TargetStartedEventArgs found = this.executedTargets.FirstOrDefault(t => t.TargetName.Equals(targetName, StringComparison.InvariantCulture));
Assert.IsNull(found, "Not expecting the target to have been executed: {0}", targetName);
}
public void TestLoggingEventCustomerSerialization()
{
Hashtable loggingTypeCacheWrites = new Hashtable();
stream.Position = 0;
BuildEventContext context = new BuildEventContext(1, 3, 5, 7);
GenericBuildEventArg genericBuildEvent = new GenericBuildEventArg("Message", "Help", "Sender");
genericBuildEvent.BuildEventContext = context;
NodeLoggingEvent genericBuildEventLoggingEvent = new NodeLoggingEvent(genericBuildEvent);
genericBuildEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
GenericCustomBuildEventArg genericCustomEvent = new GenericCustomBuildEventArg("FooFighter");
genericCustomEvent.BuildEventContext = context;
NodeLoggingEvent genericCustomEventLoggingEvent = new NodeLoggingEvent(genericCustomEvent);
genericCustomEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
BuildErrorEventArgs errorEvent = new BuildErrorEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "Message", "HelpKeyword", "SenderName");
errorEvent.BuildEventContext = context;
NodeLoggingEvent errorEventLoggingEvent = new NodeLoggingEvent(errorEvent);
errorEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
BuildMessageEventArgs messageEvent = new BuildMessageEventArgs("Message", "HelpKeyword", "SenderName", MessageImportance.High);
messageEvent.BuildEventContext = context;
NodeLoggingEvent messageEventLoggingEvent = new NodeLoggingEvent(messageEvent);
messageEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
BuildWarningEventArgs warningEvent = new BuildWarningEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "Message", "HelpKeyword", "SenderName");
warningEvent.BuildEventContext = context;
NodeLoggingEvent warningEventLoggingEvent = new NodeLoggingEvent(warningEvent);
warningEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
ProjectStartedEventArgs projectStartedEvent = new ProjectStartedEventArgs(8, "Message", "HelpKeyword", "ProjectFile", "TargetNames", null, null, new BuildEventContext(7, 8, 9, 10));
projectStartedEvent.BuildEventContext = context;
NodeLoggingEvent projectStartedEventLoggingEvent = new NodeLoggingEvent(projectStartedEvent);
projectStartedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
ProjectFinishedEventArgs projectFinishedEvent = new ProjectFinishedEventArgs("Message", "HelpKeyword", "ProjectFile", true);
projectFinishedEvent.BuildEventContext = context;
NodeLoggingEvent projectFinishedEventLoggingEvent = new NodeLoggingEvent(projectFinishedEvent);
projectFinishedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
TargetStartedEventArgs targetStartedEvent = new TargetStartedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile");
targetStartedEvent.BuildEventContext = context;
NodeLoggingEvent targetStartedEventLoggingEvent = new NodeLoggingEvent(targetStartedEvent);
targetStartedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
TargetFinishedEventArgs targetFinished = new TargetFinishedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile", true);
targetFinished.BuildEventContext = context;
NodeLoggingEvent targetFinishedEventLoggingEvent = new NodeLoggingEvent(targetFinished);
targetFinishedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
TaskStartedEventArgs taskStartedEvent = new TaskStartedEventArgs("Message", "HelpKeyword", "ProjectFile", "TaskFile", "TaskName");
taskStartedEvent.BuildEventContext = context;
NodeLoggingEvent taskStartedEventLoggingEvent = new NodeLoggingEvent(taskStartedEvent);
taskStartedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
TaskFinishedEventArgs taskFinishedEvent = new TaskFinishedEventArgs("Message", "HelpKeyword", "ProjectFile", "TaskFile", "TaskName", true);
taskFinishedEvent.BuildEventContext = context;
NodeLoggingEvent taskFinishedEventLoggingEvent = new NodeLoggingEvent(taskFinishedEvent);
taskFinishedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
BuildFinishedEventArgs buildFinishedEvent = new BuildFinishedEventArgs("Message", "Help", true);
buildFinishedEvent.BuildEventContext = context;
NodeLoggingEvent buildFinishedEventEventLoggingEvent = new NodeLoggingEvent(buildFinishedEvent);
buildFinishedEventEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
BuildStartedEventArgs buildStartedEvent = new BuildStartedEventArgs("Message", "Help");
buildStartedEvent.BuildEventContext = context;
NodeLoggingEvent buildStartedEventLoggingEvent = new NodeLoggingEvent(buildStartedEvent);
buildStartedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
TaskCommandLineEventArgs commandlineEventArg = new TaskCommandLineEventArgs("CommandLine", "TaskName", MessageImportance.High);
commandlineEventArg.BuildEventContext = context;
NodeLoggingEvent commandlineEventArgLoggingEvent = new NodeLoggingEvent(commandlineEventArg);
commandlineEventArgLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites);
Hashtable loggingTypeCacheReads = new Hashtable();
long streamWriteEndPosition = stream.Position;
stream.Position = 0;
NodeLoggingEvent nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(GenericBuildEventArg));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(GenericCustomBuildEventArg));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildErrorEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildMessageEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildWarningEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(ProjectStartedEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(ProjectFinishedEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TargetStartedEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TargetFinishedEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TaskStartedEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TaskFinishedEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildFinishedEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildStartedEventArgs));
nodeLoggingEvent = new NodeLoggingEvent(null);
nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads);
Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TaskCommandLineEventArgs));
long streamReadEndPosition = stream.Position;
Assert.AreEqual(streamWriteEndPosition, streamReadEndPosition, "Expected Read and Write Positions to match");
}
void eventSource_TargetStarted(object sender, TargetStartedEventArgs e)
{
_output.Verbose.WriteLine("{0} - TARGET STARTED, {1} : {2}", e.ProjectFile, e.TargetName, e.Message);
}
public void OnStarted([NotNull] TargetStartedEventArgs e)
{
Logger.Track(e.BuildEventContext, $"{e.TargetName}");
Logger.Indent(e.BuildEventContext);
Save(e);
}
private void TargetStarted(object sender, TargetStartedEventArgs e)
{
SendMessage(FormatMessage(e));
}
/// <summary>
/// Handler for target started events
/// </summary>
/// <param name="sender">sender (should be null)</param>
/// <param name="e">event arguments</param>
public void TargetStartedHandler(object sender, TargetStartedEventArgs e)
{
InitializeBaseConsoleLogger(); // for compat: see DDB#136924
_consoleLogger.TargetStartedHandler(sender, e);
}
private void source_TargetStarted(object sender, TargetStartedEventArgs e)
{
executedTargets.Add(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;
}
}
private void HandleTargetStarted(object sender, TargetStartedEventArgs e)
{
_targetIdsToNames[e.BuildEventContext.TargetId] = e.TargetName;
}
/// <summary>
/// This is the delegate for TargetStartedHandler events.
/// </summary>
protected virtual void TargetStartedHandler(object sender, TargetStartedEventArgs buildEvent)
{
// NOTE: This may run on a background thread!
QueueOutputEvent(MessageImportance.Low, buildEvent);
IndentOutput();
}
void TargetStarted(object sender, TargetStartedEventArgs e)
{
AppendLine("TargetStarted: " + e.Message);
}
/// <summary>
/// Initializes a new instance of the <see cref="Target"/> class.
/// </summary>
/// <param name="targetName">Name of the target.</param>
/// <param name="targetStartedEvent">The <see cref="TargetStartedEventArgs"/> instance containing the target started event data.</param>
public Target(string targetName, TargetStartedEventArgs targetStartedEvent)
{
Id = -1;
Name = targetName;
TryUpdate(targetStartedEvent);
}
public TargetStartedLogLine(TargetStartedEventArgs e) : base(
$"Target {e.TargetName} Started for " +
$"<span class=\"{StyleSheet.ProjectFileNameCssClass}\">{e.ProjectFile}</span> " +
$"<span class=\"{StyleSheet.MessageCssClass}\">{e.Message}</span><br/> ")
{
}
private void eventSource_TargetStartedHandler(object sender, TargetStartedEventArgs e)
{
LogStageStarted(XmlLoggerElements.Target, e.TargetName, "", e.Timestamp);
}
public GenerateCompileDependencyCacheTarget(TargetStartedEventArgs targetStarted)
{
TargetStarted = targetStarted;
}
