public void TestTranslationWithEmptyDictionary()
{
TaskHostTaskComplete complete = new TaskHostTaskComplete(new OutOfProcTaskHostTaskResult(TaskCompleteType.Success, new Dictionary <string, object>()), null);
((ITranslatable)complete).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = TaskHostTaskComplete.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
TaskHostTaskComplete deserializedComplete = packet as TaskHostTaskComplete;
Assert.Equal(complete.TaskResult, deserializedComplete.TaskResult);
Assert.NotNull(deserializedComplete.TaskOutputParameters);
Assert.Equal(complete.TaskOutputParameters.Count, deserializedComplete.TaskOutputParameters.Count);
}
public void TestSerializeINodePacketSerializable()
{
DerivedClass value = new DerivedClass(1, 2);
TranslationHelpers.GetWriteTranslator().Translate(ref value);
DerivedClass deserializedValue = null;
TranslationHelpers.GetReadTranslator().Translate(ref deserializedValue);
Assert.Equal(value.BaseValue, deserializedValue.BaseValue);
Assert.Equal(value.DerivedValue, deserializedValue.DerivedValue);
}
public void TestTranslationWithException()
{
TaskItem item = new TaskItem("foo", "bar.proj");
item.SetMetadata("a", "b");
TargetResult result = new TargetResult(new TaskItem[] { item }, BuildResultUtilities.GetStopWithErrorResult(new BuildAbortedException()));
((ITranslatable)result).Translate(TranslationHelpers.GetWriteTranslator());
TargetResult deserializedResult = TargetResult.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.Equal(result.ResultCode, deserializedResult.ResultCode);
Assert.True(TranslationHelpers.CompareCollections(result.Items, deserializedResult.Items, TaskItemComparer.Instance));
Assert.True(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception));
}
public void TestTranslation()
{
BuildRequestConfigurationResponse response = new BuildRequestConfigurationResponse(1, 2, 3);
Assert.Equal(NodePacketType.BuildRequestConfigurationResponse, response.Type);
((ITranslatable)response).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket deserializedPacket = BuildRequestConfigurationResponse.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
BuildRequestConfigurationResponse deserializedResponse = deserializedPacket as BuildRequestConfigurationResponse;
Assert.Equal(response.NodeConfigurationId, deserializedResponse.NodeConfigurationId);
Assert.Equal(response.GlobalConfigurationId, deserializedResponse.GlobalConfigurationId);
Assert.Equal(response.ResultsNodeId, deserializedResponse.ResultsNodeId);
}
public void TestTranslationHostObjectsWhenEmpty()
{
var hostServices = new HostServices();
BuildRequest request = new BuildRequest(
submissionId: 1,
_nodeRequestId++,
1,
new string[] { "alpha", "omega" },
hostServices: hostServices,
BuildEventContext.Invalid,
parentRequest: null);
((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator());
BuildRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
}
public void TestTranslation()
{
var globalProperties = new PropertyDictionary <ProjectPropertyInstance>();
globalProperties["a"] = ProjectPropertyInstance.Create("a", "b");
var initial = new ConfigurationMetadata("path", globalProperties);
initial.Translate(TranslationHelpers.GetWriteTranslator());
var copy = ConfigurationMetadata.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
copy.ProjectFullPath.ShouldBe(initial.ProjectFullPath);
copy.ToolsVersion.ShouldBe(initial.ToolsVersion);
Assert.Equal(copy.GlobalProperties.GetCopyOnReadEnumerable(), initial.GlobalProperties.GetCopyOnReadEnumerable(), EqualityComparer <ProjectPropertyInstance> .Default);
}
public void TestTranslationWithITaskItemInDictionary()
{
IDictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("TaskItemValue", new TaskItem("Foo"));
TaskHostTaskComplete complete = new TaskHostTaskComplete(new OutOfProcTaskHostTaskResult(TaskCompleteType.Success, parameters), null);
((ITranslatable)complete).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = TaskHostTaskComplete.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
TaskHostTaskComplete deserializedComplete = packet as TaskHostTaskComplete;
Assert.Equal(complete.TaskResult, deserializedComplete.TaskResult);
Assert.NotNull(deserializedComplete.TaskOutputParameters);
Assert.Equal(complete.TaskOutputParameters.Count, deserializedComplete.TaskOutputParameters.Count);
TaskHostPacketHelpers.AreEqual((ITaskItem)complete.TaskOutputParameters["TaskItemValue"].WrappedParameter, (ITaskItem)deserializedComplete.TaskOutputParameters["TaskItemValue"].WrappedParameter);
}
public void TestSerializeDictionaryStringTNoComparer()
{
Dictionary <string, BaseClass> value = new Dictionary <string, BaseClass>();
value["foo"] = new BaseClass(1);
value["alpha"] = new BaseClass(2);
TranslationHelpers.GetWriteTranslator().TranslateDictionary <Dictionary <string, BaseClass>, BaseClass>(ref value, BaseClass.FactoryForDeserialization);
Dictionary <string, BaseClass> deserializedValue = null;
TranslationHelpers.GetReadTranslator().TranslateDictionary <Dictionary <string, BaseClass>, BaseClass>(ref deserializedValue, BaseClass.FactoryForDeserialization);
Assert.Equal(value.Count, deserializedValue.Count);
Assert.Equal(0, BaseClass.Comparer.Compare(value["foo"], deserializedValue["foo"]));
Assert.Equal(0, BaseClass.Comparer.Compare(value["alpha"], deserializedValue["alpha"]));
Assert.False(deserializedValue.ContainsKey("FOO"));
}
public void TestSerializeDictionaryStringT()
{
Dictionary <string, BaseClass> value = new Dictionary <string, BaseClass>(StringComparer.OrdinalIgnoreCase);
value["foo"] = new BaseClass(1);
value["alpha"] = new BaseClass(2);
TranslationHelpers.GetWriteTranslator().TranslateDictionary(ref value, StringComparer.OrdinalIgnoreCase, BaseClass.FactoryForDeserialization);
Dictionary <string, BaseClass> deserializedValue = null;
TranslationHelpers.GetReadTranslator().TranslateDictionary(ref deserializedValue, StringComparer.OrdinalIgnoreCase, BaseClass.FactoryForDeserialization);
Assert.Equal(value.Count, deserializedValue.Count);
Assert.Equal(0, BaseClass.Comparer.Compare(value["foo"], deserializedValue["foo"]));
Assert.Equal(0, BaseClass.Comparer.Compare(value["alpha"], deserializedValue["alpha"]));
Assert.Equal(0, BaseClass.Comparer.Compare(value["FOO"], deserializedValue["FOO"]));
}
public void TestSerializeDictionaryStringString()
{
Dictionary <string, string> value = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
value["foo"] = "bar";
value["alpha"] = "omega";
TranslationHelpers.GetWriteTranslator().TranslateDictionary(ref value, StringComparer.OrdinalIgnoreCase);
Dictionary <string, string> deserializedValue = null;
TranslationHelpers.GetReadTranslator().TranslateDictionary(ref deserializedValue, StringComparer.OrdinalIgnoreCase);
Assert.Equal(value.Count, deserializedValue.Count);
Assert.Equal(value["foo"], deserializedValue["foo"]);
Assert.Equal(value["alpha"], deserializedValue["alpha"]);
Assert.Equal(value["FOO"], deserializedValue["FOO"]);
}
public void TestTranslation()
{
PropertyDictionary <ProjectPropertyInstance> properties = new PropertyDictionary <ProjectPropertyInstance>();
properties.Set(ProjectPropertyInstance.Create("this", "that"));
properties.Set(ProjectPropertyInstance.Create("foo", "bar"));
BuildRequestData data = new BuildRequestData("file", properties.ToDictionary(), "4.0", new string[0], null);
BuildRequestConfiguration config = new BuildRequestConfiguration(data, "2.0");
Assert.Equal(NodePacketType.BuildRequestConfiguration, config.Type);
((ITranslatable)config).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = BuildRequestConfiguration.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
BuildRequestConfiguration deserializedConfig = packet as BuildRequestConfiguration;
Assert.Equal(config, deserializedConfig);
}
public void TestTranslation()
{
TaskItem item = new TaskItem("Hello", "my.proj");
List <TaskItem> targetOutputs = new List <TaskItem>();
targetOutputs.Add(item);
string _initialTargetOutputLogging = Environment.GetEnvironmentVariable("MSBUILDTARGETOUTPUTLOGGING");
Environment.SetEnvironmentVariable("MSBUILDTARGETOUTPUTLOGGING", "1");
try {
BuildEventArgs[] testArgs = new BuildEventArgs[]
{
new BuildFinishedEventArgs("Message", "Keyword", true),
new BuildStartedEventArgs("Message", "Help"),
new BuildMessageEventArgs("Message", "help", "sender", MessageImportance.Low),
new TaskStartedEventArgs("message", "help", "projectFile", "taskFile", "taskName"),
new TaskFinishedEventArgs("message", "help", "projectFile", "taskFile", "taskName", true),
new TaskCommandLineEventArgs("commandLine", "taskName", MessageImportance.Low),
new BuildWarningEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender"),
new BuildErrorEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender"),
new TargetStartedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile"),
new TargetFinishedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile", true, targetOutputs),
new ProjectStartedEventArgs(-1, "message", "help", "ProjectFile", "targetNames", null, null, null),
new ProjectFinishedEventArgs("message", "help", "ProjectFile", true),
new ExternalProjectStartedEventArgs("message", "help", "senderName", "projectFile", "targetNames")
};
foreach (BuildEventArgs arg in testArgs)
{
LogMessagePacket packet = new LogMessagePacket(new KeyValuePair <int, BuildEventArgs>(0, arg));
((ITranslatable)packet).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket tempPacket = LogMessagePacket.FactoryForDeserialization(TranslationHelpers.GetReadTranslator()) as LogMessagePacket;
LogMessagePacket deserializedPacket = tempPacket as LogMessagePacket;
CompareLogMessagePackets(packet, deserializedPacket);
}
} finally {
Environment.SetEnvironmentVariable("MSBUILDTARGETOUTPUTLOGGING", _initialTargetOutputLogging);
}
}
public void TestTranslationRemoteHostObjects()
{
var stateInHostObject = 3;
var hostServices = new HostServices();
var rot = new MockRunningObjectTable();
hostServices.SetTestRunningObjectTable(rot);
var moniker = nameof(TestTranslationRemoteHostObjects) + Guid.NewGuid();
var remoteHost = new MockRemoteHostObject(stateInHostObject);
using (var result = rot.Register(moniker, remoteHost))
{
hostServices.RegisterHostObject(
"WithOutOfProc.targets",
"DisplayMessages",
"ATask",
moniker);
BuildRequest request = new BuildRequest(
submissionId: 1,
_nodeRequestId++,
1,
new string[] { "alpha", "omega" },
hostServices: hostServices,
BuildEventContext.Invalid,
parentRequest: null);
((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = BuildRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
BuildRequest deserializedRequest = packet as BuildRequest;
deserializedRequest.HostServices.SetTestRunningObjectTable(rot);
var hostObject = deserializedRequest.HostServices.GetHostObject(
"WithOutOfProc.targets",
"DisplayMessages",
"ATask") as ITestRemoteHostObject;
hostObject.GetState().ShouldBe(stateInHostObject);
}
}
public void TestTranslation()
{
BuildRequest request = new BuildRequest(1, 1, 2, new string[] { "alpha", "omega" }, null, new BuildEventContext(1, 1, 2, 3, 4, 5), null);
BuildResult result = new BuildResult(request, new BuildAbortedException());
TaskItem fooTaskItem = new TaskItem("foo", "asdf.proj");
fooTaskItem.SetMetadata("meta1", "metavalue1");
fooTaskItem.SetMetadata("meta2", "metavalue2");
result.InitialTargets = new List <string> {
"a", "b"
};
result.DefaultTargets = new List <string> {
"c", "d"
};
result.AddResultsForTarget("alpha", new TargetResult(new TaskItem[] { fooTaskItem }, BuildResultUtilities.GetSuccessResult()));
result.AddResultsForTarget("omega", new TargetResult(new TaskItem[] { }, BuildResultUtilities.GetStopWithErrorResult(new ArgumentException("The argument was invalid"))));
Assert.Equal(NodePacketType.BuildResult, (result as INodePacket).Type);
((ITranslatable)result).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = BuildResult.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
BuildResult deserializedResult = packet as BuildResult;
Assert.Equal(result.ConfigurationId, deserializedResult.ConfigurationId);
Assert.True(TranslationHelpers.CompareCollections(result.DefaultTargets, deserializedResult.DefaultTargets, StringComparer.Ordinal));
Assert.True(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception));
Assert.Equal(result.Exception.Message, deserializedResult.Exception.Message);
Assert.Equal(result.GlobalRequestId, deserializedResult.GlobalRequestId);
Assert.True(TranslationHelpers.CompareCollections(result.InitialTargets, deserializedResult.InitialTargets, StringComparer.Ordinal));
Assert.Equal(result.NodeRequestId, deserializedResult.NodeRequestId);
Assert.Equal(result["alpha"].ResultCode, deserializedResult["alpha"].ResultCode);
Assert.True(TranslationHelpers.CompareExceptions(result["alpha"].Exception, deserializedResult["alpha"].Exception));
Assert.True(TranslationHelpers.CompareCollections(result["alpha"].Items, deserializedResult["alpha"].Items, TaskItemComparer.Instance));
Assert.Equal(result["omega"].ResultCode, deserializedResult["omega"].ResultCode);
Assert.True(TranslationHelpers.CompareExceptions(result["omega"].Exception, deserializedResult["omega"].Exception));
Assert.True(TranslationHelpers.CompareCollections(result["omega"].Items, deserializedResult["omega"].Items, TaskItemComparer.Instance));
}
public void TestTranslationWithITaskItemArrayInDictionary()
{
IDictionary <string, object> parameters = new Dictionary <string, object>();
parameters.Add("TaskItemArrayValue", new ITaskItem[] { new TaskItem("Foo"), new TaskItem("Baz") });
TaskHostConfiguration config = new TaskHostConfiguration(
1,
Directory.GetCurrentDirectory(),
null,
Thread.CurrentThread.CurrentCulture,
Thread.CurrentThread.CurrentUICulture,
#if FEATURE_APPDOMAIN
null,
#endif
1,
1,
@"c:\my project\myproj.proj",
_continueOnErrorDefault,
"TaskName",
@"c:\MyTasks\MyTask.dll",
parameters,
null);
((ITranslatable)config).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = TaskHostConfiguration.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
TaskHostConfiguration deserializedConfig = packet as TaskHostConfiguration;
Assert.Equal(config.TaskName, deserializedConfig.TaskName);
#if !FEATURE_ASSEMBLYLOADCONTEXT
Assert.Equal(config.TaskLocation, deserializedConfig.TaskLocation);
#endif
Assert.NotNull(deserializedConfig.TaskParameters);
Assert.Equal(config.TaskParameters.Count, deserializedConfig.TaskParameters.Count);
ITaskItem[] itemArray = (ITaskItem[])config.TaskParameters["TaskItemArrayValue"].WrappedParameter;
ITaskItem[] deserializedItemArray = (ITaskItem[])deserializedConfig.TaskParameters["TaskItemArrayValue"].WrappedParameter;
TaskHostPacketHelpers.AreEqual(itemArray, deserializedItemArray);
}
public void TestTranslationWithNullDictionary()
{
var expectedGlobalProperties = new Dictionary <string, string>
{
["Property1"] = "Value1",
["Property2"] = "Value2"
};
TaskHostConfiguration config = new TaskHostConfiguration(
1,
Directory.GetCurrentDirectory(),
null,
Thread.CurrentThread.CurrentCulture,
Thread.CurrentThread.CurrentUICulture,
#if FEATURE_APPDOMAIN
null,
#endif
1,
1,
@"c:\my project\myproj.proj",
_continueOnErrorDefault,
"TaskName",
@"c:\MyTasks\MyTask.dll",
null,
expectedGlobalProperties);
((ITranslatable)config).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = TaskHostConfiguration.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
TaskHostConfiguration deserializedConfig = packet as TaskHostConfiguration;
Assert.Equal(config.TaskName, deserializedConfig.TaskName);
#if !FEATURE_ASSEMBLYLOADCONTEXT
Assert.Equal(config.TaskLocation, deserializedConfig.TaskLocation);
#endif
Assert.Null(deserializedConfig.TaskParameters);
Assert.Equal(expectedGlobalProperties, deserializedConfig.GlobalProperties);
}
public void TestTranslation()
{
BuildRequest request = CreateNewBuildRequest(1, new string[] { "alpha", "omega" });
Assert.Equal(NodePacketType.BuildRequest, request.Type);
((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = BuildRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
BuildRequest deserializedRequest = packet as BuildRequest;
Assert.Equal(request.BuildEventContext, deserializedRequest.BuildEventContext);
Assert.Equal(request.ConfigurationId, deserializedRequest.ConfigurationId);
Assert.Equal(request.GlobalRequestId, deserializedRequest.GlobalRequestId);
Assert.Equal(request.IsConfigurationResolved, deserializedRequest.IsConfigurationResolved);
Assert.Equal(request.NodeRequestId, deserializedRequest.NodeRequestId);
Assert.Equal(request.ParentBuildEventContext, deserializedRequest.ParentBuildEventContext);
Assert.Equal(request.Targets.Count, deserializedRequest.Targets.Count);
for (int i = 0; i < request.Targets.Count; i++)
{
Assert.Equal(request.Targets[i], deserializedRequest.Targets[i]);
}
}