mcs/class/corlib/Test/System.Reflection.Emit/DerivedTypesTest.cs

   1 //
   2 // DerivedType.cs - NUnit Test Cases for types derived from TypeBuilder
   3 //
   4 // Rodrigo Kumpera <rkumpera@novell.com>
   5 //
   6 // Copyright (C) 2009 Novell, Inc (http://www.novell.com)
   7 //
   8
   9 using System;
  10 using System.Collections;
  11 using System.Threading;
  12 using System.Reflection;
  13 using System.Reflection.Emit;
  14 using System.IO;
  15 using System.Security;
  16 using System.Security.Permissions;
  17 using System.Runtime.InteropServices;
  18 using NUnit.Framework;
  19 using System.Runtime.CompilerServices;
  20
  21 using System.Collections.Generic;
  22
  23 namespace MonoTests.System.Reflection.Emit
  24 {
  25         [TestFixture]
  26         public class PointerTypeTest
  27         {
  28                 AssemblyBuilder assembly;
  29                 ModuleBuilder module;
  30                 int typeCount;
  31                 static string ASSEMBLY_NAME = "MonoTests.System.Reflection.Emit.TypeBuilderTest";
  32
  33                 string MakeName ()
  34                 {
  35                         return "internal__type"+ typeCount++;
  36                 }
  37
  38                 [SetUp]
  39                 protected void SetUp ()
  40                 {
  41                         AssemblyName assemblyName = new AssemblyName ();
  42                         assemblyName.Name = ASSEMBLY_NAME;
  43
  44                         assembly =
  45                                 Thread.GetDomain ().DefineDynamicAssembly (
  46                                         assemblyName, AssemblyBuilderAccess.RunAndSave, Path.GetTempPath ());
  47
  48                         module = assembly.DefineDynamicModule ("module1");
  49                         typeCount = 0;
  50                 }
  51
  52                 [Test]
  53                 public void PropertiesValue ()
  54                 {
  55                         TypeBuilder tb = module.DefineType ("ns.type", TypeAttributes.Public);
  56                         Type ptr = tb.MakePointerType ();
  57
  58                         Assert.AreEqual (assembly, ptr.Assembly, "#1");
  59                         Assert.AreEqual ("ns.type*, " + assembly.FullName, ptr.AssemblyQualifiedName, "#2");
  60                         Assert.AreEqual ("ns.type*", ptr.FullName, "#4");
  61                         Assert.AreEqual (module, ptr.Module, "#5");
  62                         Assert.AreEqual ("ns", ptr.Namespace, "#6");
  63                         Assert.AreEqual (ptr, ptr.UnderlyingSystemType, "#7");
  64                         Assert.AreEqual ("type*", ptr.Name, "#8");
  65
  66                         try {
  67                                 object x = ptr.GUID;
  68                                 Assert.Fail ("#9");
  69                         } catch (NotSupportedException) {}
  70
  71                         try {
  72                                 object x = ptr.TypeHandle;
  73                                 Assert.Fail ("#10");
  74                         } catch (NotSupportedException) {}
  75                 }
  76
  77                 [Test]
  78                 public void Methods ()
  79                 {
  80                         TypeBuilder tb = module.DefineType ("ns.type", TypeAttributes.Public);
  81                         Type ptr = tb.MakePointerType ();
  82
  83                         try {
  84                                 ptr.GetInterface ("foo", true);
  85                                 Assert.Fail ("#1");
  86                         } catch (NotSupportedException) {
  87
  88                         }
  89
  90                         try {
  91                                 ptr.GetInterfaces ();
  92                                 Assert.Fail ("#2");
  93                         } catch (NotSupportedException) {
  94
  95                         }
  96
  97                         Assert.AreEqual (tb, ptr.GetElementType ());
  98
  99                         try {
 100                                 ptr.GetEvent ("foo", BindingFlags.Public);
 101                                 Assert.Fail ("#4");
 102                         } catch (NotSupportedException) {
 103
 104                         }
 105
 106                         try {
 107                                 ptr.GetEvents (BindingFlags.Public);
 108                                 Assert.Fail ("#5");
 109                         } catch (NotSupportedException) {
 110
 111                         }
 112
 113                         try {
 114                                 ptr.GetField ("foo", BindingFlags.Public);
 115                                 Assert.Fail ("#6");
 116                         } catch (NotSupportedException) {
 117
 118                         }
 119
 120                         try {
 121                                 ptr.GetFields (BindingFlags.Public);
 122                                 Assert.Fail ("#7");
 123                         } catch (NotSupportedException) {
 124
 125                         }
 126
 127                         try {
 128                                 ptr.GetMembers (BindingFlags.Public);
 129                                 Assert.Fail ("#8");
 130                         } catch (NotSupportedException) {
 131
 132                         }
 133
 134                         try {
 135                                 ptr.GetMethod ("Sort");
 136                                 Assert.Fail ("#9");
 137                         } catch (NotSupportedException) {
 138
 139                         }
 140
 141                         try {
 142                                 ptr.GetMethods (BindingFlags.Public);
 143                                 Assert.Fail ("#9");
 144                         } catch (NotSupportedException) {
 145
 146                         }
 147
 148                         try {
 149                                 ptr.GetNestedType ("bla", BindingFlags.Public);
 150                                 Assert.Fail ("#10");
 151                         } catch (NotSupportedException) {
 152
 153                         }
 154
 155                         try {
 156                                 ptr.GetNestedTypes (BindingFlags.Public);
 157                                 Assert.Fail ("#11");
 158                         } catch (NotSupportedException) {
 159
 160                         }
 161
 162                         try {
 163                                 ptr.GetProperties (BindingFlags.Public);
 164                                 Assert.Fail ("#12");
 165                         } catch (NotSupportedException) {
 166
 167                         }
 168
 169                         try {
 170                                 ptr.GetProperty ("Length");
 171                                 Assert.Fail ("#13");
 172                         } catch (NotSupportedException) {
 173
 174                         }
 175
 176                         try {
 177                                 ptr.GetConstructor (new Type[] { typeof (int) });
 178                                 Assert.Fail ("#14");
 179                         } catch (NotSupportedException) {
 180
 181                         }
 182
 183                         TypeAttributes attr = TypeAttributes.AutoLayout | TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Public;
 184                         Assert.AreEqual (attr, ptr.Attributes, "#15");
 185
 186                         Assert.IsTrue (ptr.HasElementType, "#16");
 187                         Assert.IsFalse (ptr.IsArray, "#17");
 188                         Assert.IsFalse (ptr.IsByRef, "#18");
 189                         Assert.IsFalse (ptr.IsCOMObject, "#19");
 190                         Assert.IsTrue (ptr.IsPointer, "#20");
 191                         Assert.IsFalse (ptr.IsPrimitive, "#21");
 192
 193                         try {
 194                                 ptr.GetConstructors (BindingFlags.Public);
 195                                 Assert.Fail ("#22");
 196                         } catch (NotSupportedException) {
 197
 198                         }
 199
 200                         try {
 201                                 ptr.InvokeMember ("GetLength", BindingFlags.Public, null, null, null);
 202                                 Assert.Fail ("#23");
 203                         } catch (NotSupportedException) {
 204
 205                         }
 206
 207                         try {
 208                                 ptr.GetArrayRank ();
 209                                 Assert.Fail ("#23");
 210                         } catch (NotSupportedException) {
 211
 212                         }
 213                 }
 214
 215                 [Test]
 216                 public void GenericTypeMembers ()
 217                 {
 218                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 219                         Type arr = tb.MakeArrayType ();
 220
 221                         try {
 222                                 arr.GetGenericArguments ();
 223                                 Assert.Fail ("#1");
 224                         } catch (NotSupportedException) {}
 225
 226                         try {
 227                                 arr.GetGenericParameterConstraints ();
 228                                 Assert.Fail ("#2");
 229                         } catch (InvalidOperationException) {}
 230
 231                         try {
 232                                 arr.GetGenericTypeDefinition ();
 233                                 Assert.Fail ("#3");
 234                         } catch (NotSupportedException) {}
 235
 236                         Assert.IsFalse (arr.ContainsGenericParameters, "#4");
 237                         try {
 238                                 var x = arr.GenericParameterAttributes;
 239                                 Assert.Fail ("#5");
 240                         } catch (NotSupportedException) {}
 241
 242                         try {
 243                                 var x = arr.GenericParameterPosition;
 244                                 Assert.Fail ("#6");
 245                         } catch (InvalidOperationException) {}
 246
 247                         Assert.IsFalse (arr.ContainsGenericParameters, "#7");
 248
 249                         Assert.IsFalse (arr.IsGenericParameter, "#8");
 250                         Assert.IsFalse (arr.IsGenericType, "#9");
 251                         Assert.IsFalse (arr.IsGenericTypeDefinition, "#10");
 252                 }
 253
 254                 [Test]
 255                 public void AttributeValues ()
 256                 {
 257                                 TypeBuilder tb = module.DefineType (MakeName (), TypeAttributes.NotPublic);
 258                                 Assert.AreEqual (TypeAttributes.NotPublic, tb.Attributes, "#1");
 259
 260                                 tb = module.DefineType (MakeName (), TypeAttributes.Public);
 261                                 Assert.AreEqual (TypeAttributes.Public, tb.Attributes, "#2");
 262
 263                                 tb = module.DefineType (MakeName (), TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed);
 264                                 Assert.AreEqual (TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed, tb.Attributes, "#3");
 265
 266                                 tb = module.DefineType (MakeName (), TypeAttributes.Public | TypeAttributes.Abstract);
 267                                 Assert.AreEqual (TypeAttributes.Public | TypeAttributes.Abstract, tb.Attributes, "$4");
 268                 }
 269
 270                 [Test]
 271                 public void AsParamType ()
 272                 {
 273
 274                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 275                         Type ptr = tb.MakePointerType ();
 276
 277                         MethodBuilder mb = tb.DefineMethod ("Test", MethodAttributes.Public, typeof (void), new Type [1] { ptr });
 278                         ILGenerator ilgen = mb.GetILGenerator ();
 279                         ilgen.Emit (OpCodes.Ret);
 280
 281                         Type res = tb.CreateType ();
 282
 283                         object o = Activator.CreateInstance (res);
 284                         //FIXME this crashes the runtime
 285                         //res.GetMethod ("Test").Invoke (o, new object[1] { null });
 286                 }
 287
 288                 [Test]
 289                 public void AsLocalVariable ()
 290                 {
 291
 292                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 293                         Type ptr = tb.MakePointerType ();
 294
 295                         MethodBuilder mb = tb.DefineMethod ("Test", MethodAttributes.Public, typeof (void), new Type [0]);
 296                         ILGenerator ilgen = mb.GetILGenerator ();
 297                         ilgen.DeclareLocal (ptr);
 298                         ilgen.Emit (OpCodes.Ret);
 299
 300                         Type res = tb.CreateType ();
 301
 302                         object o = Activator.CreateInstance (res);
 303                         res.GetMethod ("Test").Invoke (o, null);
 304                 }
 305
 306                 [Test]
 307                 public void TestEquals ()
 308                 {
 309                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 310                         Type ptr = tb.MakePointerType ();
 311                         Type ptr2 = tb.MakePointerType ();
 312                         Assert.IsTrue (ptr.Equals (ptr), "#2");
 313                 }
 314
 315                 [Test]
 316                 [Category ("NotWorking")] //two stage type creation makes this fail
 317                 public void TestEquals2 ()
 318                 {
 319                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 320                         Type ptr = tb.MakePointerType ();
 321                         Type ptr2 = tb.MakePointerType ();
 322                         Assert.IsFalse (ptr.Equals (ptr2), "#1");
 323                 }
 324
 325                 [Test]
 326                 public void IsSubclassOf ()
 327                 {
 328                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 329                         Type ptr = tb.MakePointerType ();
 330                         Assert.IsFalse (ptr.IsSubclassOf (tb), "#1");
 331                         Assert.IsFalse (ptr.IsSubclassOf (typeof (object[])), "#2");
 332                 }
 333
 334                 [Test]
 335                 public void IsAssignableFrom ()
 336                 {
 337                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 338                         Type ptr = tb.MakePointerType ();
 339                         Assert.IsFalse (ptr.IsAssignableFrom (tb), "#1");
 340                         Assert.IsFalse (ptr.IsAssignableFrom (typeof (object[])), "#2");
 341                 }
 342
 343                 [Test]
 344                 [Category ("NotWorking")] //two stage type creation makes this fail
 345                 public void IsAssignableFrom2 ()
 346                 {
 347                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 348                         Type ptr = tb.MakePointerType ();
 349                         Assert.IsFalse (typeof (object[]).IsAssignableFrom (ptr), "#1");
 350                         Assert.IsFalse (typeof (object).IsAssignableFrom (ptr), "#2");
 351                 }
 352
 353
 354                 [Test]
 355                 public void GetInterfaceMap ()
 356                 {
 357                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 358                         Type ptr = tb.MakePointerType ();
 359                         try {
 360                                 ptr.GetInterfaceMap (typeof (IEnumerable));
 361                                 Assert.Fail ("#1");
 362                         } catch (NotSupportedException) {
 363
 364                         }
 365                 }
 366
 367                 [Test]
 368                 public void IsInstanceOfType ()
 369                 {
 370                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 371                         Type ptr = tb.MakePointerType ();
 372                         Assert.IsFalse (ptr.IsInstanceOfType (tb), "#1");
 373                         Assert.IsFalse (ptr.IsInstanceOfType (null), "#2");
 374                         Assert.IsFalse (ptr.IsInstanceOfType (new object [1]), "#3");
 375
 376                         Type t = tb.CreateType ();
 377                         object obj = Activator.CreateInstance (t);
 378                         Assert.IsFalse (ptr.IsInstanceOfType (obj), "#4");
 379                 }
 380
 381                 [Test]
 382                 public void IsGenericTypeDefinition ()
 383                 {
 384                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 385                         Type ptr = tb.MakePointerType ();
 386                         Assert.IsFalse (ptr.IsGenericTypeDefinition, "#1");
 387                 }
 388
 389                 [Test]
 390                 public void IsGenericType ()
 391                 {
 392                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 393                         Type ptr = tb.MakePointerType ();
 394                         Assert.IsFalse (ptr.IsGenericType, "#1");
 395                 }
 396
 397                 [Test]
 398                 public void MakeGenericType ()
 399                 {
 400                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 401                         Type ptr = tb.MakePointerType ();
 402                         try {
 403                                 ptr.MakeGenericType (new Type[] { typeof (string) });
 404                                 Assert.Fail ("#1");
 405                         } catch (NotSupportedException) {}
 406                 }
 407
 408                 [Test]
 409                 public void GenericParameterPosition ()
 410                 {
 411                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 412                         Type ptr = tb.MakePointerType ();
 413                         try {
 414                                 int pos = ptr.GenericParameterPosition;
 415                                 Assert.Fail ("#1");
 416                         } catch (InvalidOperationException) {}
 417                 }
 418
 419                 [Test]
 420                 public void GenericParameterAttributes ()
 421                 {
 422                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 423                         Type ptr = tb.MakePointerType ();
 424                         try {
 425                                 object attr = ptr.GenericParameterAttributes;
 426                                 Assert.Fail ("#1");
 427                         } catch (NotSupportedException) {}
 428                 }
 429
 430                 [Test]
 431                 public void GetGenericParameterConstraints ()
 432                 {
 433                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 434                         Type ptr = tb.MakePointerType ();
 435                         try {
 436                                 ptr.GetGenericParameterConstraints ();
 437                                 Assert.Fail ("#1");
 438                         } catch (InvalidOperationException) {}
 439                 }
 440
 441                 [Test]
 442                 public void MakeArrayType ()
 443                 {
 444                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 445                         Type ptr = tb.MakePointerType ();
 446                         Type res = ptr.MakeArrayType ();
 447                         Assert.IsNotNull (res, "#1");
 448                         Assert.IsTrue (res.IsArray, "#2");
 449
 450                         res = ptr.MakeArrayType (2);
 451                         Assert.IsNotNull (res, "#3");
 452                         Assert.IsTrue (res.IsArray, "#4");
 453                 }
 454
 455                 [Test]
 456                 public void MakeByRefType ()
 457                 {
 458                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 459                         Type ptr = tb.MakePointerType ();
 460                         Type res = ptr.MakeByRefType ();
 461
 462                         Assert.IsNotNull (res, "#1");
 463                         Assert.IsTrue (res.IsByRef, "#2");
 464                 }
 465
 466                 [Test]
 467                 public void MakePointerType ()
 468                 {
 469                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 470                         Type ptr = tb.MakePointerType ();
 471                         Type res = ptr.MakePointerType ();
 472
 473                         Assert.IsNotNull (res, "#1");
 474                         Assert.IsTrue (res.IsPointer, "#2");
 475                 }
 476
 477                 [Test]
 478                 public void StructLayoutAttribute ()
 479                 {
 480                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 481                         Type ptr = tb.MakePointerType ();
 482                         try {
 483                                 object x = ptr.StructLayoutAttribute;
 484                                 Assert.Fail ("#1");
 485                         } catch (NotSupportedException) {}
 486                 }
 487
 488                 [Test]
 489                 public void ByRefOfGenericTypeParameter ()
 490                 {
 491                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 492                         var gparam = tb.DefineGenericParameters ("F")[0];
 493                         Type ptr = gparam.MakePointerType ();
 494
 495                         try {
 496                                 ptr.GetGenericArguments ();
 497                                 Assert.Fail ("#1");
 498                         } catch (NotSupportedException) {}
 499
 500                         try {
 501                                 ptr.GetGenericParameterConstraints ();
 502                                 Assert.Fail ("#2");
 503                         } catch (InvalidOperationException) {}
 504
 505                         try {
 506                                 ptr.GetGenericTypeDefinition ();
 507                                 Assert.Fail ("#3");
 508                         } catch (NotSupportedException) {}
 509
 510                         Assert.IsTrue (ptr.ContainsGenericParameters, "#4");
 511                         try {
 512                                 var x = ptr.GenericParameterAttributes;
 513                                 Assert.Fail ("#5");
 514                         } catch (NotSupportedException) {}
 515
 516                         try {
 517                                 var x = ptr.GenericParameterPosition;
 518                                 Assert.Fail ("#6");
 519                         } catch (InvalidOperationException) {}
 520
 521
 522                         Assert.IsFalse (ptr.IsGenericParameter, "#8");
 523                         Assert.IsFalse (ptr.IsGenericType, "#9");
 524                         Assert.IsFalse (ptr.IsGenericTypeDefinition, "#10");
 525
 526                         Assert.AreEqual (TypeAttributes.Public, ptr.Attributes, "#11");
 527
 528                         Assert.IsTrue (ptr.HasElementType, "#12");
 529                         Assert.IsTrue (ptr.IsPointer, "#13");
 530
 531                         Assert.AreEqual (assembly, ptr.Assembly, "#14");
 532                         Assert.AreEqual (null, ptr.AssemblyQualifiedName, "#15");
 533                         //XXX LAMEIMPL this passes on MS even thou it's pretty much very wrong.
 534                         Assert.AreEqual (typeof (Array), ptr.BaseType, "#16");
 535                         Assert.AreEqual (null, ptr.FullName, "#17");
 536                         Assert.AreEqual (module, ptr.Module, "#18");
 537                         Assert.AreEqual (null, ptr.Namespace, "#19");
 538                         Assert.AreEqual (ptr, ptr.UnderlyingSystemType, "#20");
 539                         Assert.AreEqual ("F*", ptr.Name, "#21");
 540
 541                         Assert.AreEqual (gparam, ptr.GetElementType (), "#22");
 542                 }
 543         }
 544
 545
 546         [TestFixture]
 547         public class ByrefTypeTest
 548         {
 549                 AssemblyBuilder assembly;
 550                 ModuleBuilder module;
 551                 int typeCount;
 552                 static string ASSEMBLY_NAME = "MonoTests.System.Reflection.Emit.TypeBuilderTest";
 553
 554                 string MakeName ()
 555                 {
 556                         return "internal__type"+ typeCount++;
 557                 }
 558
 559                 [SetUp]
 560                 protected void SetUp ()
 561                 {
 562                         SetUp (AssemblyBuilderAccess.RunAndSave);
 563                 }
 564
 565                 protected void SetUp (AssemblyBuilderAccess mode)
 566                 {
 567                         AssemblyName assemblyName = new AssemblyName ();
 568                         assemblyName.Name = ASSEMBLY_NAME;
 569
 570                         assembly =
 571                                 Thread.GetDomain ().DefineDynamicAssembly (
 572                                         assemblyName, mode, Path.GetTempPath ());
 573
 574                         module = assembly.DefineDynamicModule ("module1");
 575                         typeCount = 0;
 576                 }
 577
 578                 [Test]
 579                 public void PropertiesValue ()
 580                 {
 581                         TypeBuilder tb = module.DefineType ("ns.type", TypeAttributes.Public);
 582                         Type byref = tb.MakeByRefType ();
 583
 584                         Assert.AreEqual (assembly, byref.Assembly, "#1");
 585                         Assert.AreEqual ("ns.type&, " + assembly.FullName, byref.AssemblyQualifiedName, "#2");
 586                         Assert.AreEqual ("ns.type&", byref.FullName, "#4");
 587                         Assert.AreEqual (module, byref.Module, "#5");
 588                         Assert.AreEqual ("ns", byref.Namespace, "#6");
 589                         Assert.AreEqual (byref, byref.UnderlyingSystemType, "#7");
 590                         Assert.AreEqual ("type&", byref.Name, "#8");
 591
 592                         try {
 593                                 object x = byref.GUID;
 594                                 Assert.Fail ("#9");
 595                         } catch (NotSupportedException) {}
 596
 597                         try {
 598                                 object x = byref.TypeHandle;
 599                                 Assert.Fail ("#10");
 600                         } catch (NotSupportedException) {}
 601                 }
 602
 603                 [Test]
 604                 public void Methods ()
 605                 {
 606                         TypeBuilder tb = module.DefineType ("ns.type", TypeAttributes.Public);
 607                         Type byref = tb.MakeByRefType ();
 608
 609                         try {
 610                                 byref.GetInterface ("foo", true);
 611                                 Assert.Fail ("#1");
 612                         } catch (NotSupportedException) {
 613
 614                         }
 615
 616                         try {
 617                                 byref.GetInterfaces ();
 618                                 Assert.Fail ("#2");
 619                         } catch (NotSupportedException) {
 620
 621                         }
 622
 623                         Assert.AreEqual (tb, byref.GetElementType ());
 624
 625                         try {
 626                                 byref.GetEvent ("foo", BindingFlags.Public);
 627                                 Assert.Fail ("#4");
 628                         } catch (NotSupportedException) {
 629
 630                         }
 631
 632                         try {
 633                                 byref.GetEvents (BindingFlags.Public);
 634                                 Assert.Fail ("#5");
 635                         } catch (NotSupportedException) {
 636
 637                         }
 638
 639                         try {
 640                                 byref.GetField ("foo", BindingFlags.Public);
 641                                 Assert.Fail ("#6");
 642                         } catch (NotSupportedException) {
 643
 644                         }
 645
 646                         try {
 647                                 byref.GetFields (BindingFlags.Public);
 648                                 Assert.Fail ("#7");
 649                         } catch (NotSupportedException) {
 650
 651                         }
 652
 653                         try {
 654                                 byref.GetMembers (BindingFlags.Public);
 655                                 Assert.Fail ("#8");
 656                         } catch (NotSupportedException) {
 657
 658                         }
 659
 660                         try {
 661                                 byref.GetMethod ("Sort");
 662                                 Assert.Fail ("#9");
 663                         } catch (NotSupportedException) {
 664
 665                         }
 666
 667                         try {
 668                                 byref.GetMethods (BindingFlags.Public);
 669                                 Assert.Fail ("#9");
 670                         } catch (NotSupportedException) {
 671
 672                         }
 673
 674                         try {
 675                                 byref.GetNestedType ("bla", BindingFlags.Public);
 676                                 Assert.Fail ("#10");
 677                         } catch (NotSupportedException) {
 678
 679                         }
 680
 681                         try {
 682                                 byref.GetNestedTypes (BindingFlags.Public);
 683                                 Assert.Fail ("#11");
 684                         } catch (NotSupportedException) {
 685
 686                         }
 687
 688                         try {
 689                                 byref.GetProperties (BindingFlags.Public);
 690                                 Assert.Fail ("#12");
 691                         } catch (NotSupportedException) {
 692
 693                         }
 694
 695                         try {
 696                                 byref.GetProperty ("Length");
 697                                 Assert.Fail ("#13");
 698                         } catch (NotSupportedException) {
 699
 700                         }
 701
 702                         try {
 703                                 byref.GetConstructor (new Type[] { typeof (int) });
 704                                 Assert.Fail ("#14");
 705                         } catch (NotSupportedException) {
 706
 707                         }
 708
 709                         TypeAttributes attr = TypeAttributes.AutoLayout | TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Public;
 710                         Assert.AreEqual (attr, byref.Attributes, "#15");
 711
 712                         Assert.IsTrue (byref.HasElementType, "#16");
 713                         Assert.IsFalse (byref.IsArray, "#17");
 714                         Assert.IsTrue (byref.IsByRef, "#18");
 715                         Assert.IsFalse (byref.IsCOMObject, "#19");
 716                         Assert.IsFalse (byref.IsPointer, "#20");
 717                         Assert.IsFalse (byref.IsPrimitive, "#21");
 718
 719                         try {
 720                                 byref.GetConstructors (BindingFlags.Public);
 721                                 Assert.Fail ("#22");
 722                         } catch (NotSupportedException) {
 723
 724                         }
 725
 726                         try {
 727                                 byref.InvokeMember ("GetLength", BindingFlags.Public, null, null, null);
 728                                 Assert.Fail ("#23");
 729                         } catch (NotSupportedException) {
 730
 731                         }
 732
 733                         try {
 734                                 byref.GetArrayRank ();
 735                                 Assert.Fail ("#23");
 736                         } catch (NotSupportedException) {
 737
 738                         }
 739                 }
 740
 741                 [Test]
 742                 public void AttributeValues ()
 743                 {
 744                                 TypeBuilder tb = module.DefineType (MakeName (), TypeAttributes.NotPublic);
 745                                 Assert.AreEqual (TypeAttributes.NotPublic, tb.Attributes, "#1");
 746
 747                                 tb = module.DefineType (MakeName (), TypeAttributes.Public);
 748                                 Assert.AreEqual (TypeAttributes.Public, tb.Attributes, "#2");
 749
 750                                 tb = module.DefineType (MakeName (), TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed);
 751                                 Assert.AreEqual (TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed, tb.Attributes, "#3");
 752
 753                                 tb = module.DefineType (MakeName (), TypeAttributes.Public | TypeAttributes.Abstract);
 754                                 Assert.AreEqual (TypeAttributes.Public | TypeAttributes.Abstract, tb.Attributes, "$4");
 755                 }
 756
 757                 [Test]
 758                 public void AsParamType ()
 759                 {
 760
 761                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 762                         Type byref = tb.MakeByRefType ();
 763
 764                         MethodBuilder mb = tb.DefineMethod ("Test", MethodAttributes.Public, typeof (void), new Type [1] { byref });
 765                         ILGenerator ilgen = mb.GetILGenerator ();
 766                         ilgen.Emit (OpCodes.Ret);
 767
 768                         Type res = tb.CreateType ();
 769
 770                         object o = Activator.CreateInstance (res);
 771                         res.GetMethod ("Test").Invoke (o, new object[1] { null });
 772                 }
 773
 774                 [Test]
 775                 public void AsLocalVariable ()
 776                 {
 777
 778                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 779                         Type byref = tb.MakeByRefType ();
 780
 781                         MethodBuilder mb = tb.DefineMethod ("Test", MethodAttributes.Public, typeof (void), new Type [0]);
 782                         ILGenerator ilgen = mb.GetILGenerator ();
 783                         ilgen.DeclareLocal (byref);
 784                         ilgen.Emit (OpCodes.Ret);
 785
 786                         Type res = tb.CreateType ();
 787
 788                         object o = Activator.CreateInstance (res);
 789                         res.GetMethod ("Test").Invoke (o, null);
 790                 }
 791
 792                 [Test]
 793                 public void TestEquals ()
 794                 {
 795                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 796                         Type byref = tb.MakeByRefType ();
 797                         Type byref2 = tb.MakeByRefType ();
 798                         Assert.IsTrue (byref.Equals (byref), "#1");
 799                 }
 800
 801                 [Test]
 802                 [Category ("NotWorking")] //two stage type creation makes this fail
 803                 public void TestEquals2 ()
 804                 {
 805                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 806                         Type byref = tb.MakeByRefType ();
 807                         Type byref2 = tb.MakeByRefType ();
 808                         Assert.IsFalse (byref.Equals (byref2), "#1");
 809                 }
 810
 811                 [Test]
 812                 public void IsSubclassOf ()
 813                 {
 814                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 815                         Type byref = tb.MakeByRefType ();
 816                         Assert.IsFalse (byref.IsSubclassOf (tb), "#1");
 817                         Assert.IsFalse (byref.IsSubclassOf (typeof (object[])), "#2");
 818                 }
 819
 820                 [Test]
 821                 public void IsAssignableFrom ()
 822                 {
 823                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 824                         Type byref = tb.MakeByRefType ();
 825                         Assert.IsFalse (byref.IsAssignableFrom (tb), "#1");
 826                         Assert.IsFalse (byref.IsAssignableFrom (typeof (object[])), "#2");
 827                 }
 828
 829                 [Test]
 830                 [Category ("NotWorking")] //two stage type creation makes this fail
 831                 public void IsAssignableFrom2 ()
 832                 {
 833                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 834                         Type byref = tb.MakeByRefType ();
 835                         Assert.IsFalse (typeof (object[]).IsAssignableFrom (byref), "#1");
 836                         Assert.IsFalse (typeof (object).IsAssignableFrom (byref), "#2");
 837                 }
 838
 839                 [Test]
 840                 public void GetInterfaceMap ()
 841                 {
 842                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 843                         Type byref = tb.MakeByRefType ();
 844                         try {
 845                                 byref.GetInterfaceMap (typeof (IEnumerable));
 846                                 Assert.Fail ("#1");
 847                         } catch (NotSupportedException) {
 848
 849                         }
 850                 }
 851
 852                 [Test]
 853                 public void IsInstanceOfType ()
 854                 {
 855                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 856                         Type byref = tb.MakeByRefType ();
 857                         Assert.IsFalse (byref.IsInstanceOfType (tb), "#1");
 858                         Assert.IsFalse (byref.IsInstanceOfType (null), "#2");
 859                         Assert.IsFalse (byref.IsInstanceOfType (new object [1]), "#3");
 860
 861                         Type t = tb.CreateType ();
 862                         object obj = Activator.CreateInstance (t);
 863                         Assert.IsFalse (byref.IsInstanceOfType (obj), "#4");
 864                 }
 865
 866                 [Test]
 867                 public void IsGenericTypeDefinition ()
 868                 {
 869                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 870                         Type byref = tb.MakeByRefType ();
 871                         Assert.IsFalse (byref.IsGenericTypeDefinition, "#1");
 872                 }
 873
 874                 [Test]
 875                 public void IsGenericType ()
 876                 {
 877                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 878                         Type byref = tb.MakeByRefType ();
 879                         Assert.IsFalse (byref.IsGenericType, "#1");
 880                 }
 881
 882                 [Test]
 883                 public void MakeGenericType ()
 884                 {
 885                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 886                         Type byref = tb.MakeByRefType ();
 887                         try {
 888                                 byref.MakeGenericType (new Type[] { typeof (string) });
 889                                 Assert.Fail ("#1");
 890                         } catch (NotSupportedException) {}
 891                 }
 892
 893                 [Test]
 894                 public void GenericParameterPosition ()
 895                 {
 896                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 897                         Type byref = tb.MakeByRefType ();
 898                         try {
 899                                 int pos = byref.GenericParameterPosition;
 900                                 Assert.Fail ("#1");
 901                         } catch (InvalidOperationException) {}
 902                 }
 903
 904                 [Test]
 905                 public void GenericParameterAttributes ()
 906                 {
 907                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 908                         Type byref = tb.MakeByRefType ();
 909                         try {
 910                                 object attr = byref.GenericParameterAttributes;
 911                                 Assert.Fail ("#1");
 912                         } catch (NotSupportedException) {}
 913                 }
 914
 915                 [Test]
 916                 public void GetGenericParameterConstraints ()
 917                 {
 918                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 919                         Type byref = tb.MakeByRefType ();
 920                         try {
 921                                 byref.GetGenericParameterConstraints ();
 922                                 Assert.Fail ("#1");
 923                         } catch (InvalidOperationException) {}
 924                 }
 925
 926                 [Test]
 927                 public void MakeArrayType ()
 928                 {
 929                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 930                         Type byref = tb.MakeByRefType ();
 931                         try {
 932                                 byref.MakeArrayType ();
 933                                 Assert.Fail ("#1");
 934                         } catch (ArgumentException) {};
 935                         try {
 936                                 byref.MakeArrayType (2);
 937                                 Assert.Fail ("#2");
 938                         } catch (ArgumentException) {};
 939                 }
 940
 941                 [Test]
 942                 public void MakeByRefType ()
 943                 {
 944                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 945                         Type byref = tb.MakeByRefType ();
 946                         try {
 947                                 byref.MakeByRefType ();
 948                                 Assert.Fail ("#1");
 949                         } catch (ArgumentException) {}
 950                 }
 951
 952                 [Test]
 953                 public void MakePointerType ()
 954                 {
 955                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 956                         Type byref = tb.MakeByRefType ();
 957                         try {
 958                                 byref.MakePointerType ();
 959                                 Assert.Fail ("#1");
 960                         } catch (ArgumentException) {}
 961                 }
 962
 963                 [Test]
 964                 public void StructLayoutAttribute ()
 965                 {
 966                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 967                         Type byref = tb.MakeByRefType ();
 968                         try {
 969                                 object x = byref.StructLayoutAttribute;
 970                                 Assert.Fail ("#1");
 971                         } catch (NotSupportedException) {}
 972                 }
 973
 974                 [Test]
 975                 [Category ("NotDotNet")]
 976                 // CompilerContext no longer supported
 977                 [Category ("NotWorking")]
 978                 public void ByRefOfAttriburesUnderCompilerContext ()
 979                 {
 980                         SetUp (AssemblyBuilderAccess.RunAndSave | (AssemblyBuilderAccess)0x800);
 981
 982                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 983                         var gparam = tb.DefineGenericParameters ("F")[0];
 984                         Type byref = gparam.MakeByRefType ();
 985
 986                         tb = module.DefineType (MakeName (), TypeAttributes.Public);
 987                         Assert.AreEqual (TypeAttributes.Public , byref.Attributes, "#1");
 988
 989                 }
 990
 991                 [Test]
 992                 public void ByRefOfGenericTypeParameter ()
 993                 {
 994                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
 995                         var gparam = tb.DefineGenericParameters ("F")[0];
 996                         Type byref = gparam.MakeByRefType ();
 997
 998                         try {
 999                                 byref.GetGenericArguments ();
1000                                 Assert.Fail ("#1");
1001                         } catch (NotSupportedException) {}
1002
1003                         try {
1004                                 byref.GetGenericParameterConstraints ();
1005                                 Assert.Fail ("#2");
1006                         } catch (InvalidOperationException) {}
1007
1008                         try {
1009                                 byref.GetGenericTypeDefinition ();
1010                                 Assert.Fail ("#3");
1011                         } catch (NotSupportedException) {}
1012
1013                         Assert.IsTrue (byref.ContainsGenericParameters, "#4");
1014                         try {
1015                                 var x = byref.GenericParameterAttributes;
1016                                 Assert.Fail ("#5");
1017                         } catch (NotSupportedException) {}
1018
1019                         try {
1020                                 var x = byref.GenericParameterPosition;
1021                                 Assert.Fail ("#6");
1022                         } catch (InvalidOperationException) {}
1023
1024
1025                         Assert.IsFalse (byref.IsGenericParameter, "#8");
1026                         Assert.IsFalse (byref.IsGenericType, "#9");
1027                         Assert.IsFalse (byref.IsGenericTypeDefinition, "#10");
1028
1029
1030                         Assert.AreEqual (TypeAttributes.Public, byref.Attributes, "#11");
1031
1032                         Assert.IsTrue (byref.HasElementType, "#12");
1033                         Assert.IsTrue (byref.IsByRef, "#13");
1034
1035                         Assert.AreEqual (assembly, byref.Assembly, "#14");
1036                         Assert.AreEqual (null, byref.AssemblyQualifiedName, "#15");
1037                         //XXX LAMEIMPL this passes on MS even thou it's pretty much very wrong.
1038                         Assert.AreEqual (typeof (Array), byref.BaseType, "#16");
1039                         Assert.AreEqual (null, byref.FullName, "#17");
1040                         Assert.AreEqual (module, byref.Module, "#18");
1041                         Assert.AreEqual (null, byref.Namespace, "#19");
1042                         Assert.AreEqual (byref, byref.UnderlyingSystemType, "#20");
1043                         Assert.AreEqual ("F&", byref.Name, "#21");
1044
1045                         Assert.AreEqual (gparam, byref.GetElementType (), "#22");
1046                 }
1047         }
1048
1049         [TestFixture]
1050         public class ArrayTypeTest
1051         {
1052                 AssemblyBuilder assembly;
1053                 ModuleBuilder module;
1054                 int typeCount;
1055                 static string ASSEMBLY_NAME = "MonoTests.System.Reflection.Emit.TypeBuilderTest";
1056
1057                 string MakeName ()
1058                 {
1059                         return "internal__type"+ typeCount++;
1060                 }
1061
1062
1063                 [SetUp]
1064                 protected void SetUp ()
1065                 {
1066                         SetUp (AssemblyBuilderAccess.RunAndSave);
1067                 }
1068
1069                 protected void SetUp (AssemblyBuilderAccess mode)
1070                 {
1071                         AssemblyName assemblyName = new AssemblyName ();
1072                         assemblyName.Name = ASSEMBLY_NAME;
1073
1074                         assembly =
1075                                 Thread.GetDomain ().DefineDynamicAssembly (
1076                                         assemblyName, mode, Path.GetTempPath ());
1077
1078                         module = assembly.DefineDynamicModule ("module1");
1079                         typeCount = 0;
1080                 }
1081
1082                 [Test]
1083                 public void OneDimMultiDimentionArray ()
1084                 {
1085                         TypeBuilder tb = module.DefineType ("ns.type", TypeAttributes.Public);
1086
1087                         Type arr1 = tb.MakeArrayType ();
1088                         Type arr2 = tb.MakeArrayType (1);
1089                         Type arr3 = arr1.MakeArrayType (1);
1090
1091                         Assert.AreEqual ("type[]", arr1.Name, "#1");
1092                         Assert.AreEqual ("type[*]", arr2.Name, "#2");
1093                         Assert.AreEqual ("type[][*]", arr3.Name, "#3");
1094
1095                         var gparam = tb.DefineGenericParameters ("F")[0];
1096                         Type arr4 = gparam.MakeArrayType ();
1097                         Type arr5 = gparam.MakeArrayType (1);
1098
1099                         Assert.AreEqual ("F[]", arr4.Name, "#4");
1100                         Assert.AreEqual ("F[*]", arr5.Name, "#5");
1101
1102                         var eb = module.DefineEnum ("enum", TypeAttributes.Public, tb);
1103                         Type arr6 = eb.MakeArrayType ();
1104                         Type arr7 = eb.MakeArrayType (1);
1105
1106                         Assert.AreEqual ("enum[]", arr6.Name, "#6");
1107                         Assert.AreEqual ("enum[*]", arr7.Name, "#7");
1108                 }
1109
1110                 [Test]
1111                 public void PropertiesValue ()
1112                 {
1113                         TypeBuilder tb = module.DefineType ("ns.type", TypeAttributes.Public);
1114                         Type arr = tb.MakeArrayType ();
1115
1116                         Assert.AreEqual (assembly, arr.Assembly, "#1");
1117                         Assert.AreEqual ("ns.type[], " + assembly.FullName, arr.AssemblyQualifiedName, "#2");
1118                         Assert.AreEqual (typeof (Array), arr.BaseType, "#3");
1119                         Assert.AreEqual ("ns.type[]", arr.FullName, "#4");
1120                         Assert.AreEqual (module, arr.Module, "#5");
1121                         Assert.AreEqual ("ns", arr.Namespace, "#6");
1122                         Assert.AreEqual (arr, arr.UnderlyingSystemType, "#7");
1123                         Assert.AreEqual ("type[]", arr.Name, "#8");
1124
1125                         try {
1126                                 object x = arr.GUID;
1127                                 Assert.Fail ("#9");
1128                         } catch (NotSupportedException) {}
1129
1130                         try {
1131                                 object x = arr.TypeHandle;
1132                                 Assert.Fail ("#10");
1133                         } catch (NotSupportedException) {}
1134                 }
1135
1136                 [Test]
1137                 public void Methods ()
1138                 {
1139                         TypeBuilder tb = module.DefineType ("ns.type", TypeAttributes.Public);
1140                         Type arr = tb.MakeArrayType ();
1141
1142                         try {
1143                                 arr.GetInterface ("foo", true);
1144                                 Assert.Fail ("#1");
1145                         } catch (NotSupportedException) {
1146
1147                         }
1148
1149                         try {
1150                                 arr.GetInterfaces ();
1151                                 Assert.Fail ("#2");
1152                         } catch (NotSupportedException) {
1153
1154                         }
1155
1156                         Assert.AreEqual (tb, arr.GetElementType ());
1157
1158                         try {
1159                                 arr.GetEvent ("foo", BindingFlags.Public);
1160                                 Assert.Fail ("#4");
1161                         } catch (NotSupportedException) {
1162
1163                         }
1164
1165                         try {
1166                                 arr.GetEvents (BindingFlags.Public);
1167                                 Assert.Fail ("#5");
1168                         } catch (NotSupportedException) {
1169
1170                         }
1171
1172                         try {
1173                                 arr.GetField ("foo", BindingFlags.Public);
1174                                 Assert.Fail ("#6");
1175                         } catch (NotSupportedException) {
1176
1177                         }
1178
1179                         try {
1180                                 arr.GetFields (BindingFlags.Public);
1181                                 Assert.Fail ("#7");
1182                         } catch (NotSupportedException) {
1183
1184                         }
1185
1186                         try {
1187                                 arr.GetMembers (BindingFlags.Public);
1188                                 Assert.Fail ("#8");
1189                         } catch (NotSupportedException) {
1190
1191                         }
1192
1193                         try {
1194                                 arr.GetMethod ("Sort");
1195                                 Assert.Fail ("#9");
1196                         } catch (NotSupportedException) {
1197
1198                         }
1199
1200                         try {
1201                                 arr.GetMethods (BindingFlags.Public);
1202                                 Assert.Fail ("#9");
1203                         } catch (NotSupportedException) {
1204
1205                         }
1206
1207                         try {
1208                                 arr.GetNestedType ("bla", BindingFlags.Public);
1209                                 Assert.Fail ("#10");
1210                         } catch (NotSupportedException) {
1211
1212                         }
1213
1214                         try {
1215                                 arr.GetNestedTypes (BindingFlags.Public);
1216                                 Assert.Fail ("#11");
1217                         } catch (NotSupportedException) {
1218
1219                         }
1220
1221                         try {
1222                                 arr.GetProperties (BindingFlags.Public);
1223                                 Assert.Fail ("#12");
1224                         } catch (NotSupportedException) {
1225
1226                         }
1227
1228                         try {
1229                                 arr.GetProperty ("Length");
1230                                 Assert.Fail ("#13");
1231                         } catch (NotSupportedException) {
1232
1233                         }
1234
1235                         try {
1236                                 arr.GetConstructor (new Type[] { typeof (int) });
1237                                 Assert.Fail ("#14");
1238                         } catch (NotSupportedException) {
1239
1240                         }
1241
1242                         TypeAttributes attr = TypeAttributes.AutoLayout | TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Public;
1243                         Assert.AreEqual (attr, arr.Attributes, "#15");
1244
1245                         Assert.IsTrue (arr.HasElementType, "#16");
1246                         Assert.IsTrue (arr.IsArray, "#17");
1247                         Assert.IsFalse (arr.IsByRef, "#18");
1248                         Assert.IsFalse (arr.IsCOMObject, "#19");
1249                         Assert.IsFalse (arr.IsPointer, "#20");
1250                         Assert.IsFalse (arr.IsPrimitive, "#21");
1251
1252                         try {
1253                                 arr.GetConstructors (BindingFlags.Public);
1254                                 Assert.Fail ("#22");
1255                         } catch (NotSupportedException) {
1256
1257                         }
1258
1259                         try {
1260                                 arr.InvokeMember ("GetLength", BindingFlags.Public, null, null, null);
1261                                 Assert.Fail ("#23");
1262                         } catch (NotSupportedException) {
1263
1264                         }
1265                 }
1266
1267                 [Test]
1268                 public void AttributeValues ()
1269                 {
1270                         TypeBuilder tb = module.DefineType (MakeName (), TypeAttributes.NotPublic);
1271                         Assert.AreEqual (TypeAttributes.NotPublic, tb.Attributes, "#1");
1272
1273                         tb = module.DefineType (MakeName (), TypeAttributes.Public);
1274                         Assert.AreEqual (TypeAttributes.Public, tb.Attributes, "#2");
1275
1276                         tb = module.DefineType (MakeName (), TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed);
1277                         Assert.AreEqual (TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed, tb.Attributes, "#3");
1278
1279                         tb = module.DefineType (MakeName (), TypeAttributes.Public | TypeAttributes.Abstract);
1280                         Assert.AreEqual (TypeAttributes.Public | TypeAttributes.Abstract, tb.Attributes, "$4");
1281                 }
1282
1283                 [Test]
1284                 [Category ("NotDotNet")]
1285                 // CompilerContext no longer supported
1286                 [Category ("NotWorking")]
1287                 public void AttributeValuesUnderCompilerContext ()
1288                 {
1289                         SetUp (AssemblyBuilderAccess.RunAndSave | (AssemblyBuilderAccess)0x800);
1290
1291                         TypeAttributes arrayAttr = TypeAttributes.Sealed | TypeAttributes.Serializable;
1292
1293                         TypeBuilder tb = module.DefineType (MakeName (), TypeAttributes.NotPublic);
1294                         Assert.AreEqual (TypeAttributes.NotPublic | arrayAttr, tb.MakeArrayType ().Attributes, "#1");
1295
1296                         tb = module.DefineType (MakeName (), TypeAttributes.Public);
1297                         Assert.AreEqual (TypeAttributes.Public | arrayAttr, tb.MakeArrayType ().Attributes, "#2");
1298
1299                         tb = module.DefineType (MakeName (), TypeAttributes.Public | TypeAttributes.Serializable | TypeAttributes.Sealed);
1300                         Assert.AreEqual (TypeAttributes.Public | arrayAttr, tb.MakeArrayType ().Attributes, "#3");
1301
1302                         tb = module.DefineType (MakeName (), TypeAttributes.Public | TypeAttributes.Abstract);
1303                         Assert.AreEqual (TypeAttributes.Public | arrayAttr, tb.MakeArrayType ().Attributes, "$4");
1304                 }
1305
1306                 [Test]
1307                 public void AsReturnType ()
1308                 {
1309
1310                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1311                         Type arr = tb.MakeArrayType ();
1312
1313                         MethodBuilder mb = tb.DefineMethod ("Test", MethodAttributes.Public, arr, new Type [0]);
1314                         ILGenerator ilgen = mb.GetILGenerator ();
1315                         ilgen.Emit (OpCodes.Ldnull);
1316                         ilgen.Emit (OpCodes.Ret);
1317
1318                         Type res = tb.CreateType ();
1319
1320                         object o = Activator.CreateInstance (res);
1321                         res.GetMethod ("Test").Invoke (o, null);
1322                 }
1323
1324                 [Test]
1325                 public void AsParamType ()
1326                 {
1327
1328                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1329                         Type arr = tb.MakeArrayType ();
1330
1331                         MethodBuilder mb = tb.DefineMethod ("Test", MethodAttributes.Public, typeof (void), new Type [1] { arr });
1332                         ILGenerator ilgen = mb.GetILGenerator ();
1333                         ilgen.Emit (OpCodes.Ret);
1334
1335                         Type res = tb.CreateType ();
1336
1337                         object o = Activator.CreateInstance (res);
1338                         res.GetMethod ("Test").Invoke (o, new object[1] { null });
1339                 }
1340
1341                 [Test]
1342                 public void AsLocalVariable ()
1343                 {
1344
1345                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1346                         Type arr = tb.MakeArrayType ();
1347
1348                         MethodBuilder mb = tb.DefineMethod ("Test", MethodAttributes.Public, arr, new Type [0]);
1349                         ILGenerator ilgen = mb.GetILGenerator ();
1350                         ilgen.DeclareLocal (arr);
1351                         ilgen.Emit (OpCodes.Ldnull);
1352                         ilgen.Emit (OpCodes.Stloc_0);
1353                         ilgen.Emit (OpCodes.Ldloc_0);
1354                         ilgen.Emit (OpCodes.Ret);
1355
1356                         Type res = tb.CreateType ();
1357
1358                         object o = Activator.CreateInstance (res);
1359                         res.GetMethod ("Test").Invoke (o, null);
1360                 }
1361
1362                 [Test]
1363                 public void TestEquals ()
1364                 {
1365                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1366                         Type arr = tb.MakeArrayType ();
1367                         Type arr2 = tb.MakeArrayType ();
1368                         Assert.IsTrue (arr.Equals (arr), "#1");
1369                 }
1370
1371                 [Test]
1372                 [Category ("NotWorking")] //two stage type creation makes this fail
1373                 public void TestEquals2 ()
1374                 {
1375                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1376                         Type arr = tb.MakeArrayType ();
1377                         Type arr2 = tb.MakeArrayType ();
1378                         Assert.IsFalse (arr.Equals (arr2), "#1");
1379                 }
1380
1381                 [Test]
1382                 public void IsSubclassOf ()
1383                 {
1384                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1385                         Type arr = tb.MakeArrayType ();
1386                         Assert.IsFalse (arr.IsSubclassOf (tb), "#1");
1387                         Assert.IsFalse (arr.IsSubclassOf (typeof (object[])), "#2");
1388                 }
1389
1390                 [Test]
1391                 public void IsAssignableFrom ()
1392                 {
1393                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1394                         Type arr = tb.MakeArrayType ();
1395                         Assert.IsFalse (arr.IsAssignableFrom (tb), "#1");
1396                         Assert.IsFalse (arr.IsAssignableFrom (typeof (object[])), "#2");
1397                 }
1398
1399                 [Test]
1400                 [Category ("NotWorking")] //two stage type creation makes this fail
1401                 public void IsAssignableFrom2 ()
1402                 {
1403                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1404                         Type arr = tb.MakeArrayType ();
1405                         Assert.IsFalse (typeof (object[]).IsAssignableFrom (arr), "#1");
1406                         Assert.IsFalse (typeof (object).IsAssignableFrom (arr), "#2");
1407                 }
1408
1409                 [Test]
1410                 public void GetInterfaceMap ()
1411                 {
1412                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1413                         Type arr = tb.MakeArrayType ();
1414                         try {
1415                                 arr.GetInterfaceMap (typeof (IEnumerable));
1416                                 Assert.Fail ("#1");
1417                         } catch (NotSupportedException) {
1418
1419                         }
1420                 }
1421
1422                 [Test]
1423                 public void IsInstanceOfType ()
1424                 {
1425                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1426                         Type arr = tb.MakeArrayType ();
1427                         Assert.IsFalse (arr.IsInstanceOfType (tb), "#1");
1428                         Assert.IsFalse (arr.IsInstanceOfType (null), "#2");
1429                         Assert.IsFalse (arr.IsInstanceOfType (new object [1]), "#3");
1430
1431                         Type t = tb.CreateType ();
1432                         object obj = Array.CreateInstance (t, 10);
1433                         Assert.IsFalse (arr.IsInstanceOfType (obj), "#4");
1434                 }
1435
1436                 [Test]
1437                 public void IsGenericTypeDefinition ()
1438                 {
1439                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1440                         Type arr = tb.MakeArrayType ();
1441                         Assert.IsFalse (arr.IsGenericTypeDefinition, "#1");
1442                 }
1443
1444                 [Test]
1445                 public void IsGenericType ()
1446                 {
1447                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1448                         Type arr = tb.MakeArrayType ();
1449                         Assert.IsFalse (arr.IsGenericType, "#1");
1450                 }
1451
1452                 [Test]
1453                 public void MakeGenericType ()
1454                 {
1455                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1456                         Type arr = tb.MakeArrayType ();
1457                         try {
1458                                 arr.MakeGenericType (new Type[] { typeof (string) });
1459                                 Assert.Fail ("#1");
1460                         } catch (NotSupportedException) {}
1461                 }
1462
1463                 [Test]
1464                 public void GenericParameterPosition ()
1465                 {
1466                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1467                         Type arr = tb.MakeArrayType ();
1468                         try {
1469                                 int pos = arr.GenericParameterPosition;
1470                                 Assert.Fail ("#1");
1471                         } catch (InvalidOperationException) {}
1472                 }
1473
1474                 [Test]
1475                 public void GenericParameterAttributes ()
1476                 {
1477                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1478                         Type arr = tb.MakeArrayType ();
1479                         try {
1480                                 object attr = arr.GenericParameterAttributes;
1481                                 Assert.Fail ("#1");
1482                         } catch (NotSupportedException) {}
1483                 }
1484
1485                 [Test]
1486                 public void GetGenericParameterConstraints ()
1487                 {
1488                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1489                         Type arr = tb.MakeArrayType ();
1490                         try {
1491                                 arr.GetGenericParameterConstraints ();
1492                                 Assert.Fail ("#1");
1493                         } catch (InvalidOperationException) {}
1494                 }
1495
1496                 [Test]
1497                 public void MakeArrayType ()
1498                 {
1499                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1500                         Type arr = tb.MakeArrayType ();
1501                         Type res = arr.MakeArrayType ();
1502                         Assert.IsNotNull (res, "#1");
1503                         Assert.IsTrue (res.IsArray, "#2");
1504
1505                         res = arr.MakeArrayType (2);
1506                         Assert.IsNotNull (res, "#3");
1507                         Assert.IsTrue (res.IsArray, "#4");
1508                 }
1509
1510                 [Test]
1511                 public void MakeByRefType ()
1512                 {
1513                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1514                         Type arr = tb.MakeArrayType ();
1515                         Type res = arr.MakeByRefType ();
1516
1517                         Assert.IsNotNull (res, "#1");
1518                         Assert.IsTrue (res.IsByRef, "#2");
1519                 }
1520
1521                 [Test]
1522                 public void MakePointerType ()
1523                 {
1524                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1525                         Type arr = tb.MakeArrayType ();
1526                         Type res = arr.MakePointerType ();
1527
1528                         Assert.IsNotNull (res, "#1");
1529                         Assert.IsTrue (res.IsPointer, "#2");
1530                 }
1531
1532                 [Test]
1533                 public void StructLayoutAttribute ()
1534                 {
1535                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1536                         Type arr = tb.MakeArrayType ();
1537                         try {
1538                                 object x = arr.StructLayoutAttribute;
1539                                 Assert.Fail ("#1");
1540                         } catch (NotSupportedException) {}
1541                 }
1542
1543                 [Test]
1544                 public void GetArrayRank ()
1545                 {
1546                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1547
1548                         Assert.AreEqual (1, tb.MakeArrayType ().GetArrayRank (), "#1");
1549                         Assert.AreEqual (2, tb.MakeArrayType (2).GetArrayRank (), "#2");
1550                 }
1551
1552                 [Test]
1553                 public void GenericTypeMembers ()
1554                 {
1555                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1556                         Type arr = tb.MakeArrayType ();
1557
1558                         try {
1559                                 arr.GetGenericArguments ();
1560                                 Assert.Fail ("#1");
1561                         } catch (NotSupportedException) {}
1562
1563                         try {
1564                                 arr.GetGenericParameterConstraints ();
1565                                 Assert.Fail ("#2");
1566                         } catch (InvalidOperationException) {}
1567
1568                         try {
1569                                 arr.GetGenericTypeDefinition ();
1570                                 Assert.Fail ("#3");
1571                         } catch (NotSupportedException) {}
1572
1573                         Assert.IsFalse (arr.ContainsGenericParameters, "#4");
1574                         try {
1575                                 var x = arr.GenericParameterAttributes;
1576                                 Assert.Fail ("#5");
1577                         } catch (NotSupportedException) {}
1578
1579                         try {
1580                                 var x = arr.GenericParameterPosition;
1581                                 Assert.Fail ("#6");
1582                         } catch (InvalidOperationException) {}
1583
1584                         Assert.IsFalse (arr.ContainsGenericParameters, "#7");
1585
1586                         Assert.IsFalse (arr.IsGenericParameter, "#8");
1587                         Assert.IsFalse (arr.IsGenericType, "#9");
1588                         Assert.IsFalse (arr.IsGenericTypeDefinition, "#10");
1589                 }
1590
1591                 [Test]
1592                 public void ArrayAsGenericArgumentOfNonSreType ()
1593                 {
1594                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1595
1596                         Type arr = tb.MakeArrayType ();
1597                         Type inst = typeof (Foo<>).MakeGenericType (arr);
1598
1599                         MethodBuilder mb = tb.DefineMethod ("Main", MethodAttributes.Public | MethodAttributes.Static, typeof (object), Type.EmptyTypes);
1600
1601                         ILGenerator ilgen = mb.GetILGenerator ();
1602                         ilgen.Emit (OpCodes.Ldtoken, inst);
1603                         ilgen.Emit (OpCodes.Call, typeof (Type).GetMethod ("GetTypeFromHandle"));
1604                         ilgen.Emit (OpCodes.Ret);
1605
1606                         Type res = tb.CreateType ();
1607                         Type expected = typeof (Foo<>).MakeGenericType (res.MakeArrayType ());
1608
1609                         Assert.AreEqual (expected, res.GetMethod ("Main").Invoke (null, null), "#1");
1610                         Assert.IsNotNull (Activator.CreateInstance (expected), "#2");
1611                 }
1612
1613
1614                 [Test]
1615                 public void GenericTypeMembersOfGenericTypeParam ()
1616                 {
1617                         TypeBuilder tb = module.DefineType ("dd.test", TypeAttributes.Public);
1618                         var gparam = tb.DefineGenericParameters ("F")[0];
1619                         Type arr = gparam.MakeArrayType ();
1620
1621                         try {
1622                                 arr.GetGenericArguments ();
1623                                 Assert.Fail ("#1");
1624                         } catch (NotSupportedException) {}
1625
1626                         try {
1627                                 arr.GetGenericParameterConstraints ();
1628                                 Assert.Fail ("#2");
1629                         } catch (InvalidOperationException) {}
1630
1631                         try {
1632                                 arr.GetGenericTypeDefinition ();
1633                                 Assert.Fail ("#3");
1634                         } catch (NotSupportedException) {}
1635
1636                         Assert.IsTrue (arr.ContainsGenericParameters, "#4");
1637                         try {
1638                                 var x = arr.GenericParameterAttributes;
1639                                 Assert.Fail ("#5");
1640                         } catch (NotSupportedException) {}
1641
1642                         try {
1643                                 var x = arr.GenericParameterPosition;
1644                                 Assert.Fail ("#6");
1645                         } catch (InvalidOperationException) {}
1646
1647
1648                         Assert.IsFalse (arr.IsGenericParameter, "#8");
1649                         Assert.IsFalse (arr.IsGenericType, "#9");
1650                         Assert.IsFalse (arr.IsGenericTypeDefinition, "#10");
1651
1652                         Assert.AreEqual (TypeAttributes.Public, arr.Attributes, "#11");
1653
1654                         Assert.IsTrue (arr.HasElementType, "#12");
1655                         Assert.IsTrue (arr.IsArray, "#13");
1656
1657                         Assert.AreEqual (assembly, arr.Assembly, "#14");
1658                         Assert.AreEqual (null, arr.AssemblyQualifiedName, "#15");
1659                         Assert.AreEqual (typeof (Array), arr.BaseType, "#16");
1660                         Assert.AreEqual (null, arr.FullName, "#17");
1661                         Assert.AreEqual (module, arr.Module, "#18");
1662                         Assert.AreEqual (null, arr.Namespace, "#19");
1663                         Assert.AreEqual (arr, arr.UnderlyingSystemType, "#20");
1664                         Assert.AreEqual ("F[]", arr.Name, "#21");
1665
1666                         Assert.AreEqual (gparam, arr.GetElementType (), "#22");
1667                 }
1668
1669                 [Test]
1670                 public void GenericTypeMembersOfEnum ()
1671                 {
1672                         var eb = module.DefineEnum ("dd.enum", TypeAttributes.Public, typeof (int));
1673                         Type arr = eb.MakeArrayType ();
1674
1675                         try {
1676                                 arr.GetGenericArguments ();
1677                                 Assert.Fail ("#1");
1678                         } catch (NotSupportedException) {}
1679
1680                         try {
1681                                 arr.GetGenericParameterConstraints ();
1682                                 Assert.Fail ("#2");
1683                         } catch (InvalidOperationException) {}
1684
1685                         try {
1686                                 arr.GetGenericTypeDefinition ();
1687                                 Assert.Fail ("#3");
1688                         } catch (NotSupportedException) {}
1689
1690                         Assert.IsFalse (arr.ContainsGenericParameters, "#4");
1691                         try {
1692                                 var x = arr.GenericParameterAttributes;
1693                                 Assert.Fail ("#5");
1694                         } catch (NotSupportedException) {}
1695
1696                         try {
1697                                 var x = arr.GenericParameterPosition;
1698                                 Assert.Fail ("#6");
1699                         } catch (InvalidOperationException) {}
1700
1701
1702                         Assert.IsFalse (arr.IsGenericParameter, "#8");
1703                         Assert.IsFalse (arr.IsGenericType, "#9");
1704                         Assert.IsFalse (arr.IsGenericTypeDefinition, "#10");
1705
1706                         Assert.AreEqual (TypeAttributes.Public | TypeAttributes.Sealed, arr.Attributes, "#11");
1707
1708                         Assert.IsTrue (arr.HasElementType, "#12");
1709                         Assert.IsTrue (arr.IsArray, "#13");
1710
1711                         Assert.AreEqual (assembly, arr.Assembly, "#14");
1712                         Assert.AreEqual ("dd.enum[], MonoTests.System.Reflection.Emit.TypeBuilderTest, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", arr.AssemblyQualifiedName, "#15");
1713                         Assert.AreEqual (typeof (Array), arr.BaseType, "#16");
1714                         Assert.AreEqual ("dd.enum[]", arr.FullName, "#17");
1715                         Assert.AreEqual (module, arr.Module, "#18");
1716                         Assert.AreEqual ("dd", arr.Namespace, "#19");
1717                         Assert.AreEqual (arr, arr.UnderlyingSystemType, "#20");
1718                         Assert.AreEqual ("enum[]", arr.Name, "#21");
1719
1720                         Assert.AreEqual (eb, arr.GetElementType (), "#22");
1721                 }
1722
1723         }
1724 }