public void MultipleCanonicalCLCompactMissingOnSuccessMultiEntry()
{
Console.WriteLine("Test: MultipleCanonicalCLCompactMissingOnSuccessMultiEntry");
// Prepare files
DependencyTestHelper.WriteAll("TestFiles\\one1.h", "");
DependencyTestHelper.WriteAll("TestFiles\\one2.h", "");
DependencyTestHelper.WriteAll("TestFiles\\one3.h", "");
DependencyTestHelper.WriteAll("TestFiles\\one.cpp", "");
DependencyTestHelper.WriteAll("TestFiles\\one.obj", "");
Thread.Sleep(sleepTimeMilliseconds); // need to wait since the timestamp check needs some time to register
File.WriteAllLines("TestFiles\\one.read.tlog", new string[] {
"#Command some-command",
"^" + Path.GetFullPath("TestFiles\\one.cpp"),
Path.GetFullPath("TestFiles\\one1.h"),
Path.GetFullPath("TestFiles\\one2.h"),
Path.GetFullPath("TestFiles\\one3.h"),
"^" + Path.GetFullPath("TestFiles\\two.cpp"),
Path.GetFullPath("TestFiles\\two1.h"),
Path.GetFullPath("TestFiles\\two2.h"),
});
File.WriteAllLines("TestFiles\\one.write.tlog", new string[] {
"#Command some-command",
"^" + Path.GetFullPath("TestFiles\\one.cpp"),
Path.GetFullPath("TestFiles\\one.obj"),
Path.GetFullPath("TestFiles\\sometempfile.obj"),
"^" + Path.GetFullPath("TestFiles\\two.cpp"),
Path.GetFullPath("TestFiles\\two.obj"),
Path.GetFullPath("TestFiles\\sometempfile2.obj")
});
CanonicalTrackedOutputFiles compactOutputs = new CanonicalTrackedOutputFiles(DependencyTestHelper.MockTask, DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.write.tlog")));
compactOutputs.RemoveDependenciesFromEntryIfMissing(new TaskItem(Path.GetFullPath("TestFiles\\one.cpp")));
compactOutputs.SaveTlog();
// Compact the read tlog
CanonicalTrackedInputFiles compactInputs = new CanonicalTrackedInputFiles
(
DependencyTestHelper.MockTask,
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.read.tlog")),
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.cpp")),
null,
compactOutputs,
false, /* no minimal rebuild optimization */
false /* shred composite rooting markers */
);
compactInputs.RemoveDependenciesFromEntryIfMissing(new TaskItem(Path.GetFullPath("TestFiles\\one.cpp")));
compactInputs.SaveTlog();
CanonicalTrackedOutputFiles writtenOutputs = new CanonicalTrackedOutputFiles(DependencyTestHelper.MockTask,
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.write.tlog")));
CanonicalTrackedInputFiles writtenInputs = new CanonicalTrackedInputFiles
(
DependencyTestHelper.MockTask,
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.read.tlog")),
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.cpp")),
null,
writtenOutputs,
false, /* no minimal rebuild optimization */
false /* shred composite rooting markers */
);
Assert.Equal(1, writtenOutputs.DependencyTable[Path.GetFullPath("TestFiles\\one.cpp")].Count);
Assert.Equal(4, writtenInputs.DependencyTable[Path.GetFullPath("TestFiles\\one.cpp")].Count);
// Everything to do with two.cpp should be left intact
Assert.Equal(2, writtenOutputs.DependencyTable[Path.GetFullPath("TestFiles\\two.cpp")].Count);
Assert.Equal(3, writtenInputs.DependencyTable[Path.GetFullPath("TestFiles\\two.cpp")].Count);
}
public void MultipleCanonicalCLCompactMissingOnSuccess()
{
Console.WriteLine("Test: MultipleCanonicalCLCompactMissingOnSuccess");
// Prepare files
DependencyTestHelper.WriteAll("TestFiles\\one1.h", "");
DependencyTestHelper.WriteAll("TestFiles\\one2.h", "");
DependencyTestHelper.WriteAll("TestFiles\\one3.h", "");
DependencyTestHelper.WriteAll("TestFiles\\one.cpp", "");
DependencyTestHelper.WriteAll("TestFiles\\one.obj", "");
Thread.Sleep(sleepTimeMilliseconds); // need to wait since the timestamp check needs some time to register
File.WriteAllLines("TestFiles\\one.read.tlog", new string[] {
"#Command some-command",
"^" + Path.GetFullPath("TestFiles\\one.cpp"),
Path.GetFullPath("TestFiles\\one1.h"),
Path.GetFullPath("TestFiles\\one2.h"),
Path.GetFullPath("TestFiles\\one3.h"),
});
File.WriteAllLines("TestFiles\\one.write.tlog", new string[] {
"#Command some-command",
"^" + Path.GetFullPath("TestFiles\\one.cpp"),
Path.GetFullPath("TestFiles\\one.obj"),
Path.GetFullPath("TestFiles\\sometempfile.obj")
});
CanonicalTrackedOutputFiles compactOutputs = new CanonicalTrackedOutputFiles(DependencyTestHelper.MockTask, DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.write.tlog")));
compactOutputs.RemoveDependenciesFromEntryIfMissing(new TaskItem(Path.GetFullPath("TestFiles\\one.cpp")));
compactOutputs.SaveTlog();
// Compact the read tlog
CanonicalTrackedInputFiles compactInputs = new CanonicalTrackedInputFiles
(
DependencyTestHelper.MockTask,
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.read.tlog")),
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.cpp")),
null,
compactOutputs,
false, /* no minimal rebuild optimization */
false /* shred composite rooting markers */
);
compactInputs.RemoveDependenciesFromEntryIfMissing(new TaskItem(Path.GetFullPath("TestFiles\\one.cpp")));
compactInputs.SaveTlog();
CanonicalTrackedOutputFiles outputs = new CanonicalTrackedOutputFiles(DependencyTestHelper.MockTask,
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.write.tlog")));
CanonicalTrackedInputFiles d = new CanonicalTrackedInputFiles
(
DependencyTestHelper.MockTask,
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.read.tlog")),
DependencyTestHelper.ItemArray(new TaskItem("TestFiles\\one.cpp")),
null,
outputs,
false, /* no minimal rebuild optimization */
false /* shred composite rooting markers */
);
ITaskItem[] outofdate = d.ComputeSourcesNeedingCompilation();
Assert.Equal(0, outofdate.Length);
}
protected override int ExecuteTool(string pathToTool, string responseFileCommands, string commandLineCommands)
{
responseFileCommands = responseFileCommands.Replace("[PackageName]", PackageName);
commandLineCommands = commandLineCommands.Replace("[PackageName]", PackageName);
string src = "";
foreach (var item in Sources)
src += " " + item.ToString();
if (ShowCommandLine)
Log.LogMessage(MessageImportance.High, pathToTool + " " + responseFileCommands + " " + commandLineCommands);
else
Log.LogMessage(MessageImportance.High, "Compiling" + src);
/*
return base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands);
*/
int num = 0;
try
{
num = this.TrackerExecuteTool(pathToTool, responseFileCommands, commandLineCommands);
return num;
}
finally
{
if (this.MinimalRebuildFromTracking || this.TrackFileAccess)
{
CanonicalTrackedOutputFiles trackedOutputFiles = new CanonicalTrackedOutputFiles(this.TLogWriteFiles);
CanonicalTrackedInputFiles trackedInputFiles = new CanonicalTrackedInputFiles(this.TLogReadFiles, this.Sources, this.ExcludedInputPaths, trackedOutputFiles, true, this.MaintainCompositeRootingMarkers);
DependencyFilter includeInTLog = new DependencyFilter(this.OutputDependencyFilter);
DependencyFilter dependencyFilter = new DependencyFilter(this.InputDependencyFilter);
this.trackedInputFilesToRemove = new Dictionary<string, ITaskItem>((IEqualityComparer<string>) StringComparer.OrdinalIgnoreCase);
if (this.TrackedInputFilesToIgnore != null)
{
foreach (ITaskItem taskItem in this.TrackedInputFilesToIgnore)
this.trackedInputFilesToRemove.Add(taskItem.GetMetadata("FullPath"), taskItem);
}
this.trackedOutputFilesToRemove = new Dictionary<string, ITaskItem>((IEqualityComparer<string>) StringComparer.OrdinalIgnoreCase);
if (this.TrackedOutputFilesToIgnore != null)
{
foreach (ITaskItem taskItem in this.TrackedOutputFilesToIgnore)
this.trackedOutputFilesToRemove.Add(taskItem.GetMetadata("FullPath"), taskItem);
}
trackedOutputFiles.RemoveDependenciesFromEntryIfMissing(this.SourcesCompiled);
trackedInputFiles.RemoveDependenciesFromEntryIfMissing(this.SourcesCompiled);
if (num != 0)
{
ITaskItem[] source1;
ITaskItem[] upToDateSources;
if (this.SourcesCompiled.Length > 1)
{
KeyValuePair<string, bool>[] keyValuePairArray = new KeyValuePair<string, bool>[]{
new KeyValuePair<string, bool>("ObjectFile", true),
/*
new KeyValuePair<string, bool>("BrowseInformationFile", this.BrowseInformation),
new KeyValuePair<string, bool>("XMLDocumentationFileName", this.GenerateXMLDocumentationFiles)
*/
};
foreach (ITaskItem source2 in this.Sources)
{
string sourceKey = FileTracker.FormatRootingMarker(source2);
foreach (KeyValuePair<string, bool> keyValuePair in keyValuePairArray)
{
string metadata = source2.GetMetadata(keyValuePair.Key);
if (keyValuePair.Value && !string.IsNullOrEmpty(metadata))
trackedOutputFiles.AddComputedOutputForSourceRoot(sourceKey, metadata);
}
}
source1 = trackedInputFiles.ComputeSourcesNeedingCompilation();
List<ITaskItem> taskItemList = new List<ITaskItem>();
int index = 0;
foreach (ITaskItem taskItem in this.SourcesCompiled)
{
if (index >= source1.Length)
taskItemList.Add(taskItem);
else if (!source1[index].Equals((object) taskItem))
taskItemList.Add(taskItem);
else
++index;
}
upToDateSources = taskItemList.ToArray();
foreach (ITaskItem source2 in this.Sources)
{
string sourceRoot = FileTracker.FormatRootingMarker(source2);
foreach (KeyValuePair<string, bool> keyValuePair in keyValuePairArray)
{
string metadata = source2.GetMetadata(keyValuePair.Key);
if (keyValuePair.Value && !string.IsNullOrEmpty(metadata))
trackedOutputFiles.RemoveOutputForSourceRoot(sourceRoot, metadata);
}
}
}
else
{
source1 = this.SourcesCompiled;
upToDateSources = new ITaskItem[0];
}
//trackedOutputFiles.RemoveEntriesForSource(source1, this.preprocessOutput);
trackedOutputFiles.SaveTlog(includeInTLog);
trackedInputFiles.RemoveEntriesForSource(source1);
trackedInputFiles.SaveTlog(dependencyFilter);
this.ConstructCommandTLog(upToDateSources, dependencyFilter);
}
else
{
this.RemoveTaskSpecificInputs(trackedInputFiles);
trackedOutputFiles.SaveTlog(includeInTLog);
trackedInputFiles.SaveTlog(dependencyFilter);
this.ConstructCommandTLog(this.SourcesCompiled, dependencyFilter);
}
TrackedVCToolTask.DeleteEmptyFile(this.TLogWriteFiles);
TrackedVCToolTask.DeleteEmptyFile(this.TLogReadFiles);
}
}
}
protected int ExecuteTool2(string pathToTool, string responseFileCommands, string commandLineCommands)
{
int num = 0;
try
{
num = this.TrackerExecuteTool(pathToTool, responseFileCommands, commandLineCommands);
}
finally
{
if (this.MinimalRebuildFromTracking || this.TrackFileAccess)
{
CanonicalTrackedOutputFiles outputs = new CanonicalTrackedOutputFiles(this.TLogWriteFiles);
CanonicalTrackedInputFiles compactInputs = new CanonicalTrackedInputFiles(this.TLogReadFiles, this.TrackedInputFiles, this.ExcludedInputPaths, outputs, false, this.MaintainCompositeRootingMarkers);
string[] strArray = null;
IDictionary<string, string> sourcesToCommandLines = this.MapSourcesToCommandLines();
if (num != 0)
{
outputs.RemoveEntriesForSource(this.SourcesCompiled);
outputs.SaveTlog();
compactInputs.RemoveEntriesForSource(this.SourcesCompiled);
compactInputs.SaveTlog();
if (this.MaintainCompositeRootingMarkers)
{
sourcesToCommandLines.Remove(FileTracker.FormatRootingMarker(this.SourcesCompiled));
}
else
{
foreach (ITaskItem item in this.SourcesCompiled)
{
sourcesToCommandLines.Remove(FileTracker.FormatRootingMarker(item));
}
}
this.WriteSourcesToCommandLinesTable(sourcesToCommandLines);
}
else
{
this.AddTaskSpecificOutputs(this.SourcesCompiled, outputs);
this.RemoveTaskSpecificOutputs(outputs);
outputs.RemoveDependenciesFromEntryIfMissing(this.SourcesCompiled);
if (this.MaintainCompositeRootingMarkers)
{
strArray = outputs.RemoveRootsWithSharedOutputs(this.SourcesCompiled);
foreach (string str in strArray)
{
compactInputs.RemoveEntryForSourceRoot(str);
}
}
if ((this.TrackedOutputFilesToIgnore != null) && (this.TrackedOutputFilesToIgnore.Length > 0))
{
Dictionary<string, ITaskItem> trackedOutputFilesToRemove = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase);
foreach (ITaskItem item2 in this.TrackedOutputFilesToIgnore)
{
trackedOutputFilesToRemove.Add(item2.GetMetadata("FullPath"), item2);
}
outputs.SaveTlog(delegate(string fullTrackedPath)
{
if (trackedOutputFilesToRemove.ContainsKey(fullTrackedPath))
{
return false;
}
return true;
});
}
else
{
outputs.SaveTlog();
}
this.RemoveTaskSpecificInputs(compactInputs);
compactInputs.RemoveDependenciesFromEntryIfMissing(this.SourcesCompiled);
if ((this.TrackedInputFilesToIgnore != null) && (this.TrackedInputFilesToIgnore.Length > 0))
{
Dictionary<string, ITaskItem> trackedInputFilesToRemove = new Dictionary<string, ITaskItem>(StringComparer.OrdinalIgnoreCase);
foreach (ITaskItem item3 in this.TrackedInputFilesToIgnore)
{
trackedInputFilesToRemove.Add(item3.GetMetadata("FullPath"), item3);
}
compactInputs.SaveTlog(delegate(string fullTrackedPath)
{
if (trackedInputFilesToRemove.ContainsKey(fullTrackedPath))
{
return false;
}
return true;
});
}
else
{
compactInputs.SaveTlog();
}
if (this.MaintainCompositeRootingMarkers)
{
string str2 = GenerateCommandLine();
sourcesToCommandLines[FileTracker.FormatRootingMarker(this.SourcesCompiled)] = str2;
if (strArray != null)
{
foreach (string str3 in strArray)
{
sourcesToCommandLines.Remove(str3);
}
}
}
else
{
string str4 = this.SourcesPropertyName ?? "Sources";
string str5 = GenerateCommandLineExceptSwitches(new string[] { str4 });
foreach (ITaskItem item4 in this.SourcesCompiled)
{
sourcesToCommandLines[FileTracker.FormatRootingMarker(item4)] = str5 + " " + item4.GetMetadata("FullPath").ToUpperInvariant();
}
}
this.WriteSourcesToCommandLinesTable(sourcesToCommandLines);
}
}
}
return num;
}
private void CompactTrackingLogs(bool taskSucceeded)
{
CanonicalTrackedOutputFiles outputs = new CanonicalTrackedOutputFiles(this.TLogWriteFiles);
CanonicalTrackedInputFiles files2 = new CanonicalTrackedInputFiles(this.TLogReadFiles, this.Sources, this.ExcludedInputPaths, outputs, true, false);
outputs.RemoveDependenciesFromEntryIfMissing(this.Sources);
files2.RemoveDependenciesFromEntryIfMissing(this.Sources);
if (!taskSucceeded)
{
foreach (ITaskItem item in this.Sources)
{
string sourceKey = FileTracker.FormatRootingMarker(item);
outputs.AddComputedOutputForSourceRoot(sourceKey, item.GetMetadata(outputFileMetadataName));
}
ITaskItem[] source = files2.ComputeSourcesNeedingCompilation();
foreach (ITaskItem item2 in this.Sources)
{
string sourceRoot = FileTracker.FormatRootingMarker(item2);
outputs.RemoveOutputForSourceRoot(sourceRoot, item2.GetMetadata(outputFileMetadataName));
}
outputs.RemoveEntriesForSource(source);
files2.RemoveEntriesForSource(source);
}
if (!string.IsNullOrEmpty(this.StronglyTypedFileName) && this.stronglyTypedResourceSuccessfullyCreated)
{
string stronglyTypedFileName = this.StronglyTypedFileName;
foreach (ITaskItem item3 in this.Sources)
{
string str4 = FileTracker.FormatRootingMarker(item3);
outputs.AddComputedOutputForSourceRoot(str4, stronglyTypedFileName);
}
}
files2.SaveTlog();
outputs.SaveTlog();
}
