pimhwang
/
ILSpy
mirror of https://github.com/icsharpcode/ILSpy.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add RunVB() for VB correctness tests

pull/1425/head
Daniel Grunwald 7 years ago
parent
fcc12bf390
commit
0c0ac6ea44
6 changed files with 231 additions and 244 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 138
      ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs
  2. 73
      ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs
  3. 64
      ICSharpCode.Decompiler.Tests/Helpers/Tester.cs
  4. 148
      ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
  5. 32
      ICSharpCode.Decompiler.Tests/UglyTestRunner.cs
  6. 20
      ICSharpCode.Decompiler.Tests/VBPrettyTestRunner.cs

138
ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs
Unescape View File

@ -46,152 +46,152 @@ namespace ICSharpCode.Decompiler.Tests @@ -46,152 +46,152 @@ namespace ICSharpCode.Decompiler.Tests
}
}
static readonly CSharpCompilerOptions[] noMonoOptions =
static readonly CompilerOptions[] noMonoOptions =
{
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn,
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn,
};
static readonly CSharpCompilerOptions[] defaultOptions =
static readonly CompilerOptions[] defaultOptions =
{
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.UseMcs,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseMcs
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn,
CompilerOptions.UseMcs,
CompilerOptions.Optimize | CompilerOptions.UseMcs
};
static readonly CSharpCompilerOptions[] roslynOnlyOptions =
static readonly CompilerOptions[] roslynOnlyOptions =
{
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
};
[Test]
public void Comparisons([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void Comparisons([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Conversions([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void Conversions([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void FloatingPointArithmetic([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void FloatingPointArithmetic([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void HelloWorld([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void HelloWorld([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void ControlFlow([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void ControlFlow([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void CompoundAssignment([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void CompoundAssignment([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void PropertiesAndEvents([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void PropertiesAndEvents([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Switch([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void Switch([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Using([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void Using([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Loops([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void Loops([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void NullableTests([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void NullableTests([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Generics([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void Generics([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void ValueTypeCall([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void ValueTypeCall([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void InitializerTests([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void InitializerTests([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void DecimalFields([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void DecimalFields([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void UndocumentedExpressions([ValueSource("noMonoOptions")] CSharpCompilerOptions options)
public void UndocumentedExpressions([ValueSource("noMonoOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void MemberLookup([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void MemberLookup([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void OverloadResolution([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void OverloadResolution([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void ExpressionTrees([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void ExpressionTrees([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void NullPropagation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions options)
public void NullPropagation([ValueSource("roslynOnlyOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void RefLocalsAndReturns([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions options)
public void RefLocalsAndReturns([ValueSource("roslynOnlyOptions")] CompilerOptions options)
{
RunCS(options: options);
}
@ -199,10 +199,10 @@ namespace ICSharpCode.Decompiler.Tests @@ -199,10 +199,10 @@ namespace ICSharpCode.Decompiler.Tests
[Test]
public void BitNot([Values(false, true)] bool force32Bit)
{
CSharpCompilerOptions compiler = CSharpCompilerOptions.UseDebug;
CompilerOptions compiler = CompilerOptions.UseDebug;
AssemblerOptions asm = AssemblerOptions.None;
if (force32Bit) {
compiler |= CSharpCompilerOptions.Force32Bit;
compiler |= CompilerOptions.Force32Bit;
asm |= AssemblerOptions.Force32Bit;
}
RunIL("BitNot.il", compiler, asm);
@ -217,79 +217,79 @@ namespace ICSharpCode.Decompiler.Tests @@ -217,79 +217,79 @@ namespace ICSharpCode.Decompiler.Tests
[Test]
public void StackTypes([Values(false, true)] bool force32Bit)
{
CSharpCompilerOptions compiler = CSharpCompilerOptions.UseRoslyn | CSharpCompilerOptions.UseDebug;
CompilerOptions compiler = CompilerOptions.UseRoslyn | CompilerOptions.UseDebug;
AssemblerOptions asm = AssemblerOptions.None;
if (force32Bit) {
compiler |= CSharpCompilerOptions.Force32Bit;
compiler |= CompilerOptions.Force32Bit;
asm |= AssemblerOptions.Force32Bit;
}
RunIL("StackTypes.il", compiler, asm);
}
[Test]
public void UnsafeCode([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void UnsafeCode([ValueSource("defaultOptions")] CompilerOptions options)
{
if (options.HasFlag(CSharpCompilerOptions.UseMcs)) {
if (options.HasFlag(CompilerOptions.UseMcs)) {
Assert.Ignore("Decompiler bug with mono!");
}
RunCS(options: options);
}
[Test]
public void ConditionalAttr([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void ConditionalAttr([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void TrickyTypes([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void TrickyTypes([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Capturing([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void Capturing([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void YieldReturn([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void YieldReturn([ValueSource("defaultOptions")] CompilerOptions options)
{
if (options.HasFlag(CSharpCompilerOptions.UseMcs)) {
if (options.HasFlag(CompilerOptions.UseMcs)) {
Assert.Ignore("Decompiler bug with mono!");
}
RunCS(options: options);
}
[Test]
public void Async([ValueSource("noMonoOptions")] CSharpCompilerOptions options)
public void Async([ValueSource("noMonoOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void LINQRaytracer([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void LINQRaytracer([ValueSource("defaultOptions")] CompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void MiniJSON([ValueSource("defaultOptions")] CSharpCompilerOptions options)
public void MiniJSON([ValueSource("defaultOptions")] CompilerOptions options)
{
if (options.HasFlag(CSharpCompilerOptions.UseMcs)) {
if (options.HasFlag(CompilerOptions.UseMcs)) {
Assert.Ignore("Decompiler bug with mono!");
}
RunCS(options: options);
}
[Test]
public void LocalFunctions([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions options)
public void LocalFunctions([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions options)
{
RunCS(options: options);
}
void RunCS([CallerMemberName] string testName = null, CSharpCompilerOptions options = CSharpCompilerOptions.UseDebug)
void RunCS([CallerMemberName] string testName = null, CompilerOptions options = CompilerOptions.UseDebug)
{
string testFileName = testName + ".cs";
string testOutputFileName = testName + Tester.GetSuffix(options) + ".exe";
@ -299,12 +299,12 @@ namespace ICSharpCode.Decompiler.Tests @@ -299,12 +299,12 @@ namespace ICSharpCode.Decompiler.Tests
outputFile = Tester.CompileCSharp(Path.Combine(TestCasePath, testFileName), options,
outputFileName: Path.Combine(TestCasePath, testOutputFileName));
string decompiledCodeFile = Tester.DecompileCSharp(outputFile.PathToAssembly, Tester.GetSettings(options));
if (options.HasFlag(CSharpCompilerOptions.UseMcs)) {
if (options.HasFlag(CompilerOptions.UseMcs)) {
// For second pass, use roslyn instead of mcs.
// mcs has some compiler bugs that cause it to not accept ILSpy-generated code,
// for example when there's unreachable code due to other compiler bugs in the first mcs run.
options &= ~CSharpCompilerOptions.UseMcs;
options |= CSharpCompilerOptions.UseRoslyn;
options &= ~CompilerOptions.UseMcs;
options |= CompilerOptions.UseRoslyn;
// Also, add an .exe.config so that we consistently use the .NET 4.x runtime.
File.WriteAllText(outputFile.PathToAssembly + ".config", @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
@ -327,7 +327,31 @@ namespace ICSharpCode.Decompiler.Tests @@ -327,7 +327,31 @@ namespace ICSharpCode.Decompiler.Tests
}
}
void RunIL(string testFileName, CSharpCompilerOptions options = CSharpCompilerOptions.UseDebug, AssemblerOptions asmOptions = AssemblerOptions.None)
void RunVB([CallerMemberName] string testName = null, CompilerOptions options = CompilerOptions.UseDebug)
{
string testFileName = testName + ".vb";
string testOutputFileName = testName + Tester.GetSuffix(options) + ".exe";
CompilerResults outputFile = null, decompiledOutputFile = null;
try {
outputFile = Tester.CompileVB(Path.Combine(TestCasePath, testFileName), options,
outputFileName: Path.Combine(TestCasePath, testOutputFileName));
string decompiledCodeFile = Tester.DecompileCSharp(outputFile.PathToAssembly, Tester.GetSettings(options));
decompiledOutputFile = Tester.CompileCSharp(decompiledCodeFile, options);
Tester.RunAndCompareOutput(testFileName, outputFile.PathToAssembly, decompiledOutputFile.PathToAssembly, decompiledCodeFile);
File.Delete(decompiledCodeFile);
File.Delete(decompiledOutputFile.PathToAssembly);
} finally {
if (outputFile != null)
outputFile.TempFiles.Delete();
if (decompiledOutputFile != null)
decompiledOutputFile.TempFiles.Delete();
}
}
void RunIL(string testFileName, CompilerOptions options = CompilerOptions.UseDebug, AssemblerOptions asmOptions = AssemblerOptions.None)
{
string outputFile = null;
CompilerResults decompiledOutputFile = null;

73
ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs
Unescape View File

@ -12,71 +12,26 @@ using Microsoft.VisualBasic; @@ -12,71 +12,26 @@ using Microsoft.VisualBasic;
namespace ICSharpCode.Decompiler.Tests.Helpers
{
[Flags]
public enum VBCompilerOptions
{
None,
Optimize = 0x1,
UseDebug = 0x2,
Force32Bit = 0x4,
Library = 0x8,
UseRoslyn = 0x10,
}
partial class Tester
{
internal static string GetSuffix(VBCompilerOptions vbcOptions)
{
string suffix = "";
if ((vbcOptions & VBCompilerOptions.Optimize) != 0)
suffix += ".opt";
if ((vbcOptions & VBCompilerOptions.Force32Bit) != 0)
suffix += ".32";
if ((vbcOptions & VBCompilerOptions.UseDebug) != 0)
suffix += ".dbg";
if ((vbcOptions & VBCompilerOptions.UseRoslyn) != 0)
suffix += ".roslyn";
return suffix;
}
public static List<KeyValuePair<string, object>> GetPreprocessorSymbols(VBCompilerOptions flags)
{
var preprocessorSymbols = new List<KeyValuePair<string, object>>();
if (flags.HasFlag(VBCompilerOptions.UseDebug)) {
preprocessorSymbols.Add(new KeyValuePair<string, object>("DEBUG", 1));
}
if (flags.HasFlag(VBCompilerOptions.Optimize)) {
preprocessorSymbols.Add(new KeyValuePair<string, object>("OPT", 1));
}
if (flags.HasFlag(VBCompilerOptions.UseRoslyn)) {
preprocessorSymbols.Add(new KeyValuePair<string, object>("ROSLYN", 1));
preprocessorSymbols.Add(new KeyValuePair<string, object>("VB11", 1));
preprocessorSymbols.Add(new KeyValuePair<string, object>("VB14", 1));
preprocessorSymbols.Add(new KeyValuePair<string, object>("VB15", 1));
} else {
preprocessorSymbols.Add(new KeyValuePair<string, object>("LEGACY_VBC", 1));
}
return preprocessorSymbols;
}
public static CompilerResults CompileVB(string sourceFileName, VBCompilerOptions flags = VBCompilerOptions.UseDebug, string outputFileName = null)
public static CompilerResults CompileVB(string sourceFileName, CompilerOptions flags = CompilerOptions.UseDebug, string outputFileName = null)
{
List<string> sourceFileNames = new List<string> { sourceFileName };
foreach (Match match in Regex.Matches(File.ReadAllText(sourceFileName), @"#include ""([\w\d./]+)""")) {
sourceFileNames.Add(Path.GetFullPath(Path.Combine(Path.GetDirectoryName(sourceFileName), match.Groups[1].Value)));
}
var preprocessorSymbols = GetPreprocessorSymbols(flags);
var preprocessorSymbols = GetPreprocessorSymbols(flags).Select(symbol => new KeyValuePair<string, object>(symbol, 1)).ToList();
if (flags.HasFlag(VBCompilerOptions.UseRoslyn)) {
if (flags.HasFlag(CompilerOptions.UseRoslyn)) {
var parseOptions = new VisualBasicParseOptions(preprocessorSymbols: preprocessorSymbols, languageVersion: LanguageVersion.Latest);
var syntaxTrees = sourceFileNames.Select(f => SyntaxFactory.ParseSyntaxTree(File.ReadAllText(f), parseOptions, path: f));
var compilation = VisualBasicCompilation.Create(Path.GetFileNameWithoutExtension(sourceFileName),
syntaxTrees, defaultReferences.Value,
new VisualBasicCompilationOptions(
flags.HasFlag(VBCompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication,
platform: flags.HasFlag(VBCompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu,
optimizationLevel: flags.HasFlag(VBCompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug,
flags.HasFlag(CompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication,
platform: flags.HasFlag(CompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu,
optimizationLevel: flags.HasFlag(CompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug,
deterministic: true
));
CompilerResults results = new CompilerResults(new TempFileCollection());
@ -90,15 +45,17 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -90,15 +45,17 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
throw new Exception(b.ToString());
}
return results;
} else if (flags.HasFlag(CompilerOptions.UseMcs)) {
throw new NotSupportedException("Cannot use mcs for VB");
} else {
var provider = new VBCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v10.0" } });
var provider = new VBCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = !flags.HasFlag(VBCompilerOptions.Library);
options.CompilerOptions = "/o" + (flags.HasFlag(VBCompilerOptions.Optimize) ? "+" : "-");
options.CompilerOptions += (flags.HasFlag(VBCompilerOptions.UseDebug) ? " /debug" : "");
options.CompilerOptions += (flags.HasFlag(VBCompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : "");
options.GenerateExecutable = !flags.HasFlag(CompilerOptions.Library);
options.CompilerOptions = "/o" + (flags.HasFlag(CompilerOptions.Optimize) ? "+" : "-");
options.CompilerOptions += (flags.HasFlag(CompilerOptions.UseDebug) ? " /debug" : "");
options.CompilerOptions += (flags.HasFlag(CompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : "");
if (preprocessorSymbols.Count > 0) {
options.CompilerOptions += " /d:" + string.Join(";", preprocessorSymbols);
options.CompilerOptions += " /d:" + string.Join(",", preprocessorSymbols.Select(p => $"{p.Key}={p.Value}"));
}
if (outputFileName != null) {
options.OutputAssembly = outputFileName;
@ -107,6 +64,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -107,6 +64,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.Core.dll");
options.ReferencedAssemblies.Add("System.Xml.dll");
options.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll");
CompilerResults results = provider.CompileAssemblyFromFile(options, sourceFileNames.ToArray());
if (results.Errors.Cast<CompilerError>().Any(e => !e.IsWarning)) {
StringBuilder b = new StringBuilder("Compiler error:");
@ -118,6 +76,5 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -118,6 +76,5 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
return results;
}
}
}
}

64
ICSharpCode.Decompiler.Tests/Helpers/Tester.cs
Unescape View File

@ -42,7 +42,7 @@ using NUnit.Framework; @@ -42,7 +42,7 @@ using NUnit.Framework;
namespace ICSharpCode.Decompiler.Tests.Helpers
{
[Flags]
public enum CSharpCompilerOptions
public enum CompilerOptions
{
None,
Optimize = 0x1,
@ -189,36 +189,41 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -189,36 +189,41 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
MetadataReference.CreateFromFile(Path.Combine(refAsmPath, @"Facades\System.Runtime.dll")),
MetadataReference.CreateFromFile(Path.Combine(refAsmPath, "System.Xml.dll")),
MetadataReference.CreateFromFile(Path.Combine(refAsmPath, "Microsoft.CSharp.dll")),
MetadataReference.CreateFromFile(Path.Combine(refAsmPath, "Microsoft.VisualBasic.dll")),
MetadataReference.CreateFromFile(typeof(ValueTuple).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Span<>).Assembly.Location),
};
});
public static List<string> GetPreprocessorSymbols(CSharpCompilerOptions flags)
public static List<string> GetPreprocessorSymbols(CompilerOptions flags)
{
var preprocessorSymbols = new List<string>();
if (flags.HasFlag(CSharpCompilerOptions.UseDebug)) {
if (flags.HasFlag(CompilerOptions.UseDebug)) {
preprocessorSymbols.Add("DEBUG");
}
if (flags.HasFlag(CSharpCompilerOptions.Optimize)) {
if (flags.HasFlag(CompilerOptions.Optimize)) {
preprocessorSymbols.Add("OPT");
}
if (flags.HasFlag(CSharpCompilerOptions.UseRoslyn)) {
if (flags.HasFlag(CompilerOptions.UseRoslyn)) {
preprocessorSymbols.Add("ROSLYN");
preprocessorSymbols.Add("CS60");
preprocessorSymbols.Add("CS70");
preprocessorSymbols.Add("CS71");
preprocessorSymbols.Add("CS72");
} else if (flags.HasFlag(CSharpCompilerOptions.UseMcs)) {
preprocessorSymbols.Add("CS73");
preprocessorSymbols.Add("VB11");
preprocessorSymbols.Add("VB14");
preprocessorSymbols.Add("VB15");
} else if (flags.HasFlag(CompilerOptions.UseMcs)) {
preprocessorSymbols.Add("MCS");
} else {
preprocessorSymbols.Add("LEGACY_CSC");
preprocessorSymbols.Add("LEGACY_VBC");
}
return preprocessorSymbols;
}
public static CompilerResults CompileCSharp(string sourceFileName, CSharpCompilerOptions flags = CSharpCompilerOptions.UseDebug, string outputFileName = null)
public static CompilerResults CompileCSharp(string sourceFileName, CompilerOptions flags = CompilerOptions.UseDebug, string outputFileName = null)
{
List<string> sourceFileNames = new List<string> { sourceFileName };
foreach (Match match in Regex.Matches(File.ReadAllText(sourceFileName), @"#include ""([\w\d./]+)""")) {
@ -227,15 +232,15 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -227,15 +232,15 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
var preprocessorSymbols = GetPreprocessorSymbols(flags);
if (flags.HasFlag(CSharpCompilerOptions.UseRoslyn)) {
if (flags.HasFlag(CompilerOptions.UseRoslyn)) {
var parseOptions = new CSharpParseOptions(preprocessorSymbols: preprocessorSymbols.ToArray(), languageVersion: Microsoft.CodeAnalysis.CSharp.LanguageVersion.Latest);
var syntaxTrees = sourceFileNames.Select(f => SyntaxFactory.ParseSyntaxTree(File.ReadAllText(f), parseOptions, path: f));
var compilation = CSharpCompilation.Create(Path.GetFileNameWithoutExtension(sourceFileName),
syntaxTrees, defaultReferences.Value,
new CSharpCompilationOptions(
flags.HasFlag(CSharpCompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication,
platform: flags.HasFlag(CSharpCompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu,
optimizationLevel: flags.HasFlag(CSharpCompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug,
flags.HasFlag(CompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication,
platform: flags.HasFlag(CompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu,
optimizationLevel: flags.HasFlag(CompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug,
allowUnsafe: true,
deterministic: true
));
@ -250,7 +255,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -250,7 +255,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
throw new Exception(b.ToString());
}
return results;
} else if (flags.HasFlag(CSharpCompilerOptions.UseMcs)) {
} else if (flags.HasFlag(CompilerOptions.UseMcs)) {
CompilerResults results = new CompilerResults(new TempFileCollection());
results.PathToAssembly = outputFileName ?? Path.GetTempFileName();
string testBasePath = RoundtripAssembly.TestDir;
@ -259,19 +264,19 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -259,19 +264,19 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
$"git clone https://github.com/icsharpcode/ILSpy-tests \"{testBasePath}\"");
}
string mcsPath = Path.Combine(testBasePath, @"mcs\2.6.4\bin\gmcs.bat");
string otherOptions = " -unsafe -o" + (flags.HasFlag(CSharpCompilerOptions.Optimize) ? "+ " : "- ");
string otherOptions = " -unsafe -o" + (flags.HasFlag(CompilerOptions.Optimize) ? "+ " : "- ");
if (flags.HasFlag(CSharpCompilerOptions.Library)) {
if (flags.HasFlag(CompilerOptions.Library)) {
otherOptions += "-t:library ";
} else {
otherOptions += "-t:exe ";
}
if (flags.HasFlag(CSharpCompilerOptions.UseDebug)) {
if (flags.HasFlag(CompilerOptions.UseDebug)) {
otherOptions += "-g ";
}
if (flags.HasFlag(CSharpCompilerOptions.Force32Bit)) {
if (flags.HasFlag(CompilerOptions.Force32Bit)) {
otherOptions += "-platform:x86 ";
} else {
otherOptions += "-platform:anycpu ";
@ -303,10 +308,10 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -303,10 +308,10 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
} else {
var provider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = !flags.HasFlag(CSharpCompilerOptions.Library);
options.CompilerOptions = "/unsafe /o" + (flags.HasFlag(CSharpCompilerOptions.Optimize) ? "+" : "-");
options.CompilerOptions += (flags.HasFlag(CSharpCompilerOptions.UseDebug) ? " /debug" : "");
options.CompilerOptions += (flags.HasFlag(CSharpCompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : "");
options.GenerateExecutable = !flags.HasFlag(CompilerOptions.Library);
options.CompilerOptions = "/unsafe /o" + (flags.HasFlag(CompilerOptions.Optimize) ? "+" : "-");
options.CompilerOptions += (flags.HasFlag(CompilerOptions.UseDebug) ? " /debug" : "");
options.CompilerOptions += (flags.HasFlag(CompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : "");
if (preprocessorSymbols.Count > 0) {
options.CompilerOptions += " /d:" + string.Join(";", preprocessorSymbols);
}
@ -318,6 +323,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -318,6 +323,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
options.ReferencedAssemblies.Add("System.Core.dll");
options.ReferencedAssemblies.Add("System.Xml.dll");
options.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
options.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll");
CompilerResults results = provider.CompileAssemblyFromFile(options, sourceFileNames.ToArray());
if (results.Errors.Cast<CompilerError>().Any(e => !e.IsWarning)) {
StringBuilder b = new StringBuilder("Compiler error:");
@ -330,9 +336,9 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -330,9 +336,9 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
}
}
internal static DecompilerSettings GetSettings(CSharpCompilerOptions cscOptions)
internal static DecompilerSettings GetSettings(CompilerOptions cscOptions)
{
if (cscOptions.HasFlag(CSharpCompilerOptions.UseRoslyn)) {
if (cscOptions.HasFlag(CompilerOptions.UseRoslyn)) {
return new DecompilerSettings(CSharp.LanguageVersion.Latest);
} else {
return new DecompilerSettings(CSharp.LanguageVersion.CSharp5);
@ -358,18 +364,18 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -358,18 +364,18 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
return decompiler;
}
internal static string GetSuffix(CSharpCompilerOptions cscOptions)
internal static string GetSuffix(CompilerOptions cscOptions)
{
string suffix = "";
if ((cscOptions & CSharpCompilerOptions.Optimize) != 0)
if ((cscOptions & CompilerOptions.Optimize) != 0)
suffix += ".opt";
if ((cscOptions & CSharpCompilerOptions.Force32Bit) != 0)
if ((cscOptions & CompilerOptions.Force32Bit) != 0)
suffix += ".32";
if ((cscOptions & CSharpCompilerOptions.UseDebug) != 0)
if ((cscOptions & CompilerOptions.UseDebug) != 0)
suffix += ".dbg";
if ((cscOptions & CSharpCompilerOptions.UseRoslyn) != 0)
if ((cscOptions & CompilerOptions.UseRoslyn) != 0)
suffix += ".roslyn";
if ((cscOptions & CSharpCompilerOptions.UseMcs) != 0)
if ((cscOptions & CompilerOptions.UseMcs) != 0)
suffix += ".mcs";
return suffix;
}

148
ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
Unescape View File

@ -47,34 +47,34 @@ namespace ICSharpCode.Decompiler.Tests @@ -47,34 +47,34 @@ namespace ICSharpCode.Decompiler.Tests
}
}
static readonly CSharpCompilerOptions[] noRoslynOptions =
static readonly CompilerOptions[] noRoslynOptions =
{
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize
CompilerOptions.None,
CompilerOptions.Optimize
};
static readonly CSharpCompilerOptions[] roslynOnlyOptions =
static readonly CompilerOptions[] roslynOnlyOptions =
{
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
};
static readonly CSharpCompilerOptions[] defaultOptions =
static readonly CompilerOptions[] defaultOptions =
{
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
};
static readonly CSharpCompilerOptions[] defaultOptionsWithMcs =
static readonly CompilerOptions[] defaultOptionsWithMcs =
{
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.UseMcs,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseMcs
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn,
CompilerOptions.UseMcs,
CompilerOptions.Optimize | CompilerOptions.UseMcs
};
[Test]
@ -85,316 +85,316 @@ namespace ICSharpCode.Decompiler.Tests @@ -85,316 +85,316 @@ namespace ICSharpCode.Decompiler.Tests
}
[Test]
public void InlineAssignmentTest([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void InlineAssignmentTest([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CompoundAssignmentTest([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void CompoundAssignmentTest([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void ShortCircuit([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void ShortCircuit([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CustomShortCircuitOperators([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void CustomShortCircuitOperators([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void ExceptionHandling([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void ExceptionHandling([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
NullPropagation = false,
// legacy csc generates a dead store in debug builds
RemoveDeadCode = (cscOptions == CSharpCompilerOptions.None)
RemoveDeadCode = (cscOptions == CompilerOptions.None)
});
}
[Test]
public void Switch([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void Switch([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
// legacy csc generates a dead store in debug builds
RemoveDeadCode = (cscOptions == CSharpCompilerOptions.None)
RemoveDeadCode = (cscOptions == CompilerOptions.None)
});
}
[Test]
public void ReduceNesting([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void ReduceNesting([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void DelegateConstruction([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void DelegateConstruction([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void AnonymousTypes([ValueSource(nameof(defaultOptionsWithMcs))] CSharpCompilerOptions cscOptions)
public void AnonymousTypes([ValueSource(nameof(defaultOptionsWithMcs))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Async([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void Async([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Lock([ValueSource(nameof(defaultOptionsWithMcs))] CSharpCompilerOptions cscOptions)
public void Lock([ValueSource(nameof(defaultOptionsWithMcs))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Using([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void Using([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void LiftedOperators([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void LiftedOperators([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Generics([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void Generics([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Loops([ValueSource(nameof(defaultOptionsWithMcs))] CSharpCompilerOptions cscOptions)
public void Loops([ValueSource(nameof(defaultOptionsWithMcs))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
// legacy csc generates a dead store in debug builds
RemoveDeadCode = (cscOptions == CSharpCompilerOptions.None)
RemoveDeadCode = (cscOptions == CompilerOptions.None)
});
}
[Test]
public void PropertiesAndEvents([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void PropertiesAndEvents([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void AutoProperties([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void AutoProperties([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void QueryExpressions([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void QueryExpressions([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void TypeAnalysisTests([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void TypeAnalysisTests([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CheckedUnchecked([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void CheckedUnchecked([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void UnsafeCode([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void UnsafeCode([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void ConstructorInitializers([ValueSource(nameof(defaultOptionsWithMcs))] CSharpCompilerOptions cscOptions)
public void ConstructorInitializers([ValueSource(nameof(defaultOptionsWithMcs))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void PInvoke([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void PInvoke([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
// This tests needs our own disassembler; ildasm has a bug with marshalinfo.
RunForLibrary(cscOptions: cscOptions, asmOptions: AssemblerOptions.UseOwnDisassembler);
}
[Test]
public void InitializerTests([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void InitializerTests([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void DynamicTests([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void DynamicTests([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void ExpressionTrees([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void ExpressionTrees([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void FixProxyCalls([Values(CSharpCompilerOptions.None, CSharpCompilerOptions.Optimize, CSharpCompilerOptions.UseRoslyn)] CSharpCompilerOptions cscOptions)
public void FixProxyCalls([Values(CompilerOptions.None, CompilerOptions.Optimize, CompilerOptions.UseRoslyn)] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void VariableNaming([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void VariableNaming([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void VariableNamingWithoutSymbols([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void VariableNamingWithoutSymbols([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings { UseDebugSymbols = false });
}
[Test]
public void CS72_PrivateProtected([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void CS72_PrivateProtected([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void AsyncMain([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void AsyncMain([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
Run(cscOptions: cscOptions);
}
[Test]
public void NullPropagation([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void NullPropagation([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CS6_StringInterpolation([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void CS6_StringInterpolation([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
Run(cscOptions: cscOptions);
}
[Test]
public void CS73_StackAllocInitializers([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void CS73_StackAllocInitializers([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void RefLocalsAndReturns([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void RefLocalsAndReturns([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void WellKnownConstants([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void WellKnownConstants([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void QualifierTests([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void QualifierTests([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void TupleTests([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void TupleTests([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void NamedArguments([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void NamedArguments([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void OptionalArguments([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void OptionalArguments([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void ConstantsTests([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void ConstantsTests([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Issue1080([ValueSource(nameof(roslynOnlyOptions))] CSharpCompilerOptions cscOptions)
public void Issue1080([ValueSource(nameof(roslynOnlyOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void AssemblyCustomAttributes([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void AssemblyCustomAttributes([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CustomAttributes([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void CustomAttributes([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CustomAttributeConflicts([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void CustomAttributeConflicts([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CustomAttributeSamples([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void CustomAttributeSamples([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void MemberTests([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void MemberTests([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void TypeTests([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void TypeTests([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void YieldReturn([ValueSource(nameof(defaultOptions))] CSharpCompilerOptions cscOptions)
public void YieldReturn([ValueSource(nameof(defaultOptions))] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null)
void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null)
{
Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CSharpCompilerOptions.Library, decompilerSettings);
Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CompilerOptions.Library, decompilerSettings);
}
void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null)
void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null)
{
var ilFile = Path.Combine(TestCasePath, testName) + Tester.GetSuffix(cscOptions) + ".il";
var csFile = Path.Combine(TestCasePath, testName + ".cs");
@ -404,7 +404,7 @@ namespace ICSharpCode.Decompiler.Tests @@ -404,7 +404,7 @@ namespace ICSharpCode.Decompiler.Tests
CompilerResults output = null;
try {
string outputFile = Path.ChangeExtension(ilFile,
cscOptions.HasFlag(CSharpCompilerOptions.Library) ? ".dll" : ".exe");
cscOptions.HasFlag(CompilerOptions.Library) ? ".dll" : ".exe");
output = Tester.CompileCSharp(csFile, cscOptions, outputFile);
Tester.Disassemble(output.PathToAssembly, ilFile, asmOptions);
} finally {

32
ICSharpCode.Decompiler.Tests/UglyTestRunner.cs
Unescape View File

@ -47,28 +47,28 @@ namespace ICSharpCode.Decompiler.Tests @@ -47,28 +47,28 @@ namespace ICSharpCode.Decompiler.Tests
}
}
static readonly CSharpCompilerOptions[] noRoslynOptions =
static readonly CompilerOptions[] noRoslynOptions =
{
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize
CompilerOptions.None,
CompilerOptions.Optimize
};
static readonly CSharpCompilerOptions[] roslynOnlyOptions =
static readonly CompilerOptions[] roslynOnlyOptions =
{
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
};
static readonly CSharpCompilerOptions[] defaultOptions =
static readonly CompilerOptions[] defaultOptions =
{
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
};
[Test]
public void NoArrayInitializers([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
public void NoArrayInitializers([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
ArrayInitializers = false
@ -76,19 +76,19 @@ namespace ICSharpCode.Decompiler.Tests @@ -76,19 +76,19 @@ namespace ICSharpCode.Decompiler.Tests
}
[Test]
public void NoDecimalConstants([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
public void NoDecimalConstants([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
DecimalConstants = false
});
}
void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null)
void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null)
{
Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CSharpCompilerOptions.Library, decompilerSettings);
Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CompilerOptions.Library, decompilerSettings);
}
void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null)
void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null)
{
var ilFile = Path.Combine(TestCasePath, testName) + Tester.GetSuffix(cscOptions) + ".il";
var csFile = Path.Combine(TestCasePath, testName + ".cs");

20
ICSharpCode.Decompiler.Tests/VBPrettyTestRunner.cs
Unescape View File

@ -46,27 +46,27 @@ namespace ICSharpCode.Decompiler.Tests @@ -46,27 +46,27 @@ namespace ICSharpCode.Decompiler.Tests
}
}
static readonly VBCompilerOptions[] defaultOptions =
static readonly CompilerOptions[] defaultOptions =
{
VBCompilerOptions.None,
VBCompilerOptions.Optimize,
VBCompilerOptions.UseRoslyn,
VBCompilerOptions.Optimize | VBCompilerOptions.UseRoslyn,
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn,
};
static readonly VBCompilerOptions[] roslynOnlyOptions =
static readonly CompilerOptions[] roslynOnlyOptions =
{
VBCompilerOptions.UseRoslyn,
VBCompilerOptions.Optimize | VBCompilerOptions.UseRoslyn,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn,
};
[Test, Ignore("Implement VB async/await")]
public void Async([ValueSource("defaultOptions")] VBCompilerOptions options)
public void Async([ValueSource("defaultOptions")] CompilerOptions options)
{
Run(options: options);
}
void Run([CallerMemberName] string testName = null, VBCompilerOptions options = VBCompilerOptions.UseDebug, DecompilerSettings settings = null)
void Run([CallerMemberName] string testName = null, CompilerOptions options = CompilerOptions.UseDebug, DecompilerSettings settings = null)
{
var vbFile = Path.Combine(TestCasePath, testName + ".vb");
var csFile = Path.Combine(TestCasePath, testName + ".cs");

Write Preview
Loading…
Cancel
Save