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);
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);
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");
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(warning, LoggingEventType.BuildWarningEvent);
VerifyLoggingPacket(error, LoggingEventType.BuildErrorEvent);
VerifyLoggingPacket(targetStarted, LoggingEventType.TargetStartedEvent);
VerifyLoggingPacket(targetFinished, LoggingEventType.TargetFinishedEvent);
VerifyLoggingPacket(projectStarted, LoggingEventType.ProjectStartedEvent);
VerifyLoggingPacket(projectFinished, LoggingEventType.ProjectFinishedEvent);
VerifyLoggingPacket(externalStartedEvent, LoggingEventType.CustomEvent);
}
private void eventSource_TargetFinished(object sender, Microsoft.Build.Framework.TargetFinishedEventArgs e)
{
if (needToLog)
{
needToLog = false;
}
}
public void EventArgsCtors()
{
List<ITaskItem> outputs = new List<ITaskItem>();
TargetFinishedEventArgs targetFinishedEvent = new TargetFinishedEventArgs2();
targetFinishedEvent = new TargetFinishedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile", true);
targetFinishedEvent = new TargetFinishedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile", true, DateTime.Now, outputs);
targetFinishedEvent = new TargetFinishedEventArgs(null, null, null, null, null, true);
targetFinishedEvent = new TargetFinishedEventArgs(null, null, null, null, null, true, DateTime.Now, null);
}
public void TestSendsAbsoluteFileThreadSafeUsesStack()
{
TargetStartedEventArgs s1 = MakeTargetStartedEventArgs("/home/samantha/work/module1/module1.csproj");
TargetStartedEventArgs s2 = MakeTargetStartedEventArgs("/home/samantha/work/module2/module2.csproj");
logger.TargetStarted(this, s1);
logger.TargetStarted(this, s2);
TargetFinishedEventArgs f1 = new TargetFinishedEventArgs("", "", "", s2.ProjectFile, s2.ProjectFile, true);
f1.BuildEventContext = s1.BuildEventContext;
logger.TargetFinished(this, f1);
logger.BuildErrorRaised(this, MakeBuildErrorEventArgs());
Assert.That(files.Count, Is.EqualTo(1));
Assert.That(Path.IsPathRooted(files[0]), Is.True);
Assert.That(files[0], Text.Contains("module1"));
}
public void AssignmentTest ()
{
TargetFinishedEventArgs tfea;
string message = "message";
string helpKeyword = "helpKeyword";
string targetName = "targetName";
string projectFile = "projectFile";
string targetFile = "targetFile";
bool succeeded = true;
tfea = new TargetFinishedEventArgs (message, helpKeyword, targetName, projectFile, targetFile, succeeded);
Assert.AreEqual (message, tfea.Message, "Message");
Assert.AreEqual (helpKeyword, tfea.HelpKeyword, "HelpKeyword");
Assert.AreEqual (targetName, tfea.TargetName, "TargetName");
Assert.AreEqual (projectFile, tfea.ProjectFile, "ProjectFile");
Assert.AreEqual (targetFile, tfea.TargetFile, "TargetFile");
Assert.AreEqual (succeeded, tfea.Succeeded, "Succeeded");
}
/// <summary>
/// Translate the TargetOutputs for the target finished event.
/// </summary>
private static void TranslateTargetFinishedEvent(INodePacketTranslator translator, TargetFinishedEventArgs finishedEvent)
{
List<TaskItem> targetOutputs = null;
if (translator.Mode == TranslationDirection.WriteToStream)
{
if (finishedEvent.TargetOutputs != null)
{
targetOutputs = new List<TaskItem>();
foreach (TaskItem item in finishedEvent.TargetOutputs)
{
targetOutputs.Add(item);
}
}
}
translator.Translate<TaskItem>(ref targetOutputs, TaskItem.FactoryForDeserialization);
if (translator.Mode == TranslationDirection.ReadFromStream)
{
finishedEvent.TargetOutputs = targetOutputs;
}
}
void TargetFinished(object sender, TargetFinishedEventArgs e)
{
var startInfo = _targetsStarted.Pop();
// var execInfo = new TargetExecutionInfo(startInfo.TargetStartedArgs, e);
var execInfo = new TargetExecutionInfo(startInfo.TargetStartedArgs, e);
// see if the target is already in the executed list
TargetExecutionInfo previoudExecInfo;
this._targetsExecuted.TryGetValue(e.TargetName, out previoudExecInfo);
if (previoudExecInfo != null) {
execInfo.TimeSpent = execInfo.TimeSpent.Add(previoudExecInfo.TimeSpent);
}
this._targetsExecuted[execInfo.Name] = execInfo;
AppendLine(string.Format("####TargetFinished:{0}", e.Message.EscapeMarkdownCharacters()));
}
void LogTargetFinished (Target target, bool succeeded)
{
TargetFinishedEventArgs tfea;
string projectFile = project.FullFileName;
tfea = new TargetFinishedEventArgs (String.Format ("Target {0} finished.", target.Name), null,
target.Name, projectFile, target.TargetFile, succeeded);
target.Engine.EventSource.FireTargetFinished (this, tfea);
}
public abstract void TargetFinishedHandler(object sender, TargetFinishedEventArgs e);
private void eventSource_TargetFinishedHandler(object sender, TargetFinishedEventArgs e)
{
LogStageFinished(e.Succeeded, e.Timestamp);
}
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");
}
/// <summary>
/// This is the delegate for TargetFinishedHandler events.
/// </summary>
private void TargetFinishedHandler(object sender, TargetFinishedEventArgs buildEvent)
{
--this.currentIndent;
if ((isLogTaskDone) &&
LogAtImportance(buildEvent.Succeeded ? MessageImportance.Low
: MessageImportance.High))
{
LogEvent(sender, buildEvent);
}
}
/// <summary>
/// Handler for target finished events
/// </summary>
/// <param name="sender">sender (should be null)</param>
/// <param name="e">event arguments</param>
public void TargetFinishedHandler(object sender, TargetFinishedEventArgs e)
{
InitializeBaseConsoleLogger(); // for compat: see DDB#136924
_consoleLogger.TargetFinishedHandler(sender, e);
}
private void eventSource_TargetFinished(object sender, TargetFinishedEventArgs e)
{
if (stop) {
return;
}
Execute(new BuildMessage(e));
if (stop) {
KillThyself();
}
}
public void TestTargetFinishedEventArgs()
{
// Test using reasonable values
TargetFinishedEventArgs genericEvent = new TargetFinishedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile", true);
genericEvent.BuildEventContext = new BuildEventContext(5, 4, 3, 2);
// Serialize
genericEvent.WriteToStream(_writer);
long streamWriteEndPosition = _stream.Position;
// Deserialize and Verify
_stream.Position = 0;
TargetFinishedEventArgs newGenericEvent = new TargetFinishedEventArgs(null, null, null, null, null, false);
newGenericEvent.CreateFromStream(_reader, _eventArgVersion);
long streamReadEndPosition = _stream.Position;
Assert.IsTrue(streamWriteEndPosition == streamReadEndPosition, "Stream End Positions Should Match");
VerifyGenericEventArg(genericEvent, newGenericEvent);
VerifyTargetFinished(genericEvent, newGenericEvent);
// Test using empty strings
_stream.Position = 0;
genericEvent = new TargetFinishedEventArgs(string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, true);
genericEvent.BuildEventContext = new BuildEventContext(5, 4, 3, 2);
// Serialize
genericEvent.WriteToStream(_writer);
streamWriteEndPosition = _stream.Position;
// Deserialize and Verify
_stream.Position = 0;
newGenericEvent = new TargetFinishedEventArgs(null, null, null, null, null, false);
newGenericEvent.CreateFromStream(_reader, _eventArgVersion);
streamReadEndPosition = _stream.Position;
Assert.IsTrue(streamWriteEndPosition == streamReadEndPosition, "Stream End Positions Should Match");
VerifyGenericEventArg(genericEvent, newGenericEvent);
VerifyTargetFinished(genericEvent, newGenericEvent);
// Test using null strings
_stream.Position = 0;
// Make sure null string are passed correctly
genericEvent = new TargetFinishedEventArgs(null, null, null, null, null, true);
genericEvent.BuildEventContext = null;
//Serialize
genericEvent.WriteToStream(_writer);
streamWriteEndPosition = _stream.Position;
//Deserialize and Verify
_stream.Position = 0;
newGenericEvent = new TargetFinishedEventArgs("Something", "Something", "Something", "Something", "Something", false);
newGenericEvent.CreateFromStream(_reader, _eventArgVersion);
streamReadEndPosition = _stream.Position;
Assert.IsTrue(streamWriteEndPosition == streamReadEndPosition, "Stream End Positions Should Match");
VerifyGenericEventArg(genericEvent, newGenericEvent);
VerifyTargetFinished(genericEvent, newGenericEvent);
}
/// <summary>
/// Compare two TargetFinished events
/// </summary>
private static void VerifyTargetFinished(TargetFinishedEventArgs genericEvent, TargetFinishedEventArgs newGenericEvent)
{
Assert.IsTrue(genericEvent.Succeeded == newGenericEvent.Succeeded, "Expected Succeeded to Match");
Assert.IsTrue(string.Compare(genericEvent.ProjectFile, newGenericEvent.ProjectFile, StringComparison.OrdinalIgnoreCase) == 0, "Expected ProjectFile to Match");
Assert.IsTrue(string.Compare(genericEvent.TargetFile, newGenericEvent.TargetFile, StringComparison.OrdinalIgnoreCase) == 0, "Expected TargetFile to Match");
Assert.IsTrue(string.Compare(genericEvent.TargetName, newGenericEvent.TargetName, StringComparison.OrdinalIgnoreCase) == 0, "Expected TargetName to Match");
}
/// <summary>
/// Handler for target finished events
/// </summary>
/// <param name="sender">sender (should be null)</param>
/// <param name="e">event arguments</param>
public override void TargetFinishedHandler(object sender, TargetFinishedEventArgs e)
{
// Done with the target, so shift everything left again.
this.currentIndentLevel--;
if (this.showPerfSummary)
{
PerformanceCounter counter = GetPerformanceCounter(e.TargetName, ref targetPerformanceCounters);
// Place the counter "in scope" meaning the target is done executing right now.
counter.InScope = false;
}
bool targetHasErrorsOrWarnings = contextStack.Peek().hasErrorsOrWarnings;
// if verbosity is diagnostic,
// or there was an error or warning and verbosity is normal or detailed
if ((targetHasErrorsOrWarnings && (IsVerbosityAtLeast(LoggerVerbosity.Normal)))
|| Verbosity == LoggerVerbosity.Diagnostic)
{
setColor(ConsoleColor.Cyan);
if (showTargetOutputs)
{
IEnumerable targetOutputs = e.TargetOutputs;
if (targetOutputs != null)
{
WriteLinePretty(ResourceUtilities.FormatResourceString("TargetOutputItemsHeader"));
foreach (ITaskItem item in targetOutputs)
{
WriteLinePretty(ResourceUtilities.FormatResourceString("TargetOutputItem", item.ItemSpec));
}
}
}
WriteLinePretty(e.Message);
resetColor();
}
Frame top = contextStack.Pop();
this.VerifyStack(top.type == FrameType.Target, "bad stack frame type");
this.VerifyStack(top.ID == e.TargetName, "bad stack frame id");
// set the value on the Project frame, for the ProjectFinished handler
if (targetHasErrorsOrWarnings)
{
SetErrorsOrWarningsOnCurrentFrame();
}
}
void TargetFinished(object sender, TargetFinishedEventArgs e)
{
XmlElement targetElement = targetElements.Pop();
targetElements.Push(targetElement);
targetElement.Attributes.Append(CreateFinishedAttribute(e.Timestamp));
targetElement.Attributes.Append(CreateAttribute("Succeeded", e.Succeeded.ToString()));
if (base.IsVerbosityAtLeast(LoggerVerbosity.Detailed))
{
targetElement.Attributes.Append(CreateAttribute("FinishMessage", e.Message));
}
buildTypeList.Pop();
}
public TargetExecutionInfo(TargetStartedEventArgs startedArgs, TargetFinishedEventArgs finishedArgs)
: this()
{
this.Name = startedArgs.TargetName;
this.TimeSpent = finishedArgs.Timestamp.Subtract(startedArgs.Timestamp);
}
private void OnTargetFinished(object sender, TargetFinishedEventArgs eventArgs)
{
}
/// <summary>
/// Raises a "target build finished" event to all registered loggers.
/// </summary>
/// <param name="sender">sender of the event</param>
/// <param name="buildEvent">TargetFinishedEventArgs</param>
/// <exception cref="LoggerException">When EventHandler raises an logger exception the LoggerException is rethrown</exception>
/// <exception cref="InternalLoggerException">Any exceptions which are not LoggerExceptions are wrapped in an InternalLoggerException</exception>
/// <exception cref="Exception">ExceptionHandling.IsCriticalException exceptions will not be wrapped</exception>
private void RaiseTargetFinishedEvent(object sender, TargetFinishedEventArgs buildEvent)
{
if (TargetFinished != null)
{
try
{
TargetFinished(sender, buildEvent);
}
catch (LoggerException)
{
// if a logger has failed politely, abort immediately
// first unregister all loggers, since other loggers may receive remaining events in unexpected orderings
// if a fellow logger is throwing in an event handler.
this.UnregisterAllEventHandlers();
throw;
}
catch (Exception exception)
{
// first unregister all loggers, since other loggers may receive remaining events in unexpected orderings
// if a fellow logger is throwing in an event handler.
this.UnregisterAllEventHandlers();
if (ExceptionHandling.IsCriticalException(exception))
{
throw;
}
InternalLoggerException.Throw(exception, buildEvent, "FatalErrorWhileLogging", false);
}
}
RaiseStatusEvent(sender, buildEvent);
}
public BuildMessage(TargetFinishedEventArgs args)
{
EventType = args.GetType().Name.Replace("EventArgs", "");
Message = args.Message;
ProjectFile = args.ProjectFile;
Succeeded = args.Succeeded;
TargetFile = args.TargetFile;
TargetName = args.TargetName;
HelpKeyword = args.HelpKeyword;
SenderName = args.SenderName;
Timestamp = args.Timestamp;
ThreadId = args.ThreadId;
}
private void TargetFinished(object sender, TargetFinishedEventArgs e)
{
this.LogFinished();
}
/// <summary>
/// Compare this build event context with another object to determine
/// equality. This means the values inside the object are identical.
/// </summary>
/// <param name="obj">Object to compare to this object</param>
/// <returns>True if the object values are identical, false if they are not identical</returns>
public static bool IsEquivalent(TargetFinishedEventArgs args, TargetFinishedEventArgs other)
{
if (!String.Equals(args.ProjectFile, other.ProjectFile, StringComparison.OrdinalIgnoreCase))
{
return false;
}
if (!String.Equals(args.TargetFile, other.TargetFile, StringComparison.OrdinalIgnoreCase))
{
return false;
}
if (!String.Equals(args.TargetName, other.TargetName, StringComparison.OrdinalIgnoreCase))
{
return false;
}
if (!Object.ReferenceEquals(args.TargetOutputs, other.TargetOutputs))
{
// See if one is null, if so they are not equal
if (args.TargetOutputs == null || other.TargetOutputs == null)
{
return false;
}
List<string> argItemIncludes = new List<string>();
foreach (TaskItem item in args.TargetOutputs)
{
argItemIncludes.Add(item.ToString());
}
List<string> otherItemIncludes = new List<string>();
foreach (TaskItem item in other.TargetOutputs)
{
otherItemIncludes.Add(item.ToString());
}
argItemIncludes.Sort();
otherItemIncludes.Sort();
if (argItemIncludes.Count != otherItemIncludes.Count)
{
return false;
}
// Since the lists are sorted each include must match
for (int i = 0; i < argItemIncludes.Count; i++)
{
if (!argItemIncludes[i].Equals(otherItemIncludes[i], StringComparison.OrdinalIgnoreCase))
{
return false;
}
}
}
return ((BuildEventArgs)args).IsEquivalent(other);
}
private void TargetFinished(object sender, Microsoft.Build.Framework.TargetFinishedEventArgs e)
{
ChromeTracer.AddEndEvent(e.ThreadId, "Target:" + e.TargetName, GetTimeStamp(e.Timestamp), string.Empty);
}
private void TargetFinished(object sender, TargetFinishedEventArgs e)
{
string line = string.Format(CultureInfo.InvariantCulture, "Done building target \"{0}\" in project \"{1}\"", e.TargetName, e.ProjectFile);
this.indent--;
this.WriteLine(line);
}
/// <summary>
/// Handle a target finished event
/// </summary>
/// <param name="sender">Who sent the event</param>
/// <param name="e">Event raised on the event source</param>
private void Source_TargetFinished(object sender, TargetFinishedEventArgs e)
{
HandleEvent(e);
}
private void eventSource_TargetFinished(object sender, Microsoft.Build.Framework.TargetFinishedEventArgs e)
{
textBox.Text += Environment.NewLine + e.Message;
}
void TargetFinished (object sender, TargetFinishedEventArgs args)
{
target_finished_events++;
}
/// <summary>
/// This is the delegate for TargetFinishedHandler events.
/// </summary>
private void TargetFinishedHandler(object sender, TargetFinishedEventArgs buildEvent)
{
try
{
--this.currentIndent;
if ((isLogTaskDone) &&
LogAtImportance(buildEvent.Succeeded ? MessageImportance.Low
: MessageImportance.High))
{
LogEvent(sender, buildEvent);
}
}
catch (Exception e)
{
Debug.Assert(false, "Problem logging targetfinished event: " + e.Message + " at " + e.TargetSite);
// swallow the exception
}
}
void TargetFinished(object sender, TargetFinishedEventArgs e)
{
}
/// <summary>
/// This is the delegate for TargetFinishedHandler events.
/// </summary>
protected virtual void TargetFinishedHandler(object sender, TargetFinishedEventArgs buildEvent)
{
// NOTE: This may run on a background thread!
UnindentOutput();
QueueOutputEvent(MessageImportance.Low, buildEvent);
}
public void TestMinimalWithNormalMessage()
{
for (int i = 1; i <= 2; i++)
{
EventSourceSink es = new EventSourceSink();
SimulatedConsole sc = new SimulatedConsole();
ConsoleLogger L = new ConsoleLogger(LoggerVerbosity.Minimal,
sc.Write, sc.SetColor,
sc.ResetColor);
L.Initialize(es, i);
BuildEventContext buildEventContext = new BuildEventContext(1, 2, 3, 4);
BuildStartedEventArgs bse = new BuildStartedEventArgs("bs", null);
bse.BuildEventContext = buildEventContext;
es.Consume(bse);
ProjectStartedEventArgs pse = new ProjectStartedEventArgs(1, "ps", null, "fname", "", null, null, new BuildEventContext(1, 1, 1, 1));
pse.BuildEventContext = buildEventContext;
es.Consume(pse);
TargetStartedEventArgs trse = new TargetStartedEventArgs("ts", null, "trname", "pfile", "tfile");
trse.BuildEventContext = buildEventContext;
es.Consume(trse);
TaskStartedEventArgs tase = new TaskStartedEventArgs("tks", null, "tname", "tfname", "tsname");
tase.BuildEventContext = buildEventContext;
es.Consume(tase);
BuildMessageEventArgs bmea = new BuildMessageEventArgs("foo!", null, "sender", MessageImportance.Normal);
bmea.BuildEventContext = buildEventContext;
es.Consume(bmea);
TaskFinishedEventArgs tafea = new TaskFinishedEventArgs("tkf", null, "fname", "tsname", "tfname", true);
tafea.BuildEventContext = buildEventContext;
es.Consume(tafea);
TargetFinishedEventArgs trfea = new TargetFinishedEventArgs("tf", null, "trname", "fname", "tfile", true);
trfea.BuildEventContext = buildEventContext;
es.Consume(trfea);
ProjectFinishedEventArgs pfea = new ProjectFinishedEventArgs("pf", null, "fname", true);
pfea.BuildEventContext = buildEventContext;
es.Consume(pfea);
BuildFinishedEventArgs bfea = new BuildFinishedEventArgs("bf", null, true);
bfea.BuildEventContext = buildEventContext;
es.Consume(bfea);
Assert.AreEqual(String.Empty, sc.ToString());
}
}
