public void CopyMetadataFromITaskItem()
{
TaskItem from = new TaskItem();
from.ItemSpec = "Monkey.txt";
from.SetMetadata("Dog", "Bingo");
from.SetMetadata("Cat", "Morris");
from.SetMetadata("Bird", "Big");
TaskItem to = new TaskItem();
to.ItemSpec = "Bonobo.txt";
to.SetMetadata("Sponge", "Bob");
to.SetMetadata("Dog", "Harriet");
to.SetMetadata("Cat", "Mike");
from.CopyMetadataTo(to);
Assert.AreEqual("Bonobo.txt", to.ItemSpec); // ItemSpec is never overwritten
Assert.AreEqual("Bob", to.GetMetadata("Sponge")); // Metadata not in source are preserverd.
Assert.AreEqual("Harriet", to.GetMetadata("Dog")); // Metadata present on destination are not overwritten.
Assert.AreEqual("Mike", to.GetMetadata("Cat"));
Assert.AreEqual("Big", to.GetMetadata("Bird"));
}
public void ReturnsFirstOne()
{
FindInList f = new FindInList();
f.BuildEngine = new MockEngine();
f.ItemSpecToFind = "a.cs";
ITaskItem item1 = new TaskItem("a.cs");
item1.SetMetadata("id", "1");
ITaskItem item2 = new TaskItem("a.cs");
item2.SetMetadata("id", "2");
f.List = new ITaskItem[] { item1, item2 };
Assert.True(f.Execute());
Assert.Equal("a.cs", f.ItemFound.ItemSpec);
Assert.Equal(item1.GetMetadata("id"), f.ItemFound.GetMetadata("id"));
}
/// <summary>
/// Add all items to the command line
/// </summary>
private static void AddLibraryName(IEnumerable<ITaskItem> items, List<ITaskItem> outputItems)
{
if (items == null) return;
foreach (var x in items)
{
var outputItem = new TaskItem(x);
x.CopyMetadataTo(outputItem);
if (string.IsNullOrEmpty(outputItem.GetMetadata("LibraryName")))
{
outputItem.SetMetadata("LibraryName", Path.GetFileNameWithoutExtension(x.ItemSpec));
}
outputItems.Add(outputItem);
}
}
public void ReturnsLastOne()
{
FindInList f = new FindInList();
f.BuildEngine = new MockEngine();
f.ItemSpecToFind = "a.cs";
f.FindLastMatch = true;
ITaskItem item1 = new TaskItem("a.cs");
item1.SetMetadata("id", "1");
ITaskItem item2 = new TaskItem("a.cs");
item2.SetMetadata("id", "2");
f.List = new ITaskItem[] { item1, item2 };
Assert.IsTrue(f.Execute(), "Expect success");
Assert.AreEqual("a.cs", f.ItemFound.ItemSpec);
Assert.AreEqual(item2.GetMetadata("id"), f.ItemFound.GetMetadata("id"));
}
public void ConstructWithITaskItem()
{
TaskItem from = new TaskItem();
from.ItemSpec = "Monkey.txt";
from.SetMetadata("Dog", "Bingo");
from.SetMetadata("Cat", "Morris");
TaskItem to = new TaskItem((ITaskItem)from);
Assert.AreEqual("Monkey.txt", to.ItemSpec);
Assert.AreEqual("Monkey.txt", (string)to);
Assert.AreEqual("Bingo", to.GetMetadata("Dog"));
Assert.AreEqual("Morris", to.GetMetadata("Cat"));
// Test that item metadata are case-insensitive.
to.SetMetadata("CaT", "");
Assert.AreEqual("", to.GetMetadata("Cat"));
// manipulate the item-spec a bit
Assert.AreEqual("Monkey", to.GetMetadata(FileUtilities.ItemSpecModifiers.Filename));
Assert.AreEqual(".txt", to.GetMetadata(FileUtilities.ItemSpecModifiers.Extension));
Assert.AreEqual(String.Empty, to.GetMetadata(FileUtilities.ItemSpecModifiers.RelativeDir));
}
public void CreateTaskItemWithNullMetadata()
{
IDictionary<string, string> metadata = new Dictionary<string, string>();
metadata.Add("m", null);
TaskItem item = new TaskItem("bar", (IDictionary)metadata);
Assert.AreEqual(String.Empty, item.GetMetadata("m"));
}
public void SetNullMetadataValue()
{
TaskItem item = new TaskItem("bar");
item.SetMetadata("m", null);
Assert.AreEqual(String.Empty, item.GetMetadata("m"));
}
public void NonexistentRequestIdentity()
{
TaskItem from = new TaskItem();
from.ItemSpec = "Monkey.txt";
Assert.AreEqual
(
"Monkey.txt",
from.GetMetadata(FileUtilities.ItemSpecModifiers.Identity)
);
}
public void RequestTimeStamps()
{
TaskItem from = new TaskItem();
from.ItemSpec = FileUtilities.GetTemporaryFile();
Assert.IsTrue
(
from.GetMetadata(FileUtilities.ItemSpecModifiers.ModifiedTime).Length > 0
);
Assert.IsTrue
(
from.GetMetadata(FileUtilities.ItemSpecModifiers.CreatedTime).Length > 0
);
Assert.IsTrue
(
from.GetMetadata(FileUtilities.ItemSpecModifiers.AccessedTime).Length > 0
);
File.Delete(from.ItemSpec);
Assert.IsTrue
(
from.GetMetadata(FileUtilities.ItemSpecModifiers.ModifiedTime).Length == 0
);
Assert.IsTrue
(
from.GetMetadata(FileUtilities.ItemSpecModifiers.CreatedTime).Length == 0
);
Assert.IsTrue
(
from.GetMetadata(FileUtilities.ItemSpecModifiers.AccessedTime).Length == 0
);
}
public void TestCtor_EscapedSpecialChar_BrokenEscaping ()
{
// This is badly escaped, but MSBuild does not care.
var metadata = "*****@*****.**";
var item = new TaskItem (metadata);
Assert.AreEqual (metadata, item.ItemSpec, "#1");
Assert.AreEqual (metadata, item.GetMetadata ("Identity"), "#2");
Assert.AreEqual (Path.GetFileNameWithoutExtension (metadata), item.GetMetadata ("FileName"), "#3");
Assert.IsTrue (item.GetMetadata ("FullPath").EndsWith (metadata), "#4");
}
public void TestReferenceWithMetadataAlreadySetBuildInProjectAttributeFalse()
{
// Test the case where the metadata is missing and we are not supposed to build the reference
ITaskItem referenceItem = new TaskItem("TestItem");
referenceItem.SetMetadata("BuildReference", "true");
referenceItem.SetMetadata("ReferenceOutputAssembly", "true");
XmlDocument doc = new XmlDocument();
XmlElement element = doc.CreateElement("TestElement");
element.SetAttribute("BuildProjectInSolution", "false");
AssignProjectConfiguration.SetBuildInProjectAndReferenceOutputAssemblyMetadata(true, referenceItem, element);
Assert.IsTrue(referenceItem.GetMetadata("BuildReference").Equals("true", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(referenceItem.GetMetadata("ReferenceOutputAssembly").Equals("true", StringComparison.OrdinalIgnoreCase));
// Test the case where only ReferenceOutputAssembly is not set
referenceItem = new TaskItem("TestItem");
referenceItem.SetMetadata("BuildReference", "true");
doc = new XmlDocument();
element = doc.CreateElement("TestElement");
element.SetAttribute("BuildProjectInSolution", "false");
AssignProjectConfiguration.SetBuildInProjectAndReferenceOutputAssemblyMetadata(true, referenceItem, element);
Assert.IsTrue(referenceItem.GetMetadata("BuildReference").Equals("true", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(referenceItem.GetMetadata("ReferenceOutputAssembly").Equals("false", StringComparison.OrdinalIgnoreCase));
// Test the case where only BuildReference is not set
referenceItem = new TaskItem("TestItem");
referenceItem.SetMetadata("ReferenceOutputAssembly", "true");
doc = new XmlDocument();
element = doc.CreateElement("TestElement");
element.SetAttribute("BuildProjectInSolution", "false");
AssignProjectConfiguration.SetBuildInProjectAndReferenceOutputAssemblyMetadata(true, referenceItem, element);
Assert.IsTrue(referenceItem.GetMetadata("BuildReference").Equals("false", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(referenceItem.GetMetadata("ReferenceOutputAssembly").Equals("true", StringComparison.OrdinalIgnoreCase));
}
public void NonexistentRequestRootDir()
{
TaskItem from = new TaskItem();
from.ItemSpec = "Monkey.txt";
Assert.AreEqual
(
Path.GetPathRoot
(
from.GetMetadata(FileUtilities.ItemSpecModifiers.FullPath)
),
from.GetMetadata(FileUtilities.ItemSpecModifiers.RootDir)
);
}
public void CheckSetCopyLocalToFalseOnGacAssemblies()
{
string gacPath = @"C:\windows\gac";
ResolveComReference rcr = new ResolveComReference();
rcr.BuildEngine = new MockEngine();
ArrayList taskItems = new ArrayList();
TaskItem nonGacNoPrivate = new TaskItem(@"C:\windows\gar\test1.dll");
TaskItem gacNoPrivate = new TaskItem(@"C:\windows\gac\assembly1.dll");
TaskItem nonGacPrivateFalse = new TaskItem(@"C:\windows\gar\test1.dll");
nonGacPrivateFalse.SetMetadata(ItemMetadataNames.privateMetadata, "false");
TaskItem gacPrivateFalse = new TaskItem(@"C:\windows\gac\assembly1.dll");
gacPrivateFalse.SetMetadata(ItemMetadataNames.privateMetadata, "false");
TaskItem nonGacPrivateTrue = new TaskItem(@"C:\windows\gar\test1.dll");
nonGacPrivateTrue.SetMetadata(ItemMetadataNames.privateMetadata, "true");
TaskItem gacPrivateTrue = new TaskItem(@"C:\windows\gac\assembly1.dll");
gacPrivateTrue.SetMetadata(ItemMetadataNames.privateMetadata, "true");
taskItems.Add(nonGacNoPrivate);
taskItems.Add(gacNoPrivate);
taskItems.Add(nonGacPrivateFalse);
taskItems.Add(gacPrivateFalse);
taskItems.Add(nonGacPrivateTrue);
taskItems.Add(gacPrivateTrue);
rcr.SetCopyLocalToFalseOnGacOrNoPIAAssemblies(taskItems, gacPath);
// if Private is missing, by default GAC items are CopyLocal=false, non GAC CopyLocal=true
Assert.IsTrue(nonGacNoPrivate.GetMetadata(ItemMetadataNames.copyLocal) == "true", "Non Gac assembly, missing Private, should be TRUE");
Assert.IsTrue(gacNoPrivate.GetMetadata(ItemMetadataNames.copyLocal) == "false", "Gac assembly, missing Private, should be FALSE");
// if Private is set, it takes precedence
Assert.IsTrue(nonGacPrivateFalse.GetMetadata(ItemMetadataNames.copyLocal) == "false", "Non Gac assembly, Private false, should be FALSE");
Assert.IsTrue(gacPrivateFalse.GetMetadata(ItemMetadataNames.copyLocal) == "false", "Gac assembly, Private false, should be FALSE");
Assert.IsTrue(nonGacPrivateTrue.GetMetadata(ItemMetadataNames.copyLocal) == "true", "Non Gac assembly, Private true, should be TRUE");
Assert.IsTrue(gacPrivateTrue.GetMetadata(ItemMetadataNames.copyLocal) == "true", "Gac assembly, Private true, should be TRUE");
}
public void ConstructFromDictionary()
{
Hashtable h = new Hashtable();
h[FileUtilities.ItemSpecModifiers.Filename] = "foo";
h[FileUtilities.ItemSpecModifiers.Extension] = "bar";
h["custom"] = "hello";
TaskItem t = new TaskItem("bamboo.baz", h);
// item-spec modifiers were not overridden by dictionary passed to constructor
Assert.AreEqual("bamboo", t.GetMetadata(FileUtilities.ItemSpecModifiers.Filename));
Assert.AreEqual(".baz", t.GetMetadata(FileUtilities.ItemSpecModifiers.Extension));
Assert.AreEqual("hello", t.GetMetadata("CUSTOM"));
}
public void NonexistentRequestFullPath()
{
TaskItem from = new TaskItem();
from.ItemSpec = "Monkey.txt";
Assert.AreEqual
(
Path.Combine
(
Directory.GetCurrentDirectory(),
"Monkey.txt"
),
from.GetMetadata(FileUtilities.ItemSpecModifiers.FullPath)
);
}
public void ReturnsLastOne()
{
FindAppConfigFile f = new FindAppConfigFile();
f.BuildEngine = new MockEngine();
ITaskItem item1 = new TaskItem("app.config");
item1.SetMetadata("id", "1");
ITaskItem item2 = new TaskItem("app.config");
item2.SetMetadata("id", "2");
f.PrimaryList = new ITaskItem[] { item1, item2 };
f.SecondaryList = new ITaskItem[] { };
f.TargetPath = "targetpath";
Assert.True(f.Execute());
Assert.Equal("app.config", f.AppConfigFile.ItemSpec);
Assert.Equal(item2.GetMetadata("id"), f.AppConfigFile.GetMetadata("id"));
}
/// <summary>
/// Resolves a single reference item by searcheing for referenced items using the specified SearchPaths.
/// This method is made public so the resolution logic can be reused by other tasks.
/// </summary>
/// <param name="reference">The referenced item.</param>
/// <param name="searchPaths">The paths to search.</param>
/// <param name="searchFilenameExtensions">Filename extensions to check.</param>
/// <param name="log">Logging helper.</param>
/// <returns>The resolved reference item, or the original reference if it could not be resolved.</returns>
public static ITaskItem ResolveReference(ITaskItem reference, string[] searchPaths, string[] searchFilenameExtensions, TaskLoggingHelper log)
{
if (reference == null)
{
throw new ArgumentNullException("reference");
}
if (searchPaths == null)
{
// Nothing to search, so just return the original reference item.
return reference;
}
if (searchFilenameExtensions == null)
{
searchFilenameExtensions = new string[] { };
}
// Copy all the metadata from the source
TaskItem resolvedReference = new TaskItem(reference);
log.LogMessage(MessageImportance.Low, "WixReference: {0}", reference.ItemSpec);
// Now find the resolved path based on our order of precedence
foreach (string searchPath in searchPaths)
{
log.LogMessage(MessageImportance.Low, "Trying {0}", searchPath);
if (searchPath.Equals(HintPathToken, StringComparison.Ordinal))
{
string path = reference.GetMetadata("HintPath");
log.LogMessage(MessageImportance.Low, "Trying path {0}", path);
if (File.Exists(path))
{
resolvedReference.ItemSpec = path;
break;
}
}
else if (searchPath.Equals(RawFileNameToken, StringComparison.Ordinal))
{
log.LogMessage(MessageImportance.Low, "Trying path {0}", resolvedReference.ItemSpec);
if (File.Exists(resolvedReference.ItemSpec))
{
break;
}
if (ResolveWixReferences.ResolveFilenameExtensions(resolvedReference,
resolvedReference.ItemSpec, searchFilenameExtensions, log))
{
break;
}
}
else
{
string path = Path.Combine(searchPath, Path.GetFileName(reference.ItemSpec));
log.LogMessage(MessageImportance.Low, "Trying path {0}", path);
if (File.Exists(path))
{
resolvedReference.ItemSpec = path;
break;
}
if (ResolveWixReferences.ResolveFilenameExtensions(resolvedReference,
path, searchFilenameExtensions, log))
{
break;
}
}
}
// Normalize the item path
resolvedReference.ItemSpec = resolvedReference.GetMetadata("FullPath");
return resolvedReference;
}
public void VerifyCacheFileNames()
{
MockEngine engine = new MockEngine();
GetSDKReferenceFiles t = new GetSDKReferenceFiles();
t.BuildEngine = engine;
t.CacheFileFolderPath = s_cacheDirectory;
ITaskItem item = new TaskItem(s_sdkDirectory);
item.SetMetadata("ExpandReferenceAssemblies", "true");
item.SetMetadata("TargetedSDKConfiguration", "Retail");
item.SetMetadata("TargetedSDKArchitecture", "x86");
item.SetMetadata("OriginalItemSpec", "SDKWithManifest, Version=2.0");
t.ResolvedSDKReferences = new ITaskItem[] { item };
bool success = t.Execute(s_getAssemblyName, s_getAssemblyRuntimeVersion, FileUtilities.FileExistsNoThrow);
Assert.IsTrue(success);
ITaskItem[] references1 = t.References;
// Verify the task created a cache file
string sdkIdentity = item.GetMetadata("OriginalItemSpec");
string sdkRoot = item.ItemSpec;
string cacheFile = sdkIdentity + ",Set=" + FileUtilities.GetHexHash(sdkIdentity) + "-" + FileUtilities.GetHexHash(sdkRoot) + ",Hash=*.dat";
Thread.Sleep(100);
string[] existingCacheFiles = Directory.GetFiles(s_cacheDirectory, cacheFile);
Assert.IsTrue(existingCacheFiles.Length == 1);
GetSDKReferenceFiles t2 = new GetSDKReferenceFiles();
t2.BuildEngine = engine;
t2.CacheFileFolderPath = s_cacheDirectory;
// Same SDK with different path
ITaskItem item2 = new TaskItem(s_sdkDirectory2);
item2.SetMetadata("ExpandReferenceAssemblies", "true");
item2.SetMetadata("TargetedSDKConfiguration", "Retail");
item2.SetMetadata("TargetedSDKArchitecture", "x86");
item2.SetMetadata("OriginalItemSpec", "SDKWithManifest, Version=2.0");
t2.ResolvedSDKReferences = new ITaskItem[] { item2 };
bool success2 = t2.Execute(s_getAssemblyName, s_getAssemblyRuntimeVersion, FileUtilities.FileExistsNoThrow);
ITaskItem[] references2 = t2.References;
Assert.IsTrue(success2);
// References from the two builds should not overlap, otherwise the cache files are being misused
foreach (var ref2 in references2)
{
Assert.IsTrue(references1.Count(i => i.ItemSpec.Equals(ref2.ItemSpec, StringComparison.InvariantCultureIgnoreCase)) == 0);
}
Thread.Sleep(100);
string sdkIdentity2 = item.GetMetadata("OriginalItemSpec");
string sdkRoot2 = item.ItemSpec;
string cacheFile2 = sdkIdentity2 + ",Set=" + FileUtilities.GetHexHash(sdkIdentity2) + "-" + FileUtilities.GetHexHash(sdkRoot2) + ",Hash=*.dat";
string[] existingCacheFiles2 = Directory.GetFiles(s_cacheDirectory, cacheFile);
Assert.IsTrue(existingCacheFiles2.Length == 1);
// There should have two cache files with the same prefix and first hash
Thread.Sleep(100);
string[] allCacheFiles = Directory.GetFiles(s_cacheDirectory, sdkIdentity2 + ",Set=" + FileUtilities.GetHexHash(sdkIdentity2) + "*");
Assert.IsTrue(allCacheFiles.Length == 2);
}
public void TestReferenceWithNoMetadataNoBuildInProjectAttribute()
{
// Test the case where the metadata is missing and we are not supposed to build the reference
ITaskItem referenceItem = new TaskItem("TestItem");
XmlDocument doc = new XmlDocument();
XmlElement element = doc.CreateElement("TestElement");
AssignProjectConfiguration.SetBuildInProjectAndReferenceOutputAssemblyMetadata(true, referenceItem, element);
Assert.Equal(0, referenceItem.GetMetadata("BuildReference").Length);
Assert.Equal(0, referenceItem.GetMetadata("ReferenceOutputAssembly").Length);
}
public void TestCopyConstructor ()
{
item1 = new TaskItem ("itemSpec");
item1.SetMetadata ("meta1", "val1");
item2 = new TaskItem (item1);
Assert.AreEqual (item1.GetMetadata ("meta1"), item2.GetMetadata ("meta1"), "A1");
item1.SetMetadata ("meta1", "val2");
Assert.AreEqual ("val2", item1.GetMetadata ("meta1"), "A2");
Assert.AreEqual ("val1", item2.GetMetadata ("meta1"), "A3");
item2.SetMetadata ("meta1", "val3");
Assert.AreEqual ("val2", item1.GetMetadata ("meta1"), "A4");
Assert.AreEqual ("val3", item2.GetMetadata ("meta1"), "A5");
}
public void CheckSetCopyLocalToFalseOnEmbedInteropTypesAssemblies()
{
string gacPath = @"C:\windows\gac";
ResolveComReference rcr = new ResolveComReference();
rcr.BuildEngine = new MockEngine();
// the matrix of TargetFrameworkVersion values we are testing
string[] fxVersions =
{
"v2.0",
"v3.0",
"v3.5",
"v4.0"
};
for (int i = 0; i < fxVersions.Length; i++)
{
string fxVersion = fxVersions[i];
ArrayList taskItems = new ArrayList();
TaskItem nonGacNoPrivate = new TaskItem(@"C:\windows\gar\test1.dll");
nonGacNoPrivate.SetMetadata(ItemMetadataNames.embedInteropTypes, "true");
TaskItem gacNoPrivate = new TaskItem(@"C:\windows\gac\assembly1.dll");
gacNoPrivate.SetMetadata(ItemMetadataNames.embedInteropTypes, "true");
TaskItem nonGacPrivateFalse = new TaskItem(@"C:\windows\gar\test1.dll");
nonGacPrivateFalse.SetMetadata(ItemMetadataNames.privateMetadata, "false");
nonGacPrivateFalse.SetMetadata(ItemMetadataNames.embedInteropTypes, "true");
TaskItem gacPrivateFalse = new TaskItem(@"C:\windows\gac\assembly1.dll");
gacPrivateFalse.SetMetadata(ItemMetadataNames.privateMetadata, "false");
gacPrivateFalse.SetMetadata(ItemMetadataNames.embedInteropTypes, "true");
TaskItem nonGacPrivateTrue = new TaskItem(@"C:\windows\gar\test1.dll");
nonGacPrivateTrue.SetMetadata(ItemMetadataNames.privateMetadata, "true");
nonGacPrivateTrue.SetMetadata(ItemMetadataNames.embedInteropTypes, "true");
TaskItem gacPrivateTrue = new TaskItem(@"C:\windows\gac\assembly1.dll");
gacPrivateTrue.SetMetadata(ItemMetadataNames.privateMetadata, "true");
gacPrivateTrue.SetMetadata(ItemMetadataNames.embedInteropTypes, "true");
taskItems.Add(nonGacNoPrivate);
taskItems.Add(gacNoPrivate);
taskItems.Add(nonGacPrivateFalse);
taskItems.Add(gacPrivateFalse);
taskItems.Add(nonGacPrivateTrue);
taskItems.Add(gacPrivateTrue);
rcr.TargetFrameworkVersion = fxVersion;
rcr.SetFrameworkVersionFromString(rcr.TargetFrameworkVersion);
rcr.SetCopyLocalToFalseOnGacOrNoPIAAssemblies(taskItems, gacPath);
bool enabledNoPIA = false;
switch (fxVersion)
{
case "v4.0":
enabledNoPIA = true;
break;
default:
break;
}
// if Private is missing, by default GAC items are CopyLocal=false, non GAC CopyLocal=true
Assert.IsTrue
(
nonGacNoPrivate.GetMetadata(ItemMetadataNames.copyLocal) == (enabledNoPIA ? "false" : "true"),
fxVersion + ": Non Gac assembly, missing Private"
);
Assert.IsTrue
(
gacNoPrivate.GetMetadata(ItemMetadataNames.copyLocal) == (enabledNoPIA ? "false" : "false"),
fxVersion + ": Gac assembly, missing Private"
);
// if Private is set, it takes precedence
Assert.IsTrue
(
nonGacPrivateFalse.GetMetadata(ItemMetadataNames.copyLocal) == (enabledNoPIA ? "false" : "false"),
fxVersion + ": Non Gac assembly, Private false"
);
Assert.IsTrue
(
gacPrivateFalse.GetMetadata(ItemMetadataNames.copyLocal) == (enabledNoPIA ? "false" : "false"),
fxVersion + ": Gac assembly, Private false"
);
Assert.IsTrue
(
nonGacPrivateTrue.GetMetadata(ItemMetadataNames.copyLocal) == (enabledNoPIA ? "false" : "true"),
fxVersion + ": Non Gac assembly, Private true, should be TRUE"
);
Assert.IsTrue
(
gacPrivateTrue.GetMetadata(ItemMetadataNames.copyLocal) == (enabledNoPIA ? "false" : "true"),
fxVersion + ": Gac assembly, Private true, should be TRUE"
);
}
}
public void SaveCompactedWriteTlog()
{
Console.WriteLine("Test: SaveCompactedWriteTlog");
TaskItem fooItem = new TaskItem("foo");
ITaskItem[] sources = new TaskItem[] {
new TaskItem(Path.GetFullPath("TestFiles\\one.cpp")),
new TaskItem(Path.GetFullPath("TestFiles\\two.cpp")),
new TaskItem(Path.GetFullPath("TestFiles\\three.cpp"))};
string rootMarker = FileTracker.FormatRootingMarker(sources);
// Prepare files
Thread.Sleep(sleepTimeMilliseconds); // need to wait since the timestamp check needs some time to register
File.WriteAllLines("TestFiles\\one.tlog", new string[] {
"#Command some-command",
"^" + rootMarker,
Path.GetFullPath("TestFiles\\oNe.obj"),
"^" + fooItem.GetMetadata("Fullpath"),
Path.GetFullPath("TestFiles\\foo1.bar"),
Path.GetFullPath("TestFiles\\bar1.baz"),
});
File.WriteAllLines("TestFiles\\two.tlog", new string[] {
"#Command some-command",
"^" + rootMarker,
Path.GetFullPath("TestFiles\\two.obj"),
Path.GetFullPath("TestFiles\\three.obj"),
"^" + fooItem.GetMetadata("Fullpath"),
Path.GetFullPath("TestFiles\\foo2.bar"),
Path.GetFullPath("TestFiles\\bar2.baz"),
});
ITaskItem[] tlogs = {
new TaskItem("TestFiles\\one.tlog"),
new TaskItem("TestFiles\\two.tlog")
};
Thread.Sleep(sleepTimeMilliseconds); // need to wait since the timestamp check needs some time to register
CanonicalTrackedOutputFiles d = new CanonicalTrackedOutputFiles(DependencyTestHelper.MockTask,
tlogs);
ITaskItem[] outputs = d.OutputsForSource(sources);
Assert.Equal(3, outputs.Length);
Assert.Equal(outputs[0].ItemSpec, Path.GetFullPath("TestFiles\\oNe.obj"));
Assert.Equal(outputs[1].ItemSpec, Path.GetFullPath("TestFiles\\two.obj"));
Assert.Equal(outputs[2].ItemSpec, Path.GetFullPath("TestFiles\\three.obj"));
outputs = d.OutputsForSource(fooItem);
Assert.Equal(4, outputs.Length);
Assert.Equal(outputs[0].ItemSpec, Path.GetFullPath("TestFiles\\foo1.bar"));
Assert.Equal(outputs[1].ItemSpec, Path.GetFullPath("TestFiles\\bar1.baz"));
Assert.Equal(outputs[2].ItemSpec, Path.GetFullPath("TestFiles\\foo2.bar"));
Assert.Equal(outputs[3].ItemSpec, Path.GetFullPath("TestFiles\\bar2.baz"));
// Compact the tlog removing all entries for "foo" leaving the other entries intact
d.RemoveEntriesForSource(fooItem);
d.SaveTlog();
// All the tlogs need to still be there even after compaction
// It's OK for them to be empty, but their absence might mean a partial clean
// A missing tlog would mean a clean build
Assert.True(Microsoft.Build.Utilities.TrackedDependencies.ItemsExist(tlogs));
// All log information should now be in the tlog[0]
ITaskItem[] tlogs2 = {
tlogs[0]
};
CanonicalTrackedOutputFiles d2 = new CanonicalTrackedOutputFiles(DependencyTestHelper.MockTask,
tlogs2);
outputs = d2.OutputsForSource(fooItem);
Assert.Equal(0, outputs.Length);
outputs = d2.OutputsForSource(sources);
Assert.Equal(3, outputs.Length);
Assert.Equal(outputs[0].ItemSpec, Path.GetFullPath("TestFiles\\oNe.obj"));
Assert.Equal(outputs[1].ItemSpec, Path.GetFullPath("TestFiles\\two.obj"));
Assert.Equal(outputs[2].ItemSpec, Path.GetFullPath("TestFiles\\three.obj"));
// There should be no difference even if we send in all the original tlogs
CanonicalTrackedOutputFiles d3 = new CanonicalTrackedOutputFiles(DependencyTestHelper.MockTask,
tlogs);
outputs = d3.OutputsForSource(fooItem);
Assert.Equal(0, outputs.Length);
outputs = d3.OutputsForSource(sources);
Assert.Equal(3, outputs.Length);
Assert.Equal(outputs[0].ItemSpec, Path.GetFullPath("TestFiles\\oNe.obj"));
Assert.Equal(outputs[1].ItemSpec, Path.GetFullPath("TestFiles\\two.obj"));
Assert.Equal(outputs[2].ItemSpec, Path.GetFullPath("TestFiles\\three.obj"));
}
public void TestCtor_EscapedSpecialChar ()
{
// If we instantiate with the *escaped* metadata, it's unescaped automatically
var metadata = "*****@*****.**";
var escapedMetadata = global::Microsoft.Build.BuildEngine.Utilities.Escape ("*****@*****.**");
var item = new TaskItem (escapedMetadata);
item.SetMetadata ("mine", escapedMetadata);
Assert.AreEqual (metadata, item.ItemSpec, "#1");
Assert.AreEqual (metadata, item.GetMetadata ("Identity"), "#2");
Assert.AreEqual (Path.GetFileNameWithoutExtension (metadata), item.GetMetadata ("FileName"), "#3");
Assert.IsTrue (item.GetMetadata ("FullPath").EndsWith (metadata), "#4");
Assert.AreEqual (metadata, item.GetMetadata ("mine"), "#5");
}
/// <summary>
/// When overridden in a derived class, executes the task.
/// </summary>
/// <returns>Returns <see langword="true" /> if the task successfully
/// executed; otherwise, <see langword="false" />.
/// </returns>
public override bool Execute()
{
bool success = true;
this.resultItems = new ITaskItem[items.Length];
for (int i = 0; i < resultItems.Length; i++)
{
ITaskItem newItem = new TaskItem(items[i]);
this.items[i].CopyMetadataTo(newItem);
//Need to set this so it is not reset
newItem.SetMetadata("RecursiveDir", items[i].GetMetadata("RecursiveDir"));
if (String.IsNullOrEmpty(this.metadataName))
{
IDictionary<string, string> metadataBag = ParseMetadata(this.metadata);
foreach (string metadataName in metadataBag.Keys)
{
newItem.SetMetadata(metadataName, metadataBag[metadataName]);
}
}
else
{
System.Collections.ArrayList names = new System.Collections.ArrayList(newItem.MetadataNames);
string value = String.Empty;
if (names.Contains(this.metadataName))
{
value = String.Format(CultureInfo.InvariantCulture, "{0};{1}", newItem.GetMetadata(this.metadataName), String.Join(";", this.metadata));
}
else
{
value = String.Join(";", this.metadata);
}
newItem.SetMetadata(this.metadataName, value);
}
this.resultItems[i] = newItem;
}
return success;
}
public void TestCtor_UnescapedSpecialChar ()
{
// If we instantiate with unescaped metadata, we get the same value back
var metadata = "*****@*****.**";
var item = new TaskItem (metadata);
item.SetMetadata ("mine", metadata);
Assert.AreEqual (metadata, item.ItemSpec, "#1");
Assert.AreEqual (metadata, item.GetMetadata ("Identity"), "#2");
Assert.AreEqual (Path.GetFileNameWithoutExtension (metadata), item.GetMetadata ("FileName"), "#3");
Assert.IsTrue (item.GetMetadata ("FullPath").EndsWith (metadata), "#4");
Assert.AreEqual (metadata, item.GetMetadata ("mine"), "#5");
}
public void TestReferenceWithNoMetadataBuildInProjectAttributeFalseReferenceAndBuildProjectsDisabledInProjectConfiguration()
{
// Test the case where the metadata is missing and we are not supposed to build the reference
ITaskItem referenceItem = new TaskItem("TestItem");
XmlDocument doc = new XmlDocument();
XmlElement element = doc.CreateElement("TestElement");
element.SetAttribute("BuildProjectInSolution", "false");
AssignProjectConfiguration.SetBuildInProjectAndReferenceOutputAssemblyMetadata(false, referenceItem, element);
Assert.IsTrue(referenceItem.GetMetadata("BuildReference").Length == 0);
Assert.IsTrue(referenceItem.GetMetadata("ReferenceOutputAssembly").Length == 0);
}
public void TestCopyMetadataTo ()
{
item1 = new TaskItem ("itemSpec");
item2 = new TaskItem ("itemSpec");
item1.SetMetadata ("A", "1");
item1.SetMetadata ("B", "1");
item1.SetMetadata ("C", "1");
item2.SetMetadata ("B", "2");
item1.CopyMetadataTo (item2);
Assert.AreEqual ("1", item2.GetMetadata ("A"), "1");
Assert.AreEqual ("2", item2.GetMetadata ("B"), "2");
Assert.AreEqual ("1", item2.GetMetadata ("C"), "3");
}
public void NonexistentRequestDirectoryUNC()
{
TaskItem from = new TaskItem();
from.ItemSpec = @"\\local\share\subdir\Monkey.txt";
Assert.AreEqual
(
@"subdir\",
from.GetMetadata(FileUtilities.ItemSpecModifiers.Directory)
);
}
/// <summary>
/// Set metadata on the items which will be output from RAR.
/// </summary>
private ITaskItem SetItemMetadata(ArrayList relatedItems, ArrayList satelliteItems, ArrayList serializationAssemblyItems, ArrayList scatterItems, string fusionName, Reference reference, AssemblyNameExtension assemblyName, FileExists fileExists)
{
// Set up the main item.
ITaskItem referenceItem = new TaskItem();
referenceItem.ItemSpec = reference.FullPath;
referenceItem.SetMetadata(ItemMetadataNames.resolvedFrom, reference.ResolvedSearchPath);
// Set the CopyLocal metadata.
if (reference.IsCopyLocal)
{
referenceItem.SetMetadata(ItemMetadataNames.copyLocal, "true");
}
else
{
referenceItem.SetMetadata(ItemMetadataNames.copyLocal, "false");
}
// Set the FusionName metadata.
referenceItem.SetMetadata(ItemMetadataNames.fusionName, fusionName);
// Set the Redist name metadata.
if (!String.IsNullOrEmpty(reference.RedistName))
{
referenceItem.SetMetadata(ItemMetadataNames.redist, reference.RedistName);
}
if (Reference.IsFrameworkFile(reference.FullPath, _frameworkPaths) || (_installedAssemblies != null && _installedAssemblies.FrameworkAssemblyEntryInRedist(assemblyName)))
{
if (!IsAssemblyRemovedFromDotNetFramework(assemblyName, reference.FullPath, _frameworkPaths, _installedAssemblies))
{
referenceItem.SetMetadata(ItemMetadataNames.frameworkFile, "true");
}
}
if (!String.IsNullOrEmpty(reference.ImageRuntime))
{
referenceItem.SetMetadata(ItemMetadataNames.imageRuntime, reference.ImageRuntime);
}
if (reference.IsWinMDFile)
{
referenceItem.SetMetadata(ItemMetadataNames.winMDFile, "true");
// The ImplementationAssembly is only set if the implementation file exits on disk
if (reference.ImplementationAssembly != null)
{
if (VerifyArchitectureOfImplementationDll(reference.ImplementationAssembly, reference.FullPath))
{
referenceItem.SetMetadata(ItemMetadataNames.winmdImplmentationFile, Path.GetFileName(reference.ImplementationAssembly));
// Add the implementation item as a related file
ITaskItem item = new TaskItem(reference.ImplementationAssembly);
// Clone metadata.
referenceItem.CopyMetadataTo(item);
// Related files don't have a fusion name.
item.SetMetadata(ItemMetadataNames.fusionName, "");
RemoveNonForwardableMetadata(item);
// Add the related item.
relatedItems.Add(item);
}
}
if (reference.IsManagedWinMDFile)
{
referenceItem.SetMetadata(ItemMetadataNames.winMDFileType, "Managed");
}
else
{
referenceItem.SetMetadata(ItemMetadataNames.winMDFileType, "Native");
}
}
// Set the IsRedistRoot metadata
if (reference.IsRedistRoot == true)
{
referenceItem.SetMetadata(ItemMetadataNames.isRedistRoot, "true");
}
else if (reference.IsRedistRoot == false)
{
referenceItem.SetMetadata(ItemMetadataNames.isRedistRoot, "false");
}
else
{
// This happens when the redist root is "null". This means there
// was no IsRedistRoot flag in the Redist XML (or there was no
// redist XML at all for this item).
}
// If there was a primary source item, then forward metadata from it.
// It's important that the metadata from the primary source item
// win over the same metadata from other source items, so that's
// why we put this first. (CopyMetadataTo will never override an
// already existing metadata.) For example, if this reference actually
// came directly from an item declared in the project file, we'd
// want to use the metadata from it, not some other random item in
// the project file that happened to have this reference as a dependency.
if (reference.PrimarySourceItem != null)
{
reference.PrimarySourceItem.CopyMetadataTo(referenceItem);
}
else
{
bool hasImplementationFile = referenceItem.GetMetadata(ItemMetadataNames.winmdImplmentationFile).Length > 0;
bool hasImageRuntime = referenceItem.GetMetadata(ItemMetadataNames.imageRuntime).Length > 0;
bool hasWinMDFile = referenceItem.GetMetadata(ItemMetadataNames.winMDFile).Length > 0;
// If there were non-primary source items, then forward metadata from them.
ICollection sourceItems = reference.GetSourceItems();
foreach (ITaskItem sourceItem in sourceItems)
{
sourceItem.CopyMetadataTo(referenceItem);
}
// If the item originally did not have the implementation file metadata then we do not want to get it from the set of primary source items
// since the implementation file is something specific to the source item and not supposed to be propigated.
if (!hasImplementationFile)
{
referenceItem.RemoveMetadata(ItemMetadataNames.winmdImplmentationFile);
}
// If the item originally did not have the ImageRuntime metadata then we do not want to get it from the set of primary source items
// since the ImageRuntime is something specific to the source item and not supposed to be propigated.
if (!hasImageRuntime)
{
referenceItem.RemoveMetadata(ItemMetadataNames.imageRuntime);
}
// If the item originally did not have the WinMDFile metadata then we do not want to get it from the set of primary source items
// since the WinMDFile is something specific to the source item and not supposed to be propigated
if (!hasWinMDFile)
{
referenceItem.RemoveMetadata(ItemMetadataNames.winMDFile);
}
}
if (reference.ReferenceVersion != null)
{
referenceItem.SetMetadata(ItemMetadataNames.version, reference.ReferenceVersion.ToString());
}
else
{
referenceItem.SetMetadata(ItemMetadataNames.version, String.Empty);
}
// Now clone all properties onto the related files.
foreach (string relatedFileExtension in reference.GetRelatedFileExtensions())
{
ITaskItem item = new TaskItem(reference.FullPathWithoutExtension + relatedFileExtension);
// Clone metadata.
referenceItem.CopyMetadataTo(item);
// Related files don't have a fusion name.
item.SetMetadata(ItemMetadataNames.fusionName, "");
RemoveNonForwardableMetadata(item);
// Add the related item.
relatedItems.Add(item);
}
// Set up the satellites.
foreach (string satelliteFile in reference.GetSatelliteFiles())
{
ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, satelliteFile));
// Clone metadata.
referenceItem.CopyMetadataTo(item);
// Set the destination directory.
item.SetMetadata(ItemMetadataNames.destinationSubDirectory, FileUtilities.EnsureTrailingSlash(Path.GetDirectoryName(satelliteFile)));
// Satellite files don't have a fusion name.
item.SetMetadata(ItemMetadataNames.fusionName, "");
RemoveNonForwardableMetadata(item);
// Add the satellite item.
satelliteItems.Add(item);
}
// Set up the serialization assemblies
foreach (string serializationAssemblyFile in reference.GetSerializationAssemblyFiles())
{
ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, serializationAssemblyFile));
// Clone metadata.
referenceItem.CopyMetadataTo(item);
// serialization assemblies files don't have a fusion name.
item.SetMetadata(ItemMetadataNames.fusionName, "");
RemoveNonForwardableMetadata(item);
// Add the serialization assembly item.
serializationAssemblyItems.Add(item);
}
// Set up the scatter files.
foreach (string scatterFile in reference.GetScatterFiles())
{
ITaskItem item = new TaskItem(Path.Combine(reference.DirectoryName, scatterFile));
// Clone metadata.
referenceItem.CopyMetadataTo(item);
// We don't have a fusion name for scatter files.
item.SetMetadata(ItemMetadataNames.fusionName, "");
RemoveNonForwardableMetadata(item);
// Add the satellite item.
scatterItems.Add(item);
}
// As long as the item has not come from somewhere else say it came from rar (p2p's can come from somewhere else).
if (referenceItem.GetMetadata(ItemMetadataNames.msbuildReferenceSourceTarget).Length == 0)
{
referenceItem.SetMetadata(ItemMetadataNames.msbuildReferenceSourceTarget, "ResolveAssemblyReference");
}
if (referenceItem.GetMetadata(ItemMetadataNames.msbuildReferenceSourceTarget).Equals("ProjectReference"))
{
if (reference.PrimarySourceItem != null)
{
referenceItem.SetMetadata(ItemMetadataNames.projectReferenceOriginalItemSpec, reference.PrimarySourceItem.GetMetadata("OriginalItemSpec"));
}
}
return referenceItem;
}
public void NonexistentRequestRecursiveDir()
{
TaskItem from = new TaskItem();
from.ItemSpec = "Monkey.txt";
Assert.IsTrue
(
from.GetMetadata(FileUtilities.ItemSpecModifiers.RecursiveDir).Length == 0
);
}
