mcs/class/corlib/Test/System.Reflection/MethodInfoTest.cs

   1 //
   2 // System.Reflection.MethodInfo Test Cases
   3 //
   4 // Authors:
   5 //  Zoltan Varga (vargaz@gmail.com)
   6 //  Aleksey Kliger (aleksey@xamarin.com)
   7 //
   8 // (c) 2003 Ximian, Inc. (http://www.ximian.com)
   9 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
  10 // Copyright (C) 2015 Xamarin, Inc. (http://www.xamarin.com)
  11 //
  12 // Permission is hereby granted, free of charge, to any person obtaining
  13 // a copy of this software and associated documentation files (the
  14 // "Software"), to deal in the Software without restriction, including
  15 // without limitation the rights to use, copy, modify, merge, publish,
  16 // distribute, sublicense, and/or sell copies of the Software, and to
  17 // permit persons to whom the Software is furnished to do so, subject to
  18 // the following conditions:
  19 //
  20 // The above copyright notice and this permission notice shall be
  21 // included in all copies or substantial portions of the Software.
  22 //
  23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30 //
  31
  32 using NUnit.Framework;
  33 using System;
  34 using System.Threading;
  35 using System.Reflection;
  36 #if !MONOTOUCH
  37 using System.Reflection.Emit;
  38 #endif
  39 using System.Runtime.InteropServices;
  40 using System.Runtime.CompilerServices;
  41
  42 using System.Collections.Generic;
  43
  44 namespace A.B.C {
  45         // Disable expected warning
  46 #pragma warning disable 169
  47         public struct MethodInfoTestStruct {
  48                 int p;
  49         }
  50 #pragma warning restore 169
  51 }
  52 namespace MonoTests.System.Reflection
  53 {
  54         [TestFixture]
  55         public class MethodInfoTest
  56         {
  57 #if MONOTOUCH
  58                 // use an existing symbol - so we can build without dlsym. It does not matter that the signature does not match for the test
  59                 [DllImport ("libc", EntryPoint="readlink", CharSet=CharSet.Unicode, ExactSpelling=false, PreserveSig=true, SetLastError=true, BestFitMapping=true, ThrowOnUnmappableChar=true)]
  60 #else
  61                 [DllImport ("libfoo", EntryPoint="foo", CharSet=CharSet.Unicode, ExactSpelling=false, PreserveSig=true, SetLastError=true, BestFitMapping=true, ThrowOnUnmappableChar=true)]
  62 #endif
  63                 public static extern void dllImportMethod ();
  64                 [MethodImplAttribute(MethodImplOptions.PreserveSig)]
  65                 public void preserveSigMethod ()
  66                 {
  67                 }
  68
  69                 [MethodImplAttribute(MethodImplOptions.Synchronized)]
  70                 public void synchronizedMethod ()
  71                 {
  72                 }
  73
  74                 public interface InterfaceTest
  75                 {
  76                         void Clone ();
  77                 }
  78
  79                 [Test]
  80                 public void IsDefined_AttributeType_Null ()
  81                 {
  82                         MethodInfo mi = typeof (MethodInfoTest).GetMethod ("foo");
  83
  84                         try {
  85                                 mi.IsDefined ((Type) null, false);
  86                                 Assert.Fail ("#1");
  87                         } catch (ArgumentNullException ex) {
  88                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
  89                                 Assert.IsNull (ex.InnerException, "#3");
  90                                 Assert.IsNotNull (ex.Message, "#4");
  91                                 Assert.IsNotNull (ex.ParamName, "#5");
  92                                 Assert.AreEqual ("attributeType", ex.ParamName, "#6");
  93                         }
  94                 }
  95
  96                 [Test]
  97                 public void TestInvokeByRefReturnMethod ()
  98                 {
  99                         try {
 100                                 MethodInfo m = typeof (int[]).GetMethod ("Address");
 101                                 m.Invoke (new int[1], new object[] { 0 });
 102                                 Assert.Fail ("#1");
 103                         } catch (NotSupportedException e) {
 104                                 Assert.AreEqual (typeof (NotSupportedException), e.GetType (), "#2");
 105                                 Assert.IsNull (e.InnerException, "#3");
 106                                 Assert.IsNotNull (e.Message, "#4");
 107                         }
 108                 }
 109
 110                 [Test]
 111                 public void PseudoCustomAttributes ()
 112                 {
 113                         Type t = typeof (MethodInfoTest);
 114
 115                         DllImportAttribute attr = (DllImportAttribute)((t.GetMethod ("dllImportMethod").GetCustomAttributes (typeof (DllImportAttribute), true)) [0]);
 116
 117                         Assert.AreEqual (CallingConvention.Winapi, attr.CallingConvention, "#1");
 118 #if MONOTOUCH
 119                         Assert.AreEqual ("readlink", attr.EntryPoint, "#2");
 120                         Assert.AreEqual ("libc", attr.Value, "#3");
 121 #else
 122                         Assert.AreEqual ("foo", attr.EntryPoint, "#2");
 123                         Assert.AreEqual ("libfoo", attr.Value, "#3");
 124 #endif
 125                         Assert.AreEqual (CharSet.Unicode, attr.CharSet, "#4");
 126                         Assert.AreEqual (false, attr.ExactSpelling, "#5");
 127                         Assert.AreEqual (true, attr.PreserveSig, "#6");
 128                         Assert.AreEqual (true, attr.SetLastError, "#7");
 129                         Assert.AreEqual (true, attr.BestFitMapping, "#8");
 130                         Assert.AreEqual (true, attr.ThrowOnUnmappableChar, "#9");
 131
 132                         PreserveSigAttribute attr2 = (PreserveSigAttribute)((t.GetMethod ("preserveSigMethod").GetCustomAttributes (true)) [0]);
 133
 134                         // This doesn't work under MS.NET
 135                         /*
 136                           MethodImplAttribute attr3 = (MethodImplAttribute)((t.GetMethod ("synchronizedMethod").GetCustomAttributes (true)) [0]);
 137                         */
 138                 }
 139
 140                 [return: MarshalAs (UnmanagedType.Interface)]
 141                 public void ReturnTypeMarshalAs ()
 142                 {
 143                 }
 144
 145                 [Test]
 146                 public void ReturnTypePseudoCustomAttributes ()
 147                 {
 148                         MethodInfo mi = typeof (MethodInfoTest).GetMethod ("ReturnTypeMarshalAs");
 149
 150                         Assert.IsTrue (mi.ReturnTypeCustomAttributes.GetCustomAttributes (typeof (MarshalAsAttribute), true).Length == 1);
 151                 }
 152
 153                 public static int foo (int i, int j)
 154                 {
 155                         return i + j;
 156                 }
 157
 158                 [Test]
 159                 public void StaticInvokeWithObject ()
 160                 {
 161                         MethodInfo mi = typeof (MethodInfoTest).GetMethod ("foo");
 162
 163                         mi.Invoke (new Object (), new object [] { 1, 2 });
 164                 }
 165
 166                 [Test]
 167                 public void ByRefInvoke ()
 168                 {
 169                         MethodInfo met = typeof(MethodInfoTest).GetMethod ("ByRefTest");
 170                         object[] parms = new object[] {1};
 171                         met.Invoke (null, parms);
 172                         Assert.AreEqual (2, parms[0]);
 173                 }
 174
 175                 public static void ByRefTest (ref int a1)
 176                 {
 177                         if (a1 == 1)
 178                                 a1 = 2;
 179                 }
 180
 181                 static int byref_arg;
 182
 183                 public static void ByrefVtype (ref int i) {
 184                         byref_arg = i;
 185                         i = 5;
 186                 }
 187
 188                 [Test]
 189                 public void ByrefVtypeInvoke ()
 190                 {
 191                         MethodInfo mi = typeof (MethodInfoTest).GetMethod ("ByrefVtype");
 192
 193                         object o = 1;
 194                         object[] args = new object [] { o };
 195                         mi.Invoke (null, args);
 196                         Assert.AreEqual (1, byref_arg, "#A1");
 197                         Assert.AreEqual (1, o, "#A2");
 198                         Assert.AreEqual (5, args[0], "#A3");
 199
 200                         args [0] = null;
 201                         mi.Invoke (null, args);
 202                         Assert.AreEqual (0, byref_arg, "#B1");
 203                         Assert.AreEqual (5, args[0], "#B2");
 204                 }
 205
 206                 public void HeyHey (out string out1, ref DateTime ref1)
 207                 {
 208                         out1 = null;
 209                 }
 210
 211                 public void SignatureTest (__arglist)
 212                 {
 213                 }
 214
 215                 public static unsafe int* PtrFunc (int* a)
 216                 {
 217                         return (int*) 0;
 218                 }
 219
 220 #if MONO_FEATURE_THREAD_ABORT
 221                 [Test] // bug #81538
 222                 public void InvokeThreadAbort ()
 223                 {
 224                         MethodInfo method = typeof (MethodInfoTest).GetMethod ("AbortIt");
 225                         try {
 226                                 method.Invoke (null, new object [0]);
 227                                 Assert.Fail ("#1");
 228                         }
 229                         catch (ThreadAbortException ex) {
 230                                 Thread.ResetAbort ();
 231                                 Assert.IsNull (ex.InnerException, "#2");
 232                         }
 233                 }
 234
 235                 public static void AbortIt ()
 236                 {
 237                         Thread.CurrentThread.Abort ();
 238                 }
 239 #endif
 240
 241                 [Test] // bug #76541
 242                 public void ToStringByRef ()
 243                 {
 244                         Assert.AreEqual ("Void HeyHey(System.String ByRef, System.DateTime ByRef)",
 245                                 this.GetType ().GetMethod ("HeyHey").ToString ());
 246                 }
 247
 248                 [Test]
 249                 public void ToStringArgList ()
 250                 {
 251                         Assert.AreEqual ("Void SignatureTest(...)",
 252                                 this.GetType ().GetMethod ("SignatureTest").ToString ());
 253                 }
 254
 255                 [Test]
 256                 public void ToStringWithPointerSignatures () //bug #409583
 257                 {
 258                         Assert.AreEqual ("Int32* PtrFunc(Int32*)", this.GetType ().GetMethod ("PtrFunc").ToString ());
 259                 }
 260
 261                 public struct SimpleStruct
 262                 {
 263                         public int a;
 264                 }
 265
 266                 public static unsafe SimpleStruct* PtrFunc2 (SimpleStruct* a, A.B.C.MethodInfoTestStruct *b)
 267                 {
 268                         return (SimpleStruct*) 0;
 269                 }
 270
 271                 [Test]
 272                 public void ToStringWithPointerSignaturesToNonPrimitiveType ()
 273                 {
 274                         Assert.AreEqual ("SimpleStruct* PtrFunc2(SimpleStruct*, A.B.C.MethodInfoTestStruct*)",
 275                                 this.GetType ().GetMethod ("PtrFunc2").ToString ());
 276                 }
 277                 [Test]
 278                 public void ToStringGenericMethod ()
 279                 {
 280                         Assert.AreEqual ("System.Collections.ObjectModel.ReadOnlyCollection`1[T] AsReadOnly[T](T[])",
 281                                 typeof (Array).GetMethod ("AsReadOnly").ToString ());
 282                 }
 283
 284                 class GBD_A         { public virtual     void f () {} }
 285                 class GBD_B : GBD_A { public override    void f () {} }
 286                 class GBD_C : GBD_B { public override    void f () {} }
 287                 class GBD_D : GBD_C { public new virtual void f () {} }
 288                 class GBD_E : GBD_D { public override    void f () {} }
 289
 290                 [Test]
 291                 public void GetBaseDefinition ()
 292                 {
 293                         Assert.AreEqual (typeof (GBD_A), typeof (GBD_C).GetMethod ("f").GetBaseDefinition ().DeclaringType);
 294                         Assert.AreEqual (typeof (GBD_D), typeof (GBD_D).GetMethod ("f").GetBaseDefinition ().DeclaringType);
 295                         Assert.AreEqual (typeof (GBD_D), typeof (GBD_E).GetMethod ("f").GetBaseDefinition ().DeclaringType);
 296                 }
 297
 298                 class GenericBase<T,H> {
 299                         public virtual void f2 () { }
 300                 }
 301
 302                 class GenericMid<T, U> : GenericBase<T, Action<U>> {
 303                         public virtual T f1 () { return default (T); }
 304                 }
 305
 306                 class GenericChild<T> : GenericMid<T, int> {
 307                         public override T f1 () { return default (T); }
 308                         public override void f2 () { }
 309                 }
 310
 311                 [Test]
 312                 public void GetBaseDefinition_OpenConstructedBaseType () // 36305
 313                 {
 314                         var t = typeof (GenericChild<string>);
 315
 316                         var mi1 = t.GetMethod ("f1");
 317                         var mi1_base = mi1.GetBaseDefinition ();
 318
 319                         Assert.AreEqual (typeof (GenericMid<string, int>), mi1_base.DeclaringType, "#1");
 320
 321                         var mi2 = t.GetMethod ("f2");
 322                         var mi2_base = mi2.GetBaseDefinition ();
 323
 324                         Assert.AreEqual (typeof (GenericBase<string, Action<int>>), mi2_base.DeclaringType, "#2");
 325                 }
 326
 327                 class TestInheritedMethodA {
 328                         private void TestMethod ()
 329                         {
 330                         }
 331
 332                         public void TestMethod2 ()
 333                         {
 334                         }
 335                 }
 336
 337                 class TestInheritedMethodB : TestInheritedMethodA {
 338                 }
 339
 340                 [Test]
 341                 public void InheritanceTestGetMethodTest ()
 342                 {
 343                         MethodInfo inheritedMethod = typeof(TestInheritedMethodB).GetMethod("TestMethod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 344                         MethodInfo baseMethod = typeof(TestInheritedMethodB).GetMethod("TestMethod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 345                         Assert.AreSame (inheritedMethod, baseMethod);
 346
 347                         MethodInfo inheritedMethod2 = typeof(TestInheritedMethodB).GetMethod("TestMethod2", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 348                         MethodInfo baseMethod2 = typeof(TestInheritedMethodB).GetMethod("TestMethod2", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
 349                         Assert.AreSame (inheritedMethod, baseMethod);
 350                 }
 351
 352                 [Test]
 353                 public void GetMethodBody_Abstract ()
 354                 {
 355                         MethodBody mb = typeof (InterfaceTest).GetMethod ("Clone").GetMethodBody ();
 356                         Assert.IsNull (mb);
 357                 }
 358
 359                 [Test]
 360                 public void GetMethodBody_Runtime ()
 361                 {
 362                         MethodBody mb = typeof (AsyncCallback).GetMethod ("Invoke").GetMethodBody ();
 363                         Assert.IsNull (mb);
 364                 }
 365
 366                 [Test]
 367                 public void GetMethodBody_Pinvoke ()
 368                 {
 369                         MethodBody mb = typeof (MethodInfoTest).GetMethod ("dllImportMethod").GetMethodBody ();
 370                         Assert.IsNull (mb);
 371                 }
 372
 373                 [Test]
 374                 public void GetMethodBody_Icall ()
 375                 {
 376                         foreach (MethodInfo mi in typeof (object).GetMethods (BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Instance))
 377                                 if ((mi.GetMethodImplementationFlags () & MethodImplAttributes.InternalCall) != 0) {
 378                                         MethodBody mb = mi.GetMethodBody ();
 379                                         Assert.IsNull (mb);
 380                                 }
 381                 }
 382
 383                 public static void locals_method ()
 384                 {
 385                         byte[] b = new byte [10];
 386
 387                         unsafe {
 388                                 /* This generates a pinned local */
 389                                 fixed (byte *p = &b [0]) {
 390                                 }
 391                         }
 392                 }
 393
 394                 [Test]
 395                 public void GetMethodBody ()
 396                 {
 397 #if MONOTOUCH && !DEBUG
 398                         Assert.Ignore ("Release app (on devices) are stripped of (managed) IL so this test would fail");
 399 #endif
 400                         MethodBody mb = typeof (MethodInfoTest).GetMethod ("locals_method").GetMethodBody ();
 401
 402                         Assert.IsTrue (mb.InitLocals, "#1");
 403                         Assert.IsTrue (mb.LocalSignatureMetadataToken > 0, "#2");
 404
 405                         IList<LocalVariableInfo> locals = mb.LocalVariables;
 406
 407                         bool foundPinnedBytePointer = false;
 408                         unsafe {
 409                                 foreach (LocalVariableInfo lvi in locals) {
 410                                         if (lvi.LocalType == typeof (byte[]))
 411                                                 // This is optimized out by CSC in .NET 4.6
 412                                                 Assert.IsFalse (lvi.IsPinned, "#3-1");
 413
 414                                         if (/* mcs */ lvi.LocalType == typeof (byte*) || /* csc */ lvi.LocalType == typeof (byte).MakeByRefType ()) {
 415                                                 foundPinnedBytePointer = true;
 416                                                 Assert.IsTrue (lvi.IsPinned, "#3-2");
 417                                         }
 418                                 }
 419                         }
 420                         Assert.IsTrue (foundPinnedBytePointer, "#4");
 421                 }
 422
 423                 public int return_parameter_test ()
 424                 {
 425                         return 0;
 426                 }
 427
 428                 [Test]
 429                 public void GetMethodFromHandle_Generic ()
 430                 {
 431                         MethodHandleTest<int> test = new MethodHandleTest<int> ();
 432                         RuntimeMethodHandle mh = test.GetType ().GetProperty ("MyList")
 433                                 .GetGetMethod ().MethodHandle;
 434                         MethodBase mb = MethodInfo.GetMethodFromHandle (mh,
 435                                 typeof (MethodHandleTest<int>).TypeHandle);
 436                         Assert.IsNotNull (mb, "#1");
 437                         List<int> list = (List<int>) mb.Invoke (test, null);
 438                         Assert.IsNotNull (list, "#2");
 439                         Assert.AreEqual (1, list.Count, "#3");
 440                 }
 441
 442                 [Test]
 443                 public void ReturnParameter ()
 444                 {
 445                         ParameterInfo pi = typeof (MethodInfoTest).GetMethod ("return_parameter_test").ReturnParameter;
 446                         Assert.AreEqual (typeof (int), pi.ParameterType, "#1");
 447                         Assert.AreEqual (-1, pi.Position, "#2");
 448                         // MS always return false here
 449                         //Assert.IsTrue (pi.IsRetval, "#3");
 450                 }
 451
 452                 [Test]
 453                 public void MethodInfoModule ()
 454                 {
 455                         Type type = typeof (MethodInfoTest);
 456                         MethodInfo me = type.GetMethod ("return_parameter_test");
 457
 458                         Assert.AreEqual (type.Module, me.Module);
 459                 }
 460
 461                 [Test]
 462                         public void InvokeOnRefOnlyAssembly ()
 463                 {
 464                         Assembly a = Assembly.ReflectionOnlyLoad (typeof (MethodInfoTest).Assembly.FullName);
 465                         Type t = a.GetType (typeof (RefOnlyMethodClass).FullName);
 466                         MethodInfo m = t.GetMethod ("RefOnlyMethod", BindingFlags.Static | BindingFlags.NonPublic);
 467                         try {
 468                                 m.Invoke (null, new object [0]);
 469                                 Assert.Fail ("#1");
 470                         } catch (InvalidOperationException ex) {
 471                                 // The requested operation is invalid in the
 472                                 // ReflectionOnly context
 473                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 474                                 Assert.IsNull (ex.InnerException, "#3");
 475                                 Assert.IsNotNull (ex.Message, "#4");
 476                         }
 477                 }
 478
 479                 [Test]
 480                 [ExpectedException (typeof (TargetInvocationException))]
 481                 public void InvokeInvalidOpExceptionThrow () {
 482                         MethodInfo mi = typeof (MethodInfoTest).GetMethod ("ThrowMethod");
 483                         mi.Invoke(null, null);
 484                 }
 485
 486                 public static void ThrowMethod () {
 487                         throw new InvalidOperationException ();
 488                 }
 489
 490                 [Test]
 491                 public void InvokeGenericVtype ()
 492                 {
 493                         KeyValuePair<string, uint> kvp = new KeyValuePair<string, uint> ("a", 21);
 494                         Type type = kvp.GetType ();
 495                         Type [] arguments = type.GetGenericArguments ();
 496                         MethodInfo method = typeof (MethodInfoTest).GetMethod ("Go");
 497                         MethodInfo generic_method = method.MakeGenericMethod (arguments);
 498                         kvp = (KeyValuePair<string, uint>)generic_method.Invoke (null, new object [] { kvp });
 499
 500                         Assert.AreEqual ("a", kvp.Key, "#1");
 501                         Assert.AreEqual (21, kvp.Value, "#2");
 502                 }
 503
 504                 public static KeyValuePair<T1, T2> Go <T1, T2> (KeyValuePair <T1, T2> kvp)
 505                 {
 506                         return kvp;
 507                 }
 508
 509                 [Test] // bug #81997
 510                 public void InvokeGenericInst ()
 511                 {
 512                         List<string> str = null;
 513
 514                         object [] methodArgs = new object [] { str };
 515                         MethodInfo mi = typeof (MethodInfoTest).GetMethod ("GenericRefMethod");
 516                         mi.Invoke (null, methodArgs);
 517                         Assert.IsNotNull (methodArgs [0], "#A1");
 518                         Assert.IsNull (str, "#A2");
 519                         Assert.IsTrue (methodArgs [0] is List<string>, "#A3");
 520
 521                         List<string> refStr = methodArgs [0] as List<string>;
 522                         Assert.IsNotNull (refStr, "#B1");
 523                         Assert.AreEqual (1, refStr.Count, "#B2");
 524                         Assert.AreEqual ("test", refStr [0], "#B3");
 525                 }
 526
 527                 public static void GenericRefMethod (ref List<string> strArg)
 528                 {
 529                         strArg = new List<string> ();
 530                         strArg.Add ("test");
 531                 }
 532
 533                 public void MakeGenericMethodArgsMismatchFoo<T> ()
 534                 {
 535                 }
 536
 537                 [Test]
 538                 public void MakeGenericMethodArgsMismatch ()
 539                 {
 540                         MethodInfo gmi = this.GetType ().GetMethod (
 541                                 "MakeGenericMethodArgsMismatchFoo");
 542                         try {
 543                                 gmi.MakeGenericMethod ();
 544                                 Assert.Fail ("#1");
 545                         } catch (ArgumentException ex) {
 546                                 // The type or method has 1 generic parameter(s),
 547                                 // but 0 generic argument(s) were provided. A
 548                                 // generic argument must be provided for each
 549                                 // generic parameter
 550                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 551                                 Assert.IsNull (ex.InnerException, "#3");
 552                                 Assert.IsNotNull (ex.Message, "#4");
 553                                 Assert.IsNull (ex.ParamName, "#5");
 554                         }
 555                 }
 556
 557                 public void SimpleGenericMethod<TFoo, TBar> () {}
 558
 559                 [Test]
 560                 public void MakeGenericMethodWithNullArray ()
 561                 {
 562                         MethodInfo gmi = this.GetType ().GetMethod ("SimpleGenericMethod");
 563                         try {
 564                                 gmi.MakeGenericMethod ((Type []) null);
 565                                 Assert.Fail ("#1");
 566                         } catch (ArgumentNullException ex) {
 567                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 568                                 Assert.IsNull (ex.InnerException, "#3");
 569                                 Assert.IsNotNull (ex.Message, "#4");
 570                                 Assert.AreEqual ("methodInstantiation", ex.ParamName, "#5");
 571                         }
 572                 }
 573
 574                 [Test]
 575                 public void MakeGenericMethodWithNullValueInTypesArray ()
 576                 {
 577                         MethodInfo gmi = this.GetType ().GetMethod ("SimpleGenericMethod");
 578                         try {
 579                                 gmi.MakeGenericMethod (new Type [] { typeof (int), null });
 580                                 Assert.Fail ("#1");
 581                         } catch (ArgumentNullException ex) {
 582                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 583                                 Assert.IsNull (ex.InnerException, "#3");
 584                                 Assert.IsNotNull (ex.Message, "#4");
 585                                 Assert.IsNull (ex.ParamName, "#5");
 586                         }
 587                 }
 588
 589                 [Test]
 590                 public void MakeGenericMethodWithNonGenericMethodDefinitionMethod ()
 591                 {
 592                         MethodInfo gmi = this.GetType ().GetMethod ("SimpleGenericMethod");
 593                         MethodInfo inst = gmi.MakeGenericMethod (typeof (int), typeof (double));
 594                         try {
 595                                 inst.MakeGenericMethod (typeof (int), typeof (double));
 596                                 Assert.Fail ("#1");
 597                         } catch (InvalidOperationException ex) {
 598                         }
 599                 }
 600 #if !MONOTOUCH
 601                 public TFoo SimpleGenericMethod2<TFoo, TBar> () { return default (TFoo); }
 602                 /*Test for the uggly broken behavior of SRE.*/
 603                 [Test]
 604                 public void MakeGenericMethodWithSreTypeResultsInStupidMethodInfo ()
 605                 {
 606                         AssemblyName assemblyName = new AssemblyName ();
 607                         assemblyName.Name = "MonoTests.System.Reflection.Emit.MethodInfoTest";
 608                         AssemblyBuilder assembly = Thread.GetDomain ().DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.RunAndSave, ".");
 609                         ModuleBuilder module = assembly.DefineDynamicModule ("module1", "tst.dll");
 610                         TypeBuilder tb = module.DefineType ("Test", TypeAttributes.Public);
 611
 612                         MethodInfo gmi = this.GetType ().GetMethod ("SimpleGenericMethod2");
 613                         MethodInfo ins = gmi.MakeGenericMethod (typeof (int), tb);
 614
 615                         Assert.AreSame (tb, ins.GetGenericArguments () [1], "#1");
 616                         /*broken ReturnType*/
 617                         Assert.AreSame (gmi.GetGenericArguments () [0], ins.ReturnType, "#2");
 618                 }
 619 #endif
 620                 public static int? pass_nullable (int? i)
 621                 {
 622                         return i;
 623                 }
 624
 625                 [Test]
 626                 public void NullableTests ()
 627                 {
 628                         MethodInfo mi = typeof (MethodInfoTest).GetMethod ("pass_nullable");
 629                         Assert.AreEqual (102, mi.Invoke (null, new object [] { 102 }), "#1");
 630                         Assert.AreEqual (null, mi.Invoke (null, new object [] { null }), "#2");
 631
 632                         // Test conversion of vtype to a nullable type for the this argument
 633                         PropertyInfo pi = typeof (Nullable <int>).GetProperty ("HasValue");
 634                         Assert.AreEqual (true, pi.GetGetMethod ().Invoke (10, null));
 635                         PropertyInfo pi2 = typeof (Nullable <int>).GetProperty ("Value");
 636                         Assert.AreEqual (10, pi2.GetGetMethod ().Invoke (10, null));
 637                 }
 638
 639                 public static void foo_generic<T> ()
 640                 {
 641                 }
 642
 643                 [Test]
 644                 public void IsGenericMethod ()
 645                 {
 646                         MethodInfo mi = typeof (MethodInfoTest).GetMethod ("foo_generic");
 647                         Assert.AreEqual (true, mi.IsGenericMethod, "#1");
 648                         MethodInfo mi2 = mi.MakeGenericMethod (new Type[] { typeof (int) });
 649                         Assert.AreEqual (true, mi2.IsGenericMethod, "#2");
 650                         MethodInfo mi3 = typeof (GenericHelper<int>).GetMethod ("Test");
 651                         Assert.AreEqual (false, mi3.IsGenericMethod, "#3");
 652                 }
 653
 654                 class A<T>
 655                 {
 656                         public static void Foo<T2> (T2 i)
 657                         {
 658                         }
 659
 660                         public static void Bar ()
 661                         {
 662                         }
 663
 664                         public class B
 665                         {
 666                                 public static void Baz ()
 667                                 {
 668                                 }
 669                         }
 670                 }
 671
 672                 [Test]
 673                 public void ContainsGenericParameters ()
 674                 {
 675                         // Non-generic method in open generic type
 676                         Assert.IsTrue (typeof (A<int>).GetGenericTypeDefinition ().GetMethod ("Bar").ContainsGenericParameters);
 677                         // open generic method in closed generic type
 678                         Assert.IsTrue (typeof (A<int>).GetMethod ("Foo").ContainsGenericParameters);
 679                         // non-generic method in closed generic type
 680                         Assert.IsFalse (typeof (A<int>).GetMethod ("Bar").ContainsGenericParameters);
 681                         // closed generic method in closed generic type
 682                         Assert.IsFalse (typeof (A<int>).GetMethod ("Foo").MakeGenericMethod (new Type [] { typeof (int) }).ContainsGenericParameters);
 683                         // non-generic method in non-generic nested type of closed generic type
 684                         Assert.IsFalse (typeof (A<int>.B).GetMethod ("Baz").ContainsGenericParameters);
 685                         // non-generic method in non-generic nested type of open generic type
 686                         Assert.IsTrue (typeof (A<int>.B).GetGenericTypeDefinition ().GetMethod ("Baz").ContainsGenericParameters);
 687                 }
 688
 689                 [Test]
 690                 public void IsGenericMethodDefinition ()
 691                 {
 692                         MethodInfo m1 = typeof (A<>).GetMethod ("Foo");
 693                         Assert.IsTrue (m1.IsGenericMethod, "#A1");
 694                         Assert.IsTrue (m1.IsGenericMethodDefinition, "#A2");
 695
 696                         MethodInfo m2 = typeof (A<int>).GetMethod ("Foo");
 697                         Assert.IsTrue (m2.IsGenericMethod, "#B1");
 698                         Assert.IsTrue (m2.IsGenericMethodDefinition, "#B2");
 699
 700                         MethodInfo m3 = m2.MakeGenericMethod (typeof (int));
 701                         Assert.IsTrue (m3.IsGenericMethod, "#C1");
 702                         Assert.IsFalse (m3.IsGenericMethodDefinition, "#C2");
 703                 }
 704
 705                 [Test]
 706                 public void GetGenericMethodDefinition ()
 707                 {
 708                         MethodInfo mi1 = typeof (MyList<>).GetMethod ("ConvertAll");
 709                         MethodInfo mi2 = typeof (MyList<int>).GetMethod ("ConvertAll");
 710
 711                         Assert.AreEqual ("MonoTests.System.Reflection.MethodInfoTest+Foo`2[T,TOutput]",
 712                                          mi1.GetParameters () [0].ParameterType.ToString (), "#A1");
 713                         Assert.AreEqual ("MonoTests.System.Reflection.MethodInfoTest+Foo`2[System.Int32,TOutput]",
 714                                          mi2.GetParameters () [0].ParameterType.ToString (), "#A2");
 715                         Assert.IsTrue (mi1.IsGenericMethod, "#A3");
 716                         Assert.IsTrue (mi1.IsGenericMethodDefinition, "#A4");
 717                         Assert.IsTrue (mi2.IsGenericMethod, "#A5");
 718                         Assert.IsTrue (mi2.IsGenericMethodDefinition, "#A6");
 719
 720                         MethodInfo mi3 = mi2.GetGenericMethodDefinition ();
 721
 722                         Assert.IsTrue (mi3.IsGenericMethod, "#B1");
 723                         Assert.IsTrue (mi3.IsGenericMethodDefinition, "#B2");
 724                         Assert.AreSame (mi2, mi3, "#B3");
 725
 726                         MethodInfo mi4 = mi2.MakeGenericMethod (typeof (short));
 727                         Assert.IsTrue (mi4.IsGenericMethod, "#C1");
 728                         Assert.IsFalse (mi4.IsGenericMethodDefinition, "#C2");
 729                         Assert.AreSame (mi2, mi4.GetGenericMethodDefinition (), "#C3");
 730                 }
 731
 732                 public void TestMethod123(int a, int b) {}
 733
 734                 [Test]
 735                 public void GetParametersDontReturnInternedArray ()
 736                 {
 737                         var method = typeof (MethodInfoTest).GetMethod ("TestMethod123");
 738                         var parms = method.GetParameters ();
 739                         Assert.AreNotSame (parms, method.GetParameters (), "#1");
 740
 741                         parms [0] = null;
 742                         Assert.IsNotNull (method.GetParameters () [0], "#2");
 743                 }
 744
 745                 [Test]
 746                 public void Bug354757 ()
 747                 {
 748                         MethodInfo gmd = (typeof (MyList <int>)).GetMethod ("ConvertAll");
 749                         MethodInfo oi = gmd.MakeGenericMethod (gmd.GetGenericArguments ());
 750                         Assert.AreSame (gmd, oi);
 751                 }
 752
 753                 [Test]
 754                 [ExpectedException (typeof (ArgumentException))]
 755 #if MOBILE
 756                 [Category ("NotWorking")] // #10552
 757 #endif
 758                 public void MakeGenericMethodRespectConstraints ()
 759                 {
 760                         var m = typeof (MethodInfoTest).GetMethod ("TestMethod");
 761                         m.MakeGenericMethod (typeof (Type));
 762                 }
 763
 764                 public void TestMethod <T> () where T : Exception
 765                 {
 766                 }
 767
 768                 public class MyList<T>
 769                 {
 770                         public TOutput ConvertAll<TOutput> (Foo<T,TOutput> arg)
 771                         {
 772                                 return default (TOutput);
 773                         }
 774                         public T ConvertAll2 (MyList<T> arg)
 775                         {
 776                                 return default (T);
 777                         }
 778                 }
 779
 780                 public class Foo<T,TOutput>
 781                 {
 782                 }
 783
 784                 class GenericHelper<T>
 785                 {
 786                         public void Test (T t)
 787                         {
 788                         }
 789                 }
 790                 interface IMethodInvoke<out T>
 791                 {
 792                     T Test ();
 793                 }
 794
 795                 class MethodInvoke : IMethodInvoke<string>
 796                 {
 797                     public string Test ()
 798                     {
 799                         return "MethodInvoke";
 800                     }
 801                 }
 802
 803                 [Test]
 804                 public void GetInterfaceMapWorksWithVariantIfaces ()
 805                 {
 806                         var m0 = typeof (IMethodInvoke<object>).GetMethod ("Test");
 807                         var m1 = typeof (IMethodInvoke<string>).GetMethod ("Test");
 808                         var obj = new MethodInvoke ();
 809
 810                         Assert.AreEqual ("MethodInvoke", m0.Invoke (obj, new Object [0]));
 811                         Assert.AreEqual ("MethodInvoke", m1.Invoke (obj, new Object [0]));
 812                 }
 813
 814
 815                 public int? Bug12856 ()
 816                 {
 817                         return null;
 818                 }
 819
 820                 [Test] //Bug #12856
 821                 public void MethodToStringShouldPrintFullNameOfGenericStructs ()
 822                 {
 823                         var m = GetType ().GetMethod ("Bug12856");
 824                         Assert.AreEqual ("System.Nullable`1[System.Int32] Bug12856()", m.ToString (), "#1");
 825                 }
 826
 827 #if !MONOTOUCH
 828                 class GenericClass<T>
 829                 {
 830                         public void Method ()
 831                         {
 832                                 T lv = default(T);
 833                                 Console.WriteLine(lv);
 834                         }
 835
 836                         public void Method2<K> (T a0, K a1)
 837                         {
 838                                 T var0 = a0;
 839                                 K var1 = a1;
 840                                 Console.WriteLine (var0);
 841                                 Console.WriteLine (var1);
 842                         }
 843                 }
 844
 845                 [Test]
 846                 public void TestLocalVariableTypes ()
 847                 {
 848                         var typeofT = typeof (GenericClass<>).GetGenericArguments () [0];
 849                         var typeofK = typeof (GenericClass<>).GetMethod ("Method2").GetGenericArguments () [0];
 850
 851                         var type = typeof (GenericClass<>).GetMethod("Method").GetMethodBody().LocalVariables[0].LocalType;
 852                         Assert.AreEqual (typeofT, type);
 853                         Assert.AreEqual (typeof (GenericClass<>), type.DeclaringType);
 854
 855                         bool foundTypeOfK = false;
 856                         bool foundExpectedType = false;
 857
 858                         MethodBody mb = typeof (GenericClass<>).GetMethod("Method2").GetMethodBody();
 859                         foreach (LocalVariableInfo lvi in mb.LocalVariables) {
 860                                 if (lvi.LocalType == typeofK) {
 861                                         foundTypeOfK = true;
 862                                         Assert.AreEqual (typeof (GenericClass<>), lvi.LocalType.DeclaringType, "#1-1");
 863                                 } else if (lvi.LocalType == typeofT) {
 864                                         foundExpectedType = true;
 865                                         Assert.AreEqual (typeof (GenericClass<>), lvi.LocalType.DeclaringType, "#1-2");
 866                                 }
 867                         }
 868
 869                         Assert.IsTrue (foundTypeOfK, "#1-3");
 870                         if (mb.LocalVariables.Count < 2)
 871                                 Assert.Ignore ("Code built in release mode - 'T var0' optmized out");
 872                         else
 873                                 Assert.IsTrue (foundExpectedType, "#1-4");
 874
 875                         foundTypeOfK = false;
 876                         foundExpectedType = false;
 877                         mb = typeof (GenericClass<int>).GetMethod("Method2").GetMethodBody();
 878                         foreach (LocalVariableInfo lvi in mb.LocalVariables) {
 879                                 if (lvi.LocalType == typeofK) {
 880                                         foundTypeOfK = true;
 881                                         Assert.AreEqual (typeof (GenericClass<>), lvi.LocalType.DeclaringType, "#2-1");
 882                                 } else if (lvi.LocalType == typeof (int)) {
 883                                         foundExpectedType = true;
 884                                 }
 885                         }
 886
 887                         Assert.IsTrue (foundTypeOfK, "#2-3");
 888                         if (mb.LocalVariables.Count < 2)
 889                                 Assert.Ignore ("Code built in release mode - 'int var0' optmized out");
 890                         else
 891                                 Assert.IsTrue (foundExpectedType, "#2-4");
 892                 }
 893 #endif
 894         }
 895
 896         // Helper class
 897         class RefOnlyMethodClass
 898         {
 899                 // Helper static method
 900                 static void RefOnlyMethod ()
 901                 {
 902                 }
 903         }
 904
 905         public class MethodHandleTest<T>
 906         {
 907                 private List<T> _myList = new List<T> ();
 908
 909                 public MethodHandleTest ()
 910                 {
 911                         _myList.Add (default (T));
 912                 }
 913
 914                 public List<T> MyList {
 915                         get { return _myList; }
 916                         set { _myList = value; }
 917                 }
 918         }
 919 }