Browse Source

Rename CompilerOptions to CSharpCompilerOptions and add Tester.CompileVB

pull/1087/head
Siegfried Pammer 8 years ago
parent
commit
7f210b585a
  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

@ -46,146 +46,146 @@ namespace ICSharpCode.Decompiler.Tests @@ -46,146 +46,146 @@ namespace ICSharpCode.Decompiler.Tests
}
}
static readonly CompilerOptions[] noMonoOptions =
static readonly CSharpCompilerOptions[] noMonoOptions =
{
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn,
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn,
};
static readonly CompilerOptions[] defaultOptions =
static readonly CSharpCompilerOptions[] defaultOptions =
{
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn,
CompilerOptions.UseMcs,
CompilerOptions.Optimize | CompilerOptions.UseMcs
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.UseMcs,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseMcs
};
static readonly CompilerOptions[] roslynOnlyOptions =
static readonly CSharpCompilerOptions[] roslynOnlyOptions =
{
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
};
[Test]
public void Comparisons([ValueSource("defaultOptions")] CompilerOptions options)
public void Comparisons([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Conversions([ValueSource("defaultOptions")] CompilerOptions options)
public void Conversions([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void FloatingPointArithmetic([ValueSource("defaultOptions")] CompilerOptions options)
public void FloatingPointArithmetic([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void HelloWorld([ValueSource("defaultOptions")] CompilerOptions options)
public void HelloWorld([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void ControlFlow([ValueSource("defaultOptions")] CompilerOptions options)
public void ControlFlow([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void CompoundAssignment([ValueSource("defaultOptions")] CompilerOptions options)
public void CompoundAssignment([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void PropertiesAndEvents([ValueSource("defaultOptions")] CompilerOptions options)
public void PropertiesAndEvents([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Switch([ValueSource("defaultOptions")] CompilerOptions options)
public void Switch([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Using([ValueSource("defaultOptions")] CompilerOptions options)
public void Using([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Loops([ValueSource("defaultOptions")] CompilerOptions options)
public void Loops([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void NullableTests([ValueSource("defaultOptions")] CompilerOptions options)
public void NullableTests([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Generics([ValueSource("defaultOptions")] CompilerOptions options)
public void Generics([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void ValueTypeCall([ValueSource("defaultOptions")] CompilerOptions options)
public void ValueTypeCall([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void InitializerTests([ValueSource("defaultOptions")] CompilerOptions options)
public void InitializerTests([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void DecimalFields([ValueSource("defaultOptions")] CompilerOptions options)
public void DecimalFields([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void UndocumentedExpressions([ValueSource("noMonoOptions")] CompilerOptions options)
public void UndocumentedExpressions([ValueSource("noMonoOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void MemberLookup([ValueSource("defaultOptions")] CompilerOptions options)
public void MemberLookup([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void OverloadResolution([ValueSource("defaultOptions")] CompilerOptions options)
public void OverloadResolution([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void ExpressionTrees([ValueSource("defaultOptions")] CompilerOptions options)
public void ExpressionTrees([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void NullPropagation([ValueSource("roslynOnlyOptions")] CompilerOptions options)
public void NullPropagation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
@ -193,10 +193,10 @@ namespace ICSharpCode.Decompiler.Tests @@ -193,10 +193,10 @@ namespace ICSharpCode.Decompiler.Tests
[Test]
public void BitNot([Values(false, true)] bool force32Bit)
{
CompilerOptions compiler = CompilerOptions.UseDebug;
CSharpCompilerOptions compiler = CSharpCompilerOptions.UseDebug;
AssemblerOptions asm = AssemblerOptions.None;
if (force32Bit) {
compiler |= CompilerOptions.Force32Bit;
compiler |= CSharpCompilerOptions.Force32Bit;
asm |= AssemblerOptions.Force32Bit;
}
RunIL("BitNot.il", compiler, asm);
@ -211,79 +211,79 @@ namespace ICSharpCode.Decompiler.Tests @@ -211,79 +211,79 @@ namespace ICSharpCode.Decompiler.Tests
[Test]
public void StackTypes([Values(false, true)] bool force32Bit)
{
CompilerOptions compiler = CompilerOptions.UseRoslyn | CompilerOptions.UseDebug;
CSharpCompilerOptions compiler = CSharpCompilerOptions.UseRoslyn | CSharpCompilerOptions.UseDebug;
AssemblerOptions asm = AssemblerOptions.None;
if (force32Bit) {
compiler |= CompilerOptions.Force32Bit;
compiler |= CSharpCompilerOptions.Force32Bit;
asm |= AssemblerOptions.Force32Bit;
}
RunIL("StackTypes.il", compiler, asm);
}
[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!");
}
RunCS(options: options);
}
[Test]
public void ConditionalAttr([ValueSource("defaultOptions")] CompilerOptions options)
public void ConditionalAttr([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void TrickyTypes([ValueSource("defaultOptions")] CompilerOptions options)
public void TrickyTypes([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[Test]
public void Capturing([ValueSource("defaultOptions")] CompilerOptions options)
public void Capturing([ValueSource("defaultOptions")] CSharpCompilerOptions options)
{
RunCS(options: options);
}
[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!");
}
RunCS(options: options);
}
[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!");
}
RunCS(options: options);
}
[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!");
}
RunCS(options: options);
}
[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!");
}
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 testOutputFileName = testName + Tester.GetSuffix(options) + ".exe";
@ -293,12 +293,12 @@ namespace ICSharpCode.Decompiler.Tests @@ -293,12 +293,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(CompilerOptions.UseMcs)) {
if (options.HasFlag(CSharpCompilerOptions.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 &= ~CompilerOptions.UseMcs;
options |= CompilerOptions.UseRoslyn;
options &= ~CSharpCompilerOptions.UseMcs;
options |= CSharpCompilerOptions.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>
@ -321,7 +321,7 @@ namespace ICSharpCode.Decompiler.Tests @@ -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;
CompilerResults decompiledOutputFile = null;

123
ICSharpCode.Decompiler.Tests/Helpers/Tester.VB.cs

@ -0,0 +1,123 @@ @@ -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

@ -40,7 +40,7 @@ using NUnit.Framework; @@ -40,7 +40,7 @@ using NUnit.Framework;
namespace ICSharpCode.Decompiler.Tests.Helpers
{
[Flags]
public enum CompilerOptions
public enum CSharpCompilerOptions
{
None,
Optimize = 0x1,
@ -61,7 +61,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -61,7 +61,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
UseOwnDisassembler = 0x8,
}
public static class Tester
public static partial class Tester
{
public static string AssembleIL(string sourceFileName, AssemblerOptions options = AssemblerOptions.UseDebug)
{
@ -161,22 +161,22 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -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>();
if (flags.HasFlag(CompilerOptions.UseDebug)) {
if (flags.HasFlag(CSharpCompilerOptions.UseDebug)) {
preprocessorSymbols.Add("DEBUG");
}
if (flags.HasFlag(CompilerOptions.Optimize)) {
if (flags.HasFlag(CSharpCompilerOptions.Optimize)) {
preprocessorSymbols.Add("OPT");
}
if (flags.HasFlag(CompilerOptions.UseRoslyn)) {
if (flags.HasFlag(CSharpCompilerOptions.UseRoslyn)) {
preprocessorSymbols.Add("ROSLYN");
preprocessorSymbols.Add("CS60");
preprocessorSymbols.Add("CS70");
preprocessorSymbols.Add("CS71");
preprocessorSymbols.Add("CS72");
} else if (flags.HasFlag(CompilerOptions.UseMcs)) {
} else if (flags.HasFlag(CSharpCompilerOptions.UseMcs)) {
preprocessorSymbols.Add("MCS");
} else {
preprocessorSymbols.Add("LEGACY_CSC");
@ -184,7 +184,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -184,7 +184,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
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 };
foreach (Match match in Regex.Matches(File.ReadAllText(sourceFileName), @"#include ""([\w\d./]+)""")) {
@ -193,15 +193,15 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -193,15 +193,15 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
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 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(CompilerOptions.Library) ? OutputKind.DynamicallyLinkedLibrary : OutputKind.ConsoleApplication,
platform: flags.HasFlag(CompilerOptions.Force32Bit) ? Platform.X86 : Platform.AnyCpu,
optimizationLevel: flags.HasFlag(CompilerOptions.Optimize) ? OptimizationLevel.Release : OptimizationLevel.Debug,
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,
allowUnsafe: true,
deterministic: true
));
@ -216,7 +216,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -216,7 +216,7 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
throw new Exception(b.ToString());
}
return results;
} else if (flags.HasFlag(CompilerOptions.UseMcs)) {
} else if (flags.HasFlag(CSharpCompilerOptions.UseMcs)) {
CompilerResults results = new CompilerResults(new TempFileCollection());
results.PathToAssembly = outputFileName ?? Path.GetTempFileName();
string testBasePath = RoundtripAssembly.TestDir;
@ -225,19 +225,19 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -225,19 +225,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(CompilerOptions.Optimize) ? "+ " : "- ");
string otherOptions = " -unsafe -o" + (flags.HasFlag(CSharpCompilerOptions.Optimize) ? "+ " : "- ");
if (flags.HasFlag(CompilerOptions.Library)) {
if (flags.HasFlag(CSharpCompilerOptions.Library)) {
otherOptions += "-t:library ";
} else {
otherOptions += "-t:exe ";
}
if (flags.HasFlag(CompilerOptions.UseDebug)) {
if (flags.HasFlag(CSharpCompilerOptions.UseDebug)) {
otherOptions += "-g ";
}
if (flags.HasFlag(CompilerOptions.Force32Bit)) {
if (flags.HasFlag(CSharpCompilerOptions.Force32Bit)) {
otherOptions += "-platform:x86 ";
} else {
otherOptions += "-platform:anycpu ";
@ -269,10 +269,10 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -269,10 +269,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(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" : "");
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" : "");
if (preprocessorSymbols.Count > 0) {
options.CompilerOptions += " /d:" + string.Join(";", preprocessorSymbols);
}
@ -295,10 +295,10 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -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();
if ((cscOptions & CompilerOptions.UseRoslyn) == 0) {
if ((cscOptions & CSharpCompilerOptions.UseRoslyn) == 0) {
// disable C# features not available in legacy compiler
settings.NullPropagation = false;
settings.StringInterpolation = false;
@ -324,18 +324,18 @@ namespace ICSharpCode.Decompiler.Tests.Helpers @@ -324,18 +324,18 @@ namespace ICSharpCode.Decompiler.Tests.Helpers
return decompiler;
}
internal static string GetSuffix(CompilerOptions cscOptions)
internal static string GetSuffix(CSharpCompilerOptions cscOptions)
{
string suffix = "";
if ((cscOptions & CompilerOptions.Optimize) != 0)
if ((cscOptions & CSharpCompilerOptions.Optimize) != 0)
suffix += ".opt";
if ((cscOptions & CompilerOptions.Force32Bit) != 0)
if ((cscOptions & CSharpCompilerOptions.Force32Bit) != 0)
suffix += ".32";
if ((cscOptions & CompilerOptions.UseDebug) != 0)
if ((cscOptions & CSharpCompilerOptions.UseDebug) != 0)
suffix += ".dbg";
if ((cscOptions & CompilerOptions.UseRoslyn) != 0)
if ((cscOptions & CSharpCompilerOptions.UseRoslyn) != 0)
suffix += ".roslyn";
if ((cscOptions & CompilerOptions.UseMcs) != 0)
if ((cscOptions & CSharpCompilerOptions.UseMcs) != 0)
suffix += ".mcs";
return suffix;
}

2
ICSharpCode.Decompiler.Tests/ICSharpCode.Decompiler.Tests.csproj

@ -38,6 +38,7 @@ @@ -38,6 +38,7 @@
<ItemGroup>
<PackageReference Include="DiffLib" Version="1.0.0.55" />
<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="System.Collections.Immutable" Version="1.3.1" />
<PackageReference Include="NUnit" Version="3.9.0" />
@ -93,6 +94,7 @@ @@ -93,6 +94,7 @@
<Compile Include="Helpers\SdkUtility.cs" />
<Compile Include="Helpers\RemoveCompilerAttribute.cs" />
<Compile Include="Helpers\Tester.cs" />
<Compile Include="Helpers\Tester.VB.cs" />
<Compile Include="Helpers\TypeSystemHelper.cs" />
<Compile Include="ILPrettyTestRunner.cs" />
<Compile Include="Stub.cs" />

100
ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs

@ -47,34 +47,34 @@ namespace ICSharpCode.Decompiler.Tests @@ -47,34 +47,34 @@ namespace ICSharpCode.Decompiler.Tests
}
}
static readonly CompilerOptions[] noRoslynOptions =
static readonly CSharpCompilerOptions[] noRoslynOptions =
{
CompilerOptions.None,
CompilerOptions.Optimize
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize
};
static readonly CompilerOptions[] roslynOnlyOptions =
static readonly CSharpCompilerOptions[] roslynOnlyOptions =
{
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
};
static readonly CompilerOptions[] defaultOptions =
static readonly CSharpCompilerOptions[] defaultOptions =
{
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
};
static readonly CompilerOptions[] defaultOptionsWithMcs =
static readonly CSharpCompilerOptions[] defaultOptionsWithMcs =
{
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn,
CompilerOptions.UseMcs,
CompilerOptions.Optimize | CompilerOptions.UseMcs
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.UseMcs,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseMcs
};
[Test]
@ -85,25 +85,25 @@ namespace ICSharpCode.Decompiler.Tests @@ -85,25 +85,25 @@ namespace ICSharpCode.Decompiler.Tests
}
[Test]
public void InlineAssignmentTest([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void InlineAssignmentTest([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CompoundAssignmentTest([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void CompoundAssignmentTest([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void ShortCircuit([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void ShortCircuit([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void ExceptionHandling([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void ExceptionHandling([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
NullPropagation = false
@ -111,162 +111,162 @@ namespace ICSharpCode.Decompiler.Tests @@ -111,162 +111,162 @@ namespace ICSharpCode.Decompiler.Tests
}
[Test]
public void Switch([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void Switch([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void DelegateConstruction([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void DelegateConstruction([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void AnonymousTypes([Values(CompilerOptions.None, CompilerOptions.Optimize)] CompilerOptions cscOptions)
public void AnonymousTypes([Values(CSharpCompilerOptions.None, CSharpCompilerOptions.Optimize)] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Async([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void Async([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Lock([ValueSource("defaultOptionsWithMcs")] CompilerOptions cscOptions)
public void Lock([ValueSource("defaultOptionsWithMcs")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Using([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void Using([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void LiftedOperators([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void LiftedOperators([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Generics([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void Generics([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void Loops([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void Loops([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void PropertiesAndEvents([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void PropertiesAndEvents([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void AutoProperties([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions)
public void AutoProperties([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void QueryExpressions([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void QueryExpressions([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void TypeAnalysisTests([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void TypeAnalysisTests([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void CheckedUnchecked([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void CheckedUnchecked([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void UnsafeCode([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void UnsafeCode([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[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.
RunForLibrary(cscOptions: cscOptions, asmOptions: AssemblerOptions.UseOwnDisassembler);
}
[Test]
public void InitializerTests([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void InitializerTests([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void ExpressionTrees([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void ExpressionTrees([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[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);
}
[Test]
public void VariableNaming([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void VariableNaming([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void VariableNamingWithoutSymbols([ValueSource("defaultOptions")] CompilerOptions cscOptions)
public void VariableNamingWithoutSymbols([ValueSource("defaultOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings { UseDebugSymbols = false });
}
[Test]
public void CS72_PrivateProtected([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions)
public void CS72_PrivateProtected([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions);
}
[Test]
public void AsyncMain([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions)
public void AsyncMain([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{
Run(cscOptions: cscOptions);
}
[Test]
public void NullPropagation([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions)
public void NullPropagation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions 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]
public void CS6_StringInterpolation([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions)
public void CS6_StringInterpolation([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions 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 csFile = Path.Combine(TestCasePath, testName + ".cs");

30
ICSharpCode.Decompiler.Tests/UglyTestRunner.cs

@ -47,40 +47,40 @@ namespace ICSharpCode.Decompiler.Tests @@ -47,40 +47,40 @@ namespace ICSharpCode.Decompiler.Tests
}
}
static readonly CompilerOptions[] noRoslynOptions =
static readonly CSharpCompilerOptions[] noRoslynOptions =
{
CompilerOptions.None,
CompilerOptions.Optimize
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize
};
static readonly CompilerOptions[] roslynOnlyOptions =
static readonly CSharpCompilerOptions[] roslynOnlyOptions =
{
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
};
static readonly CompilerOptions[] defaultOptions =
static readonly CSharpCompilerOptions[] defaultOptions =
{
CompilerOptions.None,
CompilerOptions.Optimize,
CompilerOptions.UseRoslyn,
CompilerOptions.Optimize | CompilerOptions.UseRoslyn
CSharpCompilerOptions.None,
CSharpCompilerOptions.Optimize,
CSharpCompilerOptions.UseRoslyn,
CSharpCompilerOptions.Optimize | CSharpCompilerOptions.UseRoslyn
};
[Test]
public void NoArrayInitializers([ValueSource("roslynOnlyOptions")] CompilerOptions cscOptions)
public void NoArrayInitializers([ValueSource("roslynOnlyOptions")] CSharpCompilerOptions cscOptions)
{
RunForLibrary(cscOptions: cscOptions, decompilerSettings: new DecompilerSettings {
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 csFile = Path.Combine(TestCasePath, testName + ".cs");

Loading…
Cancel
Save