/// <summary>
/// Logs the project started/finished pair for projects which are skipped entirely because all
/// of their results are available in the cache.
/// </summary>
internal void LogRequestHandledFromCache(BuildRequest request, BuildRequestConfiguration configuration, BuildResult result)
{
ProjectLoggingContext projectLoggingContext = LogProjectStarted(request, configuration);
// When pulling a request from the cache, we want to make sure we log a target skipped event for any targets which
// were used to build the request including default and initial targets.
foreach (string target in configuration.GetTargetsUsedToBuildRequest(request))
{
var targetResult = result[target];
bool isFailure = targetResult.ResultCode == TargetResultCode.Failure;
var skippedTargetEventArgs = new TargetSkippedEventArgs(message: null)
{
BuildEventContext = projectLoggingContext.BuildEventContext,
TargetName = target,
BuildReason = TargetBuiltReason.None,
SkipReason = isFailure ? TargetSkipReason.PreviouslyBuiltUnsuccessfully : TargetSkipReason.PreviouslyBuiltSuccessfully,
OriginallySucceeded = !isFailure,
OriginalBuildEventContext = (targetResult as TargetResult)?.OriginalBuildEventContext
};
projectLoggingContext.LogBuildEvent(skippedTargetEventArgs);
if (targetResult.ResultCode == TargetResultCode.Failure)
{
break;
}
}
projectLoggingContext.LogProjectFinished(result.OverallResult == BuildResultCode.Success);
}
public void RoundtripTargetSkippedEventArgs()
{
var args = new TargetSkippedEventArgs(
"Target \"target\" skipped. Previously built unsuccessfully.")
{
BuildEventContext = BuildEventContext.Invalid,
ProjectFile = "foo.csproj",
TargetName = "target",
ParentTarget = "bar",
BuildReason = TargetBuiltReason.DependsOn,
SkipReason = TargetSkipReason.PreviouslyBuiltSuccessfully,
Condition = "$(condition) == true",
EvaluatedCondition = "true == true",
OriginalBuildEventContext = new BuildEventContext(1, 2, 3, 4, 5, 6, 7),
OriginallySucceeded = false,
TargetFile = "foo.csproj"
};
Roundtrip(args,
e => e.BuildEventContext.ToString(),
e => e.ParentTarget,
e => e.Importance.ToString(),
e => e.LineNumber.ToString(),
e => e.ColumnNumber.ToString(),
e => e.Message,
e => e.ProjectFile,
e => e.TargetFile,
e => e.TargetName,
e => e.BuildReason.ToString(),
e => e.SkipReason.ToString(),
e => e.Condition,
e => e.EvaluatedCondition,
e => e.OriginalBuildEventContext.ToString(),
e => e.OriginallySucceeded.ToString());
}
private void Write(TargetSkippedEventArgs e)
{
Write(BinaryLogRecordKind.TargetSkipped);
WriteMessageFields(e);
WriteOptionalString(e.TargetFile);
WriteOptionalString(e.TargetName);
WriteOptionalString(e.ParentTarget);
Write((int)e.BuildReason);
}
/// <summary>
/// Determines if the current target should be skipped, and logs the appropriate message.
/// </summary>
/// <returns>True to skip the target, false otherwise.</returns>
private bool CheckSkipTarget(ref bool stopProcessingStack, TargetEntry currentTargetEntry)
{
if (_buildResult.HasResultsForTarget(currentTargetEntry.Name))
{
TargetResult targetResult = _buildResult[currentTargetEntry.Name] as TargetResult;
ErrorUtilities.VerifyThrowInternalNull(targetResult, "targetResult");
if (targetResult.ResultCode != TargetResultCode.Skipped)
{
// If we've already dealt with this target and it didn't skip, let's log appropriately
// Otherwise we don't want anything more to do with it.
var skippedTargetEventArgs = new TargetSkippedEventArgs(
ResourceUtilities.GetResourceString(targetResult.ResultCode == TargetResultCode.Success
? "TargetAlreadyCompleteSuccess"
: "TargetAlreadyCompleteFailure"),
currentTargetEntry.Name)
{
BuildEventContext = _projectLoggingContext.BuildEventContext,
TargetName = currentTargetEntry.Name,
TargetFile = currentTargetEntry.Target.Location.File,
ParentTarget = currentTargetEntry.ParentEntry?.Target.Name,
BuildReason = currentTargetEntry.BuildReason
};
_projectLoggingContext.LogBuildEvent(skippedTargetEventArgs);
if (currentTargetEntry.StopProcessingOnCompletion)
{
stopProcessingStack = true;
}
if (targetResult.ResultCode == TargetResultCode.Success)
{
_targetsToBuild.Peek().LeaveLegacyCallTargetScopes();
_targetsToBuild.Pop();
}
else
{
TargetEntry topEntry = _targetsToBuild.Pop();
// If this is a skip because of target failure, we should behave in the same way as we
// would if this target actually failed -- remove all its dependencies from the stack as
// well. Otherwise, we could encounter a situation where a failure target happens in the
// middle of execution once, then exits, then a request comes through to build the same
// targets, reaches that target, skips-already-failed, and then continues building.
PopDependencyTargetsOnTargetFailure(topEntry, targetResult, ref stopProcessingStack);
}
return(true);
}
}
return(false);
}
private void Write(TargetSkippedEventArgs e)
{
Write(BinaryLogRecordKind.TargetSkipped);
WriteMessageFields(e, writeMessage: false);
WriteDeduplicatedString(e.TargetFile);
WriteDeduplicatedString(e.TargetName);
WriteDeduplicatedString(e.ParentTarget);
WriteDeduplicatedString(e.Condition);
WriteDeduplicatedString(e.EvaluatedCondition);
Write(e.OriginallySucceeded);
Write((int)e.BuildReason);
}
private void OnTargetSkipped(TargetSkippedEventArgs args)
{
var projectInfo = FindProjectContext(args);
var targetInfo = new TargetInfo(
Intern(args.TargetName),
Intern(args.TargetFile),
Intern(args.ParentTarget),
args.BuildReason,
args.Timestamp);
AddMessage(targetInfo, args);
projectInfo.AddExecutedTarget(args.TargetName, targetInfo);
}
private void Write(TargetSkippedEventArgs e)
{
ErrorUtilities.VerifyThrow(e.SkipReason != TargetSkipReason.None, "TargetSkippedEventArgs.SkipReason needs to be set");
Write(BinaryLogRecordKind.TargetSkipped);
WriteMessageFields(e, writeMessage: false);
WriteDeduplicatedString(e.TargetFile);
WriteDeduplicatedString(e.TargetName);
WriteDeduplicatedString(e.ParentTarget);
WriteDeduplicatedString(e.Condition);
WriteDeduplicatedString(e.EvaluatedCondition);
Write(e.OriginallySucceeded);
Write((int)e.BuildReason);
Write((int)e.SkipReason);
binaryWriter.WriteOptionalBuildEventContext(e.OriginalBuildEventContext);
}
private static TargetSkippedEventArgs CreateTargetSkipped()
{
var result = new TargetSkippedEventArgs(message: null)
{
BuildReason = TargetBuiltReason.DependsOn,
SkipReason = TargetSkipReason.PreviouslyBuiltSuccessfully,
BuildEventContext = CreateBuildEventContext(),
OriginalBuildEventContext = CreateBuildEventContext(),
Condition = "$(Condition) == 'true'",
EvaluatedCondition = "'true' == 'true'",
Importance = MessageImportance.Normal,
OriginallySucceeded = true,
ProjectFile = "1.proj",
TargetFile = "1.proj",
TargetName = "Build",
ParentTarget = "ParentTarget"
};
return(result);
}
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);
}
private BuildEventArgs ReadTargetSkippedEventArgs()
{
var fields = ReadBuildEventArgsFields();
// Read unused Importance, it defaults to Low
ReadInt32();
var targetFile = ReadOptionalString();
var targetName = ReadOptionalString();
var parentTarget = ReadOptionalString();
var buildReason = (TargetBuiltReason)ReadInt32();
var e = new TargetSkippedEventArgs(
fields.Message);
SetCommonFields(e, fields);
e.ProjectFile = fields.ProjectFile;
e.TargetFile = targetFile;
e.TargetName = targetName;
e.ParentTarget = parentTarget;
e.BuildReason = buildReason;
return(e);
}
public void RoundtripTargetSkippedEventArgs()
{
var args = new TargetSkippedEventArgs(
"Message")
{
BuildEventContext = BuildEventContext.Invalid,
ProjectFile = "foo.csproj",
TargetName = "target",
ParentTarget = "bar",
BuildReason = TargetBuiltReason.DependsOn
};
Roundtrip(args,
e => e.ParentTarget,
e => e.Importance.ToString(),
e => e.LineNumber.ToString(),
e => e.ColumnNumber.ToString(),
e => e.LineNumber.ToString(),
e => e.Message,
e => e.ProjectFile,
e => e.TargetFile,
e => e.TargetName,
e => e.BuildReason.ToString());
}
/// <summary>
/// Write a provided instance of BuildEventArgs to the BinaryWriter
/// </summary>
public void Write(BuildEventArgs e)
{
var type = e.GetType().Name;
// the cases are ordered by most used first for performance
if (e is BuildMessageEventArgs && type != "ProjectImportedEventArgs" && type != "TargetSkippedEventArgs")
{
Write((BuildMessageEventArgs)e);
}
else if (e is TaskStartedEventArgs)
{
Write((TaskStartedEventArgs)e);
}
else if (e is TaskFinishedEventArgs)
{
Write((TaskFinishedEventArgs)e);
}
else if (e is TargetStartedEventArgs)
{
Write((TargetStartedEventArgs)e);
}
else if (e is TargetFinishedEventArgs)
{
Write((TargetFinishedEventArgs)e);
}
else if (e is BuildErrorEventArgs)
{
Write((BuildErrorEventArgs)e);
}
else if (e is BuildWarningEventArgs)
{
Write((BuildWarningEventArgs)e);
}
else if (e is ProjectStartedEventArgs)
{
Write((ProjectStartedEventArgs)e);
}
else if (e is ProjectFinishedEventArgs)
{
Write((ProjectFinishedEventArgs)e);
}
else if (e is BuildStartedEventArgs)
{
Write((BuildStartedEventArgs)e);
}
else if (e is BuildFinishedEventArgs)
{
Write((BuildFinishedEventArgs)e);
}
else if (e is ProjectEvaluationStartedEventArgs)
{
Write((ProjectEvaluationStartedEventArgs)e);
}
else if (e is ProjectEvaluationFinishedEventArgs)
{
Write((ProjectEvaluationFinishedEventArgs)e);
}
// The following cases are due to the fact that StructuredLogger.dll
// only references MSBuild 14.0 .dlls. The following BuildEventArgs types
// were only introduced in MSBuild 15.3 so we can't refer to them statically.
// To still provide a good experience to those who are using the BinaryLogger
// from StructuredLogger.dll against MSBuild 15.3 or later we need to preserve
// these new events, so use reflection to create our "equivalents" of those
// and populate them to be binary identical to the originals. Then serialize
// our copies so that it's impossible to tell what wrote these.
else if (type == "ProjectEvaluationStartedEventArgs")
{
var evaluationStarted = new ProjectEvaluationStartedEventArgs(e.Message);
evaluationStarted.BuildEventContext = e.BuildEventContext;
evaluationStarted.ProjectFile = Reflector.GetProjectFileFromEvaluationStarted(e);
Write(evaluationStarted);
}
else if (type == "ProjectEvaluationFinishedEventArgs")
{
var evaluationFinished = new ProjectEvaluationFinishedEventArgs(e.Message);
evaluationFinished.BuildEventContext = e.BuildEventContext;
evaluationFinished.ProjectFile = Reflector.GetProjectFileFromEvaluationFinished(e);
Write(evaluationFinished);
}
else if (type == "ProjectImportedEventArgs")
{
var message = e as BuildMessageEventArgs;
var projectImported = new ProjectImportedEventArgs(message.LineNumber, message.ColumnNumber, e.Message);
projectImported.BuildEventContext = e.BuildEventContext;
projectImported.ProjectFile = message.ProjectFile;
projectImported.ImportedProjectFile = Reflector.GetImportedProjectFile(e);
projectImported.UnexpandedProject = Reflector.GetUnexpandedProject(e);
Write(projectImported);
}
else if (type == "TargetSkippedEventArgs")
{
var message = e as BuildMessageEventArgs;
var targetSkipped = new TargetSkippedEventArgs(e.Message);
targetSkipped.BuildEventContext = e.BuildEventContext;
targetSkipped.ProjectFile = message.ProjectFile;
targetSkipped.TargetName = Reflector.GetTargetNameFromTargetSkipped(e);
targetSkipped.TargetFile = Reflector.GetTargetFileFromTargetSkipped(e);
targetSkipped.ParentTarget = Reflector.GetParentTargetFromTargetSkipped(e);
targetSkipped.BuildReason = Reflector.GetBuildReasonFromTargetSkipped(e);
Write(targetSkipped);
}
else
{
// convert all unrecognized objects to message
// and just preserve the message
var buildMessageEventArgs = new BuildMessageEventArgs(
e.Message,
e.HelpKeyword,
e.SenderName,
MessageImportance.Normal,
e.Timestamp);
buildMessageEventArgs.BuildEventContext = e.BuildEventContext ?? BuildEventContext.Invalid;
Write(buildMessageEventArgs);
}
}
/// <summary>
/// Retrieves the list of dependencies this target needs to have built and moves the target to the next state.
/// Never returns null.
/// </summary>
/// <returns>A collection of targets on which this target depends.</returns>
internal List <TargetSpecification> GetDependencies(ProjectLoggingContext projectLoggingContext)
{
VerifyState(_state, TargetEntryState.Dependencies);
// Resolve the target now, since from this point on we are going to be doing work with the actual instance.
GetTargetInstance();
// We first make sure no batching was attempted with the target's condition.
// UNDONE: (Improvement) We want to allow this actually. In order to do this we need to determine what the
// batching buckets are, and if there are any which aren't empty, return our list of dependencies.
// Only in the case where all bucket conditions fail do we want to skip the target entirely (and
// this skip building the dependencies.)
if (ExpressionShredder.ContainsMetadataExpressionOutsideTransform(_target.Condition))
{
ProjectErrorUtilities.ThrowInvalidProject(_target.ConditionLocation, "TargetConditionHasInvalidMetadataReference", _target.Name, _target.Condition);
}
// If condition is false (based on propertyBag), set this target's state to
// "Skipped" since we won't actually build it.
bool condition = ConditionEvaluator.EvaluateCondition
(
_target.Condition,
ParserOptions.AllowPropertiesAndItemLists,
_expander,
ExpanderOptions.ExpandPropertiesAndItems,
_requestEntry.ProjectRootDirectory,
_target.ConditionLocation,
projectLoggingContext.LoggingService,
projectLoggingContext.BuildEventContext,
FileSystems.Default);
if (!condition)
{
_targetResult = new TargetResult(Array.Empty <TaskItem>(), new WorkUnitResult(WorkUnitResultCode.Skipped, WorkUnitActionCode.Continue, null));
_state = TargetEntryState.Completed;
if (!projectLoggingContext.LoggingService.OnlyLogCriticalEvents)
{
// Expand the expression for the Log. Since we know the condition evaluated to false, leave unexpandable properties in the condition so as not to cause an error
string expanded = _expander.ExpandIntoStringAndUnescape(_target.Condition, ExpanderOptions.ExpandPropertiesAndItems | ExpanderOptions.LeavePropertiesUnexpandedOnError | ExpanderOptions.Truncate, _target.ConditionLocation);
// By design: Not building dependencies. This is what NAnt does too.
// NOTE: In the original code, this was logged from the target logging context. However, the target
// hadn't been "started" by then, so you'd get a target message outside the context of a started
// target. In the Task builder (and original Task Engine), a Task Skipped message would be logged in
// the context of the target, not the task. This should be the same, especially given that we
// wish to allow batching on the condition of a target.
var skippedTargetEventArgs = new TargetSkippedEventArgs(
ResourceUtilities.GetResourceString("TargetSkippedFalseCondition"),
_target.Name,
_target.Condition,
expanded)
{
BuildEventContext = projectLoggingContext.BuildEventContext,
TargetName = _target.Name,
TargetFile = _target.Location.File,
ParentTarget = ParentEntry?.Target?.Name,
BuildReason = BuildReason
};
projectLoggingContext.LogBuildEvent(skippedTargetEventArgs);
}
return(new List <TargetSpecification>());
}
var dependencies = _expander.ExpandIntoStringListLeaveEscaped(_target.DependsOnTargets, ExpanderOptions.ExpandPropertiesAndItems, _target.DependsOnTargetsLocation);
List <TargetSpecification> dependencyTargets = new List <TargetSpecification>();
foreach (string escapedDependency in dependencies)
{
string dependencyTargetName = EscapingUtilities.UnescapeAll(escapedDependency);
dependencyTargets.Add(new TargetSpecification(dependencyTargetName, _target.DependsOnTargetsLocation));
}
_state = TargetEntryState.Execution;
return(dependencyTargets);
}
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;
}
}
public async void OnTargetSkipped(SolutionItem solutionItem, TargetSkippedEventArgs e)
{
await MessageSinks[0].AddMessage(e);
}
