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

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]