mcs/class/corlib/Test/System/ActivatorTest.cs

   1 //
   2 // ActivatorTest.cs - NUnit Test Cases for System.Activator
   3 //
   4 // Authors:
   5 //      Nick Drochak <ndrochak@gol.com>
   6 //      Gert Driesen <drieseng@users.sourceforge.net>
   7 //      Sebastien Pouliot  <sebastien@ximian.com>
   8 //
   9 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
  10 //
  11
  12 using System;
  13 using System.Globalization;
  14 using System.IO;
  15 using System.Reflection;
  16 #if !MONOTOUCH && !FULL_AOT_RUNTIME
  17 using System.Reflection.Emit;
  18 #endif
  19 using System.Runtime.InteropServices;
  20 using System.Runtime.Remoting;
  21 using System.Runtime.Remoting.Channels;
  22 using System.Security;
  23 using System.Security.Permissions;
  24
  25 using NUnit.Framework;
  26
  27 // The class in this namespace is used by the main test class
  28 namespace MonoTests.System.ActivatorTestInternal {
  29
  30         // We need a COM class to test the Activator class
  31         [ComVisible (true)]
  32         public class COMTest : MarshalByRefObject {
  33
  34                 private int id;
  35                 public bool constructorFlag = false;
  36
  37                 public COMTest ()
  38                 {
  39                         id = 0;
  40                 }
  41
  42                 public COMTest (int id)
  43                 {
  44                         this.id = id;
  45                 }
  46
  47                 // This property is visible
  48                 [ComVisible (true)]
  49                 public int Id {
  50                         get { return id; }
  51                         set { id = value; }
  52                 }
  53         }
  54
  55         [ComVisible (false)]
  56         public class NonCOMTest : COMTest {
  57         }
  58 }
  59
  60 namespace MonoTests.System {
  61
  62         using MonoTests.System.ActivatorTestInternal;
  63
  64         class CustomUserType : Type
  65         {
  66                 public override Assembly Assembly
  67                 {
  68                         get { throw new NotImplementedException (); }
  69                 }
  70
  71                 public override string AssemblyQualifiedName
  72                 {
  73                         get { throw new NotImplementedException (); }
  74                 }
  75
  76                 public override Type BaseType
  77                 {
  78                         get { throw new NotImplementedException (); }
  79                 }
  80
  81                 public override string FullName
  82                 {
  83                         get { throw new NotImplementedException (); }
  84                 }
  85
  86                 public override Guid GUID
  87                 {
  88                         get { throw new NotImplementedException (); }
  89                 }
  90
  91                 protected override TypeAttributes GetAttributeFlagsImpl ()
  92                 {
  93                         throw new NotImplementedException ();
  94                 }
  95
  96                 protected override ConstructorInfo GetConstructorImpl (BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  97                 {
  98                         throw new NotImplementedException ();
  99                 }
 100
 101                 public override ConstructorInfo[] GetConstructors (BindingFlags bindingAttr)
 102                 {
 103                         throw new NotImplementedException ();
 104                 }
 105
 106                 public override Type GetElementType ()
 107                 {
 108                         throw new NotImplementedException ();
 109                 }
 110
 111                 public override EventInfo GetEvent (string name, BindingFlags bindingAttr)
 112                 {
 113                         throw new NotImplementedException ();
 114                 }
 115
 116                 public override EventInfo[] GetEvents (BindingFlags bindingAttr)
 117                 {
 118                         throw new NotImplementedException ();
 119                 }
 120
 121                 public override FieldInfo GetField (string name, BindingFlags bindingAttr)
 122                 {
 123                         throw new NotImplementedException ();
 124                 }
 125
 126                 public override FieldInfo[] GetFields (BindingFlags bindingAttr)
 127                 {
 128                         throw new NotImplementedException ();
 129                 }
 130
 131                 public override Type GetInterface (string name, bool ignoreCase)
 132                 {
 133                         throw new NotImplementedException ();
 134                 }
 135
 136                 public override Type[] GetInterfaces ()
 137                 {
 138                         throw new NotImplementedException ();
 139                 }
 140
 141                 public override MemberInfo[] GetMembers (BindingFlags bindingAttr)
 142                 {
 143                         throw new NotImplementedException ();
 144                 }
 145
 146                 protected override MethodInfo GetMethodImpl (string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
 147                 {
 148                         throw new NotImplementedException ();
 149                 }
 150
 151                 public override MethodInfo[] GetMethods (BindingFlags bindingAttr)
 152                 {
 153                         throw new NotImplementedException ();
 154                 }
 155
 156                 public override Type GetNestedType (string name, BindingFlags bindingAttr)
 157                 {
 158                         throw new NotImplementedException ();
 159                 }
 160
 161                 public override Type[] GetNestedTypes (BindingFlags bindingAttr)
 162                 {
 163                         throw new NotImplementedException ();
 164                 }
 165
 166                 public override PropertyInfo[] GetProperties (BindingFlags bindingAttr)
 167                 {
 168                         throw new NotImplementedException ();
 169                 }
 170
 171                 protected override PropertyInfo GetPropertyImpl (string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
 172                 {
 173                         throw new NotImplementedException ();
 174                 }
 175
 176                 protected override bool HasElementTypeImpl ()
 177                 {
 178                         throw new NotImplementedException ();
 179                 }
 180
 181                 public override object InvokeMember (string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
 182                 {
 183                         throw new NotImplementedException ();
 184                 }
 185
 186                 protected override bool IsArrayImpl ()
 187                 {
 188                         throw new NotImplementedException ();
 189                 }
 190
 191                 protected override bool IsByRefImpl ()
 192                 {
 193                         throw new NotImplementedException ();
 194                 }
 195
 196                 protected override bool IsCOMObjectImpl ()
 197                 {
 198                         throw new NotImplementedException ();
 199                 }
 200
 201                 protected override bool IsPointerImpl ()
 202                 {
 203                         throw new NotImplementedException ();
 204                 }
 205
 206                 protected override bool IsPrimitiveImpl ()
 207                 {
 208                         throw new NotImplementedException ();
 209                 }
 210
 211                 public override Module Module
 212                 {
 213                         get { throw new NotImplementedException (); }
 214                 }
 215
 216                 public override string Namespace
 217                 {
 218                         get { throw new NotImplementedException (); }
 219                 }
 220
 221                 public override Type UnderlyingSystemType
 222                 {
 223                         get {
 224                                 return this;
 225                         }
 226                 }
 227
 228                 public override object[] GetCustomAttributes (Type attributeType, bool inherit)
 229                 {
 230                         throw new NotImplementedException ();
 231                 }
 232
 233                 public override object[] GetCustomAttributes (bool inherit)
 234                 {
 235                         throw new NotImplementedException ();
 236                 }
 237
 238                 public override bool IsDefined (Type attributeType, bool inherit)
 239                 {
 240                         throw new NotImplementedException ();
 241                 }
 242
 243                 public override string Name
 244                 {
 245                         get { throw new NotImplementedException (); }
 246                 }
 247         }
 248
 249
 250         [TestFixture]
 251         public class ActivatorTest {
 252
 253                 private string testLocation = typeof (ActivatorTest).Assembly.Location;
 254
 255                 [Test]
 256                 public void CreateInstance_Type()
 257                 {
 258                         COMTest objCOMTest = (COMTest) Activator.CreateInstance (typeof (COMTest));
 259                         Assert.AreEqual ("MonoTests.System.ActivatorTestInternal.COMTest", (objCOMTest.GetType ()).ToString (), "#A02");
 260                 }
 261
 262                 [Test]
 263                 [ExpectedException (typeof (ArgumentNullException))]
 264                 public void CreateInstance_TypeNull ()
 265                 {
 266                         Activator.CreateInstance ((Type)null);
 267                 }
 268
 269                 [Test]
 270                 [ExpectedException (typeof (ArgumentException))]
 271                 public void CreateInstance_CustomType ()
 272                 {
 273                         Activator.CreateInstance (new CustomUserType ());
 274                 }
 275
 276                 [Test]
 277                 public void CreateInstance_StringString ()
 278                 {
 279                         ObjectHandle objHandle = Activator.CreateInstance (null, "MonoTests.System.ActivatorTestInternal.COMTest");
 280                         COMTest objCOMTest = (COMTest)objHandle.Unwrap ();
 281                         objCOMTest.Id = 2;
 282                         Assert.AreEqual (2, objCOMTest.Id, "#A03");
 283                 }
 284
 285                 [Test]
 286                 [ExpectedException (typeof (ArgumentNullException))]
 287                 public void CreateInstance_StringNull ()
 288                 {
 289                         Activator.CreateInstance ((string)null, null);
 290                 }
 291
 292                 [Test]
 293                 [ExpectedException (typeof (TypeLoadException))]
 294                 public void CreateInstance_StringTypeNameDoesNotExists ()
 295                 {
 296                         Activator.CreateInstance ((string)null, "MonoTests.System.ActivatorTestInternal.DoesntExistsCOMTest");
 297                 }
 298
 299                 [Test]
 300                 public void CreateInstance_TypeBool ()
 301                 {
 302                         COMTest objCOMTest = (COMTest)Activator.CreateInstance (typeof (COMTest), false);
 303                         Assert.AreEqual ("MonoTests.System.ActivatorTestInternal.COMTest", objCOMTest.GetType ().ToString (), "#A04");
 304                 }
 305
 306                 [Test]
 307                 public void CreateInstance_TypeObjectArray ()
 308                 {
 309                         object[] objArray = new object[1] { 7 };
 310                         COMTest objCOMTest = (COMTest)Activator.CreateInstance (typeof (COMTest), objArray);
 311                         Assert.AreEqual (7, objCOMTest.Id, "#A05");
 312                 }
 313
 314 #if !MONOTOUCH && !FULL_AOT_RUNTIME
 315                 [Test]
 316                 [ExpectedException (typeof (MissingMethodException))]
 317                 public void CreateInstance_TypeBuilder ()
 318                 {
 319                         Type tb = typeof (TypeBuilder); // no public ctor - but why is it documented as NotSupportedException ?
 320                         ConstructorInfo[] ctors = tb.GetConstructors (BindingFlags.Instance | BindingFlags.NonPublic);
 321                         Activator.CreateInstance (tb, new object [ctors [0].GetParameters ().Length]);
 322                 }
 323
 324                 [Test]
 325                 [ExpectedException (typeof (NotSupportedException))]
 326                 public void CreateInstance_TypedReference ()
 327                 {
 328                         Activator.CreateInstance (typeof (TypedReference), null);
 329                 }
 330
 331                 [Test]
 332                 [ExpectedException (typeof (NotSupportedException))]
 333                 public void CreateInstance_ArgIterator ()
 334                 {
 335                         Activator.CreateInstance (typeof (ArgIterator), null);
 336                 }
 337 #endif
 338
 339                 [Test]
 340                 [ExpectedException (typeof (NotSupportedException))]
 341                 public void CreateInstance_Void ()
 342                 {
 343                         Activator.CreateInstance (typeof (void), null);
 344                 }
 345
 346                 [Test]
 347                 [ExpectedException (typeof (NotSupportedException))]
 348                 public void CreateInstance_RuntimeArgumentHandle ()
 349                 {
 350                         Activator.CreateInstance (typeof (RuntimeArgumentHandle), null);
 351                 }
 352
 353                 [Test]
 354                 [ExpectedException (typeof (NotSupportedException))]
 355                 public void CreateInstance_NotMarshalByReferenceWithActivationAttributes ()
 356                 {
 357                         Activator.CreateInstance (typeof (object), null, new object[1] { null });
 358                 }
 359
 360                 // TODO: Implemente the test methods for all the overriden functions using activationAttribute
 361
 362                 [Test]
 363                 [ExpectedException(typeof(MissingMethodException))]
 364                 public void CreateInstanceAbstract1 ()
 365                 {
 366                         Activator.CreateInstance (typeof (Type));
 367                 }
 368
 369                 [Test]
 370                 [ExpectedException(typeof(MissingMethodException))]
 371                 public void CreateInstanceAbstract2 ()
 372                 {
 373                         Activator.CreateInstance (typeof (Type), true);
 374                 }
 375
 376                 [Test]
 377                 [ExpectedException(typeof(MissingMethodException))]
 378                 public void CreateInstanceAbstract3 ()
 379                 {
 380                         Activator.CreateInstance (typeof (Type), null, null);
 381                 }
 382
 383                 [Test]
 384                 [ExpectedException(typeof(MissingMethodException))]
 385                 public void CreateInstanceAbstract4()
 386                 {
 387                         Activator.CreateInstance (typeof (Type), BindingFlags.CreateInstance | (BindingFlags.Public | BindingFlags.Instance), null, null, CultureInfo.InvariantCulture, null);
 388                 }
 389
 390                 [Test]
 391                 [ExpectedException (typeof (MissingMethodException))]
 392                 public void CreateInstanceAbstract5 ()
 393                 {
 394                         Activator.CreateInstance (typeof (Type), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, null, CultureInfo.InvariantCulture, null);
 395                 }
 396
 397                 [Test]
 398                 public void CreateInstance_Nullable ()
 399                 {
 400                         Assert.AreEqual (5, Activator.CreateInstance (typeof (Nullable<int>), new object [] { 5 }));
 401                         Assert.AreEqual (typeof (int), Activator.CreateInstance (typeof (Nullable<int>), new object [] { 5 }).GetType ());
 402                         Assert.AreEqual (0, Activator.CreateInstance (typeof (Nullable<int>), new object [] { null }));
 403                         Assert.AreEqual (typeof (int), Activator.CreateInstance (typeof (Nullable<int>), new object [] { null }).GetType ());
 404                         Assert.AreEqual (null, Activator.CreateInstance (typeof (Nullable<int>)));
 405                 }
 406 #if FEATURE_REMOTING
 407                 [Test]
 408                 [ExpectedException (typeof (ArgumentNullException))]
 409                 public void GetObject_TypeNull ()
 410                 {
 411                         Activator.GetObject (null, "tcp://localhost:1234/COMTestUri");
 412                 }
 413
 414                 [Test]
 415                 [ExpectedException (typeof (ArgumentNullException))]
 416                 public void GetObject_UrlNull ()
 417                 {
 418                         Activator.GetObject (typeof (COMTest), null);
 419                 }
 420 #endif
 421
 422                 // TODO: Implemente the test methods for all the overriden function using activationAttribute
 423
 424                 [Test]
 425                 [Category ("AndroidNotWorking")] // Assemblies aren't accessible using filesystem paths (they're either in apk, embedded in native code or not there at all
 426                 public void CreateInstanceFrom ()
 427                 {
 428                         ObjectHandle objHandle = Activator.CreateInstanceFrom (testLocation, "MonoTests.System.ActivatorTestInternal.COMTest");
 429                         Assert.IsNotNull (objHandle, "#A09");
 430                         objHandle.Unwrap ();
 431                         // TODO: Implement the test methods for all the overriden function using activationAttribute
 432                 }
 433
 434 #if !MOBILE
 435
 436                 // note: this only ensure that the ECMA key support unification (more test required, outside corlib, for other keys, like MS final).
 437                 private const string CorlibPermissionPattern = "System.Security.Permissions.FileDialogPermission, mscorlib, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 438                 private const string SystemPermissionPattern = "System.Net.DnsPermission, System, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 439                 private const string fx10version = "1.0.3300.0";
 440                 private const string fx11version = "1.0.5000.0";
 441                 private const string fx20version = "2.0.0.0";
 442
 443                 private static object[] psNone = new object [1] { PermissionState.None };
 444
 445                 private void Unification (string fullname)
 446                 {
 447                         Type t = Type.GetType (fullname);
 448                         IPermission p = (IPermission)Activator.CreateInstance (t, psNone);
 449                         string currentVersion = typeof (string).Assembly.GetName ().Version.ToString ();
 450                         Assert.IsTrue ((p.ToString ().IndexOf (currentVersion) > 0), currentVersion);
 451                 }
 452
 453                 [Test]
 454                 public void Unification_FromFx10 ()
 455                 {
 456                         Unification (String.Format (CorlibPermissionPattern, fx10version));
 457                         Unification (String.Format (SystemPermissionPattern, fx10version));
 458                 }
 459
 460                 [Test]
 461                 public void Unification_FromFx11 ()
 462                 {
 463                         Unification (String.Format (CorlibPermissionPattern, fx11version));
 464                         Unification (String.Format (SystemPermissionPattern, fx11version));
 465                 }
 466
 467                 [Test]
 468                 public void Unification_FromFx20 ()
 469                 {
 470                         Unification (String.Format (CorlibPermissionPattern, fx20version));
 471                         Unification (String.Format (SystemPermissionPattern, fx20version));
 472                 }
 473
 474                 [Test]
 475                 public void Unification_FromFx99_Corlib ()
 476                 {
 477                         Unification (String.Format (CorlibPermissionPattern, "9.99.999.9999"));
 478                 }
 479
 480                 [Test]
 481                 [Category ("NotWorking")]
 482                 public void Unification_FromFx99_System ()
 483                 {
 484                         Assert.IsNull (Type.GetType (String.Format (SystemPermissionPattern, "9.99.999.9999")));
 485                 }
 486 #endif
 487                 class foo2<T, U> {}
 488                 class foo1<T> : foo2<T, int> {}
 489
 490                 [Test, ExpectedException (typeof (ArgumentException))]
 491                 public void GenericType_Open1 ()
 492                 {
 493                         Activator.CreateInstance (typeof (foo2<,>));
 494                 }
 495                 [Test, ExpectedException (typeof (ArgumentException))]
 496                 public void GenericType_Open2 ()
 497                 {
 498                         Activator.CreateInstance (typeof (foo1<>));
 499                 }
 500                 [Test]
 501                 public void GenericTypes_Closed ()
 502                 {
 503                         Assert.IsNotNull (Activator.CreateInstance (typeof (foo1<int>)), "foo1<int>");
 504                         Assert.IsNotNull (Activator.CreateInstance (typeof (foo2<long, int>)), "foo2<long, int>");
 505                 }
 506
 507                 [Test]
 508                 public void CreateInstanceCrossDomain ()
 509                 {
 510                         Activator.CreateInstance (AppDomain.CurrentDomain, "mscorlib.dll", "System.Object");
 511                         Activator.CreateInstance (AppDomain.CurrentDomain, "mscorlib.dll", "System.Object", false,
 512                                                   BindingFlags.Public | BindingFlags.Instance, null, null, CultureInfo.InvariantCulture,
 513                                                   null, null);
 514                 }
 515
 516 #if !MONOTOUCH && !FULL_AOT_RUNTIME
 517                 [Test]
 518                 public void CreateInstanceCustomDomain ()
 519                 {
 520                         // FIXME: below works as a standalone case, but does not as a unit test (causes JIT error).
 521                         Activator.CreateInstance (AppDomain.CreateDomain ("foo"), "mscorlib.dll", "System.Object", false,
 522                                                   BindingFlags.Public | BindingFlags.Instance, null, null, null,
 523                                                   null, null);
 524                 }
 525 #endif
 526                 [Test]
 527                 public void CreateInstanceCrossDomainNonSerializableArgs ()
 528                 {
 529                         // I'm not sure why this is possible ...
 530                         Activator.CreateInstance (AppDomain.CurrentDomain, "mscorlib.dll", "System.WeakReference", false,
 531                                                   BindingFlags.Public | BindingFlags.Instance, null, new object [] {ModuleHandle.EmptyHandle}, null, null, null);
 532                 }
 533
 534                 [Test]
 535                 [ExpectedException (typeof (NotSupportedException))]
 536                 public void CreateInstanceNonSerializableAtts ()
 537                 {
 538                         // even on invalid success it causes different exception though.
 539                         Activator.CreateInstance ("mscorlib.dll", "System.Object", false,
 540                                                   BindingFlags.Public | BindingFlags.Instance, null, null, null,
 541                                                   new object [] {ModuleHandle.EmptyHandle}, null);
 542                 }
 543
 544                 [Test]
 545                 [ExpectedException (typeof (NotSupportedException))]
 546                 public void CreateInstanceCrossDomainNonSerializableAtts ()
 547                 {
 548                         // even on invalid success it causes different exception though.
 549                         Activator.CreateInstance (AppDomain.CurrentDomain, "mscorlib.dll", "System.Object", false,
 550                                                   BindingFlags.Public | BindingFlags.Instance, null, null, null,
 551                                                   new object [] {ModuleHandle.EmptyHandle}, null);
 552                 }
 553
 554                 public class ParamsConstructor {
 555
 556                         public int A;
 557                         public string X;
 558                         public string Y;
 559
 560                         public ParamsConstructor (int a, params string [] s)
 561                         {
 562                                 A = a;
 563
 564                                 Assert.IsNotNull (s);
 565
 566                                 if (s.Length == 0)
 567                                         return;
 568
 569                                 X = s [0];
 570
 571                                 if (s.Length == 1)
 572                                         return;
 573
 574                                 Y = s [1];
 575                         }
 576                 }
 577
 578                 [Test]
 579                 public void CreateInstanceParamsConstructor ()
 580                 {
 581                         var a = (ParamsConstructor) Activator.CreateInstance (
 582                                 typeof (ParamsConstructor), new object [] { 42, "foo", "bar" });
 583
 584                         Assert.AreEqual (42, a.A);
 585                         Assert.AreEqual ("foo", a.X);
 586                         Assert.AreEqual ("bar", a.Y);
 587
 588                         a = (ParamsConstructor) Activator.CreateInstance (
 589                                 typeof (ParamsConstructor), new object [] { 42, "foo" });
 590
 591                         Assert.AreEqual (42, a.A);
 592                         Assert.AreEqual ("foo", a.X);
 593                         Assert.AreEqual (null, a.Y);
 594
 595                         a = (ParamsConstructor) Activator.CreateInstance (
 596                                 typeof (ParamsConstructor), new object [] { 42 });
 597
 598                         Assert.AreEqual (42, a.A);
 599                         Assert.AreEqual (null, a.X);
 600                         Assert.AreEqual (null, a.Y);
 601
 602                         var b = Activator.CreateInstance (typeof (SimpleParamsObjectConstructor), 1, 2, 3, 4, 5);
 603                         Assert.IsNotNull (b);
 604                 }
 605
 606                 class SimpleParamsObjectConstructor
 607                 {
 608                         public SimpleParamsObjectConstructor (params object[] parameters)
 609                         {
 610                         }
 611                 }
 612
 613                 class SimpleParamsConstructor {
 614
 615                         public string X;
 616                         public string Y;
 617
 618                         public SimpleParamsConstructor (params string [] s)
 619                         {
 620                                 Assert.IsNotNull (s);
 621
 622                                 if (s.Length == 0)
 623                                         return;
 624
 625                                 X = s [0];
 626
 627                                 if (s.Length == 1)
 628                                         return;
 629
 630                                 Y = s [1];
 631                         }
 632                 }
 633
 634                 [Test]
 635                 public void CreateInstanceSimpleParamsConstructor ()
 636                 {
 637                         var a = (SimpleParamsConstructor) Activator.CreateInstance (
 638                                 typeof (SimpleParamsConstructor), new object [] { "foo", "bar" });
 639
 640                         Assert.AreEqual ("foo", a.X);
 641                         Assert.AreEqual ("bar", a.Y);
 642
 643                         a = (SimpleParamsConstructor) Activator.CreateInstance (
 644                                 typeof (SimpleParamsConstructor), new object [0]);
 645
 646                         Assert.AreEqual (null, a.X);
 647                         Assert.AreEqual (null, a.Y);
 648                 }
 649
 650                 class ParamsConstructorWithObjectConversion
 651                 {
 652                         public ParamsConstructorWithObjectConversion (params int[] x)
 653                         {
 654                         }
 655                 }
 656
 657                 [Test]
 658                 public void CreateInstanceParamsConstructorWithObjectConversion ()
 659                 {
 660                         var a = Activator.CreateInstance (typeof(ParamsConstructorWithObjectConversion), new object[] { (object) 2 });
 661                         Assert.IsNotNull (a);
 662                 }
 663         }
 664 }