using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
-#if NET_2_0
using System.Collections.Generic;
-#endif
namespace A.B.C {
+ // Disable expected warning
+#pragma warning disable 169
public struct MethodInfoTestStruct {
int p;
}
+#pragma warning restore 169
}
namespace MonoTests.System.Reflection
{
[TestFixture]
public class MethodInfoTest
{
-#if !TARGET_JVM
[DllImport ("libfoo", EntryPoint="foo", CharSet=CharSet.Unicode, ExactSpelling=false, PreserveSig=true, SetLastError=true, BestFitMapping=true, ThrowOnUnmappableChar=true)]
public static extern void dllImportMethod ();
-#endif
[MethodImplAttribute(MethodImplOptions.PreserveSig)]
public void preserveSigMethod ()
{
{
}
+ public interface InterfaceTest
+ {
+ void Clone ();
+ }
+
[Test]
public void IsDefined_AttributeType_Null ()
{
}
}
-#if NET_2_0
[Test]
public void PseudoCustomAttributes ()
{
}
[Test]
- [Category ("TargetJvmNotWorking")]
public void ReturnTypePseudoCustomAttributes ()
{
MethodInfo mi = typeof (MethodInfoTest).GetMethod ("ReturnTypeMarshalAs");
Assert.IsTrue (mi.ReturnTypeCustomAttributes.GetCustomAttributes (typeof (MarshalAsAttribute), true).Length == 1);
}
-#endif
public static int foo (int i, int j)
{
}
[Test]
-#if ONLY_1_1
- [Category ("NotDotNet")] // #A2 fails on MS.NET 1.x
-#endif
public void ByrefVtypeInvoke ()
{
MethodInfo mi = typeof (MethodInfoTest).GetMethod ("ByrefVtype");
method.Invoke (null, new object [0]);
Assert.Fail ("#1");
}
-#if NET_2_0
catch (ThreadAbortException ex) {
Thread.ResetAbort ();
Assert.IsNull (ex.InnerException, "#2");
}
-#else
- catch (TargetInvocationException ex) {
- Thread.ResetAbort ();
- Assert.IsNotNull (ex.InnerException, "#2");
- Assert.AreEqual (typeof (ThreadAbortException), ex.InnerException.GetType (), "#3");
- }
-#endif
}
public static void AbortIt ()
public struct SimpleStruct
{
- int a;
+ public int a;
}
public static unsafe SimpleStruct* PtrFunc2 (SimpleStruct* a, A.B.C.MethodInfoTestStruct *b)
Assert.AreSame (inheritedMethod, baseMethod);
}
-#if NET_2_0
-#if !TARGET_JVM // MethodBody is not supported for TARGET_JVM
[Test]
public void GetMethodBody_Abstract ()
{
- MethodBody mb = typeof (ICloneable).GetMethod ("Clone").GetMethodBody ();
+ MethodBody mb = typeof (InterfaceTest).GetMethod ("Clone").GetMethodBody ();
Assert.IsNull (mb);
}
IList<LocalVariableInfo> locals = mb.LocalVariables;
- // This might break with different compilers etc.
- Assert.AreEqual (2, locals.Count, "#3");
-
- Assert.IsTrue ((locals [0].LocalType == typeof (byte[])) || (locals [1].LocalType == typeof (byte[])), "#4");
- if (locals [0].LocalType == typeof (byte[]))
- Assert.AreEqual (false, locals [0].IsPinned, "#5");
- else
- Assert.AreEqual (false, locals [1].IsPinned, "#6");
+ bool foundPinnedBytePointer = false;
+ unsafe {
+ foreach (LocalVariableInfo lvi in locals) {
+ if (lvi.LocalType == typeof (byte[]))
+ // This is optimized out by CSC in .NET 4.6
+ Assert.IsFalse (lvi.IsPinned, "#3-1");
+
+ if (/* mcs */ lvi.LocalType == typeof (byte*) || /* csc */ lvi.LocalType == typeof (byte).MakeByRefType ()) {
+ foundPinnedBytePointer = true;
+ Assert.IsTrue (lvi.IsPinned, "#3-2");
+ }
+ }
+ }
+ Assert.IsTrue (foundPinnedBytePointer, "#4");
}
-#endif // TARGET_JVM
public int return_parameter_test ()
{
//Assert.IsTrue (pi.IsRetval, "#3");
}
-#if !TARGET_JVM // ReflectionOnly is not supported yet on TARGET_JVM
+ [Test]
+ public void MethodInfoModule ()
+ {
+ Type type = typeof (MethodInfoTest);
+ MethodInfo me = type.GetMethod ("return_parameter_test");
+
+ Assert.AreEqual (type.Module, me.Module);
+ }
+
[Test]
public void InvokeOnRefOnlyAssembly ()
{
Assert.IsNotNull (ex.Message, "#4");
}
}
-#endif // TARGET_JVM
[Test]
[ExpectedException (typeof (TargetInvocationException))]
{
}
}
-#endif
-#if NET_4_0
interface IMethodInvoke<out T>
{
T Test ();
Assert.AreEqual ("MethodInvoke", m0.Invoke (obj, new Object [0]));
Assert.AreEqual ("MethodInvoke", m1.Invoke (obj, new Object [0]));
}
-#endif
public int? Bug12856 ()
var m = GetType ().GetMethod ("Bug12856");
Assert.AreEqual ("System.Nullable`1[System.Int32] Bug12856()", m.ToString (), "#1");
}
+
+#if !MONOTOUCH
+ class GenericClass<T>
+ {
+ public void Method ()
+ {
+ T lv = default(T);
+ Console.WriteLine(lv);
+ }
+
+ public void Method2<K> (T a0, K a1)
+ {
+ T var0 = a0;
+ K var1 = a1;
+ Console.WriteLine (var0);
+ Console.WriteLine (var1);
+ }
+ }
+
+ [Test]
+ public void TestLocalVariableTypes ()
+ {
+ var typeofT = typeof (GenericClass<>).GetGenericArguments () [0];
+ var typeofK = typeof (GenericClass<>).GetMethod ("Method2").GetGenericArguments () [0];
+
+ var type = typeof (GenericClass<>).GetMethod("Method").GetMethodBody().LocalVariables[0].LocalType;
+ Assert.AreEqual (typeofT, type);
+ Assert.AreEqual (typeof (GenericClass<>), type.DeclaringType);
+
+ bool foundTypeOfK = false;
+ bool foundExpectedType = false;
+
+ MethodBody mb = typeof (GenericClass<>).GetMethod("Method2").GetMethodBody();
+ foreach (LocalVariableInfo lvi in mb.LocalVariables) {
+ if (lvi.LocalType == typeofK) {
+ foundTypeOfK = true;
+ Assert.AreEqual (typeof (GenericClass<>), lvi.LocalType.DeclaringType, "#1-1");
+ } else if (lvi.LocalType == typeofT) {
+ foundExpectedType = true;
+ Assert.AreEqual (typeof (GenericClass<>), lvi.LocalType.DeclaringType, "#1-2");
+ }
+ }
+
+ Assert.IsTrue (foundTypeOfK, "#1-3");
+ if (mb.LocalVariables.Count < 2)
+ Assert.Ignore ("Code built in release mode - 'T var0' optmized out");
+ else
+ Assert.IsTrue (foundExpectedType, "#1-4");
+
+ foundTypeOfK = false;
+ foundExpectedType = false;
+ mb = typeof (GenericClass<int>).GetMethod("Method2").GetMethodBody();
+ foreach (LocalVariableInfo lvi in mb.LocalVariables) {
+ if (lvi.LocalType == typeofK) {
+ foundTypeOfK = true;
+ Assert.AreEqual (typeof (GenericClass<>), lvi.LocalType.DeclaringType, "#2-1");
+ } else if (lvi.LocalType == typeof (int)) {
+ foundExpectedType = true;
+ }
+ }
+
+ Assert.IsTrue (foundTypeOfK, "#2-3");
+ if (mb.LocalVariables.Count < 2)
+ Assert.Ignore ("Code built in release mode - 'int var0' optmized out");
+ else
+ Assert.IsTrue (foundExpectedType, "#2-4");
+ }
+#endif
}
-#if NET_2_0
// Helper class
class RefOnlyMethodClass
{
set { _myList = value; }
}
}
-#endif
}
projects / mono.git / blobdiff