275 lines
7.3 KiB
C#
275 lines
7.3 KiB
C#
using System;
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace Mono.Cecil.Tests {
|
|
|
|
[TestFixture]
|
|
public class ParameterTests : BaseTestFixture {
|
|
|
|
[Test]
|
|
public void MarshalAsI4 ()
|
|
{
|
|
TestModule ("marshal.dll", module => {
|
|
var bar = module.GetType ("Bar");
|
|
var pan = bar.GetMethod ("Pan");
|
|
|
|
Assert.AreEqual (1, pan.Parameters.Count);
|
|
|
|
var parameter = pan.Parameters [0];
|
|
|
|
Assert.IsTrue (parameter.HasMarshalInfo);
|
|
var info = parameter.MarshalInfo;
|
|
|
|
Assert.AreEqual (typeof (MarshalInfo), info.GetType ());
|
|
Assert.AreEqual (NativeType.I4, info.NativeType);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void CustomMarshaler ()
|
|
{
|
|
TestModule ("marshal.dll", module => {
|
|
var bar = module.GetType ("Bar");
|
|
var pan = bar.GetMethod ("PanPan");
|
|
|
|
var parameter = pan.Parameters [0];
|
|
|
|
Assert.IsTrue (parameter.HasMarshalInfo);
|
|
|
|
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 ("Boc", info.ManagedType.FullName);
|
|
Assert.AreEqual (module, info.ManagedType.Scope);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void SafeArrayMarshaler ()
|
|
{
|
|
TestModule ("marshal.dll", module => {
|
|
var bar = module.GetType ("Bar");
|
|
var pan = bar.GetMethod ("PanPan");
|
|
|
|
Assert.IsTrue (pan.MethodReturnType.HasMarshalInfo);
|
|
|
|
var info = (SafeArrayMarshalInfo) pan.MethodReturnType.MarshalInfo;
|
|
|
|
Assert.AreEqual (VariantType.Dispatch, info.ElementType);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void ArrayMarshaler ()
|
|
{
|
|
TestModule ("marshal.dll", module => {
|
|
var bar = module.GetType ("Bar");
|
|
var pan = bar.GetMethod ("PanPan");
|
|
|
|
var parameter = pan.Parameters [1];
|
|
|
|
Assert.IsTrue (parameter.HasMarshalInfo);
|
|
|
|
var info = (ArrayMarshalInfo) parameter.MarshalInfo;
|
|
|
|
Assert.AreEqual (NativeType.I8, info.ElementType);
|
|
Assert.AreEqual (66, info.Size);
|
|
Assert.AreEqual (2, info.SizeParameterIndex);
|
|
|
|
parameter = pan.Parameters [3];
|
|
|
|
Assert.IsTrue (parameter.HasMarshalInfo);
|
|
|
|
info = (ArrayMarshalInfo) parameter.MarshalInfo;
|
|
|
|
Assert.AreEqual (NativeType.I2, info.ElementType);
|
|
Assert.AreEqual (-1, info.Size);
|
|
Assert.AreEqual (-1, info.SizeParameterIndex);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void ArrayMarshalerSized ()
|
|
{
|
|
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.IsNotNull (array_info);
|
|
|
|
Assert.AreEqual (0, array_info.SizeParameterMultiplier);
|
|
});
|
|
}
|
|
|
|
[Test]
|
|
public void NullableConstant ()
|
|
{
|
|
TestModule ("nullable-constant.exe", module => {
|
|
var type = module.GetType ("Program");
|
|
var method = type.GetMethod ("Foo");
|
|
|
|
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]
|
|
public void AddParameterIndex ()
|
|
{
|
|
var object_ref = new TypeReference ("System", "Object", null, null, false);
|
|
var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref);
|
|
|
|
var x = new ParameterDefinition ("x", ParameterAttributes.None, object_ref);
|
|
var y = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
|
|
|
|
method.Parameters.Add (x);
|
|
method.Parameters.Add (y);
|
|
|
|
Assert.AreEqual (0, x.Index);
|
|
Assert.AreEqual (1, y.Index);
|
|
|
|
Assert.AreEqual (method, x.Method);
|
|
Assert.AreEqual (method, y.Method);
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveAtParameterIndex ()
|
|
{
|
|
var object_ref = new TypeReference ("System", "Object", null, null, false);
|
|
var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref);
|
|
|
|
var x = new ParameterDefinition ("x", ParameterAttributes.None, object_ref);
|
|
var y = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
|
|
var z = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
|
|
|
|
method.Parameters.Add (x);
|
|
method.Parameters.Add (y);
|
|
method.Parameters.Add (z);
|
|
|
|
Assert.AreEqual (0, x.Index);
|
|
Assert.AreEqual (1, y.Index);
|
|
Assert.AreEqual (2, z.Index);
|
|
|
|
method.Parameters.RemoveAt (1);
|
|
|
|
Assert.AreEqual (0, x.Index);
|
|
Assert.AreEqual (-1, y.Index);
|
|
Assert.AreEqual (1, z.Index);
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveParameterIndex ()
|
|
{
|
|
var object_ref = new TypeReference ("System", "Object", null, null, false);
|
|
var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref);
|
|
|
|
var x = new ParameterDefinition ("x", ParameterAttributes.None, object_ref);
|
|
var y = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
|
|
var z = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
|
|
|
|
method.Parameters.Add (x);
|
|
method.Parameters.Add (y);
|
|
method.Parameters.Add (z);
|
|
|
|
Assert.AreEqual (0, x.Index);
|
|
Assert.AreEqual (1, y.Index);
|
|
Assert.AreEqual (2, z.Index);
|
|
|
|
method.Parameters.Remove (y);
|
|
|
|
Assert.AreEqual (0, x.Index);
|
|
Assert.AreEqual (-1, y.Index);
|
|
Assert.AreEqual (1, z.Index);
|
|
}
|
|
|
|
[Test]
|
|
public void InsertParameterIndex ()
|
|
{
|
|
var object_ref = new TypeReference ("System", "Object", null, null, false);
|
|
var method = new MethodDefinition ("foo", MethodAttributes.Static, object_ref);
|
|
|
|
var x = new ParameterDefinition ("x", ParameterAttributes.None, object_ref);
|
|
var y = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
|
|
var z = new ParameterDefinition ("y", ParameterAttributes.None, object_ref);
|
|
|
|
method.Parameters.Add (x);
|
|
method.Parameters.Add (z);
|
|
|
|
Assert.AreEqual (0, x.Index);
|
|
Assert.AreEqual (-1, y.Index);
|
|
Assert.AreEqual (1, z.Index);
|
|
|
|
method.Parameters.Insert (1, y);
|
|
|
|
Assert.AreEqual (0, x.Index);
|
|
Assert.AreEqual (1, y.Index);
|
|
Assert.AreEqual (2, z.Index);
|
|
}
|
|
|
|
[Test]
|
|
public void GenericParameterConstant ()
|
|
{
|
|
TestIL ("hello.il", module => {
|
|
var foo = module.GetType ("Foo");
|
|
var method = foo.GetMethod ("GetState");
|
|
|
|
Assert.IsNotNull (method);
|
|
|
|
var parameter = method.Parameters [1];
|
|
|
|
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);
|
|
});
|
|
}
|
|
}
|
|
}
|