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

Rename CompilerOptions to CSharpCompilerOptions and add Tester.CompileVB

pull/1087/head
Siegfried Pammer 8 years ago
parent
adda97cf84
commit
7f210b585a
6 changed files with 277 additions and 152 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 114
      ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs
  2. 123
      ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs
  3. 58
      ICSharpCode.Decompiler.Tests/Helpers/Tester.cs
  4. 2
      ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
  5. 100
      ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs
  6. 30
      ICSharpCode.Decompiler.Tests/UglyTestRunner.cs

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

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

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

@ -0,0 +1,123 @@
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.VisualBasic;
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)
{
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);
if (flags.HasFlag(VBCompilerOptions.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,
deterministic: true
));
CompilerResults results = new CompilerResults(new TempFileCollection());
results.PathToAssembly = outputFileName ?? Path.GetTempFileName();
var emitResult = compilation.Emit(results.PathToAssembly);
if (!emitResult.Success) {
StringBuilder b = new StringBuilder("Compiler error:");
foreach (var diag in emitResult.Diagnostics) {
b.AppendLine(diag.ToString());
}
throw new Exception(b.ToString());
}
return results;
} else {
var provider = new VBCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v10.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" : "");
if (preprocessorSymbols.Count > 0) {
options.CompilerOptions += " /d:" + string.Join(";", preprocessorSymbols);
}
if (outputFileName != null) {
options.OutputAssembly = outputFileName;
}
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.Core.dll");
options.ReferencedAssemblies.Add("System.Xml.dll");
CompilerResults results = provider.CompileAssemblyFromFile(options, sourceFileNames.ToArray());
if (results.Errors.Cast<CompilerError>().Any(e => !e.IsWarning)) {
StringBuilder b = new StringBuilder("Compiler error:");
foreach (var error in results.Errors) {
b.AppendLine(error.ToString());
}
throw new Exception(b.ToString());
}
return results;
}
}
}
}

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

