mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 4.8.0.309

Browse Source 
Former-commit-id: 5f9c6ae75f295e057a7d2971f3a6df4656fa8850
This commit is contained in:
Xamarin Public Jenkins (auto-signing)
2016-11-10 13:04:39 +00:00
parent ee1447783b
commit 94b2861243
4912 changed files with 390737 additions and 49310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

305
external/cecil/Test/Mono.Cecil.Tests/Addin.cs vendored
View File

@@ -1,305 +0,0 @@
using System;
using System.IO;
using System.Reflection;
using NUnit.Core;
using NUnit.Core.Extensibility;
using Mono.Cecil.Cil;
namespace Mono.Cecil.Tests {
public abstract class TestCecilAttribute : Attribute {
bool verify = true;
Type symbol_reader_provider;
Type symbol_writer_provider;
public bool Verify {
get { return verify; }
set { verify = value; }
}
public Type SymbolReaderProvider {
get { return symbol_reader_provider; }
set { symbol_reader_provider = value; }
}
public Type SymbolWriterProvider {
get { return symbol_writer_provider; }
set { symbol_writer_provider = value; }
}
public abstract string GetModuleLocation (Assembly assembly);
}
[AttributeUsage (AttributeTargets.Method, AllowMultiple = false)]
public sealed class TestModuleAttribute : TestCecilAttribute {
readonly string module;
public string Module {
get { return module; }
}
public TestModuleAttribute (string assembly)
{
this.module = assembly;
}
public override string GetModuleLocation (Assembly assembly)
{
return BaseTestFixture.GetAssemblyResourcePath (module, assembly);
}
}
[AttributeUsage (AttributeTargets.Method, AllowMultiple = false)]
public sealed class TestCSharpAttribute : TestCecilAttribute {
readonly string file;
public string File {
get { return file; }
}
public TestCSharpAttribute (string file)
{
this.file = file;
}
public override string GetModuleLocation (Assembly assembly)
{
return CompilationService.CompileResource (
BaseTestFixture.GetCSharpResourcePath (file, assembly));
}
}
[AttributeUsage (AttributeTargets.Method, AllowMultiple = false)]
public sealed class TestILAttribute : TestCecilAttribute {
readonly string file;
public string File {
get { return file; }
}
public TestILAttribute (string file)
{
this.file = file;
}
public override string GetModuleLocation (Assembly assembly)
{
return CompilationService.CompileResource (
BaseTestFixture.GetILResourcePath (file, assembly));
}
}
class CecilTestCase : NUnitTestMethod {
readonly TestCecilAttribute attribute;
readonly TestCaseType type;
public CecilTestCase (MethodInfo method, TestCecilAttribute attribute, TestCaseType type)
: base (method)
{
this.TestName.Name = type.ToString ();
this.TestName.FullName = method.DeclaringType.FullName + "." + method.Name + "." + type;
this.attribute = attribute;
this.type = type;
}
ModuleDefinition GetModule ()
{
var location = attribute.GetModuleLocation (this.Method.DeclaringType.Assembly);
var parameters = new ReaderParameters {
SymbolReaderProvider = GetSymbolReaderProvider (attribute),
};
switch (type) {
case TestCaseType.ReadImmediate:
parameters.ReadingMode = ReadingMode.Immediate;
return ModuleDefinition.ReadModule (location, parameters);
case TestCaseType.ReadDeferred:
parameters.ReadingMode = ReadingMode.Deferred;
return ModuleDefinition.ReadModule (location, parameters);
case TestCaseType.WriteFromImmediate:
parameters.ReadingMode = ReadingMode.Immediate;
return RoundTrip (location, parameters, "cecil-irt");
case TestCaseType.WriteFromDeferred:
parameters.ReadingMode = ReadingMode.Deferred;
return RoundTrip (location, parameters, "cecil-drt");
default:
return null;
}
}
static ISymbolReaderProvider GetSymbolReaderProvider (TestCecilAttribute attribute)
{
if (attribute.SymbolReaderProvider == null)
return null;
return (ISymbolReaderProvider) Activator.CreateInstance (attribute.SymbolReaderProvider);
}
static ISymbolWriterProvider GetSymbolWriterProvider (TestCecilAttribute attribute)
{
if (attribute.SymbolReaderProvider == null)
return null;
return (ISymbolWriterProvider) Activator.CreateInstance (attribute.SymbolWriterProvider);
}
ModuleDefinition RoundTrip (string location, ReaderParameters reader_parameters, string folder)
{
var module = ModuleDefinition.ReadModule (location, reader_parameters);
var rt_folder = Path.Combine (Path.GetTempPath (), folder);
if (!Directory.Exists (rt_folder))
Directory.CreateDirectory (rt_folder);
var rt_module = Path.Combine (rt_folder, Path.GetFileName (location));
var writer_parameters = new WriterParameters {
SymbolWriterProvider = GetSymbolWriterProvider (attribute),
};
Reflect.InvokeMethod (Method, Fixture, new object [] { module });
module.Write (rt_module, writer_parameters);
if (attribute.Verify)
CompilationService.Verify (rt_module);
return ModuleDefinition.ReadModule (rt_module, reader_parameters);
}
public override TestResult RunTest ()
{
var result = new TestResult (TestName);
var module = GetModule ();
if (module == null)
return result;
Reflect.InvokeMethod (Method, Fixture, new object [] { module });
result.Success ();
return result;
}
}
class CecilTestSuite : TestSuite {
public CecilTestSuite (MethodInfo method)
: base (method.DeclaringType.FullName, method.Name)
{
}
public override TestResult Run (EventListener listener, ITestFilter filter)
{
if (this.Parent != null)
this.Fixture = this.Parent.Fixture;
return base.Run (listener, filter);
}
protected override void DoOneTimeSetUp (TestResult suiteResult)
{
}
protected override void DoOneTimeTearDown (TestResult suiteResult)
{
}
}
enum TestCaseType {
ReadImmediate,
ReadDeferred,
WriteFromImmediate,
WriteFromDeferred,
}
static class CecilTestFactory {
public static CecilTestSuite CreateTestSuite (MethodInfo method)
{
if (method == null)
throw new ArgumentNullException ("method");
var suite = new CecilTestSuite (method);
NUnitFramework.ApplyCommonAttributes (method, suite);
PopulateTestSuite (method, suite);
return suite;
}
static void PopulateTestSuite (MethodInfo method, CecilTestSuite suite)
{
var attribute = GetTestCecilAttribute (method);
if (attribute == null)
throw new ArgumentException ();
foreach (var value in Enum.GetValues (typeof (TestCaseType))) {
var test = CreateTestCase (method, attribute, (TestCaseType) value);
if (test != null)
suite.Add (test);
}
}
static CecilTestCase CreateTestCase (MethodInfo method, TestCecilAttribute attribute, TestCaseType type)
{
return new CecilTestCase (method, attribute, type);
}
static TestCecilAttribute GetTestCecilAttribute (MethodInfo method)
{
foreach (var attribute in method.GetCustomAttributes (false)) {
var test = attribute as TestCecilAttribute;
if (test != null)
return test;
}
return null;
}
}
[NUnitAddin]
public class CecilTestAddin : IAddin, ITestCaseBuilder {
public bool Install (IExtensionHost host)
{
if (host == null)
throw new ArgumentNullException ("host");
var builders = host.GetExtensionPoint ("TestCaseBuilders");
if (builders == null)
return false;
builders.Install (this);
return true;
}
public Test BuildFrom (MethodInfo method)
{
if (method == null)
throw new ArgumentNullException ("method");
return CecilTestFactory.CreateTestSuite (method);
}
public bool CanBuildFrom (MethodInfo method)
{
if (method == null)
return false;
return IsCecilTestMethod (method);
}
static bool IsCecilTestMethod (MethodInfo method)
{
return Reflect.HasAttribute (method, typeof (TestModuleAttribute).FullName, false)
|| Reflect.HasAttribute (method, typeof (TestILAttribute).FullName, false)
|| Reflect.HasAttribute (method, typeof (TestCSharpAttribute).FullName, false);
}
}
}

8
external/cecil/Test/Mono.Cecil.Tests/AssemblyInfo.cs vendored
View File

@@ -1,14 +1,6 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
[assembly: AssemblyTitle ("Mono.Cecil.Tests")]
[assembly: AssemblyProduct ("Mono.Cecil")]
[assembly: AssemblyCopyright ("Copyright © 2008 - 2011 Jb Evain")]
[assembly: ComVisible (false)]
[assembly: Guid ("da96c202-696a-457e-89af-5fa74e6bda0d")]
[assembly: AssemblyVersion ("1.0.0.0")]
[assembly: AssemblyFileVersion ("1.0.0.0")]

70
external/cecil/Test/Mono.Cecil.Tests/AssemblyTests.cs vendored
View File

@@ -9,21 +9,23 @@ namespace Mono.Cecil.Tests {
[TestFixture]
public class AssemblyTests : BaseTestFixture {
[TestModule ("hello.exe")]
public void Name (ModuleDefinition module)
[Test]
public void Name ()
{
var name = module.Assembly.Name;
TestModule ("hello.exe", module => {
var name = module.Assembly.Name;
Assert.IsNotNull (name);
Assert.IsNotNull (name);
Assert.AreEqual ("hello", name.Name);
Assert.AreEqual (string.Empty, name.Culture);
Assert.AreEqual (new Version (0, 0, 0, 0), name.Version);
Assert.AreEqual (AssemblyHashAlgorithm.SHA1, name.HashAlgorithm);
Assert.AreEqual ("hello", name.Name);
Assert.AreEqual ("", name.Culture);
Assert.AreEqual (new Version (0, 0, 0, 0), name.Version);
Assert.AreEqual (AssemblyHashAlgorithm.SHA1, name.HashAlgorithm);
});
}
[Test]
public void ParseLowerCaseNameParts()
public void ParseLowerCaseNameParts ()
{
var name = AssemblyNameReference.Parse ("Foo, version=2.0.0.0, culture=fr-FR");
Assert.AreEqual ("Foo", name.Name);
@@ -31,5 +33,55 @@ namespace Mono.Cecil.Tests {
Assert.AreEqual (0, name.Version.Minor);
Assert.AreEqual ("fr-FR", name.Culture);
}
[Test]
public void ZeroVersion ()
{
var name = new AssemblyNameReference ("Foo", null);
Assert.AreEqual ("0.0.0.0", name.Version.ToString (fieldCount: 4));
Assert.AreEqual ("Foo, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", name.FullName);
name = new AssemblyNameReference ("Foo", new Version (0, 0, 0, 0));
Assert.AreEqual ("0.0.0.0", name.Version.ToString (fieldCount: 4));
Assert.AreEqual ("Foo, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", name.FullName);
}
[Test]
public void NoBuildOrMajor ()
{
var name = new AssemblyNameReference ("Foo", new Version (0, 0));
Assert.AreEqual ("Foo, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", name.FullName);
name = new AssemblyNameReference ("Foo", new Version (0, 0, 0));
Assert.AreEqual ("Foo, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", name.FullName);
}
[Test]
public void Retargetable ()
{
TestModule ("RetargetableExample.dll", module => {
var type = module.Types [1];
var property = type.Properties [0];
var attribute = property.CustomAttributes [0];
var argumentType = ((CustomAttributeArgument) attribute.ConstructorArguments [0].Value).Type;
var reference = (AssemblyNameReference) argumentType.Scope;
Assert.AreEqual (
"System.Data, Version=3.5.0.0, Culture=neutral, PublicKeyToken=969db8053d3322ac, Retargetable=Yes",
reference.FullName);
}, verify: !Platform.OnMono);
}
[Test]
public void SystemRuntime ()
{
TestModule ("System.Runtime.dll", module => {
Assert.AreEqual ("System.Runtime", module.Assembly.Name.Name);
Assert.AreEqual (1, module.AssemblyReferences.Count);
Assert.AreNotEqual (module, module.TypeSystem.CoreLibrary);
Assert.AreEqual (module.AssemblyReferences [0], module.TypeSystem.CoreLibrary);
}, verify: !Platform.OnMono);
}
}
}

279
external/cecil/Test/Mono.Cecil.Tests/BaseTestFixture.cs vendored
View File

@@ -1,7 +1,7 @@
using System;
using System.IO;
using System.Reflection;
using Mono.Cecil.Cil;
using NUnit.Framework;
using Mono.Cecil.PE;
@@ -10,6 +10,12 @@ namespace Mono.Cecil.Tests {
public abstract class BaseTestFixture {
protected static void IgnoreOnMono ()
{
if (Platform.OnMono)
Assert.Ignore ();
}
public static string GetResourcePath (string name, Assembly assembly)
{
return Path.Combine (FindResourcesDirectory (assembly), name);
@@ -30,35 +36,35 @@ namespace Mono.Cecil.Tests {
return GetResourcePath (Path.Combine ("il", name), assembly);
}
public static ModuleDefinition GetResourceModule (string name)
public ModuleDefinition GetResourceModule (string name)
{
return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, typeof (BaseTestFixture).Assembly));
return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, GetType ().Assembly));
}
public static ModuleDefinition GetResourceModule (string name, ReaderParameters parameters)
public ModuleDefinition GetResourceModule (string name, ReaderParameters parameters)
{
return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, typeof (BaseTestFixture).Assembly), parameters);
return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, GetType ().Assembly), parameters);
}
public static ModuleDefinition GetResourceModule (string name, ReadingMode mode)
public ModuleDefinition GetResourceModule (string name, ReadingMode mode)
{
return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, typeof (BaseTestFixture).Assembly), new ReaderParameters (mode));
return ModuleDefinition.ReadModule (GetAssemblyResourcePath (name, GetType ().Assembly), new ReaderParameters (mode));
}
internal static Image GetResourceImage (string name)
internal Image GetResourceImage (string name)
{
using (var fs = new FileStream (GetAssemblyResourcePath (name, typeof (BaseTestFixture).Assembly), FileMode.Open, FileAccess.Read))
return ImageReader.ReadImageFrom (fs);
var file = new FileStream (GetAssemblyResourcePath (name, GetType ().Assembly), FileMode.Open, FileAccess.Read);
return ImageReader.ReadImage (Disposable.Owned (file as Stream), file.Name);
}
public static ModuleDefinition GetCurrentModule ()
public ModuleDefinition GetCurrentModule ()
{
return ModuleDefinition.ReadModule (typeof (BaseTestFixture).Module.FullyQualifiedName);
return ModuleDefinition.ReadModule (GetType ().Module.FullyQualifiedName);
}
public static ModuleDefinition GetCurrentModule (ReaderParameters parameters)
public ModuleDefinition GetCurrentModule (ReaderParameters parameters)
{
return ModuleDefinition.ReadModule (typeof (BaseTestFixture).Module.FullyQualifiedName, parameters);
return ModuleDefinition.ReadModule (GetType ().Module.FullyQualifiedName, parameters);
}
public static string FindResourcesDirectory (Assembly assembly)
@@ -72,5 +78,250 @@ namespace Mono.Cecil.Tests {
return Path.Combine (path, "Resources");
}
public static void AssertCode (string expected, MethodDefinition method)
{
Assert.IsTrue (method.HasBody);
Assert.IsNotNull (method.Body);
Assert.AreEqual (Normalize (expected), Normalize (Formatter.FormatMethodBody (method)));
}
static string Normalize (string str)
{
return str.Trim ().Replace ("\r\n", "\n");
}
public static void TestModule (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false)
{
Run (new ModuleTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections));
}
public static void TestCSharp (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false)
{
Run (new CSharpTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections));
}
public static void TestIL (string file, Action<ModuleDefinition> test, bool verify = true, bool readOnly = false, Type symbolReaderProvider = null, Type symbolWriterProvider = null, IAssemblyResolver assemblyResolver = null, bool applyWindowsRuntimeProjections = false)
{
Run (new ILTestCase (file, test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections));
}
static void Run (TestCase testCase)
{
using (var runner = new TestRunner (testCase, TestCaseType.ReadDeferred))
runner.RunTest ();
using (var runner = new TestRunner (testCase, TestCaseType.ReadImmediate))
runner.RunTest ();
if (testCase.ReadOnly)
return;
using (var runner = new TestRunner (testCase, TestCaseType.WriteFromDeferred))
runner.RunTest ();
using (var runner = new TestRunner (testCase, TestCaseType.WriteFromImmediate))
runner.RunTest ();
}
}
abstract class TestCase {
public readonly bool Verify;
public readonly bool ReadOnly;
public readonly Type SymbolReaderProvider;
public readonly Type SymbolWriterProvider;
public readonly IAssemblyResolver AssemblyResolver;
public readonly Action<ModuleDefinition> Test;
public readonly bool ApplyWindowsRuntimeProjections;
public abstract string ModuleLocation { get; }
protected Assembly Assembly { get { return Test.Method.Module.Assembly; } }
protected TestCase (Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections)
{
Test = test;
Verify = verify;
ReadOnly = readOnly;
SymbolReaderProvider = symbolReaderProvider;
SymbolWriterProvider = symbolWriterProvider;
AssemblyResolver = assemblyResolver;
ApplyWindowsRuntimeProjections = applyWindowsRuntimeProjections;
}
}
class ModuleTestCase : TestCase {
public readonly string Module;
public ModuleTestCase (string module, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections)
: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections)
{
Module = module;
}
public override string ModuleLocation
{
get { return BaseTestFixture.GetAssemblyResourcePath (Module, Assembly); }
}
}
class CSharpTestCase : TestCase {
public readonly string File;
public CSharpTestCase (string file, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections)
: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections)
{
File = file;
}
public override string ModuleLocation
{
get
{
return CompilationService.CompileResource (BaseTestFixture.GetCSharpResourcePath (File, Assembly));
}
}
}
class ILTestCase : TestCase {
public readonly string File;
public ILTestCase (string file, Action<ModuleDefinition> test, bool verify, bool readOnly, Type symbolReaderProvider, Type symbolWriterProvider, IAssemblyResolver assemblyResolver, bool applyWindowsRuntimeProjections)
: base (test, verify, readOnly, symbolReaderProvider, symbolWriterProvider, assemblyResolver, applyWindowsRuntimeProjections)
{
File = file;
}
public override string ModuleLocation
{
get
{
return CompilationService.CompileResource (BaseTestFixture.GetILResourcePath (File, Assembly)); ;
}
}
}
class TestRunner : IDisposable {
readonly TestCase test_case;
readonly TestCaseType type;
ModuleDefinition test_module;
DefaultAssemblyResolver test_resolver;
public TestRunner (TestCase testCase, TestCaseType type)
{
this.test_case = testCase;
this.type = type;
}
ModuleDefinition GetModule ()
{
var location = test_case.ModuleLocation;
var parameters = new ReaderParameters {
SymbolReaderProvider = GetSymbolReaderProvider (),
AssemblyResolver = GetAssemblyResolver (),
ApplyWindowsRuntimeProjections = test_case.ApplyWindowsRuntimeProjections
};
switch (type) {
case TestCaseType.ReadImmediate:
parameters.ReadingMode = ReadingMode.Immediate;
return ModuleDefinition.ReadModule (location, parameters);
case TestCaseType.ReadDeferred:
parameters.ReadingMode = ReadingMode.Deferred;
return ModuleDefinition.ReadModule (location, parameters);
case TestCaseType.WriteFromImmediate:
parameters.ReadingMode = ReadingMode.Immediate;
return RoundTrip (location, parameters, "cecil-irt");
case TestCaseType.WriteFromDeferred:
parameters.ReadingMode = ReadingMode.Deferred;
return RoundTrip (location, parameters, "cecil-drt");
default:
return null;
}
}
ISymbolReaderProvider GetSymbolReaderProvider ()
{
if (test_case.SymbolReaderProvider == null)
return null;
return (ISymbolReaderProvider) Activator.CreateInstance (test_case.SymbolReaderProvider);
}
ISymbolWriterProvider GetSymbolWriterProvider ()
{
if (test_case.SymbolReaderProvider == null)
return null;
return (ISymbolWriterProvider) Activator.CreateInstance (test_case.SymbolWriterProvider);
}
IAssemblyResolver GetAssemblyResolver ()
{
if (test_case.AssemblyResolver != null)
return test_case.AssemblyResolver;
test_resolver = new DefaultAssemblyResolver ();
var directory = Path.GetDirectoryName (test_case.ModuleLocation);
test_resolver.AddSearchDirectory (directory);
return test_resolver;
}
ModuleDefinition RoundTrip (string location, ReaderParameters reader_parameters, string folder)
{
var rt_folder = Path.Combine (Path.GetTempPath (), folder);
if (!Directory.Exists (rt_folder))
Directory.CreateDirectory (rt_folder);
var rt_module = Path.Combine (rt_folder, Path.GetFileName (location));
using (var module = ModuleDefinition.ReadModule (location, reader_parameters)) {
var writer_parameters = new WriterParameters {
SymbolWriterProvider = GetSymbolWriterProvider (),
};
test_case.Test (module);
module.Write (rt_module, writer_parameters);
}
if (test_case.Verify)
CompilationService.Verify (rt_module);
return ModuleDefinition.ReadModule (rt_module, reader_parameters);
}
public void RunTest ()
{
var module = GetModule ();
if (module == null)
return;
test_module = module;
test_case.Test (module);
}
public void Dispose ()
{
if (test_module != null)
test_module.Dispose ();
if (test_resolver != null)
test_resolver.Dispose ();
}
}
enum TestCaseType {
ReadImmediate,
ReadDeferred,
WriteFromImmediate,
WriteFromDeferred,
}
}

