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 !TARGET_JVM && !MONOTOUCH // Reflection.Emit not supported for TARGET_JVM
  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 !TARGET_JVM && !MONOTOUCH // Reflection.Emit not supported for TARGET_JVM
 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 // TARGET_JVM
 338
 339                 [Test]
 340                 [ExpectedException (typeof (NotSupportedException))]
 341                 public void CreateInstance_Void ()
 342                 {
 343                         Activator.CreateInstance (typeof (void), null);
 344                 }
 345
 346 #if !TARGET_JVM // RuntimeArgumentHandle not supported for TARGET_JVM
 347                 [Test]
 348                 [ExpectedException (typeof (NotSupportedException))]
 349                 public void CreateInstance_RuntimeArgumentHandle ()
 350                 {
 351                         Activator.CreateInstance (typeof (RuntimeArgumentHandle), null);
 352                 }
 353 #endif // TARGET_JVM
 354
 355                 [Test]
 356                 [ExpectedException (typeof (NotSupportedException))]
 357                 public void CreateInstance_NotMarshalByReferenceWithActivationAttributes ()
 358                 {
 359                         Activator.CreateInstance (typeof (object), null, new object[1] { null });
 360                 }
 361
 362                 // TODO: Implemente the test methods for all the overriden functions using activationAttribute
 363
 364                 [Test]
 365                 [ExpectedException(typeof(MissingMethodException))]
 366                 public void CreateInstanceAbstract1 ()
 367                 {
 368                         Activator.CreateInstance (typeof (Type));
 369                 }
 370
 371                 [Test]
 372                 [ExpectedException(typeof(MissingMethodException))]
 373                 [Category ("TargetJvmNotWorking")]
 374                 public void CreateInstanceAbstract2 ()
 375                 {
 376                         Activator.CreateInstance (typeof (Type), true);
 377                 }
 378
 379                 [Test]
 380                 [ExpectedException(typeof(MissingMethodException))]
 381                 public void CreateInstanceAbstract3 ()
 382                 {
 383                         Activator.CreateInstance (typeof (Type), null, null);
 384                 }
 385
 386                 [Test]
 387                 [ExpectedException(typeof(MissingMethodException))]
 388                 public void CreateInstanceAbstract4()
 389                 {
 390                         Activator.CreateInstance (typeof (Type), BindingFlags.CreateInstance | (BindingFlags.Public | BindingFlags.Instance), null, null, CultureInfo.InvariantCulture, null);
 391                 }
 392
 393                 [Test]
 394                 [ExpectedException (typeof (MissingMethodException))]
 395                 [Category ("TargetJvmNotWorking")]
 396                 public void CreateInstanceAbstract5 ()
 397                 {
 398                         Activator.CreateInstance (typeof (Type), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, null, CultureInfo.InvariantCulture, null);
 399                 }
 400
 401                 [Test]
 402                 [Category ("TargetJvmNotWorking")]
 403                 public void CreateInstance_Nullable ()
 404                 {
 405                         Assert.AreEqual (5, Activator.CreateInstance (typeof (Nullable<int>), new object [] { 5 }));
 406                         Assert.AreEqual (typeof (int), Activator.CreateInstance (typeof (Nullable<int>), new object [] { 5 }).GetType ());
 407                         Assert.AreEqual (0, Activator.CreateInstance (typeof (Nullable<int>), new object [] { null }));
 408                         Assert.AreEqual (typeof (int), Activator.CreateInstance (typeof (Nullable<int>), new object [] { null }).GetType ());
 409                         Assert.AreEqual (null, Activator.CreateInstance (typeof (Nullable<int>)));
 410                 }
 411
 412                 [Test]
 413                 [ExpectedException (typeof (ArgumentNullException))]
 414                 public void GetObject_TypeNull ()
 415                 {
 416                         Activator.GetObject (null, "tcp://localhost:1234/COMTestUri");
 417                 }
 418
 419 #if !MOBILE
 420                 [Test]
 421                 [ExpectedException (typeof (ArgumentNullException))]
 422                 [Category ("TargetJvmNotWorking")]
 423                 public void GetObject_UrlNull ()
 424                 {
 425                         Activator.GetObject (typeof (COMTest), null);
 426                 }
 427 #endif
 428
 429 /* This test is now executed in System.Runtime.Remoting unit tests
 430                 [Test]
 431                 public void GetObject ()
 432                 {
 433                         // This will provide a COMTest object on  tcp://localhost:1234/COMTestUri
 434                         COMTest objCOMTest = new COMTest (8);
 435                         TcpChannel chnServer = new TcpChannel (1234);
 436                         ChannelServices.RegisterChannel (chnServer);
 437                         RemotingServices.SetObjectUriForMarshal (objCOMTest, "COMTestUri");
 438                         RemotingServices.Marshal (objCOMTest);
 439
 440                         // This will get the remoting object
 441                         object objRem = Activator.GetObject (typeof (COMTest), "tcp://localhost:1234/COMTestUri");
 442                         Assert.IsNotNull (objRem, "#A07");
 443                         COMTest remCOMTest = (COMTest) objRem;
 444                         Assert.AreEqual (8, remCOMTest.Id, "#A08");
 445
 446                         ChannelServices.UnregisterChannel(chnServer);
 447                 }
 448 */
 449                 // TODO: Implemente the test methods for all the overriden function using activationAttribute
 450
 451                 [Test]
 452                 public void CreateInstanceFrom ()
 453                 {
 454                         ObjectHandle objHandle = Activator.CreateInstanceFrom (testLocation, "MonoTests.System.ActivatorTestInternal.COMTest");
 455                         Assert.IsNotNull (objHandle, "#A09");
 456                         objHandle.Unwrap ();
 457                         // TODO: Implement the test methods for all the overriden function using activationAttribute
 458                 }
 459
 460 #if !MOBILE
 461
 462                 // note: this only ensure that the ECMA key support unification (more test required, outside corlib, for other keys, like MS final).
 463                 private const string CorlibPermissionPattern = "System.Security.Permissions.FileDialogPermission, mscorlib, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 464                 private const string SystemPermissionPattern = "System.Net.DnsPermission, System, Version={0}, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 465                 private const string fx10version = "1.0.3300.0";
 466                 private const string fx11version = "1.0.5000.0";
 467                 private const string fx20version = "2.0.0.0";
 468
 469                 private static object[] psNone = new object [1] { PermissionState.None };
 470
 471                 private void Unification (string fullname)
 472                 {
 473                         Type t = Type.GetType (fullname);
 474                         IPermission p = (IPermission)Activator.CreateInstance (t, psNone);
 475                         string currentVersion = typeof (string).Assembly.GetName ().Version.ToString ();
 476                         Assert.IsTrue ((p.ToString ().IndexOf (currentVersion) > 0), currentVersion);
 477                 }
 478
 479                 [Test]
 480                 [Category ("TargetJvmNotSupported")] // No support under TARGET_JVM for assemlies versioning
 481                 public void Unification_FromFx10 ()
 482                 {
 483                         Unification (String.Format (CorlibPermissionPattern, fx10version));
 484                         Unification (String.Format (SystemPermissionPattern, fx10version));
 485                 }
 486
 487                 [Test]
 488                 [Category ("TargetJvmNotSupported")] // No support under TARGET_JVM for assemlies versioning
 489                 public void Unification_FromFx11 ()
 490                 {
 491                         Unification (String.Format (CorlibPermissionPattern, fx11version));
 492                         Unification (String.Format (SystemPermissionPattern, fx11version));
 493                 }
 494
 495                 [Test]
 496                 [Category ("TargetJvmNotSupported")] // No support under TARGET_JVM for assemlies versioning
 497                 public void Unification_FromFx20 ()
 498                 {
 499                         Unification (String.Format (CorlibPermissionPattern, fx20version));
 500                         Unification (String.Format (SystemPermissionPattern, fx20version));
 501                 }
 502
 503                 [Test]
 504                 [Category ("TargetJvmNotSupported")] // No support under TARGET_JVM for assemlies versioning
 505                 public void Unification_FromFx99_Corlib ()
 506                 {
 507                         Unification (String.Format (CorlibPermissionPattern, "9.99.999.9999"));
 508                 }
 509
 510                 [Test]
 511                 [Category ("TargetJvmNotSupported")] // No support under TARGET_JVM for assemlies versioning
 512                 [Category ("NotWorking")]
 513                 public void Unification_FromFx99_System ()
 514                 {
 515                         Assert.IsNull (Type.GetType (String.Format (SystemPermissionPattern, "9.99.999.9999")));
 516                 }
 517 #endif
 518                 class foo2<T, U> {}
 519                 class foo1<T> : foo2<T, int> {}
 520
 521                 [Test, ExpectedException (typeof (ArgumentException))]
 522                 public void GenericType_Open1 ()
 523                 {
 524                         Activator.CreateInstance (typeof (foo2<,>));
 525                 }
 526                 [Test, ExpectedException (typeof (ArgumentException))]
 527                 public void GenericType_Open2 ()
 528                 {
 529                         Activator.CreateInstance (typeof (foo1<>));
 530                 }
 531                 [Test]
 532                 public void GenericTypes_Closed ()
 533                 {
 534                         Assert.IsNotNull (Activator.CreateInstance (typeof (foo1<int>)), "foo1<int>");
 535                         Assert.IsNotNull (Activator.CreateInstance (typeof (foo2<long, int>)), "foo2<long, int>");
 536                 }
 537
 538                 [Test]
 539                 public void CreateInstanceCrossDomain ()
 540                 {
 541                         Activator.CreateInstance (AppDomain.CurrentDomain, "mscorlib.dll", "System.Object");
 542                         Activator.CreateInstance (AppDomain.CurrentDomain, "mscorlib.dll", "System.Object", false,
 543                                                   BindingFlags.Public | BindingFlags.Instance, null, null, CultureInfo.InvariantCulture,
 544                                                   null, null);
 545                 }
 546
 547 #if !MONOTOUCH
 548                 [Test]
 549                 public void CreateInstanceCustomDomain ()
 550                 {
 551                         // FIXME: below works as a standalone case, but does not as a unit test (causes JIT error).
 552                         Activator.CreateInstance (AppDomain.CreateDomain ("foo"), "mscorlib.dll", "System.Object", false,
 553                                                   BindingFlags.Public | BindingFlags.Instance, null, null, null,
 554                                                   null, null);
 555                 }
 556 #endif
 557                 [Test]
 558                 public void CreateInstanceCrossDomainNonSerializableArgs ()
 559                 {
 560                         // I'm not sure why this is possible ...
 561                         Activator.CreateInstance (AppDomain.CurrentDomain, "mscorlib.dll", "System.WeakReference", false,
 562                                                   BindingFlags.Public | BindingFlags.Instance, null, new object [] {ModuleHandle.EmptyHandle}, null, null, null);
 563                 }
 564
 565                 [Test]
 566                 [ExpectedException (typeof (NotSupportedException))]
 567                 public void CreateInstanceNonSerializableAtts ()
 568                 {
 569                         // even on invalid success it causes different exception though.
 570                         Activator.CreateInstance ("mscorlib.dll", "System.Object", false,
 571                                                   BindingFlags.Public | BindingFlags.Instance, null, null, null,
 572                                                   new object [] {ModuleHandle.EmptyHandle}, null);
 573                 }
 574
 575                 [Test]
 576                 [ExpectedException (typeof (NotSupportedException))]
 577                 public void CreateInstanceCrossDomainNonSerializableAtts ()
 578                 {
 579                         // even on invalid success it causes different exception though.
 580                         Activator.CreateInstance (AppDomain.CurrentDomain, "mscorlib.dll", "System.Object", false,
 581                                                   BindingFlags.Public | BindingFlags.Instance, null, null, null,
 582                                                   new object [] {ModuleHandle.EmptyHandle}, null);
 583                 }
 584
 585                 public class ParamsConstructor {
 586
 587                         public int A;
 588                         public string X;
 589                         public string Y;
 590
 591                         public ParamsConstructor (int a, params string [] s)
 592                         {
 593                                 A = a;
 594
 595                                 Assert.IsNotNull (s);
 596
 597                                 if (s.Length == 0)
 598                                         return;
 599
 600                                 X = s [0];
 601
 602                                 if (s.Length == 1)
 603                                         return;
 604
 605                                 Y = s [1];
 606                         }
 607                 }
 608
 609                 [Test]
 610                 public void CreateInstanceParamsConstructor ()
 611                 {
 612                         var a = (ParamsConstructor) Activator.CreateInstance (
 613                                 typeof (ParamsConstructor), new object [] { 42, "foo", "bar" });
 614
 615                         Assert.AreEqual (42, a.A);
 616                         Assert.AreEqual ("foo", a.X);
 617                         Assert.AreEqual ("bar", a.Y);
 618
 619                         a = (ParamsConstructor) Activator.CreateInstance (
 620                                 typeof (ParamsConstructor), new object [] { 42, "foo" });
 621
 622                         Assert.AreEqual (42, a.A);
 623                         Assert.AreEqual ("foo", a.X);
 624                         Assert.AreEqual (null, a.Y);
 625
 626                         a = (ParamsConstructor) Activator.CreateInstance (
 627                                 typeof (ParamsConstructor), new object [] { 42 });
 628
 629                         Assert.AreEqual (42, a.A);
 630                         Assert.AreEqual (null, a.X);
 631                         Assert.AreEqual (null, a.Y);
 632                 }
 633
 634                 class SimpleParamsConstructor {
 635
 636                         public string X;
 637                         public string Y;
 638
 639                         public SimpleParamsConstructor (params string [] s)
 640                         {
 641                                 Assert.IsNotNull (s);
 642
 643                                 if (s.Length == 0)
 644                                         return;
 645
 646                                 X = s [0];
 647
 648                                 if (s.Length == 1)
 649                                         return;
 650
 651                                 Y = s [1];
 652                         }
 653                 }
 654
 655                 [Test]
 656                 public void CreateInstanceSimpleParamsConstructor ()
 657                 {
 658                         var a = (SimpleParamsConstructor) Activator.CreateInstance (
 659                                 typeof (SimpleParamsConstructor), new object [] { "foo", "bar" });
 660
 661                         Assert.AreEqual ("foo", a.X);
 662                         Assert.AreEqual ("bar", a.Y);
 663
 664                         a = (SimpleParamsConstructor) Activator.CreateInstance (
 665                                 typeof (SimpleParamsConstructor), new object [0]);
 666
 667                         Assert.AreEqual (null, a.X);
 668                         Assert.AreEqual (null, a.Y);
 669                 }
 670         }
 671 }