public void TestDeepClone()
{
TaskItem parent = new TaskItem("foo", "bar.proj");
parent.SetMetadata("a", "b");
parent.SetMetadata("c", "d");
TaskItem clone = parent.DeepClone();
Assert.True(parent.Equals(clone)); // "The parent and the clone should be equal"
Assert.False(object.ReferenceEquals(parent, clone)); // "The parent and the child should not be the same object"
}
public void TestInequivalenceWithDifferentCustomMetadataCount2()
{
TaskItem left = new TaskItem("foo", "bar.proj");
left.SetMetadata("a", "b");
TaskItem right = new TaskItem("foo", "bar.proj");
right.SetMetadata("a", "b");
right.SetMetadata("c", "d");
Assert.NotEqual(left, right);
Assert.NotEqual(left, right);
}
public void TestInequivalenceWithDifferentCustomMetadataCount()
{
TaskItem left = new TaskItem("foo", "bar.proj");
left.SetMetadata("a", "b");
TaskItem right = new TaskItem("foo", "bar.proj");
Assert.IsFalse(left == right);
Assert.IsTrue(left != right);
}
public void TestEquivalenceWithCustomMetadata()
{
TaskItem left = new TaskItem("foo", "bar.proj");
left.SetMetadata("a", "b");
TaskItem right = new TaskItem("foo", "bar.proj");
right.SetMetadata("a", "b");
Assert.IsTrue(left == right);
Assert.IsFalse(left != right);
}
public void TestEquivalenceWithCustomMetadata()
{
TaskItem left = new TaskItem("foo", "bar.proj");
left.SetMetadata("a", "b");
TaskItem right = new TaskItem("foo", "bar.proj");
right.SetMetadata("a", "b");
Assert.Equal(left, right);
Assert.Equal(left, right);
}
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 Serialization()
{
TaskItem item = new TaskItem("foo", "bar.proj");
item.SetMetadata("a", "b");
TranslationHelpers.GetWriteTranslator().Translate(ref item, TaskItem.FactoryForDeserialization);
TaskItem deserializedItem = null;
TranslationHelpers.GetReadTranslator().Translate(ref deserializedItem, TaskItem.FactoryForDeserialization);
Assert.AreEqual(item.ItemSpec, deserializedItem.ItemSpec);
Assert.AreEqual(item.MetadataCount, deserializedItem.MetadataCount);
Assert.AreEqual(item.GetMetadata("a"), deserializedItem.GetMetadata("a"));
Assert.AreEqual(item.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath), deserializedItem.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath));
}
public void TestTranslationWithException()
{
TaskItem item = new TaskItem("foo", "bar.proj");
item.SetMetadata("a", "b");
TargetResult result = new TargetResult(new TaskItem[] { item }, TestUtilities.GetStopWithErrorResult(new BuildAbortedException()));
((INodePacketTranslatable)result).Translate(TranslationHelpers.GetWriteTranslator());
TargetResult deserializedResult = TargetResult.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
Assert.AreEqual(result.ResultCode, deserializedResult.ResultCode);
Assert.IsTrue(TranslationHelpers.CompareCollections(result.Items, deserializedResult.Items, TaskItemComparer.Instance));
Assert.IsTrue(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception));
}
public void Serialization()
{
TaskItem item = new TaskItem("foo", "bar.proj");
item.SetMetadata("a", "b");
TranslationHelpers.GetWriteTranslator().Translate(ref item, TaskItem.FactoryForDeserialization);
TaskItem deserializedItem = null;
TranslationHelpers.GetReadTranslator().Translate(ref deserializedItem, TaskItem.FactoryForDeserialization);
Assert.Equal(item.ItemSpec, deserializedItem.ItemSpec);
Assert.Equal(item.MetadataCount, deserializedItem.MetadataCount);
Assert.Equal(item.GetMetadata("a"), deserializedItem.GetMetadata("a"));
Assert.Equal(item.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath), deserializedItem.GetMetadata(FileUtilities.ItemSpecModifiers.DefiningProjectFullPath));
}
public void TestTranslationNoException()
{
TaskItem item = new TaskItem("foo", "bar.proj");
item.SetMetadata("a", "b");
var buildEventContext = new Framework.BuildEventContext(1, 2, 3, 4, 5, 6, 7);
TargetResult result = new TargetResult(
new TaskItem[] { item },
BuildResultUtilities.GetStopWithErrorResult(),
buildEventContext);
((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));
Assert.Equal(result.OriginalBuildEventContext, deserializedResult.OriginalBuildEventContext);
}
public void TestInequivalenceWithDifferentCustomMetadataCount2()
{
TaskItem left = new TaskItem("foo", "bar.proj");
left.SetMetadata("a", "b");
TaskItem right = new TaskItem("foo", "bar.proj");
right.SetMetadata("a", "b");
right.SetMetadata("c", "d");
Assert.NotEqual(left, right);
Assert.NotEqual(left, right);
}
/// <summary>
/// Create some items and log them
/// </summary>
/// <returns></returns>
private void WriteAndValidateItems(BaseConsoleLogger cl, SimulatedConsole sc, bool expectToSeeLogging)
{
Hashtable items = new Hashtable();
items.Add("type", (ITaskItem2)new TaskItem("spec", String.Empty));
items.Add("type2", (ITaskItem2)new TaskItem("spec2", String.Empty));
// ItemSpecs are expected to be escaped coming in
ITaskItem2 taskItem3 = new TaskItem("%28spec%3b3", String.Empty);
// As are metadata, when set with "SetMetadata"
taskItem3.SetMetadata("f)oo", "%21%40%23");
items.Add("type(3)", taskItem3);
string item1type = string.Empty;
string item2type = string.Empty;
string item3type = string.Empty;
string item1spec = string.Empty;
string item2spec = string.Empty;
string item3spec = string.Empty;
string item3metadatum = string.Empty;
if (cl is SerialConsoleLogger)
{
SortedList itemList = ((SerialConsoleLogger)cl).ExtractItemList(items);
((SerialConsoleLogger)cl).WriteItems(itemList);
item1spec = "spec" + Environment.NewLine;
item2spec = "spec2" + Environment.NewLine;
item3spec = "(spec;3" + Environment.NewLine;
item3metadatum = "f)oo = !@#" + Environment.NewLine;
}
else
{
BuildEventArgs buildEvent = new BuildErrorEventArgs("", "", "", 0, 0, 0, 0, "", "", "");
buildEvent.BuildEventContext = new BuildEventContext(1, 2, 3, 4);
((ParallelConsoleLogger)cl).WriteItems(buildEvent, items);
item1spec = Environment.NewLine + " spec" + Environment.NewLine;
item2spec = Environment.NewLine + " spec2" + Environment.NewLine;
item3spec = Environment.NewLine + " (spec;3" + Environment.NewLine;
}
item1type = "type" + Environment.NewLine;
item2type = "type2" + Environment.NewLine;
item3type = "type(3)" + Environment.NewLine;
string log = sc.ToString();
Console.WriteLine("[" + log + "]");
// Being careful not to make locale assumptions here, eg about sorting
if (expectToSeeLogging)
{
Assert.IsTrue(log.Contains(item1type));
Assert.IsTrue(log.Contains(item2type));
Assert.IsTrue(log.Contains(item3type));
Assert.IsTrue(log.Contains(item1spec));
Assert.IsTrue(log.Contains(item2spec));
Assert.IsTrue(log.Contains(item3spec));
if (!String.Equals(item3metadatum, String.Empty, StringComparison.OrdinalIgnoreCase))
{
Assert.IsTrue(log.Contains(item3metadatum));
}
}
else
{
Assert.IsFalse(log.Contains(item1type));
Assert.IsFalse(log.Contains(item2type));
Assert.IsFalse(log.Contains(item3type));
Assert.IsFalse(log.Contains(item1spec));
Assert.IsFalse(log.Contains(item2spec));
Assert.IsFalse(log.Contains(item3type));
if (!String.Equals(item3metadatum, String.Empty, StringComparison.OrdinalIgnoreCase))
{
Assert.IsFalse(log.Contains(item3metadatum));
}
}
}
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 }, TestUtilities.GetSuccessResult()));
result.AddResultsForTarget("omega", new TargetResult(new TaskItem[] { }, TestUtilities.GetStopWithErrorResult(new ArgumentException("The argument was invalid"))));
Assert.AreEqual(NodePacketType.BuildResult, (result as INodePacket).Type);
((INodePacketTranslatable)result).Translate(TranslationHelpers.GetWriteTranslator());
INodePacket packet = BuildResult.FactoryForDeserialization(TranslationHelpers.GetReadTranslator());
BuildResult deserializedResult = packet as BuildResult;
Assert.AreEqual(result.ConfigurationId, deserializedResult.ConfigurationId);
Assert.IsTrue(TranslationHelpers.CompareCollections(result.DefaultTargets, deserializedResult.DefaultTargets, StringComparer.Ordinal));
Assert.IsTrue(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception));
Assert.AreEqual(result.Exception.Message, deserializedResult.Exception.Message);
Assert.AreEqual(result.GlobalRequestId, deserializedResult.GlobalRequestId);
Assert.IsTrue(TranslationHelpers.CompareCollections(result.InitialTargets, deserializedResult.InitialTargets, StringComparer.Ordinal));
Assert.AreEqual(result.NodeRequestId, deserializedResult.NodeRequestId);
Assert.AreEqual(result["alpha"].ResultCode, deserializedResult["alpha"].ResultCode);
Assert.IsTrue(TranslationHelpers.CompareExceptions(result["alpha"].Exception, deserializedResult["alpha"].Exception));
Assert.IsTrue(TranslationHelpers.CompareCollections(result["alpha"].Items, deserializedResult["alpha"].Items, TaskItemComparer.Instance));
Assert.AreEqual(result["omega"].ResultCode, deserializedResult["omega"].ResultCode);
Assert.IsTrue(TranslationHelpers.CompareExceptions(result["omega"].Exception, deserializedResult["omega"].Exception));
Assert.IsTrue(TranslationHelpers.CompareCollections(result["omega"].Items, deserializedResult["omega"].Items, TaskItemComparer.Instance));
}
public void TestInequivalenceWithDifferentCustomMetadataValues()
{
TaskItem left = new TaskItem("foo", "bar.proj");
left.SetMetadata("a", "b");
TaskItem right = new TaskItem("foo", "bar.proj");
right.SetMetadata("a", "c");
Assert.IsFalse(left == right);
Assert.IsTrue(left != right);
}
public void TestDeepClone()
{
TaskItem parent = new TaskItem("foo", "bar.proj");
parent.SetMetadata("a", "b");
parent.SetMetadata("c", "d");
TaskItem clone = parent.DeepClone();
Assert.IsTrue(parent.Equals(clone), "The parent and the clone should be equal");
Assert.IsFalse(object.ReferenceEquals(parent, clone), "The parent and the child should not be the same object");
}
public void ItemDefinitionMetadataCopiedToTaskItem2()
{
Project p = new Project(XmlReader.Create(new StringReader(
@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<ItemDefinitionGroup>
<ItemA>
<MetaA>M-A(b)</MetaA>
<MetaB>M-B(b)</MetaB>
</ItemA>
</ItemDefinitionGroup>
</Project>")));
Assert.IsTrue(p.ItemDefinitions.ContainsKey("ItemA"));
ProjectInstance pi = p.CreateProjectInstance();
ITaskItem noMetaItem = null;
ITaskItem withMetaItem;
List<ProjectItemDefinitionInstance> itemdefs = new List<ProjectItemDefinitionInstance>();
itemdefs.Add(pi.ItemDefinitions["ItemA"]);
noMetaItem = new TaskItem("NoMetaItem", pi.FullPath);
noMetaItem.SetMetadata("MetaA", "NEWMETA_A");
withMetaItem = new TaskItem("WithMetaItem", "WithMetaItem", null, itemdefs, ".", false, pi.FullPath);
// Copy the metadata on the item with no metadata onto the item with metadata
// from an item definition. The destination item's metadata should be maintained
noMetaItem.CopyMetadataTo(withMetaItem);
// New direct metadata takes precedence over item definitions on the destination item
Assert.AreEqual("NEWMETA_A", withMetaItem.GetMetadata("MetaA"));
Assert.AreEqual("M-B(b)", withMetaItem.GetMetadata("MetaB"));
}
public void TestTranslationNoException()
{
TaskItem item = new TaskItem("foo", "bar.proj");
item.SetMetadata("a", "b");
TargetResult result = new TargetResult(new TaskItem[] { item }, TestUtilities.GetStopWithErrorResult());
((INodePacketTranslatable)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));
}