public void TestCustomSteps(ITaskItem [] customSteps)
{
var task = new MockTask()
{
CustomSteps = customSteps
};
using (var driver = task.CreateDriver()) {
foreach (var customStep in customSteps)
{
var stepType = customStep.GetMetadata("Type");
var stepName = stepType.Substring(stepType.LastIndexOf(Type.Delimiter) + 1);
var beforeStepName = customStep.GetMetadata("BeforeStep");
var afterStepName = customStep.GetMetadata("AfterStep");
Assert.True(String.IsNullOrEmpty(beforeStepName) || String.IsNullOrEmpty(afterStepName));
var actualStepNames = driver.Context.Pipeline.GetSteps().Select(s => s.GetType().Name);
if (!String.IsNullOrEmpty(beforeStepName))
{
Assert.Contains(beforeStepName, actualStepNames);
Assert.Equal(stepName, actualStepNames.TakeWhile(s => s != beforeStepName).Last());
}
else if (!String.IsNullOrEmpty(afterStepName))
{
Assert.Contains(afterStepName, actualStepNames);
Assert.Equal(stepName, actualStepNames.SkipWhile(s => s != afterStepName).ElementAt(1));
}
else
{
Assert.Equal(stepName, actualStepNames.Last());
}
}
}
}
public void TestPerAssemblyOptimizations(ITaskItem[] assemblyPaths)
{
var task = new MockTask()
{
AssemblyPaths = assemblyPaths
};
using (var driver = task.CreateDriver()) {
foreach (var item in assemblyPaths)
{
var assemblyName = Path.GetFileNameWithoutExtension(item.ItemSpec);
foreach (var optimization in MockTask.OptimizationNames)
{
Assert.True(driver.GetOptimizationName(optimization, out CodeOptimizations codeOptimizations));
var optimizationValue = item.GetMetadata(optimization);
if (String.IsNullOrEmpty(optimizationValue))
{
continue;
}
var enabled = Boolean.Parse(optimizationValue);
var actualValue = driver.Context.Optimizations.IsEnabled(codeOptimizations, assemblyName: assemblyName);
Assert.Equal(enabled, actualValue);
}
}
}
}
public void TestAssemblyPaths(ITaskItem[] assemblyPaths)
{
var task = new MockTask()
{
AssemblyPaths = assemblyPaths
};
using (var driver = task.CreateDriver()) {
var context = driver.Context;
var expectedReferences = assemblyPaths.Select(p => p.ItemSpec)
.GroupBy(p => Path.GetFileNameWithoutExtension(p))
.Select(g => g.First());
var actualReferences = driver.GetReferenceAssemblies();
Assert.Equal(expectedReferences.OrderBy(a => a), actualReferences.OrderBy(a => a));
foreach (var item in assemblyPaths)
{
var assemblyPath = item.ItemSpec;
var trimMode = item.GetMetadata("TrimMode");
if (String.IsNullOrEmpty(trimMode))
{
continue;
}
AssemblyAction expectedAction = (AssemblyAction)Enum.Parse(typeof(AssemblyAction), trimMode, ignoreCase: true);
AssemblyAction actualAction = context.Actions[Path.GetFileNameWithoutExtension(assemblyPath)];
Assert.Equal(expectedAction, actualAction);
}
}
}
public void TestInvalidFeatureSettings()
{
var task = new MockTask()
{
FeatureSettings = new ITaskItem[] { new TaskItem("FeatureName") }
};
Assert.Throws <ArgumentException> (() => task.CreateDriver());
}
public void TestInvalidDefaultAction()
{
var task = new MockTask()
{
DefaultAction = "invalid"
};
Assert.Throws <ArgumentException> (() => task.CreateDriver());
}
public void TestOptimizationsDefaults()
{
var task = new MockTask();
using (var driver = task.CreateDriver()) {
var expectedOptimizations = driver.GetDefaultOptimizations();
var actualOptimizations = driver.Context.Optimizations.Global;
Assert.Equal(expectedOptimizations, actualOptimizations);
}
}
public void TestLinkSymbols(bool linkSymbols)
{
var task = new MockTask()
{
LinkSymbols = linkSymbols
};
using (var driver = task.CreateDriver()) {
Assert.Equal(linkSymbols, driver.Context.LinkSymbols);
}
}
public void TestDumpDependencies(bool dumpDependencies)
{
var task = new MockTask()
{
DumpDependencies = dumpDependencies
};
using (var driver = task.CreateDriver()) {
Assert.Equal(dumpDependencies, driver.GetDependencyRecorders()?.Single() == MockXmlDependencyRecorder.Singleton);
}
}
public void TestWarn(string warnArg, WarnVersion expectedVersion)
{
var task = new MockTask()
{
Warn = warnArg
};
using (var driver = task.CreateDriver()) {
Assert.Equal(expectedVersion, driver.Context.WarnVersion);
}
}
public void TestAssemblyPathsWithInvalidAction()
{
var task = new MockTask()
{
AssemblyPaths = new ITaskItem [] { new TaskItem("Assembly.dll", new Dictionary <string, string> {
{ "action", "invalid" }
}) }
};
Assert.Throws <ArgumentException> (() => task.CreateDriver());
}
public void TestValidNoWarn(string noWarn, int validNoWarns)
{
var task = new MockTask()
{
NoWarn = noWarn
};
using (var driver = task.CreateDriver()) {
var actualUsedNoWarns = driver.Context.NoWarn;
Assert.Equal(validNoWarns, actualUsedNoWarns.Count);
}
}
public void TestClearInitLocals(bool clearInitLocals)
{
var task = new MockTask()
{
ClearInitLocals = clearInitLocals
};
using (var driver = task.CreateDriver()) {
var actualClearInitLocals = driver.Context.Optimizations.IsEnabled(CodeOptimizations.ClearInitLocals, assemblyName: null);
Assert.Equal(clearInitLocals, actualClearInitLocals);
}
}
public void TestCustomStepsMissingType()
{
var customSteps = new ITaskItem [] {
new TaskItem(Assembly.GetExecutingAssembly().Location)
};
var task = new MockTask()
{
CustomSteps = customSteps
};
Assert.Throws <ArgumentException> (() => task.CreateDriver());
}
public void TestGlobalOptimizations(string optimization, bool enabled)
{
var task = new MockTask();
task.SetOptimization(optimization, enabled);
// get the corresponding CodeOptimizations value
using (var driver = task.CreateDriver()) {
Assert.True(driver.GetOptimizationName(optimization, out CodeOptimizations codeOptimizations));
var actualValue = driver.Context.Optimizations.IsEnabled(codeOptimizations, assemblyName: null);
Assert.Equal(enabled, actualValue);
}
}
public void TestRootDescriptorFiles(string[] rootDescriptorFiles)
{
var task = new MockTask()
{
RootDescriptorFiles = rootDescriptorFiles.Select(f => new TaskItem(f)).ToArray()
};
using (var driver = task.CreateDriver()) {
var actualDescriptors = driver.GetRootDescriptors();
Assert.Equal(rootDescriptorFiles.OrderBy(f => f), actualDescriptors.OrderBy(f => f));
}
}
public void TestOutputDirectory(string outputDirectory)
{
var task = new MockTask()
{
OutputDirectory = new TaskItem(outputDirectory)
};
using (var driver = task.CreateDriver()) {
var actualOutputDirectory = driver.Context.OutputDirectory;
Assert.Equal(outputDirectory, actualOutputDirectory);
}
}
public void TestAssemblyPathsWithInvalidAction()
{
var task = new MockTask()
{
AssemblyPaths = new ITaskItem[] { new TaskItem("Assembly.dll", new Dictionary <string, string> {
{ "TrimMode", "invalid" }
}) }
};
using (var driver = task.CreateDriver()) {
Assert.Equal(1031, driver.Logger.Messages[0].Code);
}
}
public void TestInvalidPerAssemblyOptimizations()
{
var task = new MockTask()
{
AssemblyPaths = new ITaskItem[] {
new TaskItem("path/to/Assembly.dll", new Dictionary <string, string> {
{ "Sealer", "invalid" }
})
}
};
Assert.Throws <ArgumentException> (() => task.CreateDriver());
}
public void TestDefaultAction(string defaultAction)
{
var task = new MockTask()
{
DefaultAction = defaultAction
};
using (var driver = task.CreateDriver()) {
var expectedAction = (AssemblyAction)Enum.Parse(typeof(AssemblyAction), defaultAction, ignoreCase: true);
Assert.Equal(expectedAction, driver.Context.CoreAction);
Assert.Equal(expectedAction, driver.Context.UserAction);
}
}
public void TestRootEntryPointAssemblyNames(string[] rootAssemblyNames)
{
var task = new MockTask()
{
RootAssemblyNames = rootAssemblyNames.Select(a => new TaskItem(a)).ToArray()
};
using (var driver = task.CreateDriver()) {
var expectedRoots = rootAssemblyNames;
var actualRoots = driver.GetRootAssemblies();
Assert.Equal(rootAssemblyNames.OrderBy(r => r), actualRoots.OrderBy(r => r));
}
}
public void TestExtraArgs()
{
var task = new MockTask()
{
DefaultAction = "copy",
ExtraArgs = "-c link"
};
using (var driver = task.CreateDriver()) {
Assert.Equal(AssemblyAction.Copy, driver.Context.UserAction);
// Check that ExtraArgs can override DefaultAction
Assert.Equal(AssemblyAction.Link, driver.Context.CoreAction);
}
}
public void TestCustomStepsWithBeforeAndAfterSteps()
{
var customSteps = new ITaskItem [] {
new TaskItem(Assembly.GetExecutingAssembly().Location, new Dictionary <string, string> {
{ "Type", "ILLink.Tasks.Tests.MockCustomStep" },
{ "BeforeStep", "MarkStep" },
{ "AfterStep", "MarkStep" }
})
};
var task = new MockTask()
{
CustomSteps = customSteps
};
Assert.Throws <ArgumentException> (() => task.CreateDriver());
}
public void TestFeatureSettings(ITaskItem[] featureSettings)
{
var task = new MockTask()
{
FeatureSettings = featureSettings
};
using (var driver = task.CreateDriver()) {
var expectedSettings = featureSettings.Select(f => new { Feature = f.ItemSpec, Value = f.GetMetadata("Value") })
.GroupBy(f => f.Feature)
.Select(f => f.Last())
.ToDictionary(f => f.Feature, f => bool.Parse(f.Value));
var actualSettings = driver.Context.FeatureSettings;
Assert.Equal(expectedSettings, actualSettings);
}
}
public void TestClearInitLocalsAssemblies(string assemblyNames)
{
var task = new MockTask()
{
ClearInitLocalsAssemblies = assemblyNames,
// This task parameter ClearInitLocalsAssemblies currently only is applied if ClearInitLocals is also true,
// which turns the optimization on globally. This is redundant behavior that we might want to fix.
// For now, at least test the existing behavior.
ClearInitLocals = true
};
using (var driver = task.CreateDriver()) {
var expectedAssemblies = assemblyNames.Split(',');
var actualAssemblies = driver.Context.GetParameter("ClearInitLocalsAssemblies").Split(',');
Assert.Equal(expectedAssemblies.OrderBy(a => a), actualAssemblies.OrderBy(a => a));
}
}
public void TestSingleWarn(bool singleWarn, ITaskItem[] assemblyPaths)
{
var task = new MockTask()
{
AssemblyPaths = assemblyPaths,
SingleWarn = singleWarn
};
using (var driver = task.CreateDriver()) {
Assert.Equal(singleWarn, driver.Context.GeneralSingleWarn);
var expectedSingleWarn = assemblyPaths.ToDictionary(
p => Path.GetFileNameWithoutExtension(p.ItemSpec),
p => bool.Parse(p.GetMetadata("TrimmerSingleWarn"))
);
Assert.Equal(expectedSingleWarn, driver.Context.SingleWarn);
}
}
public void TestReferenceAssemblyPaths(string[] referenceAssemblyPaths)
{
var task = new MockTask()
{
ReferenceAssemblyPaths = referenceAssemblyPaths.Select(p => new TaskItem(p)).ToArray()
};
using (var driver = task.CreateDriver()) {
var expectedReferences = referenceAssemblyPaths;
var actualReferences = driver.GetReferenceAssemblies();
Assert.Equal(expectedReferences.OrderBy(a => a), actualReferences.OrderBy(a => a));
foreach (var reference in expectedReferences)
{
var referenceName = Path.GetFileNameWithoutExtension(reference);
var actualAction = driver.Context.Actions[referenceName];
Assert.Equal(AssemblyAction.Skip, actualAction);
}
}
}