@ -40,7 +40,7 @@ using NUnit.Framework;
namespace ICSharpCode.Decompiler.Tests.Helpers namespace ICSharpCode.Decompiler.Tests.Helpers
{ {
[Flags] [Flags]
public enum CompilerOptions public enum CSharpCompilerOptions
{ {
None, None,
Optimize = 0x1, Optimize = 0x1,
@ -61,7 +61,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
UseOwnDisassembler = 0x8, UseOwnDisassembler = 0x8,
} }
public static class Tester public static partial class Tester
{ {
public static string AssembleIL(string sourceFileName, AssemblerOptions options = AssemblerOptions.UseDebug) public static string AssembleIL(string sourceFileName, AssemblerOptions options = AssemblerOptions.UseDebug)
{ {
@ -161,22 +161,22 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
}); });
public static List<string> GetPreprocessorSymbols(CompilerOptions flags) public static List<string> GetPreprocessorSymbols(CSharpCompilerOptions flags)
{ {
var preprocessorSymbols = new List<string>(); var preprocessorSymbols = new List<string>();
if (flags.HasFlag(CompilerOptions.UseDebug)) { if (flags.HasFlag(CSharpCompilerOptions.UseDebug)) {
preprocessorSymbols.Add("DEBUG"); preprocessorSymbols.Add("DEBUG");
} }
if (flags.HasFlag(CompilerOptions.Optimize)) { if (flags.HasFlag(CSharpCompilerOptions.Optimize)) {
preprocessorSymbols.Add("OPT"); preprocessorSymbols.Add("OPT");
} }
if (flags.HasFlag(CompilerOptions.UseRoslyn)) { if (flags.HasFlag(CSharpCompilerOptions.UseRoslyn)) {
preprocessorSymbols.Add("ROSLYN"); preprocessorSymbols.Add("ROSLYN");
preprocessorSymbols.Add("CS60"); preprocessorSymbols.Add("CS60");
preprocessorSymbols.Add("CS70"); preprocessorSymbols.Add("CS70");
preprocessorSymbols.Add("CS71"); preprocessorSymbols.Add("CS71");
preprocessorSymbols.Add("CS72"); preprocessorSymbols.Add("CS72");
} else if (flags.HasFlag(CompilerOptions.UseMcs)) { } else if (flags.HasFlag(CSharpCompilerOptions.UseMcs)) {
preprocessorSymbols.Add("MCS"); preprocessorSymbols.Add("MCS");
} else { } else {
preprocessorSymbols.Add("LEGACY_CSC"); preprocessorSymbols.Add("LEGACY_CSC");
@ -184,7 +184,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
return preprocessorSymbols; return preprocessorSymbols;
} }
public static CompilerResults CompileCSharp(string sourceFileName, CompilerOptions flags = CompilerOptions.UseDebug, string outputFileName = null) public static CompilerResults CompileCSharp(string sourceFileName, CSharpCompilerOptions flags = CSharpCompilerOptions.UseDebug, string outputFileName = null)
{ {
List<string> sourceFileNames = new List<string> { sourceFileName }; List<string> sourceFileNames = new List<string> { sourceFileName };
foreach (Match match in Regex.Matches(File.ReadAllText(sourceFileName), @"#include ""([\w\d./]+)""")) { foreach (Match match in Regex.Matches(File.ReadAllText(sourceFileName), @"#include ""([\w\d./]+)""")) {
@ -193,15 +193,15 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
var preprocessorSymbols = GetPreprocessorSymbols(flags); var preprocessorSymbols = GetPreprocessorSymbols(flags);
if (flags.HasFlag(CompilerOptions.UseRoslyn)) { if (flags.HasFlag(CSharpCompilerOptions.UseRoslyn)) {
var parseOptions = new CSharpParseOptions(preprocessorSymbols: preprocessorSymbols.ToArray(), languageVersion: LanguageVersion.Latest); var parseOptions = new CSharpParseOptions(preprocessorSymbols: preprocessorSymbols.ToArray(), languageVersion: LanguageVersion.Latest);
var syntaxTrees = sourceFileNames.Select(f => SyntaxFactory.ParseSyntaxTree(File.ReadAllText(f), parseOptions, path: f)); var syntaxTrees = sourceFileNames.Select(f => SyntaxFactory.ParseSyntaxTree(File.ReadAllText(f), parseOptions, path: f));
var compilation = CSharpCompilation.Create(Path.GetFileNameWithoutExtension(sourceFileName), var compilation = CSharpCompilation.Create(Path.GetFileNameWithoutExtension(sourceFileName),
syntaxTrees, defaultReferences.Value, syntaxTrees, defaultReferences.Value,
new CSharpCompilationOptions( new CSharpCompilationOptions(
flags.HasFlag(CompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication, flags.HasFlag(CSharpCompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication,
platform: flags.HasFlag(CompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu, platform: flags.HasFlag(CSharpCompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu,
optimizationLevel: flags.HasFlag(CompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug, optimizationLevel: flags.HasFlag(CSharpCompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug,
allowUnsafe: true, allowUnsafe: true,
deterministic: true deterministic: true
)); ));
@ -216,7 +216,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
throw new Exception(b.ToString()); throw new Exception(b.ToString());
} }
return results; return results;
} else if (flags.HasFlag(CompilerOptions.UseMcs)) { } else if (flags.HasFlag(CSharpCompilerOptions.UseMcs)) {
CompilerResults results = new CompilerResults(new TempFileCollection()); CompilerResults results = new CompilerResults(new TempFileCollection());
results.PathToAssembly = outputFileName ?? Path.GetTempFileName(); results.PathToAssembly = outputFileName ?? Path.GetTempFileName();
string testBasePath = RoundtripAssembly.TestDir; string testBasePath = RoundtripAssembly.TestDir;
@ -225,19 +225,19 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
$"git clone https://github.com/icsharpcode/ILSpy-tests \"{testBasePath}\""); $"git clone https://github.com/icsharpcode/ILSpy-tests \"{testBasePath}\"");
} }
string mcsPath = Path.Combine(testBasePath, @"mcs\2.6.4\bin\gmcs.bat"); string mcsPath = Path.Combine(testBasePath, @"mcs\2.6.4\bin\gmcs.bat");
string otherOptions = " -unsafe -o" + (flags.HasFlag(CompilerOptions.Optimize) ? "+ " : "- "); string otherOptions = " -unsafe -o" + (flags.HasFlag(CSharpCompilerOptions.Optimize) ? "+ " : "- ");
if (flags.HasFlag(CompilerOptions.Library)) { if (flags.HasFlag(CSharpCompilerOptions.Library)) {
otherOptions += "-t:library "; otherOptions += "-t:library ";
} else { } else {
otherOptions += "-t:exe "; otherOptions += "-t:exe ";
} }
if (flags.HasFlag(CompilerOptions.UseDebug)) { if (flags.HasFlag(CSharpCompilerOptions.UseDebug)) {
otherOptions += "-g "; otherOptions += "-g ";
} }
if (flags.HasFlag(CompilerOptions.Force32Bit)) { if (flags.HasFlag(CSharpCompilerOptions.Force32Bit)) {
otherOptions += "-platform:x86 "; otherOptions += "-platform:x86 ";
} else { } else {
otherOptions += "-platform:anycpu "; otherOptions += "-platform:anycpu ";
@ -269,10 +269,10 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
} else { } else {
var provider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } }); var provider = new CSharpCodeProvider(new Dictionary<string, string> { { "CompilerVersion", "v4.0" } });
CompilerParameters options = new CompilerParameters(); CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = !flags.HasFlag(CompilerOptions.Library); options.GenerateExecutable = !flags.HasFlag(CSharpCompilerOptions.Library);
options.CompilerOptions = "/unsafe /o" + (flags.HasFlag(CompilerOptions.Optimize) ? "+" : "-"); options.CompilerOptions = "/unsafe /o" + (flags.HasFlag(CSharpCompilerOptions.Optimize) ? "+" : "-");
options.CompilerOptions += (flags.HasFlag(CompilerOptions.UseDebug) ? " /debug" : ""); options.CompilerOptions += (flags.HasFlag(CSharpCompilerOptions.UseDebug) ? " /debug" : "");
options.CompilerOptions += (flags.HasFlag(CompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : ""); options.CompilerOptions += (flags.HasFlag(CSharpCompilerOptions.Force32Bit) ? " /platform:anycpu32bitpreferred" : "");
if (preprocessorSymbols.Count > 0) { if (preprocessorSymbols.Count > 0) {
options.CompilerOptions += " /d:" + string.Join(";", preprocessorSymbols); options.CompilerOptions += " /d:" + string.Join(";", preprocessorSymbols);
} }
@ -295,10 +295,10 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
} }
} }
internal static DecompilerSettings GetSettings(CompilerOptions cscOptions) internal static DecompilerSettings GetSettings(CSharpCompilerOptions cscOptions)
{ {
var settings = new DecompilerSettings(); var settings = new DecompilerSettings();
if ((cscOptions & CompilerOptions.UseRoslyn) == 0) { if ((cscOptions & CSharpCompilerOptions.UseRoslyn) == 0) {
// disable C# features not available in legacy compiler // disable C# features not available in legacy compiler
settings.NullPropagation = false; settings.NullPropagation = false;
settings.StringInterpolation = false; settings.StringInterpolation = false;
@ -324,18 +324,18 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
return decompiler; return decompiler;
} }
internal static string GetSuffix(CompilerOptions cscOptions) internal static string GetSuffix(CSharpCompilerOptions cscOptions)
{ {
string suffix = ""; string suffix = "";
if ((cscOptions & CompilerOptions.Optimize) != 0) if ((cscOptions & CSharpCompilerOptions.Optimize) != 0)
suffix += ".opt"; suffix += ".opt";
if ((cscOptions & CompilerOptions.Force32Bit) != 0) if ((cscOptions & CSharpCompilerOptions.Force32Bit) != 0)
suffix += ".32"; suffix += ".32";
if ((cscOptions & CompilerOptions.UseDebug) != 0) if ((cscOptions & CSharpCompilerOptions.UseDebug) != 0)
suffix += ".dbg"; suffix += ".dbg";
if ((cscOptions & CompilerOptions.UseRoslyn) != 0) if ((cscOptions & CSharpCompilerOptions.UseRoslyn) != 0)
suffix += ".roslyn"; suffix += ".roslyn";
if ((cscOptions & CompilerOptions.UseMcs) != 0) if ((cscOptions & CSharpCompilerOptions.UseMcs) != 0)
suffix += ".mcs"; suffix += ".mcs";
return suffix; return suffix;
} }

2
ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj
Unescape View File

@ -38,6 +38,7 @@
<ItemGroup> <ItemGroup>
<PackageReference Include="DiffLib" Version="1.0.0.55" /> <PackageReference Include="DiffLib" Version="1.0.0.55" />
<PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="2.6.0" /> <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="2.6.0" />
<PackageReference Include="Microsoft.CodeAnalysis.VisualBasic" Version="2.6.0" />
<PackageReference Include="NUnit3TestAdapter" Version="3.9.0" /> <PackageReference Include="NUnit3TestAdapter" Version="3.9.0" />
<PackageReference Include="System.Collections.Immutable" Version="1.3.1" /> <PackageReference Include="System.Collections.Immutable" Version="1.3.1" />
<PackageReference Include="NUnit" Version="3.9.0" /> <PackageReference Include="NUnit" Version="3.9.0" />
@ -93,6 +94,7 @@
<Compile Include="Helpers\SdkUtility.cs" /> <Compile Include="Helpers\SdkUtility.cs" />
<Compile Include="Helpers\RemoveCompilerAttribute.cs" /> <Compile Include="Helpers\RemoveCompilerAttribute.cs" />
<Compile Include="Helpers\Tester.cs" /> <Compile Include="Helpers\Tester.cs" />
<Compile Include="Helpers\Tester.VB.cs" />
<Compile Include="Helpers\TypeSystemHelper.cs" /> <Compile Include="Helpers\TypeSystemHelper.cs" />
<Compile Include="ILPrettyTestRunner.cs" /> <Compile Include="ILPrettyTestRunner.cs" />
<Compile Include="Stub.cs" /> <Compile Include="Stub.cs" />

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

@ -47,34 +47,34 @@ namespace ICSharpCode.Decompiler.Tests
} }
} }
static readonly CompilerOptions[] noRoslynOptions = static readonly CSharpCompilerOptions[] noRoslynOptions =
{ {
CompilerOptions.None, CSharpCompilerOptions.None,
CompilerOptions.Optimize CSharpCompilerOptions.Optimize
}; };
static readonly CompilerOptions[] roslynOnlyOptions = static readonly CSharpCompilerOptions[] roslynOnlyOptions =
{ {
CompilerOptions.UseRoslyn, CSharpCompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
}; };
static readonly CompilerOptions[] defaultOptions = static readonly CSharpCompilerOptions[] defaultOptions =
{ {
CompilerOptions.None, CSharpCompilerOptions.None,
CompilerOptions.Optimize, CSharpCompilerOptions.Optimize,
CompilerOptions.UseRoslyn, CSharpCompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
}; };
static readonly CompilerOptions[] defaultOptionsWithMcs = static readonly CSharpCompilerOptions[] defaultOptionsWithMcs =
{ {
CompilerOptions.None, CSharpCompilerOptions.None,
CompilerOptions.Optimize, CSharpCompilerOptions.Optimize,
CompilerOptions.UseRoslyn, CSharpCompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn, CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn,
CompilerOptions.UseMcs, CSharpCompilerOptions.UseMcs,
CompilerOptions.Optimize | CompilerOptions.UseMcs CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseMcs
}; };
[Test] [Test]
@ -85,25 +85,25 @@ namespace ICSharpCode.Decompiler.Tests
} }
[Test] [Test]
public void InlineAssignmentTest([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void InlineAssignmentTest([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void CompoundAssignmentTest([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void CompoundAssignmentTest([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void ShortCircuit([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void ShortCircuit([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void ExceptionHandling([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void ExceptionHandling([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings { RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
NullPropagation = false NullPropagation = false
@ -111,162 +111,162 @@ namespace ICSharpCode.Decompiler.Tests
} }
[Test] [Test]
public void Switch([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void Switch([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void DelegateConstruction([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void DelegateConstruction([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void AnonymousTypes([Values(CompilerOptions.None, CompilerOptions.Optimize)] CompilerOptions cscOptions) public void AnonymousTypes([Values(CSharpCompilerOptions.None, CSharpCompilerOptions.Optimize)] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void Async([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void Async([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void Lock([ValueSource("defaultOptionsWithMcs")] CompilerOptions cscOptions) public void Lock([ValueSource("defaultOptionsWithMcs")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void Using([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void Using([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void LiftedOperators([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void LiftedOperators([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void Generics([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void Generics([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void Loops([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void Loops([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void PropertiesAndEvents([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void PropertiesAndEvents([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void AutoProperties([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) public void AutoProperties([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void QueryExpressions([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void QueryExpressions([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void TypeAnalysisTests([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void TypeAnalysisTests([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void CheckedUnchecked([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void CheckedUnchecked([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void UnsafeCode([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void UnsafeCode([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void PInvoke([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void PInvoke([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
// This tests needs our own disassembler; ildasm has a bug with marshalinfo. // This tests needs our own disassembler; ildasm has a bug with marshalinfo.
RunForLibrary(cscOptions: cscOptions, asmOptions: AssemblerOptions.UseOwnDisassembler); RunForLibrary(cscOptions: cscOptions, asmOptions: AssemblerOptions.UseOwnDisassembler);
} }
[Test] [Test]
public void InitializerTests([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void InitializerTests([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void ExpressionTrees([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void ExpressionTrees([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void FixProxyCalls([Values(CompilerOptions.None, CompilerOptions.Optimize, CompilerOptions.UseRoslyn)] CompilerOptions cscOptions) public void FixProxyCalls([Values(CSharpCompilerOptions.None, CSharpCompilerOptions.Optimize, CSharpCompilerOptions.UseRoslyn)] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void VariableNaming([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void VariableNaming([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void VariableNamingWithoutSymbols([ValueSource("defaultOptions")] CompilerOptions cscOptions) public void VariableNamingWithoutSymbols([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings { UseDebugSymbols = false }); RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings { UseDebugSymbols = false });
} }
[Test] [Test]
public void CS72_PrivateProtected([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) public void CS72_PrivateProtected([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
[Test] [Test]
public void AsyncMain([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) public void AsyncMain([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{ {
Run(cscOptions: cscOptions); Run(cscOptions: cscOptions);
} }
[Test] [Test]
public void NullPropagation([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) public void NullPropagation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{ {
RunForLibrary(cscOptions: cscOptions); RunForLibrary(cscOptions: cscOptions);
} }
void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null) void RunForLibrary([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null)
{ {
Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CompilerOptions.Library, decompilerSettings); Run(testName, asmOptions | AssemblerOptions.Library, cscOptions | CSharpCompilerOptions.Library, decompilerSettings);
} }
[Test] [Test]
public void CS6_StringInterpolation([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions) public void CS6_StringInterpolation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{ {
Run(cscOptions: cscOptions); Run(cscOptions: cscOptions);
} }
void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CompilerOptions cscOptions = CompilerOptions.None, DecompilerSettings decompilerSettings = null) void Run([CallerMemberName] string testName = null, AssemblerOptions asmOptions = AssemblerOptions.None, CSharpCompilerOptions cscOptions = CSharpCompilerOptions.None, DecompilerSettings decompilerSettings = null)
{ {
var ilFile = Path.Combine(TestCasePath, testName) + Tester.GetSuffix(cscOptions) + ".il"; var ilFile = Path.Combine(TestCasePath, testName) + Tester.GetSuffix(cscOptions) + ".il";
var csFile = Path.Combine(TestCasePath, testName + ".cs"); var csFile = Path.Combine(TestCasePath, testName + ".cs");

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

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

Write Preview
Loading…
Cancel
Save