48
external/cecil/Test/Mono.Cecil.Tests/CompilationService.cs vendored
View File

@@ -20,6 +20,11 @@ namespace Mono.Cecil.Tests {
}
}
public static class Platform {
public static bool OnMono { get { return typeof (object).Assembly.GetType ("Mono.Runtime") != null; } }
}
abstract class CompilationService {
Dictionary<string, CompilationResult> files = new Dictionary<string, CompilationResult> ();
@@ -77,11 +82,9 @@ namespace Mono.Cecil.Tests {
return Path.Combine (tmp_cecil, Path.GetFileName (file_name) + ".dll");
}
static bool OnMono { get { return typeof (object).Assembly.GetType ("Mono.Runtime") != null; } }
public static void Verify (string name)
{
var output = OnMono ? ShellService.PEDump (name) : ShellService.PEVerify (name);
var output = Platform.OnMono ? ShellService.PEDump (name) : ShellService.PEVerify (name);
if (output.ExitCode != 0)
Assert.Fail (output.ToString ());
}
@@ -216,7 +219,11 @@ namespace Mono.Cecil.Tests {
public static ProcessOutput ILAsm (string source, string output)
{
return RunProcess ("ilasm", "/nologo", "/dll", "/out:" + Quote (output), Quote (source));
var ilasm = "ilasm";
if (!Platform.OnMono)
ilasm = NetFrameworkTool ("ilasm");
return RunProcess (ilasm, "/nologo", "/dll", "/out:" + Quote (output), Quote (source));
}
static string Quote (string file)
@@ -226,12 +233,43 @@ namespace Mono.Cecil.Tests {
public static ProcessOutput PEVerify (string source)
{
return RunProcess ("peverify", "/nologo", Quote (source));
return RunProcess (WinSdkTool ("peverify"), "/nologo", Quote (source));
}
public static ProcessOutput PEDump (string source)
{
return RunProcess ("pedump", "--verify code,metadata", Quote (source));
}
static string NetFrameworkTool (string tool)
{
return Path.Combine (
Path.GetDirectoryName (typeof (object).Assembly.Location),
tool + ".exe");
}
static string WinSdkTool (string tool)
{
var sdks = new [] {
@"Microsoft SDKs\Windows\v8.1A\bin\NETFX 4.5.1 Tools",
@"Microsoft SDKs\Windows\v8.0A\bin\NETFX 4.0 Tools",
@"Microsoft SDKs\Windows\v7.0A\Bin",
};
foreach (var sdk in sdks) {
var pgf = IntPtr.Size == 8
? Environment.GetEnvironmentVariable("ProgramFiles(x86)")
: Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
var exe = Path.Combine (
Path.Combine (pgf, sdk),
tool + ".exe");
if (File.Exists(exe))
return exe;
}
return tool;
}
}
}

493
external/cecil/Test/Mono.Cecil.Tests/CustomAttributesTests.cs vendored
View File

File diff suppressed because it is too large Load Diff

77
external/cecil/Test/Mono.Cecil.Tests/EventTests.cs vendored
View File

@@ -10,57 +10,70 @@ namespace Mono.Cecil.Tests {
[TestFixture]
public class EventTests : BaseTestFixture {
[TestCSharp ("Events.cs")]
public void AbstractMethod (ModuleDefinition module)
[Test]
public void AbstractMethod ()
{
var type = module.GetType ("Foo");
TestCSharp ("Events.cs", module => {
var type = module.GetType ("Foo");
Assert.IsTrue (type.HasEvents);
Assert.IsTrue (type.HasEvents);
var events = type.Events;
var events = type.Events;
Assert.AreEqual (1, events.Count);
Assert.AreEqual (1, events.Count);
var @event = events [0];
var @event = events [0];
Assert.IsNotNull (@event);
Assert.AreEqual ("Bar", @event.Name);
Assert.IsNotNull (@event.EventType);
Assert.AreEqual ("Pan", @event.EventType.FullName);
Assert.IsNotNull (@event);
Assert.AreEqual ("Bar", @event.Name);
Assert.IsNotNull (@event.EventType);
Assert.AreEqual ("Pan", @event.EventType.FullName);
Assert.IsNotNull (@event.AddMethod);
Assert.AreEqual (MethodSemanticsAttributes.AddOn, @event.AddMethod.SemanticsAttributes);
Assert.IsNotNull (@event.RemoveMethod);
Assert.AreEqual (MethodSemanticsAttributes.RemoveOn, @event.RemoveMethod.SemanticsAttributes);
Assert.IsNotNull (@event.AddMethod);
Assert.AreEqual (MethodSemanticsAttributes.AddOn, @event.AddMethod.SemanticsAttributes);
Assert.IsNotNull (@event.RemoveMethod);
Assert.AreEqual (MethodSemanticsAttributes.RemoveOn, @event.RemoveMethod.SemanticsAttributes);
});
}
[TestIL ("others.il")]
public void OtherMethod (ModuleDefinition module)
[Test]
public void OtherMethod ()
{
var type = module.GetType ("Others");
TestIL ("others.il", module => {
var type = module.GetType ("Others");
Assert.IsTrue (type.HasEvents);
Assert.IsTrue (type.HasEvents);
var events = type.Events;
var events = type.Events;
Assert.AreEqual (1, events.Count);
Assert.AreEqual (1, events.Count);
var @event = events [0];
var @event = events [0];
Assert.IsNotNull (@event);
Assert.AreEqual ("Handler", @event.Name);
Assert.IsNotNull (@event.EventType);
Assert.AreEqual ("System.EventHandler", @event.EventType.FullName);
Assert.IsNotNull (@event);
Assert.AreEqual ("Handler", @event.Name);
Assert.IsNotNull (@event.EventType);
Assert.AreEqual ("System.EventHandler", @event.EventType.FullName);
Assert.IsTrue (@event.HasOtherMethods);
Assert.IsTrue (@event.HasOtherMethods);
Assert.AreEqual (2, @event.OtherMethods.Count);
Assert.AreEqual (2, @event.OtherMethods.Count);
var other = @event.OtherMethods [0];
Assert.AreEqual ("dang_Handler", other.Name);
var other = @event.OtherMethods [0];
Assert.AreEqual ("dang_Handler", other.Name);
other = @event.OtherMethods [1];
Assert.AreEqual ("fang_Handler", other.Name);
other = @event.OtherMethods [1];
Assert.AreEqual ("fang_Handler", other.Name);
});
}
[Test]
public void UnattachedEvent ()
{
var int32 = typeof (int).ToDefinition ();
var evt = new EventDefinition ("Event", EventAttributes.None, int32);
Assert.AreEqual (null, evt.AddMethod);
}
}
}

3
external/cecil/Test/Mono.Cecil.Tests/Extensions.cs vendored
View File

@@ -1,4 +1,5 @@
using System;
using System.IO;
using System.Linq;
using SR = System.Reflection;
@@ -20,7 +21,7 @@ namespace Mono.Cecil.Tests {
public static TypeDefinition ToDefinition (this Type self)
{
var module = ModuleDefinition.ReadModule (self.Module.FullyQualifiedName);
var module = ModuleDefinition.ReadModule (new MemoryStream (File.ReadAllBytes (self.Module.FullyQualifiedName)));
return (TypeDefinition) module.LookupToken (self.MetadataToken);
}

635
external/cecil/Test/Mono.Cecil.Tests/FieldTests.cs vendored
View File

File diff suppressed because it is too large Load Diff

13
external/cecil/Test/Mono.Cecil.Tests/Formatter.cs vendored
View File

@@ -28,7 +28,7 @@ namespace Mono.Cecil.Tests {
WriteVariables (writer, body);
foreach (Instruction instruction in body.Instructions) {
var sequence_point = instruction.SequencePoint;
var sequence_point = body.Method.DebugInformation.GetSequencePoint (instruction);
if (sequence_point != null) {
writer.Write ('\t');
WriteSequencePoint (writer, sequence_point);
@@ -56,11 +56,20 @@ namespace Mono.Cecil.Tests {
var variable = variables [i];
writer.Write ("{0} {1}", variable.VariableType, variable);
writer.Write ("{0} {1}", variable.VariableType, GetVariableName (variable, body));
}
writer.WriteLine (")");
}
static string GetVariableName (VariableDefinition variable, MethodBody body)
{
string name;
if (body.Method.DebugInformation.TryGetName (variable, out name))
return name;
return variable.ToString ();
}
static void WriteInstruction (TextWriter writer, Instruction instruction)
{
writer.Write (FormatLabel (instruction.Offset));

187
external/cecil/Test/Mono.Cecil.Tests/ImageReadTests.cs vendored
View File

@@ -15,130 +15,169 @@ namespace Mono.Cecil.Tests {
[Test]
public void ImageSections ()
{
var image = GetResourceImage ("hello.exe");
Assert.AreEqual (3, image.Sections.Length);
Assert.AreEqual (".text", image.Sections [0].Name);
Assert.AreEqual (".rsrc", image.Sections [1].Name);
Assert.AreEqual (".reloc", image.Sections [2].Name);
using (var image = GetResourceImage ("hello.exe")) {
Assert.AreEqual (3, image.Sections.Length);
Assert.AreEqual (".text", image.Sections [0].Name);
Assert.AreEqual (".rsrc", image.Sections [1].Name);
Assert.AreEqual (".reloc", image.Sections [2].Name);
}
}
[Test]
public void ImageMetadataVersion ()
{
var image = GetResourceImage ("hello.exe");
Assert.AreEqual (TargetRuntime.Net_2_0, image.Runtime);
using (var image = GetResourceImage ("hello.exe"))
Assert.AreEqual (TargetRuntime.Net_2_0, image.RuntimeVersion.ParseRuntime ());
image = GetResourceImage ("hello1.exe");
Assert.AreEqual (TargetRuntime.Net_1_1, image.Runtime);
using (var image = GetResourceImage ("hello1.exe"))
Assert.AreEqual (TargetRuntime.Net_1_1, image.RuntimeVersion.ParseRuntime ());
}
[Test]
public void ImageModuleKind ()
{
var image = GetResourceImage ("hello.exe");
Assert.AreEqual (ModuleKind.Console, image.Kind);
using (var image = GetResourceImage ("hello.exe"))
Assert.AreEqual (ModuleKind.Console, image.Kind);
image = GetResourceImage ("libhello.dll");
Assert.AreEqual (ModuleKind.Dll, image.Kind);
using (var image = GetResourceImage ("libhello.dll"))
Assert.AreEqual (ModuleKind.Dll, image.Kind);
image = GetResourceImage ("hellow.exe");
Assert.AreEqual (ModuleKind.Windows, image.Kind);
using (var image = GetResourceImage ("hellow.exe"))
Assert.AreEqual (ModuleKind.Windows, image.Kind);
}
[Test]
public void MetadataHeaps ()
{
var image = GetResourceImage ("hello.exe");
using (var image = GetResourceImage ("hello.exe")) {
Assert.IsNotNull (image.TableHeap);
Assert.IsNotNull (image.TableHeap);
Assert.IsNotNull (image.StringHeap);
Assert.AreEqual (string.Empty, image.StringHeap.Read (0));
Assert.AreEqual ("<Module>", image.StringHeap.Read (1));
Assert.IsNotNull (image.StringHeap);
Assert.AreEqual (string.Empty, image.StringHeap.Read (0));
Assert.AreEqual ("<Module>", image.StringHeap.Read (1));
Assert.IsNotNull (image.UserStringHeap);
Assert.AreEqual (string.Empty, image.UserStringHeap.Read (0));
Assert.AreEqual ("Hello Cecil World !", image.UserStringHeap.Read (1));
Assert.IsNotNull (image.UserStringHeap);
Assert.AreEqual (string.Empty, image.UserStringHeap.Read (0));
Assert.AreEqual ("Hello Cecil World !", image.UserStringHeap.Read (1));
Assert.IsNotNull (image.GuidHeap);
Assert.AreEqual (new Guid (), image.GuidHeap.Read (0));
Assert.AreEqual (new Guid ("C3BC2BD3-2576-4D00-A80E-465B5632415F"), image.GuidHeap.Read (1));
Assert.IsNotNull (image.GuidHeap);
Assert.AreEqual (new Guid (), image.GuidHeap.Read (0));
Assert.AreEqual (new Guid ("C3BC2BD3-2576-4D00-A80E-465B5632415F"), image.GuidHeap.Read (1));
Assert.IsNotNull (image.BlobHeap);
Assert.AreEqual (new byte [0], image.BlobHeap.Read (0));
Assert.IsNotNull (image.BlobHeap);
Assert.AreEqual (new byte [0], image.BlobHeap.Read (0));
}
}
[Test]
public void TablesHeap ()
{
var image = GetResourceImage ("hello.exe");
var heap = image.TableHeap;
using (var image = GetResourceImage ("hello.exe")) {
var heap = image.TableHeap;
Assert.IsNotNull (heap);
Assert.IsNotNull (heap);
Assert.AreEqual (1, heap [Table.Module].Length);
Assert.AreEqual (4, heap [Table.TypeRef].Length);
Assert.AreEqual (2, heap [Table.TypeDef].Length);
Assert.AreEqual (0, heap [Table.Field].Length);
Assert.AreEqual (2, heap [Table.Method].Length);
Assert.AreEqual (4, heap [Table.MemberRef].Length);
Assert.AreEqual (2, heap [Table.CustomAttribute].Length);
Assert.AreEqual (1, heap [Table.Assembly].Length);
Assert.AreEqual (1, heap [Table.AssemblyRef].Length);
Assert.AreEqual (1, heap [Table.Module].Length);
Assert.AreEqual (4, heap [Table.TypeRef].Length);
Assert.AreEqual (2, heap [Table.TypeDef].Length);
Assert.AreEqual (0, heap [Table.Field].Length);
Assert.AreEqual (2, heap [Table.Method].Length);
Assert.AreEqual (4, heap [Table.MemberRef].Length);
Assert.AreEqual (2, heap [Table.CustomAttribute].Length);
Assert.AreEqual (1, heap [Table.Assembly].Length);
Assert.AreEqual (1, heap [Table.AssemblyRef].Length);
}
}
[TestModule ("hello.x64.exe")]
public void X64Module (ModuleDefinition module)
[Test]
public void X64Module ()
{
Assert.AreEqual (TargetArchitecture.AMD64, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly, module.Image.Attributes);
TestModule ("hello.x64.exe", module => {
Assert.AreEqual (TargetArchitecture.AMD64, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly, module.Image.Attributes);
}, verify: !Platform.OnMono);
}
[TestModule ("hello.ia64.exe")]
public void IA64Module (ModuleDefinition module)
[Test]
public void X64ModuleTextOnlySection ()
{
Assert.AreEqual (TargetArchitecture.IA64, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly, module.Image.Attributes);
TestModule ("hello.textonly.x64.exe", module => {
Assert.AreEqual (TargetArchitecture.AMD64, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly, module.Image.Attributes);
}, verify: !Platform.OnMono);
}
[TestModule ("hello.x86.exe")]
public void X86Module (ModuleDefinition module)
[Test]
public void IA64Module ()
{
Assert.AreEqual (TargetArchitecture.I386, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly | ModuleAttributes.Required32Bit, module.Image.Attributes);
TestModule ("hello.ia64.exe", module => {
Assert.AreEqual (TargetArchitecture.IA64, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly, module.Image.Attributes);
}, verify: !Platform.OnMono);
}
[TestModule ("hello.anycpu.exe")]
public void AnyCpuModule (ModuleDefinition module)
[Test]
public void X86Module ()
{
Assert.AreEqual (TargetArchitecture.I386, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly, module.Image.Attributes);
TestModule ("hello.x86.exe", module => {
Assert.AreEqual (TargetArchitecture.I386, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly | ModuleAttributes.Required32Bit, module.Image.Attributes);
});
}
[TestModule ("delay-signed.dll")]
public void DelaySignedAssembly (ModuleDefinition module)
[Test]
public void AnyCpuModule ()
{
Assert.IsNotNull (module.Assembly.Name.PublicKey);
Assert.AreNotEqual (0, module.Assembly.Name.PublicKey.Length);
Assert.AreNotEqual (ModuleAttributes.StrongNameSigned, module.Attributes & ModuleAttributes.StrongNameSigned);
Assert.AreNotEqual (0, module.Image.StrongName.VirtualAddress);
Assert.AreNotEqual (0, module.Image.StrongName.Size);
TestModule ("hello.anycpu.exe", module => {
Assert.AreEqual (TargetArchitecture.I386, module.Image.Architecture);
Assert.AreEqual (ModuleAttributes.ILOnly, module.Image.Attributes);
});
}
[TestModule ("wp7.dll", Verify = false)]
public void WindowsPhoneNonSignedAssembly (ModuleDefinition module)
[Test]
public void DelaySignedAssembly ()
{
Assert.AreEqual (0, module.Assembly.Name.PublicKey.Length);
Assert.AreNotEqual (ModuleAttributes.StrongNameSigned, module.Attributes & ModuleAttributes.StrongNameSigned);
Assert.AreEqual (0, module.Image.StrongName.VirtualAddress);
Assert.AreEqual (0, module.Image.StrongName.Size);
TestModule ("delay-signed.dll", module => {
Assert.IsNotNull (module.Assembly.Name.PublicKey);
Assert.AreNotEqual (0, module.Assembly.Name.PublicKey.Length);
Assert.AreNotEqual (ModuleAttributes.StrongNameSigned, module.Attributes & ModuleAttributes.StrongNameSigned);
Assert.AreNotEqual (0, module.Image.StrongName.VirtualAddress);
Assert.AreNotEqual (0, module.Image.StrongName.Size);
});
}
[TestModule ("metro.exe", Verify = false)]
public void MetroAssembly (ModuleDefinition module)
[Test]
public void WindowsPhoneNonSignedAssembly ()
{
Assert.AreEqual (ModuleCharacteristics.AppContainer, module.Characteristics & ModuleCharacteristics.AppContainer);
TestModule ("wp7.dll", module => {
Assert.AreEqual (0, module.Assembly.Name.PublicKey.Length);
Assert.AreNotEqual (ModuleAttributes.StrongNameSigned, module.Attributes & ModuleAttributes.StrongNameSigned);
Assert.AreEqual (0, module.Image.StrongName.VirtualAddress);
Assert.AreEqual (0, module.Image.StrongName.Size);
}, verify: false);
}
[Test]
public void MetroAssembly ()
{
if (Platform.OnMono)
return;
TestModule ("metro.exe", module => {
Assert.AreEqual (ModuleCharacteristics.AppContainer, module.Characteristics & ModuleCharacteristics.AppContainer);
}, verify: false);
}
[Test]
public void WindowsRuntimeComponentAssembly ()
{
var resolver = WindowsRuntimeAssemblyResolver.CreateInstance ();
if (resolver == null)
return;
TestModule("winrtcomp.winmd", module => {
Assert.IsTrue (module.Assembly.Name.IsWindowsRuntime);
}, verify: false, assemblyResolver: resolver);
}
}
}

74
external/cecil/Test/Mono.Cecil.Tests/ImportCecilTests.cs vendored
View File

@@ -29,10 +29,10 @@ namespace Mono.Cecil.Tests {
type.Methods.Add (method_by_ref);
method_by_ref.MethodReturnType.ReturnType = module.Import (typeof (void).ToDefinition ());
method_by_ref.MethodReturnType.ReturnType = module.ImportReference (typeof (void).ToDefinition ());
method_by_ref.Parameters.Add (new ParameterDefinition (module.Import (typeof (string).ToDefinition ())));
method_by_ref.Parameters.Add (new ParameterDefinition (module.Import (new ByReferenceType (typeof (string).ToDefinition ()))));
method_by_ref.Parameters.Add (new ParameterDefinition (module.ImportReference (typeof (string).ToDefinition ())));
method_by_ref.Parameters.Add (new ParameterDefinition (module.ImportReference (new ByReferenceType (typeof (string).ToDefinition ()))));
var m_il = method_by_ref.Body.GetILProcessor ();
m_il.Emit (OpCodes.Ldarg_1);
@@ -40,7 +40,7 @@ namespace Mono.Cecil.Tests {
m_il.Emit (OpCodes.Stind_Ref);
m_il.Emit (OpCodes.Ret);
var v_0 = new VariableDefinition (module.Import (typeof (string).ToDefinition ()));
var v_0 = new VariableDefinition (module.ImportReference (typeof (string).ToDefinition ()));
body.Variables.Add (v_0);
var il = body.GetILProcessor ();
@@ -75,7 +75,7 @@ namespace Mono.Cecil.Tests {
{
var get_empty = Compile<Func<string>> ((module, body) => {
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldsfld, module.Import (typeof (string).GetField ("Empty").ToDefinition ()));
il.Emit (OpCodes.Ldsfld, module.ImportReference (typeof (string).GetField ("Empty").ToDefinition ()));
il.Emit (OpCodes.Ret);
});
@@ -89,7 +89,7 @@ namespace Mono.Cecil.Tests {
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldarg_1);
il.Emit (OpCodes.Call, module.Import (typeof (string).GetMethod ("Concat", new [] { typeof (string), typeof (string) }).ToDefinition ()));
il.Emit (OpCodes.Call, module.ImportReference (typeof (string).GetMethod ("Concat", new [] { typeof (string), typeof (string) }).ToDefinition ()));
il.Emit (OpCodes.Ret);
});
@@ -119,12 +119,12 @@ namespace Mono.Cecil.Tests {
public void ImportGenericField ()
{
var get_field = Compile<Func<Generic<string>, string>> ((module, body) => {
var generic_def = module.Import (typeof (Generic<>)).Resolve ();
var generic_def = module.ImportReference (typeof (Generic<>)).Resolve ();
var field_def = generic_def.Fields.Where (f => f.Name == "Field").First ();
var field_string = field_def.MakeGeneric (module.Import (typeof (string)));
var field_string = field_def.MakeGeneric (module.ImportReference (typeof (string)));
var field_ref = module.Import (field_string);
var field_ref = module.ImportReference (field_string);
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
@@ -143,11 +143,11 @@ namespace Mono.Cecil.Tests {
public void ImportGenericMethod ()
{
var generic_identity = Compile<Func<Generic<int>, int, int>> ((module, body) => {
var generic_def = module.Import (typeof (Generic<>)).Resolve ();
var generic_def = module.ImportReference (typeof (Generic<>)).Resolve ();
var method_def = generic_def.Methods.Where (m => m.Name == "Method").First ();
var method_int = method_def.MakeGeneric (module.Import (typeof (int)));
var method_ref = module.Import (method_int);
var method_int = method_def.MakeGeneric (module.ImportReference (typeof (int)));
var method_ref = module.ImportReference (method_int);
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
@@ -163,14 +163,14 @@ namespace Mono.Cecil.Tests {
public void ImportGenericMethodSpec ()
{
var gen_spec_id = Compile<Func<Generic<string>, int, int>> ((module, body) => {
var generic_def = module.Import (typeof (Generic<>)).Resolve ();
var generic_def = module.ImportReference (typeof (Generic<>)).Resolve ();
var method_def = generic_def.Methods.Where (m => m.Name == "GenericMethod").First ();
var method_string = method_def.MakeGeneric (module.Import (typeof (string)));
var method_string = method_def.MakeGeneric (module.ImportReference (typeof (string)));
var method_instance = method_string.MakeGenericMethod (module.Import (typeof (int)));
var method_instance = method_string.MakeGenericMethod (module.ImportReference (typeof (int)));
var method_ref = module.Import (method_instance);
var method_ref = module.ImportReference (method_instance);
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
@@ -187,16 +187,16 @@ namespace Mono.Cecil.Tests {
public void ImportComplexGenericMethodSpec ()
{
var gen_spec_id = Compile<Func<Generic<string>, int, int>> ((module, body) => {
var generic_def = module.Import (typeof (Generic<>)).Resolve ();
var generic_def = module.ImportReference (typeof (Generic<>)).Resolve ();
var method_def = generic_def.Methods.Where (m => m.Name == "ComplexGenericMethod").First ();
var method_string = method_def.MakeGeneric (module.Import (typeof (string)));
var method_instance = method_string.MakeGenericMethod (module.Import (typeof (int)));
var method_ref = module.Import (method_instance);
var method_string = method_def.MakeGeneric (module.ImportReference (typeof (string)));
var method_instance = method_string.MakeGenericMethod (module.ImportReference (typeof (int)));
var method_ref = module.ImportReference (method_instance);
var field_def = generic_def.Fields.Where (f => f.Name == "Field").First ();
var field_int = field_def.MakeGeneric (module.Import (typeof (int)));
var field_ref = module.Import (field_int);
var field_int = field_def.MakeGeneric (module.ImportReference (typeof (int)));
var field_ref = module.ImportReference (field_int);
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
@@ -214,11 +214,11 @@ namespace Mono.Cecil.Tests {
public void ImportMethodOnOpenGeneric ()
{
var generic = typeof (Generic<>).ToDefinition ();
var module = ModuleDefinition.CreateModule ("foo", ModuleKind.Dll);
var method = module.Import (generic.GetMethod ("Method"));
Assert.AreEqual ("T Mono.Cecil.Tests.ImportCecilTests/Generic`1::Method(T)", method.FullName);
using (var module = ModuleDefinition.CreateModule ("foo", ModuleKind.Dll)) {
var method = module.ImportReference (generic.GetMethod ("Method"));
Assert.AreEqual ("T Mono.Cecil.Tests.ImportCecilTests/Generic`1::Method(T)", method.FullName);
}
}
public class ContextGeneric1Method2<G1>
@@ -258,29 +258,29 @@ namespace Mono.Cecil.Tests {
// by mixing open generics with 2 & 1 parameters, we make sure the right context is used (because otherwise, an exception will be thrown)
var type = typeof (ContextGeneric1Method2<>).MakeGenericType (typeof (ContextGeneric2Method1<,>));
var meth = type.GetMethod ("GenericMethod");
var imported_type = module.Import (type);
var method = module.Import (meth, imported_type);
var imported_type = module.ImportReference (type);
var method = module.ImportReference (meth, imported_type);
Assert.AreEqual ("G1 Mono.Cecil.Tests.ImportCecilTests/ContextGeneric1Method2`1<Mono.Cecil.Tests.ImportCecilTests/ContextGeneric2Method1`2<G2,H2>>::GenericMethod<R1,S1>(R1,S1)", method.FullName);
// and the other way around
type = typeof (ContextGeneric2Method1<,>).MakeGenericType (typeof (ContextGeneric1Method2<>), typeof (IList<>));
meth = type.GetMethod ("GenericMethod");
imported_type = module.Import (type);
method = module.Import (meth, imported_type);
imported_type = module.ImportReference (type);
method = module.ImportReference (meth, imported_type);
Assert.AreEqual ("R2 Mono.Cecil.Tests.ImportCecilTests/ContextGeneric2Method1`2<Mono.Cecil.Tests.ImportCecilTests/ContextGeneric1Method2`1<G1>,System.Collections.Generic.IList`1<T>>::GenericMethod<R2>(G2,H2)", method.FullName);
// not sure about this one
type = typeof (NestedGenericsA<string>.NestedGenericsB<int>.NestedGenericsC<float>);
meth = type.GetMethod ("GenericMethod");
imported_type = module.Import (type);
method = module.Import (meth, imported_type);
imported_type = module.ImportReference (type);
method = module.ImportReference (meth, imported_type);
Assert.AreEqual ("A Mono.Cecil.Tests.ImportCecilTests/NestedGenericsA`1/NestedGenericsB`1/NestedGenericsC`1<System.String,System.Int32,System.Single>::GenericMethod(B,C)", method.FullName);
// We need both the method & type !
type = typeof (Generic<>).MakeGenericType (typeof (string));
meth = type.GetMethod ("ComplexGenericMethod");
imported_type = module.Import (type);
method = module.Import (meth, imported_type);
imported_type = module.ImportReference (type);
method = module.ImportReference (meth, imported_type);
Assert.AreEqual ("Mono.Cecil.Tests.ImportCecilTests/Generic`1<TS> Mono.Cecil.Tests.ImportCecilTests/Generic`1<System.String>::ComplexGenericMethod<TS>(T,TS)", method.FullName);
}
@@ -326,7 +326,7 @@ namespace Mono.Cecil.Tests {
"",
name,
TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Abstract,
module.Import (typeof (object)));
module.ImportReference (typeof (object)));
module.Types.Add (type);
@@ -349,10 +349,10 @@ namespace Mono.Cecil.Tests {
type.Methods.Add (method);
method.MethodReturnType.ReturnType = module.Import (pattern.ReturnType);
method.MethodReturnType.ReturnType = module.ImportReference (pattern.ReturnType);
foreach (var parameter_pattern in pattern.GetParameters ())
method.Parameters.Add (new ParameterDefinition (module.Import (parameter_pattern.ParameterType)));
method.Parameters.Add (new ParameterDefinition (module.ImportReference (parameter_pattern.ParameterType)));
return method;
}

122
external/cecil/Test/Mono.Cecil.Tests/ImportReflectionTests.cs vendored
View File

@@ -54,10 +54,10 @@ namespace Mono.Cecil.Tests {
type.Methods.Add (method_by_ref);
method_by_ref.MethodReturnType.ReturnType = module.Import (typeof (void));
method_by_ref.MethodReturnType.ReturnType = module.ImportReference (typeof (void));
method_by_ref.Parameters.Add (new ParameterDefinition (module.Import (typeof (string))));
method_by_ref.Parameters.Add (new ParameterDefinition (module.Import (typeof (string).MakeByRefType ())));
method_by_ref.Parameters.Add (new ParameterDefinition (module.ImportReference (typeof (string))));
method_by_ref.Parameters.Add (new ParameterDefinition (module.ImportReference (typeof (string).MakeByRefType ())));
var m_il = method_by_ref.Body.GetILProcessor ();
m_il.Emit (OpCodes.Ldarg_1);
@@ -65,7 +65,7 @@ namespace Mono.Cecil.Tests {
m_il.Emit (OpCodes.Stind_Ref);
m_il.Emit (OpCodes.Ret);
var v_0 = new VariableDefinition (module.Import (typeof (string)));
var v_0 = new VariableDefinition (module.ImportReference (typeof (string)));
body.Variables.Add (v_0);
var il = body.GetILProcessor ();
@@ -100,7 +100,7 @@ namespace Mono.Cecil.Tests {
{
var get_empty = Compile<Func<string>> ((module, body) => {
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldsfld, module.Import (typeof (string).GetField ("Empty")));
il.Emit (OpCodes.Ldsfld, module.ImportReference (typeof (string).GetField ("Empty")));
il.Emit (OpCodes.Ret);
});
@@ -114,13 +114,25 @@ namespace Mono.Cecil.Tests {
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldarg_1);
il.Emit (OpCodes.Call, module.Import (typeof (string).GetMethod ("Concat", new [] { typeof (string), typeof (string) })));
il.Emit (OpCodes.Call, module.ImportReference (typeof (string).GetMethod ("Concat", new [] { typeof (string), typeof (string) })));
il.Emit (OpCodes.Ret);
});
Assert.AreEqual ("FooBar", concat ("Foo", "Bar"));
}
[Test]
public void GeneratedAssemblyCulture ()
{
var id = Compile<Func<int, int>> ((module, body) => {
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ret);
});
Assert.AreEqual ("", id.Method.DeclaringType.Assembly.GetName ().CultureInfo.Name);
}
public class Generic<T> {
public T Field;
@@ -146,7 +158,7 @@ namespace Mono.Cecil.Tests {
var get_field = Compile<Func<Generic<string>, string>> ((module, body) => {
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldfld, module.Import (typeof (Generic<string>).GetField ("Field")));
il.Emit (OpCodes.Ldfld, module.ImportReference (typeof (Generic<string>).GetField ("Field")));
il.Emit (OpCodes.Ret);
});
@@ -164,7 +176,7 @@ namespace Mono.Cecil.Tests {
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldarg_1);
il.Emit (OpCodes.Callvirt, module.Import (typeof (Generic<int>).GetMethod ("Method")));
il.Emit (OpCodes.Callvirt, module.ImportReference (typeof (Generic<int>).GetMethod ("Method")));
il.Emit (OpCodes.Ret);
});
@@ -179,7 +191,7 @@ namespace Mono.Cecil.Tests {
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldnull);
il.Emit (OpCodes.Ldarg_1);
il.Emit (OpCodes.Callvirt, module.Import (typeof (Generic<string>).GetMethod ("GenericMethod").MakeGenericMethod (typeof (int))));
il.Emit (OpCodes.Callvirt, module.ImportReference (typeof (Generic<string>).GetMethod ("GenericMethod").MakeGenericMethod (typeof (int))));
il.Emit (OpCodes.Ret);
});
@@ -194,8 +206,8 @@ namespace Mono.Cecil.Tests {
il.Emit (OpCodes.Ldarg_0);
il.Emit (OpCodes.Ldnull);
il.Emit (OpCodes.Ldarg_1);
il.Emit (OpCodes.Callvirt, module.Import (typeof (Generic<string>).GetMethod ("ComplexGenericMethod").MakeGenericMethod (typeof (int))));
il.Emit (OpCodes.Ldfld, module.Import (typeof (Generic<string>).GetField ("Field")));
il.Emit (OpCodes.Callvirt, module.ImportReference (typeof (Generic<string>).GetMethod ("ComplexGenericMethod").MakeGenericMethod (typeof (int))));
il.Emit (OpCodes.Ldfld, module.ImportReference (typeof (Generic<int>).GetField ("Field")));
il.Emit (OpCodes.Ret);
});
@@ -209,13 +221,13 @@ namespace Mono.Cecil.Tests {
[Test]
public void ImportGenericTypeDefOrOpen ()
{
var module = typeof (Foo<>).ToDefinition ().Module;
using (var module = typeof (Foo<>).ToDefinition ().Module) {
var foo_def = module.ImportReference (typeof (Foo<>));
var foo_open = module.ImportReference (typeof (Foo<>), foo_def);
var foo_def = module.Import (typeof (Foo<>));
var foo_open = module.Import (typeof (Foo<>), foo_def);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1", foo_def.FullName);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>", foo_open.FullName);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1", foo_def.FullName);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>", foo_open.FullName);
}
}
[Test]
@@ -225,12 +237,12 @@ namespace Mono.Cecil.Tests {
var generic_list_foo_open = typeof (Generic<>).MakeGenericType (list_foo);
var foo_def = typeof (Foo<>).ToDefinition ();
var module = foo_def.Module;
using (var module = foo_def.Module) {
var generic_foo = module.ImportReference (generic_list_foo_open, foo_def);
var generic_foo = module.Import (generic_list_foo_open, foo_def);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>",
generic_foo.FullName);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>",
generic_foo.FullName);
}
}
[Test]
@@ -240,12 +252,12 @@ namespace Mono.Cecil.Tests {
var generic_foo_open = typeof (Generic<>).MakeGenericType (foo_open);
var foo_def = typeof (Foo<>).ToDefinition ();
var module = foo_def.Module;
using (var module = foo_def.Module) {
var generic_foo = module.ImportReference (generic_foo_open, foo_def);
var generic_foo = module.Import (generic_foo_open, foo_def);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Generic`1<Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>>",
generic_foo.FullName);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Generic`1<Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>>",
generic_foo.FullName);
}
}
[Test]
@@ -255,12 +267,12 @@ namespace Mono.Cecil.Tests {
var foo_open_array = foo_open.MakeArrayType ();
var foo_def = typeof (Foo<>).ToDefinition ();
var module = foo_def.Module;
using (var module = foo_def.Module) {
var array_foo = module.ImportReference (foo_open_array, foo_def);
var array_foo = module.Import (foo_open_array, foo_def);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>[]",
array_foo.FullName);
Assert.AreEqual ("Mono.Cecil.Tests.ImportReflectionTests/Foo`1<TFoo>[]",
array_foo.FullName);
}
}
[Test]
@@ -271,12 +283,12 @@ namespace Mono.Cecil.Tests {
var generic_list_foo_open_field = generic_list_foo_open.GetField ("Field");
var foo_def = typeof (Foo<>).ToDefinition ();
var module = foo_def.Module;
using (var module = foo_def.Module) {
var generic_field = module.ImportReference (generic_list_foo_open_field, foo_def);
var generic_field = module.Import (generic_list_foo_open_field, foo_def);
Assert.AreEqual ("T Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>::Field",
generic_field.FullName);
Assert.AreEqual ("T Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>::Field",
generic_field.FullName);
}
}
[Test]
@@ -287,36 +299,36 @@ namespace Mono.Cecil.Tests {
var generic_list_foo_open_method = generic_list_foo_open.GetMethod ("Method");
var foo_def = typeof (Foo<>).ToDefinition ();
var module = foo_def.Module;
using (var module = foo_def.Module) {
var generic_method = module.ImportReference (generic_list_foo_open_method, foo_def);
var generic_method = module.Import (generic_list_foo_open_method, foo_def);
Assert.AreEqual ("T Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>::Method(T)",
generic_method.FullName);
Assert.AreEqual ("T Mono.Cecil.Tests.ImportReflectionTests/Generic`1<System.Collections.Generic.List`1<TFoo>>::Method(T)",
generic_method.FullName);
}
}
[Test]
public void ImportMethodOnOpenGenericType ()
{
var module = typeof (Generic<>).ToDefinition ().Module;
using (var module = typeof (Generic<>).ToDefinition ().Module) {
var method = module.ImportReference (typeof (Generic<>).GetMethod ("Method"));
var method = module.Import (typeof (Generic<>).GetMethod ("Method"));
Assert.AreEqual ("T Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::Method(T)", method.FullName);
Assert.AreEqual ("T Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::Method(T)", method.FullName);
}
}
[Test]
public void ImportGenericMethodOnOpenGenericType ()
{
var module = typeof (Generic<>).ToDefinition ().Module;
using (var module = typeof (Generic<>).ToDefinition ().Module) {
var generic_method = module.ImportReference (typeof (Generic<>).GetMethod ("GenericMethod"));
var generic_method = module.Import (typeof (Generic<>).GetMethod ("GenericMethod"));
Assert.AreEqual ("TS Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::GenericMethod(T,TS)", generic_method.FullName);
Assert.AreEqual ("TS Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::GenericMethod(T,TS)", generic_method.FullName);
generic_method = module.ImportReference (typeof (Generic<>).GetMethod ("GenericMethod"), generic_method);
generic_method = module.Import (typeof (Generic<>).GetMethod ("GenericMethod"), generic_method);
Assert.AreEqual ("TS Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::GenericMethod<TS>(T,TS)", generic_method.FullName);
Assert.AreEqual ("TS Mono.Cecil.Tests.ImportReflectionTests/Generic`1<T>::GenericMethod<TS>(T,TS)", generic_method.FullName);
}
}
delegate void Emitter (ModuleDefinition module, MethodBody body);
@@ -361,7 +373,7 @@ namespace Mono.Cecil.Tests {
"",
name,
TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Abstract,
module.Import (typeof (object)));
module.ImportReference (typeof (object)));
module.Types.Add (type);
@@ -384,10 +396,10 @@ namespace Mono.Cecil.Tests {
type.Methods.Add (method);
method.MethodReturnType.ReturnType = module.Import (pattern.ReturnType);
method.MethodReturnType.ReturnType = module.ImportReference (pattern.ReturnType);
foreach (var parameter_pattern in pattern.GetParameters ())
method.Parameters.Add (new ParameterDefinition (module.Import (parameter_pattern.ParameterType)));
method.Parameters.Add (new ParameterDefinition (module.ImportReference (parameter_pattern.ParameterType)));
return method;
}

47
external/cecil/Test/Mono.Cecil.Tests/Linq.cs vendored
View File

@@ -1,47 +0,0 @@
using System;
using System.Collections.Generic;
using Mono;
#if !NET_3_5 && !NET_4_0
namespace System.Linq {
static class Enumerable {
public static IEnumerable<TRet> Select<TItem, TRet> (this IEnumerable<TItem> self, Func<TItem, TRet> selector)
{
foreach (var item in self)
yield return selector (item);
}
public static IEnumerable<T> Where<T> (this IEnumerable<T> self, Func<T, bool> predicate)
{
foreach (var item in self)
if (predicate (item))
yield return item;
}
public static List<T> ToList<T> (this IEnumerable<T> self)
{
return new List<T> (self);
}
public static T [] ToArray<T> (this IEnumerable<T> self)
{
return self.ToList ().ToArray ();
}
public static T First<T> (this IEnumerable<T> self)
{
using (var enumerator = self.GetEnumerator ()) {
if (!enumerator.MoveNext ())
throw new InvalidOperationException ();
return enumerator.Current;
}
}
}
}
#endif

192
external/cecil/Test/Mono.Cecil.Tests/MethodBodyTests.cs vendored
View File

@@ -11,17 +11,18 @@ namespace Mono.Cecil.Tests {
[TestFixture]
public class MethodBodyTests : BaseTestFixture {
[TestIL ("hello.il")]
public void MultiplyMethod (ModuleDefinition module)
[Test]
public void MultiplyMethod ()
{
var foo = module.GetType ("Foo");
Assert.IsNotNull (foo);
TestIL ("hello.il", module => {
var foo = module.GetType ("Foo");
Assert.IsNotNull (foo);
var bar = foo.GetMethod ("Bar");
Assert.IsNotNull (bar);
Assert.IsTrue (bar.IsIL);
var bar = foo.GetMethod ("Bar");
Assert.IsNotNull (bar);
Assert.IsTrue (bar.IsIL);
AssertCode (@"
AssertCode (@"
.locals init (System.Int32 V_0)
IL_0000: ldarg.0
IL_0001: ldarg.1
@@ -31,35 +32,39 @@ namespace Mono.Cecil.Tests {
IL_0005: call System.Void Foo::Baz(System.Int32)
IL_000a: ret
", bar);
});
}
[TestIL ("hello.il")]
public void PrintStringEmpty (ModuleDefinition module)
[Test]
public void PrintStringEmpty ()
{
var foo = module.GetType ("Foo");
Assert.IsNotNull (foo);
TestIL ("hello.il", module => {
var foo = module.GetType ("Foo");
Assert.IsNotNull (foo);
var print_empty = foo.GetMethod ("PrintEmpty");
Assert.IsNotNull (print_empty);
var print_empty = foo.GetMethod ("PrintEmpty");
Assert.IsNotNull (print_empty);
AssertCode (@"
AssertCode (@"
.locals ()
IL_0000: ldsfld System.String System.String::Empty
IL_0005: call System.Void System.Console::WriteLine(System.String)
IL_000a: ret
", print_empty);
});
}
[TestModule ("libhello.dll")]
public void Branch (ModuleDefinition module)
[Test]
public void Branch ()
{
var lib = module.GetType ("Library");
Assert.IsNotNull (lib);
TestModule ("libhello.dll", module => {
var lib = module.GetType ("Library");
Assert.IsNotNull (lib);
var method = lib.GetMethod ("GetHelloString");
Assert.IsNotNull (method);
var method = lib.GetMethod ("GetHelloString");
Assert.IsNotNull (method);
AssertCode (@"
AssertCode (@"
.locals init (System.String V_0)
IL_0000: nop
IL_0001: ldstr ""hello world of tomorrow""
@@ -68,18 +73,20 @@ namespace Mono.Cecil.Tests {
IL_0009: ldloc.0
IL_000a: ret
", method);
});
}
[TestModule ("switch.exe")]
public void Switch (ModuleDefinition module)
[Test]
public void Switch ()
{
var program = module.GetType ("Program");
Assert.IsNotNull (program);
TestModule ("switch.exe", module => {
var program = module.GetType ("Program");
Assert.IsNotNull (program);
var method = program.GetMethod ("Main");
Assert.IsNotNull (method);
var method = program.GetMethod ("Main");
Assert.IsNotNull (method);
AssertCode (@"
AssertCode (@"
.locals init (System.Int32 V_0)
IL_0000: ldarg.0
IL_0001: ldlen
@@ -112,32 +119,36 @@ namespace Mono.Cecil.Tests {
IL_0038: ldc.i4.s 42
IL_003a: ret
", method);
});
}
[TestIL ("methodspecs.il")]
public void MethodSpec (ModuleDefinition module)
[Test]
public void MethodSpec ()
{
var tamtam = module.GetType ("Tamtam");
TestIL ("methodspecs.il", module => {
var tamtam = module.GetType ("Tamtam");
var bar = tamtam.GetMethod ("Bar");
Assert.IsNotNull (bar);
var bar = tamtam.GetMethod ("Bar");
Assert.IsNotNull (bar);
AssertCode (@"
AssertCode (@"
.locals ()
IL_0000: ldc.i4.2
IL_0001: call System.Void Tamtam::Foo<System.Int32>(TFoo)
IL_0006: ret
", bar);
});
}
[TestModule ("catch.exe")]
public void NestedTryCatchFinally (ModuleDefinition module)
[Test]
public void NestedTryCatchFinally ()
{
var program = module.GetType ("Program");
var main = program.GetMethod ("Main");
Assert.IsNotNull (main);
TestModule ("catch.exe", module => {
var program = module.GetType ("Program");
var main = program.GetMethod ("Main");
Assert.IsNotNull (main);
AssertCode (@"
AssertCode (@"
.locals ()
IL_0000: call System.Void Program::Foo()
IL_0005: leave.s IL_000d
@@ -159,16 +170,18 @@ namespace Mono.Cecil.Tests {
.try IL_0000 to IL_000f catch System.Exception handler IL_0017 to IL_001f
.try IL_0000 to IL_0021 finally handler IL_0021 to IL_0027
", main);
});
}
[TestModule ("fptr.exe", Verify = false)]
public void FunctionPointersAndCallSites (ModuleDefinition module)
[Test]
public void FunctionPointersAndCallSites ()
{
var type = module.Types [0];
var start = type.GetMethod ("Start");
Assert.IsNotNull (start);
TestModule ("fptr.exe", module => {
var type = module.Types [0];
var start = type.GetMethod ("Start");
Assert.IsNotNull (start);
AssertCode (@"
AssertCode (@"
.locals init ()
IL_0000: ldc.i4.1
IL_0001: call method System.Int32 *(System.Int32) MakeDecision::Decide()
@@ -184,25 +197,28 @@ namespace Mono.Cecil.Tests {
IL_002b: call System.Void System.Console::WriteLine(System.Int32)
IL_0030: ret
", start);
}, verify: false);
}
[TestIL ("hello.il")]
public void ThisParameter (ModuleDefinition module)
[Test]
public void ThisParameter ()
{
var type = module.GetType ("Foo");
var method = type.GetMethod ("Gazonk");
TestIL ("hello.il", module => {
var type = module.GetType ("Foo");
var method = type.GetMethod ("Gazonk");
Assert.IsNotNull (method);
Assert.IsNotNull (method);
AssertCode (@"
AssertCode (@"
.locals ()
IL_0000: ldarg 0
IL_0004: pop
IL_0005: ret
", method);
Assert.AreEqual (method.Body.ThisParameter.ParameterType, type);
Assert.AreEqual (method.Body.ThisParameter, method.Body.Instructions [0].Operand);
Assert.AreEqual (method.Body.ThisParameter.ParameterType, type);
Assert.AreEqual (method.Body.ThisParameter, method.Body.Instructions [0].Operand);
});
}
[Test]
@@ -220,9 +236,9 @@ namespace Mono.Cecil.Tests {
Assert.IsNotNull (int_to_string);
var this_parameter_type = int_to_string.Body.ThisParameter.ParameterType;
Assert.IsTrue (this_parameter_type.IsPointer);
Assert.IsTrue (this_parameter_type.IsByReference);
var element_type = ((PointerType) this_parameter_type).ElementType;
var element_type = ((ByReferenceType) this_parameter_type).ElementType;
Assert.AreEqual (int32, element_type);
}
@@ -234,9 +250,9 @@ namespace Mono.Cecil.Tests {
Assert.IsNotNull (token_to_string);
var this_parameter_type = token_to_string.Body.ThisParameter.ParameterType;
Assert.IsTrue (this_parameter_type.IsPointer);
Assert.IsTrue (this_parameter_type.IsByReference);
var element_type = ((PointerType) this_parameter_type).ElementType;
var element_type = ((ByReferenceType) this_parameter_type).ElementType;
Assert.AreEqual (token, element_type);
}
@@ -253,45 +269,51 @@ namespace Mono.Cecil.Tests {
Assert.IsFalse (type.IsPointer);
}
[TestIL ("hello.il")]
public void FilterMaxStack (ModuleDefinition module)
[Test]
public void FilterMaxStack ()
{
var type = module.GetType ("Foo");
var method = type.GetMethod ("TestFilter");
TestIL ("hello.il", module => {
var type = module.GetType ("Foo");
var method = type.GetMethod ("TestFilter");
Assert.IsNotNull (method);
Assert.AreEqual (2, method.Body.MaxStackSize);
Assert.IsNotNull (method);
Assert.AreEqual (2, method.Body.MaxStackSize);
});
}
[TestModule ("iterator.exe")]
public void Iterator (ModuleDefinition module)
[Test]
public void Iterator ()
{
var method = module.GetType ("Program").GetMethod ("GetLittleArgs");
Assert.IsNotNull (method.Body);
TestModule ("iterator.exe", module => {
var method = module.GetType ("Program").GetMethod ("GetLittleArgs");
Assert.IsNotNull (method.Body);
});
}
[TestCSharp ("CustomAttributes.cs")]
public void LoadString (ModuleDefinition module)
[Test]
public void LoadString ()
{
var type = module.GetType ("FooAttribute");
var get_fiou = type.GetMethod ("get_Fiou");
Assert.IsNotNull (get_fiou);
TestCSharp ("CustomAttributes.cs", module => {
var type = module.GetType ("FooAttribute");
var get_fiou = type.GetMethod ("get_Fiou");
Assert.IsNotNull (get_fiou);
var ldstr = get_fiou.Body.Instructions.Where (i => i.OpCode == OpCodes.Ldstr).First ();
Assert.AreEqual ("fiou", ldstr.Operand);
var ldstr = get_fiou.Body.Instructions.Where (i => i.OpCode == OpCodes.Ldstr).First ();
Assert.AreEqual ("fiou", ldstr.Operand);
});
}
static void AssertCode (string expected, MethodDefinition method)
[Test]
public void UnattachedMethodBody ()
{
Assert.IsTrue (method.HasBody);
Assert.IsNotNull (method.Body);
var system_void = typeof (void).ToDefinition ();
var method = new MethodDefinition ("NewMethod", MethodAttributes.Assembly | MethodAttributes.Static, system_void);
var body = new MethodBody (method);
var il = body.GetILProcessor ();
il.Emit (OpCodes.Ret);
method.Body = body;
Assert.AreEqual (Normalize (expected), Normalize (Formatter.FormatMethodBody (method)));
}
static string Normalize (string str)
{
return str.Trim ().Replace ("\r\n", "\n");
Assert.AreEqual (body, method.Body);
}
[Test]

238
external/cecil/Test/Mono.Cecil.Tests/MethodTests.cs vendored
View File

@@ -11,183 +11,205 @@ namespace Mono.Cecil.Tests {
[TestFixture]
public class MethodTests : BaseTestFixture {
[TestCSharp ("Methods.cs")]
public void AbstractMethod (ModuleDefinition module)
[Test]
public void AbstractMethod ()
{
var type = module.Types [1];
Assert.AreEqual ("Foo", type.Name);
Assert.AreEqual (2, type.Methods.Count);
TestCSharp ("Methods.cs", module => {
var type = module.Types [1];
Assert.AreEqual ("Foo", type.Name);
Assert.AreEqual (2, type.Methods.Count);
var method = type.GetMethod ("Bar");
Assert.AreEqual ("Bar", method.Name);
Assert.IsTrue (method.IsAbstract);
Assert.IsNotNull (method.ReturnType);
var method = type.GetMethod ("Bar");
Assert.AreEqual ("Bar", method.Name);
Assert.IsTrue (method.IsAbstract);
Assert.IsNotNull (method.ReturnType);
Assert.AreEqual (1, method.Parameters.Count);
Assert.AreEqual (1, method.Parameters.Count);
var parameter = method.Parameters [0];
var parameter = method.Parameters [0];
Assert.AreEqual ("a", parameter.Name);
Assert.AreEqual ("System.Int32", parameter.ParameterType.FullName);
Assert.AreEqual ("a", parameter.Name);
Assert.AreEqual ("System.Int32", parameter.ParameterType.FullName);
});
}
[TestCSharp ("Methods.cs")]
public void SimplePInvoke (ModuleDefinition module)
[Test]
public void SimplePInvoke ()
{
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("Pan");
TestCSharp ("Methods.cs", module => {
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("Pan");
Assert.IsTrue (pan.IsPInvokeImpl);
Assert.IsNotNull (pan.PInvokeInfo);
Assert.IsTrue (pan.IsPInvokeImpl);
Assert.IsNotNull (pan.PInvokeInfo);
Assert.AreEqual ("Pan", pan.PInvokeInfo.EntryPoint);
Assert.IsNotNull (pan.PInvokeInfo.Module);
Assert.AreEqual ("foo.dll", pan.PInvokeInfo.Module.Name);
Assert.AreEqual ("Pan", pan.PInvokeInfo.EntryPoint);
Assert.IsNotNull (pan.PInvokeInfo.Module);
Assert.AreEqual ("foo.dll", pan.PInvokeInfo.Module.Name);
});
}
[TestCSharp ("Generics.cs")]
public void GenericMethodDefinition (ModuleDefinition module)
[Test]
public void GenericMethodDefinition ()
{
var baz = module.GetType ("Baz");
TestCSharp ("Generics.cs", module => {
var baz = module.GetType ("Baz");
var gazonk = baz.GetMethod ("Gazonk");
var gazonk = baz.GetMethod ("Gazonk");
Assert.IsNotNull (gazonk);
Assert.IsNotNull (gazonk);
Assert.IsTrue (gazonk.HasGenericParameters);
Assert.AreEqual (1, gazonk.GenericParameters.Count);
Assert.AreEqual ("TBang", gazonk.GenericParameters [0].Name);
Assert.IsTrue (gazonk.HasGenericParameters);
Assert.AreEqual (1, gazonk.GenericParameters.Count);
Assert.AreEqual ("TBang", gazonk.GenericParameters [0].Name);
});
}
[TestCSharp ("Generics.cs")]
public void ReturnGenericInstance (ModuleDefinition module)
[Test]
public void ReturnGenericInstance ()
{
var bar = module.GetType ("Bar`1");
TestCSharp ("Generics.cs", module => {
var bar = module.GetType ("Bar`1");
var self = bar.GetMethod ("Self");
Assert.IsNotNull (self);
var self = bar.GetMethod ("Self");
Assert.IsNotNull (self);
var bar_t = self.ReturnType;
var bar_t = self.ReturnType;
Assert.IsTrue (bar_t.IsGenericInstance);
Assert.IsTrue (bar_t.IsGenericInstance);
var bar_t_instance = (GenericInstanceType) bar_t;
var bar_t_instance = (GenericInstanceType) bar_t;
Assert.AreEqual (bar.GenericParameters [0], bar_t_instance.GenericArguments [0]);
Assert.AreEqual (bar.GenericParameters [0], bar_t_instance.GenericArguments [0]);
var self_str = bar.GetMethod ("SelfString");
Assert.IsNotNull (self_str);
var self_str = bar.GetMethod ("SelfString");
Assert.IsNotNull (self_str);
var bar_str = self_str.ReturnType;
Assert.IsTrue (bar_str.IsGenericInstance);
var bar_str = self_str.ReturnType;
Assert.IsTrue (bar_str.IsGenericInstance);
var bar_str_instance = (GenericInstanceType) bar_str;
var bar_str_instance = (GenericInstanceType) bar_str;
Assert.AreEqual ("System.String", bar_str_instance.GenericArguments [0].FullName);
Assert.AreEqual ("System.String", bar_str_instance.GenericArguments [0].FullName);
});
}
[TestCSharp ("Generics.cs")]
public void ReturnGenericInstanceWithMethodParameter (ModuleDefinition module)
[Test]
public void ReturnGenericInstanceWithMethodParameter ()
{
var baz = module.GetType ("Baz");
TestCSharp ("Generics.cs", module => {
var baz = module.GetType ("Baz");
var gazoo = baz.GetMethod ("Gazoo");
Assert.IsNotNull (gazoo);
var gazoo = baz.GetMethod ("Gazoo");
Assert.IsNotNull (gazoo);
var bar_bingo = gazoo.ReturnType;
var bar_bingo = gazoo.ReturnType;
Assert.IsTrue (bar_bingo.IsGenericInstance);
Assert.IsTrue (bar_bingo.IsGenericInstance);
var bar_bingo_instance = (GenericInstanceType) bar_bingo;
var bar_bingo_instance = (GenericInstanceType) bar_bingo;
Assert.AreEqual (gazoo.GenericParameters [0], bar_bingo_instance.GenericArguments [0]);
Assert.AreEqual (gazoo.GenericParameters [0], bar_bingo_instance.GenericArguments [0]);
});
}
[TestCSharp ("Interfaces.cs")]
public void SimpleOverrides (ModuleDefinition module)
[Test]
public void SimpleOverrides ()
{
var ibingo = module.GetType ("IBingo");
var ibingo_foo = ibingo.GetMethod ("Foo");
Assert.IsNotNull (ibingo_foo);
TestCSharp ("Interfaces.cs", module => {
var ibingo = module.GetType ("IBingo");
var ibingo_foo = ibingo.GetMethod ("Foo");
Assert.IsNotNull (ibingo_foo);
var ibingo_bar = ibingo.GetMethod ("Bar");
Assert.IsNotNull (ibingo_bar);
var ibingo_bar = ibingo.GetMethod ("Bar");
Assert.IsNotNull (ibingo_bar);
var bingo = module.GetType ("Bingo");
var bingo = module.GetType ("Bingo");
var foo = bingo.GetMethod ("IBingo.Foo");
Assert.IsNotNull (foo);
var foo = bingo.GetMethod ("IBingo.Foo");
Assert.IsNotNull (foo);
Assert.IsTrue (foo.HasOverrides);
Assert.AreEqual (ibingo_foo, foo.Overrides [0]);
Assert.IsTrue (foo.HasOverrides);
Assert.AreEqual (ibingo_foo, foo.Overrides [0]);
var bar = bingo.GetMethod ("IBingo.Bar");
Assert.IsNotNull (bar);
var bar = bingo.GetMethod ("IBingo.Bar");
Assert.IsNotNull (bar);
Assert.IsTrue (bar.HasOverrides);
Assert.AreEqual (ibingo_bar, bar.Overrides [0]);
Assert.IsTrue (bar.HasOverrides);
Assert.AreEqual (ibingo_bar, bar.Overrides [0]);
});
}
[TestModule ("varargs.exe")]
public void VarArgs (ModuleDefinition module)
[Test]
public void VarArgs ()
{
var module_type = module.Types [0];
TestModule ("varargs.exe", module => {
var module_type = module.Types [0];
Assert.AreEqual (3, module_type.Methods.Count);
Assert.AreEqual (3, module_type.Methods.Count);
var bar = module_type.GetMethod ("Bar");
var baz = module_type.GetMethod ("Baz");
var foo = module_type.GetMethod ("Foo");
var bar = module_type.GetMethod ("Bar");
var baz = module_type.GetMethod ("Baz");
var foo = module_type.GetMethod ("Foo");
Assert.IsTrue (bar.IsVarArg ());
Assert.IsFalse (baz.IsVarArg ());
Assert.IsTrue (bar.IsVarArg ());
Assert.IsFalse (baz.IsVarArg ());
Assert.IsTrue(foo.IsVarArg ());
Assert.IsTrue (foo.IsVarArg ());
var bar_reference = (MethodReference) baz.Body.Instructions.Where (i => i.Offset == 0x000a).First ().Operand;
var foo_reference = (MethodReference) baz.Body.Instructions.First (i => i.Offset == 0x000a).Operand;
Assert.IsTrue (bar_reference.IsVarArg ());
Assert.AreEqual (0, bar_reference.GetSentinelPosition ());
Assert.IsTrue (foo_reference.IsVarArg ());
Assert.AreEqual (0, foo_reference.GetSentinelPosition ());
var foo_reference = (MethodReference) baz.Body.Instructions.Where (i => i.Offset == 0x0023).First ().Operand;
Assert.AreEqual (foo, foo_reference.Resolve ());
Assert.IsTrue (foo_reference.IsVarArg ());
var bar_reference = (MethodReference) baz.Body.Instructions.First (i => i.Offset == 0x0023).Operand;
Assert.AreEqual (1, foo_reference.GetSentinelPosition ());
Assert.IsTrue (bar_reference.IsVarArg ());
Assert.AreEqual (1, bar_reference.GetSentinelPosition ());
Assert.AreEqual (bar, bar_reference.Resolve ());
});
}
[TestCSharp ("Generics.cs")]
public void GenericInstanceMethod (ModuleDefinition module)
[Test]
public void GenericInstanceMethod ()
{
var type = module.GetType ("It");
var method = type.GetMethod ("ReadPwow");
TestCSharp ("Generics.cs", module => {
var type = module.GetType ("It");
var method = type.GetMethod ("ReadPwow");
GenericInstanceMethod instance = null;
GenericInstanceMethod instance = null;
foreach (var instruction in method.Body.Instructions) {
instance = instruction.Operand as GenericInstanceMethod;
if (instance != null)
break;
}
foreach (var instruction in method.Body.Instructions) {
instance = instruction.Operand as GenericInstanceMethod;
if (instance != null)
break;
}
Assert.IsNotNull (instance);
Assert.IsNotNull (instance);
Assert.AreEqual (TokenType.MethodSpec, instance.MetadataToken.TokenType);
Assert.AreNotEqual (0, instance.MetadataToken.RID);
Assert.AreEqual (TokenType.MethodSpec, instance.MetadataToken.TokenType);
Assert.AreNotEqual (0, instance.MetadataToken.RID);
});
}
[TestCSharp ("Generics.cs")]
public void MethodRefDeclaredOnGenerics (ModuleDefinition module)
[Test]
public void MethodRefDeclaredOnGenerics ()
{
var type = module.GetType ("Tamtam");
var beta = type.GetMethod ("Beta");
var charlie = type.GetMethod ("Charlie");
TestCSharp ("Generics.cs", module => {
var type = module.GetType ("Tamtam");
var beta = type.GetMethod ("Beta");
var charlie = type.GetMethod ("Charlie");
var new_list_beta = (MethodReference) beta.Body.Instructions [0].Operand;
var new_list_charlie = (MethodReference) charlie.Body.Instructions [0].Operand;
var new_list_beta = (MethodReference) beta.Body.Instructions [0].Operand;
var new_list_charlie = (MethodReference) charlie.Body.Instructions [0].Operand;
Assert.AreEqual ("System.Collections.Generic.List`1<TBeta>", new_list_beta.DeclaringType.FullName);
Assert.AreEqual ("System.Collections.Generic.List`1<TCharlie>", new_list_charlie.DeclaringType.FullName);
Assert.AreEqual ("System.Collections.Generic.List`1<TBeta>", new_list_beta.DeclaringType.FullName);
Assert.AreEqual ("System.Collections.Generic.List`1<TCharlie>", new_list_charlie.DeclaringType.FullName);
});
}
[Test]

290
external/cecil/Test/Mono.Cecil.Tests/ModuleTests.cs vendored
View File

@@ -22,185 +22,213 @@ namespace Mono.Cecil.Tests {
Assert.AreEqual ("Test", module.Assembly.Name.Name);
}
[TestModule ("hello.exe")]
public void SingleModule (ModuleDefinition module)
[Test]
public void SingleModule ()
{
var assembly = module.Assembly;
TestModule ("hello.exe", module => {
var assembly = module.Assembly;
Assert.AreEqual (1, assembly.Modules.Count);
Assert.IsNotNull (assembly.MainModule);
Assert.AreEqual (1, assembly.Modules.Count);
Assert.IsNotNull (assembly.MainModule);
});
}
[TestModule ("hello.exe")]
public void EntryPoint (ModuleDefinition module)
[Test]
public void EntryPoint ()
{
var entry_point = module.EntryPoint;
Assert.IsNotNull (entry_point);
TestModule ("hello.exe", module => {
var entry_point = module.EntryPoint;
Assert.IsNotNull (entry_point);
Assert.AreEqual ("System.Void Program::Main()", entry_point.ToString ());
Assert.AreEqual ("System.Void Program::Main()", entry_point.ToString ());
});
}
[TestModule ("mma.exe")]
public void MultiModules (ModuleDefinition module)
[Test]
public void MultiModules ()
{
var assembly = module.Assembly;
TestModule ("mma.exe", module => {
var assembly = module.Assembly;
Assert.AreEqual (3, assembly.Modules.Count);
Assert.AreEqual (3, assembly.Modules.Count);
Assert.AreEqual ("mma.exe", assembly.Modules [0].Name);
Assert.AreEqual (ModuleKind.Console, assembly.Modules [0].Kind);
Assert.AreEqual ("mma.exe", assembly.Modules [0].Name);
Assert.AreEqual (ModuleKind.Console, assembly.Modules [0].Kind);
Assert.AreEqual ("moda.netmodule", assembly.Modules [1].Name);
Assert.AreEqual ("eedb4721-6c3e-4d9a-be30-49021121dd92", assembly.Modules [1].Mvid.ToString ());
Assert.AreEqual (ModuleKind.NetModule, assembly.Modules [1].Kind);
Assert.AreEqual ("moda.netmodule", assembly.Modules [1].Name);
Assert.AreEqual ("eedb4721-6c3e-4d9a-be30-49021121dd92", assembly.Modules [1].Mvid.ToString ());
Assert.AreEqual (ModuleKind.NetModule, assembly.Modules [1].Kind);
Assert.AreEqual ("modb.netmodule", assembly.Modules [2].Name);
Assert.AreEqual ("46c5c577-11b2-4ea0-bb3c-3c71f1331dd0", assembly.Modules [2].Mvid.ToString ());
Assert.AreEqual (ModuleKind.NetModule, assembly.Modules [2].Kind);
Assert.AreEqual ("modb.netmodule", assembly.Modules [2].Name);
Assert.AreEqual ("46c5c577-11b2-4ea0-bb3c-3c71f1331dd0", assembly.Modules [2].Mvid.ToString ());
Assert.AreEqual (ModuleKind.NetModule, assembly.Modules [2].Kind);
});
}
[TestModule ("hello.exe")]
public void ModuleInformation (ModuleDefinition module)
[Test]
public void ModuleInformation ()
{
Assert.IsNotNull (module);
TestModule ("hello.exe", module => {
Assert.IsNotNull (module);
Assert.AreEqual ("hello.exe", module.Name);
Assert.AreEqual (new Guid ("C3BC2BD3-2576-4D00-A80E-465B5632415F"), module.Mvid);
Assert.AreEqual ("hello.exe", module.Name);
Assert.AreEqual (new Guid ("C3BC2BD3-2576-4D00-A80E-465B5632415F"), module.Mvid);
});
}
[TestModule ("hello.exe")]
public void AssemblyReferences (ModuleDefinition module)
[Test]
public void AssemblyReferences ()
{
Assert.AreEqual (1, module.AssemblyReferences.Count);
TestModule ("hello.exe", module => {
Assert.AreEqual (1, module.AssemblyReferences.Count);
var reference = module.AssemblyReferences [0];
var reference = module.AssemblyReferences [0];
Assert.AreEqual ("mscorlib", reference.Name);
Assert.AreEqual (new Version (2, 0, 0, 0), reference.Version);
Assert.AreEqual (new byte [] { 0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89 }, reference.PublicKeyToken);
Assert.AreEqual ("mscorlib", reference.Name);
Assert.AreEqual (new Version (2, 0, 0, 0), reference.Version);
Assert.AreEqual (new byte [] { 0xB7, 0x7A, 0x5C, 0x56, 0x19, 0x34, 0xE0, 0x89 }, reference.PublicKeyToken);
});
}
[TestModule ("pinvoke.exe")]
public void ModuleReferences (ModuleDefinition module)
[Test]
public void ModuleReferences ()
{
Assert.AreEqual (2, module.ModuleReferences.Count);
Assert.AreEqual ("kernel32.dll", module.ModuleReferences [0].Name);
Assert.AreEqual ("shell32.dll", module.ModuleReferences [1].Name);
TestModule ("pinvoke.exe", module => {
Assert.AreEqual (2, module.ModuleReferences.Count);
Assert.AreEqual ("kernel32.dll", module.ModuleReferences [0].Name);
Assert.AreEqual ("shell32.dll", module.ModuleReferences [1].Name);
});
}
[TestModule ("hello.exe")]
public void Types (ModuleDefinition module)
[Test]
public void Types ()
{
Assert.AreEqual (2, module.Types.Count);
Assert.AreEqual ("<Module>", module.Types [0].FullName);
Assert.AreEqual ("<Module>", module.GetType ("<Module>").FullName);
Assert.AreEqual ("Program", module.Types [1].FullName);
Assert.AreEqual ("Program", module.GetType ("Program").FullName);
TestModule ("hello.exe", module => {
Assert.AreEqual (2, module.Types.Count);
Assert.AreEqual ("<Module>", module.Types [0].FullName);
Assert.AreEqual ("<Module>", module.GetType ("<Module>").FullName);
Assert.AreEqual ("Program", module.Types [1].FullName);
Assert.AreEqual ("Program", module.GetType ("Program").FullName);
});
}
[TestModule ("libres.dll")]
public void LinkedResource (ModuleDefinition module)
[Test]
public void LinkedResource ()
{
var resource = module.Resources.Where (res => res.Name == "linked.txt").First () as LinkedResource;
Assert.IsNotNull (resource);
TestModule ("libres.dll", module => {
var resource = module.Resources.Where (res => res.Name == "linked.txt").First () as LinkedResource;
Assert.IsNotNull (resource);
Assert.AreEqual ("linked.txt", resource.Name);
Assert.AreEqual ("linked.txt", resource.File);
Assert.AreEqual (ResourceType.Linked, resource.ResourceType);
Assert.IsTrue (resource.IsPublic);
Assert.AreEqual ("linked.txt", resource.Name);
Assert.AreEqual ("linked.txt", resource.File);
Assert.AreEqual (ResourceType.Linked, resource.ResourceType);
Assert.IsTrue (resource.IsPublic);
});
}
[TestModule ("libres.dll")]
public void EmbeddedResource (ModuleDefinition module)
[Test]
public void EmbeddedResource ()
{
var resource = module.Resources.Where (res => res.Name == "embedded1.txt").First () as EmbeddedResource;
Assert.IsNotNull (resource);
TestModule ("libres.dll", module => {
var resource = module.Resources.Where (res => res.Name == "embedded1.txt").First () as EmbeddedResource;
Assert.IsNotNull (resource);
Assert.AreEqual ("embedded1.txt", resource.Name);
Assert.AreEqual (ResourceType.Embedded, resource.ResourceType);
Assert.IsTrue (resource.IsPublic);
Assert.AreEqual ("embedded1.txt", resource.Name);
Assert.AreEqual (ResourceType.Embedded, resource.ResourceType);
Assert.IsTrue (resource.IsPublic);
using (var reader = new StreamReader (resource.GetResourceStream ()))
using (var reader = new StreamReader (resource.GetResourceStream ()))
Assert.AreEqual ("Hello", reader.ReadToEnd ());
resource = module.Resources.Where (res => res.Name == "embedded2.txt").First () as EmbeddedResource;
Assert.IsNotNull (resource);
resource = module.Resources.Where (res => res.Name == "embedded2.txt").First () as EmbeddedResource;
Assert.IsNotNull (resource);
Assert.AreEqual ("embedded2.txt", resource.Name);
Assert.AreEqual (ResourceType.Embedded, resource.ResourceType);
Assert.IsTrue (resource.IsPublic);
Assert.AreEqual ("embedded2.txt", resource.Name);
Assert.AreEqual (ResourceType.Embedded, resource.ResourceType);
Assert.IsTrue (resource.IsPublic);
using (var reader = new StreamReader (resource.GetResourceStream ()))
using (var reader = new StreamReader (resource.GetResourceStream ()))
Assert.AreEqual ("World", reader.ReadToEnd ());
});
}
[TestModule ("mma.exe")]
public void ExportedTypeFromNetModule (ModuleDefinition module)
[Test]
public void ExportedTypeFromNetModule ()
{
Assert.IsTrue (module.HasExportedTypes);
Assert.AreEqual (2, module.ExportedTypes.Count);
TestModule ("mma.exe", module => {
Assert.IsTrue (module.HasExportedTypes);
Assert.AreEqual (2, module.ExportedTypes.Count);
var exported_type = module.ExportedTypes [0];
var exported_type = module.ExportedTypes [0];
Assert.AreEqual ("Module.A.Foo", exported_type.FullName);
Assert.AreEqual ("moda.netmodule", exported_type.Scope.Name);
Assert.AreEqual ("Module.A.Foo", exported_type.FullName);
Assert.AreEqual ("moda.netmodule", exported_type.Scope.Name);
exported_type = module.ExportedTypes [1];
exported_type = module.ExportedTypes [1];
Assert.AreEqual ("Module.B.Baz", exported_type.FullName);
Assert.AreEqual ("modb.netmodule", exported_type.Scope.Name);
Assert.AreEqual ("Module.B.Baz", exported_type.FullName);
Assert.AreEqual ("modb.netmodule", exported_type.Scope.Name);
});
}
[TestCSharp ("CustomAttributes.cs")]
public void NestedTypeForwarder (ModuleDefinition module)
[Test]
public void NestedTypeForwarder ()
{
Assert.IsTrue (module.HasExportedTypes);
Assert.AreEqual (2, module.ExportedTypes.Count);
TestCSharp ("CustomAttributes.cs", module => {
Assert.IsTrue (module.HasExportedTypes);
Assert.AreEqual (2, module.ExportedTypes.Count);
var exported_type = module.ExportedTypes [0];
var exported_type = module.ExportedTypes [0];
Assert.AreEqual ("System.Diagnostics.DebuggableAttribute", exported_type.FullName);
Assert.AreEqual ("mscorlib", exported_type.Scope.Name);
Assert.IsTrue (exported_type.IsForwarder);
Assert.AreEqual ("System.Diagnostics.DebuggableAttribute", exported_type.FullName);
Assert.AreEqual ("mscorlib", exported_type.Scope.Name);
Assert.IsTrue (exported_type.IsForwarder);
var nested_exported_type = module.ExportedTypes [1];
var nested_exported_type = module.ExportedTypes [1];
Assert.AreEqual ("System.Diagnostics.DebuggableAttribute/DebuggingModes", nested_exported_type.FullName);
Assert.AreEqual (exported_type, nested_exported_type.DeclaringType);
Assert.AreEqual ("mscorlib", nested_exported_type.Scope.Name);
Assert.AreEqual ("System.Diagnostics.DebuggableAttribute/DebuggingModes", nested_exported_type.FullName);
Assert.AreEqual (exported_type, nested_exported_type.DeclaringType);
Assert.AreEqual ("mscorlib", nested_exported_type.Scope.Name);
});
}
[TestCSharp ("CustomAttributes.cs")]
public void HasTypeReference (ModuleDefinition module)
[Test]
public void HasTypeReference ()
{
Assert.IsTrue (module.HasTypeReference ("System.Attribute"));
Assert.IsTrue (module.HasTypeReference ("mscorlib", "System.Attribute"));
TestCSharp ("CustomAttributes.cs", module => {
Assert.IsTrue (module.HasTypeReference ("System.Attribute"));
Assert.IsTrue (module.HasTypeReference ("mscorlib", "System.Attribute"));
Assert.IsFalse (module.HasTypeReference ("System.Core", "System.Attribute"));
Assert.IsFalse (module.HasTypeReference ("System.Linq.Enumerable"));
Assert.IsFalse (module.HasTypeReference ("System.Core", "System.Attribute"));
Assert.IsFalse (module.HasTypeReference ("System.Linq.Enumerable"));
});
}
[TestModule ("libhello.dll")]
public void Win32FileVersion (ModuleDefinition module)
[Test]
public void Win32FileVersion ()
{
var version = FileVersionInfo.GetVersionInfo (module.FullyQualifiedName);
TestModule ("libhello.dll", module => {
var version = FileVersionInfo.GetVersionInfo (module.FileName);
Assert.AreEqual ("0.0.0.0", version.FileVersion);
Assert.AreEqual ("0.0.0.0", version.FileVersion);
});
}
[TestModule ("noblob.dll")]
public void ModuleWithoutBlob (ModuleDefinition module)
[Test]
public void ModuleWithoutBlob ()
{
Assert.IsNull (module.Image.BlobHeap);
TestModule ("noblob.dll", module => {
Assert.IsNull (module.Image.BlobHeap);
});
}
[Test]
public void MixedModeModule ()
{
var module = GetResourceModule ("cppcli.dll");
Assert.AreEqual (1, module.ModuleReferences.Count);
Assert.AreEqual (string.Empty, module.ModuleReferences [0].Name);
using (var module = GetResourceModule ("cppcli.dll")) {
Assert.AreEqual (1, module.ModuleReferences.Count);
Assert.AreEqual (string.Empty, module.ModuleReferences [0].Name);
}
}
[Test]
@@ -210,41 +238,47 @@ namespace Mono.Cecil.Tests {
GetResourceModule ("text_file.txt");
}
[Test]
public void WriteModuleTwice ()
{
var module = GetResourceModule ("iterator.exe");
var path = Path.Combine (Path.GetTempPath (), "cecil");
var file = Path.Combine (path, "iteratorrt.exe");
module.Write (file);
module.Write (file);
}
[Test]
public void GetTypeNamespacePlusName ()
{
var module = GetResourceModule ("moda.netmodule");
var type = module.GetType ("Module.A", "Foo");
Assert.IsNotNull (type);
using (var module = GetResourceModule ("moda.netmodule")) {
var type = module.GetType ("Module.A", "Foo");
Assert.IsNotNull (type);
}
}
[Test]
public void OpenModuleImmediate ()
{
var module = GetResourceModule ("hello.exe", ReadingMode.Immediate);
Assert.AreEqual (ReadingMode.Immediate, module.ReadingMode);
using (var module = GetResourceModule ("hello.exe", ReadingMode.Immediate)) {
Assert.AreEqual (ReadingMode.Immediate, module.ReadingMode);
}
}
[Test]
public void OpenModuleDeferred ()
{
var module = GetResourceModule ("hello.exe", ReadingMode.Deferred);
using (var module = GetResourceModule ("hello.exe", ReadingMode.Deferred)) {
Assert.AreEqual (ReadingMode.Deferred, module.ReadingMode);
}
}
Assert.AreEqual (ReadingMode.Deferred, module.ReadingMode);
[Test]
public void ReadAndWriteFile ()
{
var path = Path.GetTempFileName ();
var original = ModuleDefinition.CreateModule ("FooFoo", ModuleKind.Dll);
var type = new TypeDefinition ("Foo", "Foo", TypeAttributes.Abstract | TypeAttributes.Sealed);
original.Types.Add (type);
original.Write (path);
using (var module = ModuleDefinition.ReadModule (path, new ReaderParameters { ReadWrite = true })) {
module.Write ();
}
using (var module = ModuleDefinition.ReadModule (path))
Assert.AreEqual ("Foo.Foo", module.Types [1].FullName);
}
}
}

88
external/cecil/Test/Mono.Cecil.Tests/NestedTypesTests.cs vendored
View File

@@ -9,37 +9,83 @@ namespace Mono.Cecil.Tests {
[TestFixture]
public class NestedTypesTests : BaseTestFixture {
[TestCSharp ("NestedTypes.cs")]
public void NestedTypes (ModuleDefinition module)
[Test]
public void NestedTypes ()
{
var foo = module.GetType ("Foo");
TestCSharp ("NestedTypes.cs", module => {
var foo = module.GetType ("Foo");
Assert.AreEqual ("Foo", foo.Name);
Assert.AreEqual ("Foo", foo.FullName);
Assert.AreEqual (module, foo.Module);
Assert.AreEqual (1, foo.NestedTypes.Count);
Assert.AreEqual ("Foo", foo.Name);
Assert.AreEqual ("Foo", foo.FullName);
Assert.AreEqual (module, foo.Module);
Assert.AreEqual (1, foo.NestedTypes.Count);
var bar = foo.NestedTypes [0];
var bar = foo.NestedTypes [0];
Assert.AreEqual ("Bar", bar.Name);
Assert.AreEqual ("Foo/Bar", bar.FullName);
Assert.AreEqual (module, bar.Module);
Assert.AreEqual (1, bar.NestedTypes.Count);
Assert.AreEqual ("Bar", bar.Name);
Assert.AreEqual ("Foo/Bar", bar.FullName);
Assert.AreEqual (module, bar.Module);
Assert.AreEqual (1, bar.NestedTypes.Count);
var baz = bar.NestedTypes [0];
var baz = bar.NestedTypes [0];
Assert.AreEqual ("Baz", baz.Name);
Assert.AreEqual ("Foo/Bar/Baz", baz.FullName);
Assert.AreEqual (module, baz.Module);
Assert.AreEqual ("Baz", baz.Name);
Assert.AreEqual ("Foo/Bar/Baz", baz.FullName);
Assert.AreEqual (module, baz.Module);
});
}
[TestCSharp ("NestedTypes.cs")]
public void DirectNestedType (ModuleDefinition module)
[Test]
public void DirectNestedType ()
{
var bingo = module.GetType ("Bingo");
var get_fuel = bingo.GetMethod ("GetFuel");
TestCSharp ("NestedTypes.cs", module => {
var bingo = module.GetType ("Bingo");
var get_fuel = bingo.GetMethod ("GetFuel");
Assert.AreEqual ("Bingo/Fuel", get_fuel.ReturnType.FullName);
Assert.AreEqual ("Bingo/Fuel", get_fuel.ReturnType.FullName);
});
}
[Test]
public void NestedTypeWithOwnNamespace ()
{
TestModule ("bug-185.dll", module => {
var foo = module.GetType ("Foo");
var foo_child = foo.NestedTypes [0];
Assert.AreEqual ("<IFoo<System.Byte[]>", foo_child.Namespace);
Assert.AreEqual ("Do>d__0", foo_child.Name);
Assert.AreEqual ("Foo/<IFoo<System.Byte[]>.Do>d__0", foo_child.FullName);
});
}
[Test]
public void NestedTypeFullName ()
{
var foo = new TypeDefinition (null, "Foo", TypeAttributes.Class);
var bar = new TypeDefinition (null, "Bar", TypeAttributes.Class);
var baz = new TypeDefinition (null, "Baz", TypeAttributes.Class);
foo.NestedTypes.Add (bar);
bar.NestedTypes.Add (baz);
Assert.AreEqual ("Foo/Bar/Baz", baz.FullName);
foo.Namespace = "Change";
Assert.AreEqual ("Change.Foo/Bar", bar.FullName);
Assert.AreEqual ("Change.Foo/Bar/Baz", baz.FullName);
bar.Namespace = "AnotherChange";
Assert.AreEqual ("Change.Foo/AnotherChange.Bar", bar.FullName);
Assert.AreEqual ("Change.Foo/AnotherChange.Bar/Baz", baz.FullName);
foo.Name = "FooFoo";
Assert.AreEqual ("Change.FooFoo/AnotherChange.Bar", bar.FullName);
Assert.AreEqual ("Change.FooFoo/AnotherChange.Bar/Baz", baz.FullName);
}
}
}

196
external/cecil/Test/Mono.Cecil.Tests/ParameterTests.cs vendored
View File

@@ -1,8 +1,4 @@
using System;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Metadata;
using NUnit.Framework;
@@ -11,107 +7,136 @@ namespace Mono.Cecil.Tests {
[TestFixture]
public class ParameterTests : BaseTestFixture {
[TestModule ("marshal.dll")]
public void MarshalAsI4 (ModuleDefinition module)
[Test]
public void MarshalAsI4 ()
{
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("Pan");
TestModule ("marshal.dll", module => {
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("Pan");
Assert.AreEqual (1, pan.Parameters.Count);
Assert.AreEqual (1, pan.Parameters.Count);
var parameter = pan.Parameters [0];
var parameter = pan.Parameters [0];
Assert.IsTrue (parameter.HasMarshalInfo);
var info = parameter.MarshalInfo;
Assert.IsTrue (parameter.HasMarshalInfo);
var info = parameter.MarshalInfo;
Assert.AreEqual (typeof (MarshalInfo), info.GetType ());
Assert.AreEqual (NativeType.I4, info.NativeType);
Assert.AreEqual (typeof (MarshalInfo), info.GetType ());
Assert.AreEqual (NativeType.I4, info.NativeType);
});
}
[TestModule ("marshal.dll")]
public void CustomMarshaler (ModuleDefinition module)
[Test]
public void CustomMarshaler ()
{
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("PanPan");
TestModule ("marshal.dll", module => {
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("PanPan");
var parameter = pan.Parameters [0];
var parameter = pan.Parameters [0];
Assert.IsTrue (parameter.HasMarshalInfo);
Assert.IsTrue (parameter.HasMarshalInfo);
var info = (CustomMarshalInfo) parameter.MarshalInfo;
var info = (CustomMarshalInfo) parameter.MarshalInfo;
Assert.AreEqual (Guid.Empty, info.Guid);
Assert.AreEqual (string.Empty, info.UnmanagedType);
Assert.AreEqual (NativeType.CustomMarshaler, info.NativeType);
Assert.AreEqual ("nomnom", info.Cookie);
Assert.AreEqual (Guid.Empty, info.Guid);
Assert.AreEqual (string.Empty, info.UnmanagedType);
Assert.AreEqual (NativeType.CustomMarshaler, info.NativeType);
Assert.AreEqual ("nomnom", info.Cookie);
Assert.AreEqual ("Boc", info.ManagedType.FullName);
Assert.AreEqual (module, info.ManagedType.Scope);
Assert.AreEqual ("Boc", info.ManagedType.FullName);
Assert.AreEqual (module, info.ManagedType.Scope);
});
}
[TestModule ("marshal.dll")]
public void SafeArrayMarshaler (ModuleDefinition module)
[Test]
public void SafeArrayMarshaler ()
{
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("PanPan");
TestModule ("marshal.dll", module => {
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("PanPan");
Assert.IsTrue (pan.MethodReturnType.HasMarshalInfo);
Assert.IsTrue (pan.MethodReturnType.HasMarshalInfo);
var info = (SafeArrayMarshalInfo) pan.MethodReturnType.MarshalInfo;
var info = (SafeArrayMarshalInfo) pan.MethodReturnType.MarshalInfo;
Assert.AreEqual (VariantType.Dispatch, info.ElementType);
Assert.AreEqual (VariantType.Dispatch, info.ElementType);
});
}
[TestModule ("marshal.dll")]
public void ArrayMarshaler (ModuleDefinition module)
[Test]
public void ArrayMarshaler ()
{
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("PanPan");
TestModule ("marshal.dll", module => {
var bar = module.GetType ("Bar");
var pan = bar.GetMethod ("PanPan");
var parameter = pan.Parameters [1];
var parameter = pan.Parameters [1];
Assert.IsTrue (parameter.HasMarshalInfo);
Assert.IsTrue (parameter.HasMarshalInfo);
var info = (ArrayMarshalInfo) parameter.MarshalInfo;
var info = (ArrayMarshalInfo) parameter.MarshalInfo;
Assert.AreEqual (NativeType.I8, info.ElementType);
Assert.AreEqual (66, info.Size);
Assert.AreEqual (2, info.SizeParameterIndex);
Assert.AreEqual (NativeType.I8, info.ElementType);
Assert.AreEqual (66, info.Size);
Assert.AreEqual (2, info.SizeParameterIndex);
parameter = pan.Parameters [3];
parameter = pan.Parameters [3];
Assert.IsTrue (parameter.HasMarshalInfo);
Assert.IsTrue (parameter.HasMarshalInfo);
info = (ArrayMarshalInfo) parameter.MarshalInfo;
info = (ArrayMarshalInfo) parameter.MarshalInfo;
Assert.AreEqual (NativeType.I2, info.ElementType);
Assert.AreEqual (-1, info.Size);
Assert.AreEqual (-1, info.SizeParameterIndex);
Assert.AreEqual (NativeType.I2, info.ElementType);
Assert.AreEqual (-1, info.Size);
Assert.AreEqual (-1, info.SizeParameterIndex);
});
}
[TestModule ("marshal.dll")]
public void ArrayMarshalerSized (ModuleDefinition module)
[Test]
public void ArrayMarshalerSized ()
{
var delegate_type = module.GetType ("SomeMethod");
var parameter = delegate_type.GetMethod ("Invoke").Parameters [1];
TestModule ("marshal.dll", module => {
var delegate_type = module.GetType ("SomeMethod");
var parameter = delegate_type.GetMethod ("Invoke").Parameters [1];
Assert.IsTrue (parameter.HasMarshalInfo);
var array_info = (ArrayMarshalInfo) parameter.MarshalInfo;
Assert.IsTrue (parameter.HasMarshalInfo);
var array_info = (ArrayMarshalInfo) parameter.MarshalInfo;
Assert.IsNotNull (array_info);
Assert.IsNotNull (array_info);
Assert.AreEqual (0, array_info.SizeParameterMultiplier);
Assert.AreEqual (0, array_info.SizeParameterMultiplier);
});
}
[TestModule ("boxedoptarg.dll")]
public void BoxedDefaultArgumentValue (ModuleDefinition module)
[Test]
public void NullableConstant ()
{
var foo = module.GetType ("Foo");
var bar = foo.GetMethod ("Bar");
var baz = bar.Parameters [0];
TestModule ("nullable-constant.exe", module => {
var type = module.GetType ("Program");
var method = type.GetMethod ("Foo");
Assert.IsTrue (baz.HasConstant);
Assert.AreEqual (-1, baz.Constant);
Assert.IsTrue (method.Parameters [0].HasConstant);
Assert.IsTrue (method.Parameters [1].HasConstant);
Assert.IsTrue (method.Parameters [2].HasConstant);
Assert.AreEqual (1234, method.Parameters [0].Constant);
Assert.AreEqual (null, method.Parameters [1].Constant);
Assert.AreEqual (12, method.Parameters [2].Constant);
});
}
[Test]
public void BoxedDefaultArgumentValue ()
{
TestModule ("boxedoptarg.dll", module => {
var foo = module.GetType ("Foo");
var bar = foo.GetMethod ("Bar");
var baz = bar.Parameters [0];
Assert.IsTrue (baz.HasConstant);
Assert.AreEqual (-1, baz.Constant);
});
}
[Test]
@@ -207,18 +232,43 @@ namespace Mono.Cecil.Tests {
Assert.AreEqual (2, z.Index);
}
[TestIL ("hello.il")]
public void GenericParameterConstant (ModuleDefinition module)
[Test]
public void GenericParameterConstant ()
{
var foo = module.GetType ("Foo");
var method = foo.GetMethod ("GetState");
TestIL ("hello.il", module => {
var foo = module.GetType ("Foo");
var method = foo.GetMethod ("GetState");
Assert.IsNotNull (method);
Assert.IsNotNull (method);
var parameter = method.Parameters [1];
var parameter = method.Parameters [1];
Assert.IsTrue (parameter.HasConstant);
Assert.IsNull (parameter.Constant);
Assert.IsTrue (parameter.HasConstant);
Assert.IsNull (parameter.Constant);
});
}
[Test]
public void NullablePrimitiveParameterConstant ()
{
TestModule ("nullable-parameter.dll", module => {
var test = module.GetType ("Test");
var method = test.GetMethod ("Foo");
Assert.IsNotNull (method);
var param = method.Parameters [0];
Assert.IsTrue (param.HasConstant);
Assert.AreEqual (1234, param.Constant);
param = method.Parameters [1];
Assert.IsTrue (param.HasConstant);
Assert.AreEqual (null, param.Constant);
param = method.Parameters [2];
Assert.IsTrue (param.HasConstant);
Assert.AreEqual (12, param.Constant);
});
}
}
}

355
external/cecil/Test/Mono.Cecil.Tests/PortablePdbTests.cs vendored Normal file
View File

@@ -0,0 +1,355 @@
using System;
using System.IO;
using NUnit.Framework;
using Mono.Cecil.Cil;
namespace Mono.Cecil.Tests {
[TestFixture]
public class PortablePdbTests : BaseTestFixture {
[Test]
public void SequencePoints ()
{
TestPortablePdbModule (module => {
var type = module.GetType ("PdbTarget.Program");
var main = type.GetMethod ("Main");
AssertCode (@"
.locals init (System.Int32 a, System.String[] V_1, System.Int32 V_2, System.String arg)
.line 21,21:3,4 'C:\sources\PdbTarget\Program.cs'
IL_0000: nop
.line 22,22:4,11 'C:\sources\PdbTarget\Program.cs'
IL_0001: nop
.line 22,22:24,28 'C:\sources\PdbTarget\Program.cs'
IL_0002: ldarg.0
IL_0003: stloc.1
IL_0004: ldc.i4.0
IL_0005: stloc.2
.line 16707566,0:16707566,0 'C:\sources\PdbTarget\Program.cs'
IL_0006: br.s IL_0017
.line 22,22:13,20 'C:\sources\PdbTarget\Program.cs'
IL_0008: ldloc.1
IL_0009: ldloc.2
IL_000a: ldelem.ref
IL_000b: stloc.3
.line 23,23:5,20 'C:\sources\PdbTarget\Program.cs'
IL_000c: ldloc.3
IL_000d: call System.Void System.Console::WriteLine(System.String)
IL_0012: nop
.line 16707566,0:16707566,0 'C:\sources\PdbTarget\Program.cs'
IL_0013: ldloc.2
IL_0014: ldc.i4.1
IL_0015: add
IL_0016: stloc.2
.line 22,22:21,23 'C:\sources\PdbTarget\Program.cs'
IL_0017: ldloc.2
IL_0018: ldloc.1
IL_0019: ldlen
IL_001a: conv.i4
IL_001b: blt.s IL_0008
.line 25,25:4,22 'C:\sources\PdbTarget\Program.cs'
IL_001d: ldc.i4.1
IL_001e: ldc.i4.2
IL_001f: call System.Int32 System.Math::Min(System.Int32,System.Int32)
IL_0024: stloc.0
.line 26,26:3,4 'C:\sources\PdbTarget\Program.cs'
IL_0025: ret
", main);
});
}
[Test]
public void SequencePointsMultipleDocument ()
{
TestPortablePdbModule (module => {
var type = module.GetType ("PdbTarget.B");
var main = type.GetMethod (".ctor");
AssertCode (@"
.locals ()
.line 7,7:3,25 'C:\sources\PdbTarget\B.cs'
IL_0000: ldarg.0
IL_0001: ldstr """"
IL_0006: stfld System.String PdbTarget.B::s
.line 110,110:3,21 'C:\sources\PdbTarget\Program.cs'
IL_000b: ldarg.0
IL_000c: ldc.i4.2
IL_000d: stfld System.Int32 PdbTarget.B::a
.line 111,111:3,21 'C:\sources\PdbTarget\Program.cs'
IL_0012: ldarg.0
IL_0013: ldc.i4.3
IL_0014: stfld System.Int32 PdbTarget.B::b
.line 9,9:3,13 'C:\sources\PdbTarget\B.cs'
IL_0019: ldarg.0
IL_001a: call System.Void System.Object::.ctor()
IL_001f: nop
.line 10,10:3,4 'C:\sources\PdbTarget\B.cs'
IL_0020: nop
.line 11,11:4,19 'C:\sources\PdbTarget\B.cs'
IL_0021: ldstr ""B""
IL_0026: call System.Void System.Console::WriteLine(System.String)
IL_002b: nop
.line 12,12:3,4 'C:\sources\PdbTarget\B.cs'
IL_002c: ret
", main);
});
}
[Test]
public void LocalVariables ()
{
TestPortablePdbModule (module => {
var type = module.GetType ("PdbTarget.Program");
var method = type.GetMethod ("Bar");
var debug_info = method.DebugInformation;
Assert.IsNotNull (debug_info.Scope);
Assert.IsTrue (debug_info.Scope.HasScopes);
Assert.AreEqual (2, debug_info.Scope.Scopes.Count);
var scope = debug_info.Scope.Scopes [0];
Assert.IsNotNull (scope);
Assert.IsTrue (scope.HasVariables);
Assert.AreEqual (1, scope.Variables.Count);
var variable = scope.Variables [0];
Assert.AreEqual ("s", variable.Name);
Assert.IsFalse (variable.IsDebuggerHidden);
Assert.AreEqual (2, variable.Index);
scope = debug_info.Scope.Scopes [1];
Assert.IsNotNull (scope);
Assert.IsTrue (scope.HasVariables);
Assert.AreEqual (1, scope.Variables.Count);
variable = scope.Variables [0];
Assert.AreEqual ("s", variable.Name);
Assert.IsFalse (variable.IsDebuggerHidden);
Assert.AreEqual (3, variable.Index);
Assert.IsTrue (scope.HasScopes);
Assert.AreEqual (1, scope.Scopes.Count);
scope = scope.Scopes [0];
Assert.IsNotNull (scope);
Assert.IsTrue (scope.HasVariables);
Assert.AreEqual (1, scope.Variables.Count);
variable = scope.Variables [0];
Assert.AreEqual ("u", variable.Name);
Assert.IsFalse (variable.IsDebuggerHidden);
Assert.AreEqual (5, variable.Index);
});
}
[Test]
public void LocalConstants ()
{
TestPortablePdbModule (module => {
var type = module.GetType ("PdbTarget.Program");
var method = type.GetMethod ("Bar");
var debug_info = method.DebugInformation;
Assert.IsNotNull (debug_info.Scope);
Assert.IsTrue (debug_info.Scope.HasScopes);
Assert.AreEqual (2, debug_info.Scope.Scopes.Count);
var scope = debug_info.Scope.Scopes [1];
Assert.IsNotNull (scope);
Assert.IsTrue (scope.HasConstants);
Assert.AreEqual (2, scope.Constants.Count);
var constant = scope.Constants [0];
Assert.AreEqual ("b", constant.Name);
Assert.AreEqual (12, constant.Value);
Assert.AreEqual (MetadataType.Int32, constant.ConstantType.MetadataType);
constant = scope.Constants [1];
Assert.AreEqual ("c", constant.Name);
Assert.AreEqual ((decimal) 74, constant.Value);
Assert.AreEqual (MetadataType.ValueType, constant.ConstantType.MetadataType);
method = type.GetMethod ("Foo");
debug_info = method.DebugInformation;
Assert.IsNotNull (debug_info.Scope);
Assert.IsTrue (debug_info.Scope.HasConstants);
Assert.AreEqual (4, debug_info.Scope.Constants.Count);
constant = debug_info.Scope.Constants [0];
Assert.AreEqual ("s", constant.Name);
Assert.AreEqual ("const string", constant.Value);
Assert.AreEqual (MetadataType.String, constant.ConstantType.MetadataType);
constant = debug_info.Scope.Constants [1];
Assert.AreEqual ("f", constant.Name);
Assert.AreEqual (1, constant.Value);
Assert.AreEqual (MetadataType.Int32, constant.ConstantType.MetadataType);
constant = debug_info.Scope.Constants [2];
Assert.AreEqual ("o", constant.Name);
Assert.AreEqual (null, constant.Value);
Assert.AreEqual (MetadataType.Object, constant.ConstantType.MetadataType);
constant = debug_info.Scope.Constants [3];
Assert.AreEqual ("u", constant.Name);
Assert.AreEqual (null, constant.Value);
Assert.AreEqual (MetadataType.String, constant.ConstantType.MetadataType);
});
}
[Test]
public void ImportScope ()
{
TestPortablePdbModule (module => {
var type = module.GetType ("PdbTarget.Program");
var method = type.GetMethod ("Bar");
var debug_info = method.DebugInformation;
Assert.IsNotNull (debug_info.Scope);
var import = debug_info.Scope.Import;
Assert.IsNotNull (import);
Assert.IsFalse (import.HasTargets);
Assert.IsNotNull (import.Parent);
import = import.Parent;
Assert.IsTrue (import.HasTargets);
Assert.AreEqual (9, import.Targets.Count);
var target = import.Targets [0];
Assert.AreEqual (ImportTargetKind.ImportAlias, target.Kind);
Assert.AreEqual ("XML", target.Alias);
target = import.Targets [1];
Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
Assert.AreEqual ("System", target.Namespace);
target = import.Targets [2];
Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
Assert.AreEqual ("System.Collections.Generic", target.Namespace);
target = import.Targets [3];
Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
Assert.AreEqual ("System.IO", target.Namespace);
target = import.Targets [4];
Assert.AreEqual (ImportTargetKind.ImportNamespace, target.Kind);
Assert.AreEqual ("System.Threading.Tasks", target.Namespace);
target = import.Targets [5];
Assert.AreEqual (ImportTargetKind.ImportNamespaceInAssembly, target.Kind);
Assert.AreEqual ("System.Xml.Resolvers", target.Namespace);
Assert.AreEqual ("System.Xml", target.AssemblyReference.Name);
target = import.Targets [6];
Assert.AreEqual (ImportTargetKind.ImportType, target.Kind);
Assert.AreEqual ("System.Console", target.Type.FullName);
target = import.Targets [7];
Assert.AreEqual (ImportTargetKind.ImportType, target.Kind);
Assert.AreEqual ("System.Math", target.Type.FullName);
target = import.Targets [8];
Assert.AreEqual (ImportTargetKind.DefineTypeAlias, target.Kind);
Assert.AreEqual ("Foo", target.Alias);
Assert.AreEqual ("System.Xml.XmlDocumentType", target.Type.FullName);
Assert.IsNotNull (import.Parent);
import = import.Parent;
Assert.IsTrue (import.HasTargets);
Assert.AreEqual (1, import.Targets.Count);
Assert.IsNull (import.Parent);
target = import.Targets [0];
Assert.AreEqual (ImportTargetKind.DefineAssemblyAlias, target.Kind);
Assert.AreEqual ("XML", target.Alias);
Assert.AreEqual ("System.Xml", target.AssemblyReference.Name);
});
}
[Test]
public void StateMachineKickOff ()
{
TestPortablePdbModule (module => {
var state_machine = module.GetType ("PdbTarget.Program/<Baz>d__7");
var main = state_machine.GetMethod ("MoveNext");
var symbol = main.DebugInformation;
Assert.IsNotNull (symbol);
Assert.IsNotNull (symbol.StateMachineKickOffMethod);
Assert.AreEqual ("System.Threading.Tasks.Task PdbTarget.Program::Baz(System.IO.StreamReader)", symbol.StateMachineKickOffMethod.FullName);
});
}
[Test]
public void StateMachineCustomDebugInformation ()
{
TestPortablePdbModule (module => {
var state_machine = module.GetType ("PdbTarget.Program/<Baz>d__7");
var move_next = state_machine.GetMethod ("MoveNext");
Assert.IsTrue (move_next.HasCustomDebugInformations);
Assert.AreEqual (2, move_next.CustomDebugInformations.Count);
var state_machine_scope = move_next.CustomDebugInformations [0] as StateMachineScopeDebugInformation;
Assert.IsNotNull (state_machine_scope);
Assert.AreEqual (0, state_machine_scope.Start.Offset);
Assert.IsTrue (state_machine_scope.End.IsEndOfMethod);
var async_body = move_next.CustomDebugInformations [1] as AsyncMethodBodyDebugInformation;
Assert.IsNotNull (async_body);
Assert.AreEqual (-1, async_body.CatchHandler.Offset);
Assert.AreEqual (2, async_body.Yields.Count);
Assert.AreEqual (61, async_body.Yields [0].Offset);
Assert.AreEqual (221, async_body.Yields [1].Offset);
Assert.AreEqual (2, async_body.Resumes.Count);
Assert.AreEqual (91, async_body.Resumes [0].Offset);
Assert.AreEqual (252, async_body.Resumes [1].Offset);
Assert.AreEqual (move_next, async_body.MoveNextMethod);
});
}
void TestPortablePdbModule (Action<ModuleDefinition> test)
{
TestModule ("PdbTarget.exe", test, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
TestModule ("EmbeddedPdbTarget.exe", test, verify: !Platform.OnMono);
}
[Test]
public void RoundTripCecilPortablePdb ()
{
TestModule ("cecil.dll", module => {
Assert.IsTrue (module.HasSymbols);
}, symbolReaderProvider: typeof (PortablePdbReaderProvider), symbolWriterProvider: typeof (PortablePdbWriterProvider));
}
}
}

Some files were not shown because too many files have changed in this diff Show More