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

   1 //
   2 // EnumBuiderTest - NUnit Test Cases for the EnumBuider class
   3 //
   4 // Keerti Narayan (keertiln@rediffmail.com)
   5 // Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (C) Ximian, Inc.  http://www.ximian.com
   8 //
   9 //
  10
  11 using System;
  12 using System.IO;
  13 using System.Reflection;
  14 using System.Reflection.Emit;
  15 using System.Collections;
  16 using System.Threading;
  17
  18 using NUnit.Framework;
  19
  20 namespace MonoTests.System.Reflection.Emit
  21 {
  22         [TestFixture]
  23         public class EnumBuilderTest
  24         {
  25                 private static string _assemblyName = "MonoTests.System.Reflection.Emit.EnumBuilder";
  26                 private static string _moduleName = "EmittedModule";
  27                 private static string _enumNamespace = "MyNameSpace";
  28                 private static string _enumName = "MyEnum";
  29                 private static Type _enumType = typeof (Int32);
  30                 private static string _fieldName = "MyField";
  31                 private static object _fieldValue = 1;
  32
  33                 [Test]
  34                 public void TestEnumBuilder ()
  35                 {
  36                         EnumBuilder enumBuilder = GenerateEnum ();
  37                         VerifyType (enumBuilder);
  38
  39                         Assert.IsNotNull (enumBuilder.TypeToken, "#1");
  40                         Assert.IsNotNull (enumBuilder.UnderlyingField, "#2");
  41                         Assert.IsNull (enumBuilder.DeclaringType, "#3");
  42                         Assert.IsNull (enumBuilder.ReflectedType, "#4");
  43                         Assert.AreEqual (_enumType, enumBuilder.UnderlyingSystemType, "#5");
  44                 }
  45
  46                 [Test]
  47                 [Category ("ValueAdd")]
  48                 public void TestEnumBuilder_NotInMono ()
  49                 {
  50                         // If we decide to fix this (I dont see why we should),
  51                         // move to the routine above
  52
  53                         EnumBuilder enumBuilder = GenerateEnum ();
  54                         Assert.IsFalse (enumBuilder.IsSerializable);
  55                 }
  56
  57                 [Test]
  58 #if NET_2_0
  59                 [Category ("NotWorking")]
  60 #else
  61                 [ExpectedException (typeof (NotSupportedException))]
  62 #endif
  63                 public void TestHasElementTypeEnumBuilderIncomplete ()
  64                 {
  65                         EnumBuilder enumBuilder = GenerateEnum ();
  66                         bool hasElementType = enumBuilder.HasElementType;
  67 #if NET_2_0
  68                         Assert.IsFalse (hasElementType);
  69 #else
  70                         Assert.Fail ("Should have failed: " + hasElementType);
  71 #endif
  72                 }
  73
  74                 [Test]
  75 #if ONLY_1_1
  76                 [ExpectedException (typeof (NotSupportedException))]
  77                 [Category ("ValueAdd")] // Is this worth fixing, or is this considered, "extra value"?
  78 #endif
  79                 public void TestHasElementTypeEnumBuilderComplete ()
  80                 {
  81                         EnumBuilder enumBuilder = GenerateEnum ();
  82                         enumBuilder.CreateType ();
  83                         bool hasElementType = enumBuilder.HasElementType;
  84 #if NET_2_0
  85                         Assert.IsFalse (hasElementType);
  86 #else
  87                         Assert.Fail ("Should have failed: " + hasElementType);
  88 #endif
  89                 }
  90
  91                 [Test]
  92                 [ExpectedException (typeof (InvalidOperationException))]
  93                 public void TestDefineLiteralTypeComplete ()
  94                 {
  95                         EnumBuilder enumBuilder = GenerateEnum ();
  96                         Type enumType = enumBuilder.CreateType ();
  97                         // you should not be able to define literal after type
  98                         // has been created
  99                         enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 100                 }
 101
 102                 [Test]
 103                 public void TestDefineLiteralTypeIncomplete ()
 104                 {
 105                         EnumBuilder enumBuilder = GenerateEnum ();
 106                         FieldBuilder fieldBuilder = enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 107                         Type enumType = enumBuilder.CreateType ();
 108
 109                         Assert.IsTrue (fieldBuilder.IsPublic, "#1");
 110                         Assert.IsTrue (fieldBuilder.IsStatic, "#2");
 111                         Assert.IsTrue (fieldBuilder.IsLiteral, "#3");
 112                         Assert.AreEqual (_fieldName, fieldBuilder.Name, "#4");
 113 #if NET_2_0
 114                         Assert.IsFalse (enumType == fieldBuilder.DeclaringType, "#5");
 115                         Assert.IsFalse (enumBuilder == fieldBuilder.DeclaringType, "#6");
 116                         Assert.AreEqual (enumType.FullName, fieldBuilder.DeclaringType.FullName, "#7");
 117                         Assert.IsFalse (enumType == fieldBuilder.FieldType, "#8");
 118                         Assert.AreEqual (enumBuilder, fieldBuilder.FieldType, "#9");
 119 #else
 120                         Assert.AreEqual (enumType, fieldBuilder.DeclaringType, "#5");
 121                         Assert.AreEqual (_enumType, fieldBuilder.FieldType, "#6");
 122 #endif
 123                 }
 124
 125                 [Test]
 126                 public void TestEnumType ()
 127                 {
 128                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 129
 130                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 131                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 132                         enumBuilder.CreateType ();
 133
 134                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 135
 136                         VerifyType (enumType);
 137                 }
 138
 139                 [Test]
 140                 [ExpectedException (typeof (NotSupportedException))]
 141                 public void TestEnumBuilderGUIDIncomplete ()
 142                 {
 143                         EnumBuilder enumBuilder = GenerateEnum ();
 144                         Guid guid = enumBuilder.GUID;
 145                 }
 146
 147                 [Test]
 148                 [Category ("NotWorking")] // Bug:71299
 149                 public void TestEnumBuilderGUIDComplete ()
 150                 {
 151                         EnumBuilder enumBuilder = GenerateEnum ();
 152                         enumBuilder.CreateType ();
 153                         Assert.IsTrue (enumBuilder.GUID != Guid.Empty);
 154                 }
 155
 156                 [Test]
 157                 public void TestEnumTypeGUID ()
 158                 {
 159                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 160                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 161                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 162                         enumBuilder.CreateType ();
 163
 164                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 165
 166                         // Tested in above test: Assert (enumType.GUID != Guid.Empty);
 167                         Assert.IsNull (enumType.DeclaringType);
 168                 }
 169
 170                 [Test]
 171                 public void TestFieldProperties ()
 172                 {
 173                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 174                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 175                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 176                         FieldBuilder fieldBuilder = GenerateField (enumBuilder);
 177                         enumBuilder.CreateType ();
 178
 179                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 180                         FieldInfo fi = enumType.GetField (_fieldName);
 181                         Object o = fi.GetValue (enumType);
 182
 183                         Assert.IsTrue (fi.IsLiteral, "#1");
 184                         Assert.IsTrue (fi.IsPublic, "#2");
 185                         Assert.IsTrue (fi.IsStatic, "#3");
 186                         Assert.AreEqual (enumBuilder, fieldBuilder.FieldType, "#4");
 187                         Assert.IsFalse (enumType == fieldBuilder.FieldType, "#5");
 188 #if NET_2_0
 189                         Assert.AreEqual (enumType.FullName, fieldBuilder.FieldType.FullName, "#6");
 190                         Assert.IsFalse (_enumType == fieldBuilder.FieldType, "#7");
 191 #else
 192                         Assert.IsFalse (enumType.FullName == fieldBuilder.FieldType.FullName, "#6");
 193                         Assert.AreEqual (_enumType, fieldBuilder.FieldType, "#7");
 194 #endif
 195
 196                         object fieldValue = fi.GetValue (enumType);
 197 #if NET_2_0
 198                         Assert.IsFalse (_fieldValue == fieldValue, "#8");
 199                         Assert.IsTrue (fieldValue.GetType ().IsEnum, "#9");
 200                         Assert.AreEqual (enumType, fieldValue.GetType (), "#10");
 201 #else
 202                         Assert.AreEqual (_fieldValue, fieldValue, "#8");
 203                         Assert.IsFalse (fieldValue.GetType ().IsEnum, "#9");
 204                         Assert.AreEqual (_enumType, fieldValue.GetType (), "#10");
 205 #endif
 206                         Assert.AreEqual (_fieldValue, (int) fieldValue, "#11");
 207                 }
 208
 209                 [Test]
 210                 public void TestFindInterfaces ()
 211                 {
 212                         EnumBuilder enumBuilder = GenerateEnum ();
 213
 214                         Type [] interfaces = enumBuilder.FindInterfaces (
 215                                 new TypeFilter (MyInterfaceFilter),
 216                                 "System.Collections.IEnumerable");
 217                         Assert.AreEqual (0, interfaces.Length);
 218                 }
 219
 220                 [Test]
 221                 [ExpectedException (typeof (NotSupportedException))]
 222                 [Category ("ValueAdd")]
 223                 public void TestFindMembersIncomplete ()
 224                 {
 225                         EnumBuilder enumBuilder = GenerateEnum ();
 226                         GenerateField (enumBuilder);
 227
 228                         MemberInfo [] members = enumBuilder.FindMembers (
 229                                 MemberTypes.All, BindingFlags.Static |
 230                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 231                                 _fieldName);
 232                 }
 233
 234 #if NET_4_0
 235                 [Test]
 236                 public void GetEnumUnderlyingType ()
 237                 {
 238                         var @enum = GenerateEnum ();
 239
 240                         Assert.AreEqual (_enumType, @enum.GetEnumUnderlyingType ());
 241                 }
 242 #endif
 243
 244                 [Test]
 245                 public void TestFindMembersComplete ()
 246                 {
 247                         EnumBuilder enumBuilder = GenerateEnum ();
 248                         GenerateField (enumBuilder);
 249                         enumBuilder.CreateType ();
 250
 251                         MemberInfo [] members = enumBuilder.FindMembers (
 252                                 MemberTypes.Field, BindingFlags.Static |
 253                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 254                                 _fieldName);
 255                         Assert.AreEqual (1, members.Length, "#1");
 256
 257                         members = enumBuilder.FindMembers (
 258                                 MemberTypes.Field, BindingFlags.Static |
 259                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 260                                 "doesntmatter");
 261                         Assert.AreEqual (0, members.Length, "#2");
 262                 }
 263
 264                 [Test]
 265                 [ExpectedException (typeof (NotSupportedException))]
 266                 [Category ("ValueAdd")]
 267                 public void TestGetConstructorIncomplete ()
 268                 {
 269                         EnumBuilder enumBuilder = GenerateEnum ();
 270                         enumBuilder.GetConstructor (BindingFlags.Public, null,
 271                                 CallingConventions.Any, Type.EmptyTypes, new ParameterModifier [0]);
 272                 }
 273
 274                 [Test]
 275                 public void TestGetConstructorComplete ()
 276                 {
 277                         EnumBuilder enumBuilder = GenerateEnum ();
 278                         enumBuilder.CreateType ();
 279                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 280                                 BindingFlags.Public, null, CallingConventions.Any,
 281                                 Type.EmptyTypes, new ParameterModifier [0]);
 282                         Assert.IsNull (ctor);
 283                 }
 284
 285                 [Test]
 286                 [ExpectedException (typeof (ArgumentNullException))]
 287                 public void TestGetConstructorNullTypes ()
 288                 {
 289                         EnumBuilder enumBuilder = GenerateEnum ();
 290                         enumBuilder.CreateType ();
 291                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 292                                 BindingFlags.Public, null, CallingConventions.Any,
 293                                 null, new ParameterModifier [0]);
 294                 }
 295
 296                 [Test]
 297                 [Category ("NotWorking")]
 298                 [ExpectedException (typeof (ArgumentNullException))]
 299                 public void TestGetConstructorNullElementType ()
 300                 {
 301                         EnumBuilder enumBuilder = GenerateEnum ();
 302                         enumBuilder.CreateType ();
 303                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 304                                 BindingFlags.Public, null, CallingConventions.Any,
 305                                 new Type [] { null }, new ParameterModifier [0]);
 306                 }
 307
 308                 [Test]
 309                 [ExpectedException (typeof (NotSupportedException))]
 310                 [Category ("NotWorking")]
 311                 public void TestGetConstructorsIncomplete ()
 312                 {
 313                         EnumBuilder enumBuilder = GenerateEnum ();
 314
 315                         ConstructorInfo [] ctors = enumBuilder.GetConstructors (
 316                                 BindingFlags.Instance | BindingFlags.Public);
 317                         Assert.AreEqual (0, ctors.Length);
 318                 }
 319
 320                 [Test]
 321                 public void TestGetConstructorsComplete ()
 322                 {
 323                         EnumBuilder enumBuilder = GenerateEnum ();
 324                         enumBuilder.CreateType ();
 325
 326                         ConstructorInfo [] ctors = enumBuilder.GetConstructors (
 327                                 BindingFlags.Instance | BindingFlags.Public);
 328                         Assert.AreEqual (0, ctors.Length);
 329                 }
 330
 331                 [Test]
 332                 public void TestIsValue__SpecialName ()
 333                 {
 334                         EnumBuilder enumBuilder = GenerateEnum ();
 335                         Type enumType = enumBuilder.CreateType ();
 336                         FieldInfo value = enumType.GetField ("value__", BindingFlags.Instance | BindingFlags.NonPublic);
 337                         Assert.AreEqual (FieldAttributes.RTSpecialName, value.Attributes & FieldAttributes.RTSpecialName);
 338                 }
 339
 340                 private static void VerifyType (Type type)
 341                 {
 342                         Assert.IsNotNull (type.Assembly, "#V1");
 343                         Assert.IsNotNull (type.AssemblyQualifiedName, "#V2");
 344                         Assert.IsNotNull (type.BaseType, "#V3");
 345                         Assert.IsNotNull (type.FullName, "#V4");
 346                         Assert.IsNotNull (type.Module, "#V5");
 347                         Assert.IsNotNull (type.Name, "#V6");
 348                         Assert.IsNotNull (type.Namespace, "#V7");
 349                         Assert.IsNotNull (type.UnderlyingSystemType, "#V8");
 350
 351 #if ONLY_1_1
 352                         // on .NET 2.0, module is name is fixed to
 353                         Assert.AreEqual (_moduleName, type.Module.Name, "#V9");
 354 #endif
 355                         Assert.AreEqual (_enumNamespace, type.Namespace, "#V10");
 356                         Assert.AreEqual (_enumName, type.Name, "#V11");
 357                         Assert.AreEqual (typeof (Enum), type.BaseType, "#V12");
 358                         Assert.AreEqual (MemberTypes.TypeInfo, type.MemberType, "#V13");
 359                         Assert.AreEqual (typeof (int), Enum.GetUnderlyingType (type), "#V14");
 360
 361                         Assert.IsFalse (type.IsArray, "#V15");
 362                         Assert.IsFalse (type.IsAutoClass, "#V16");
 363                         Assert.IsTrue (type.IsAutoLayout, "#V17");
 364                         Assert.IsFalse (type.IsByRef, "#V18");
 365                         Assert.IsFalse (type.IsClass, "#V19");
 366                         Assert.IsFalse (type.IsCOMObject, "#V20");
 367                         Assert.IsFalse (type.IsContextful, "#V21");
 368                         Assert.IsTrue (type.IsEnum, "#V22");
 369                         Assert.IsFalse (type.IsExplicitLayout, "#V23");
 370                         Assert.IsFalse (type.IsImport, "#V24");
 371                         Assert.IsFalse (type.IsInterface, "#V25");
 372                         Assert.IsFalse (type.IsLayoutSequential, "#V26");
 373                         Assert.IsFalse (type.IsMarshalByRef, "#V27");
 374                         Assert.IsFalse (type.IsNestedAssembly, "#V28");
 375                         Assert.IsFalse (type.IsNestedFamily, "#V29");
 376                         Assert.IsFalse (type.IsNestedPublic, "#V30");
 377                         Assert.IsFalse (type.IsNestedPrivate, "#V31");
 378                         Assert.IsFalse (type.IsNotPublic, "#V32");
 379                         Assert.IsFalse (type.IsPrimitive, "#V33");
 380                         Assert.IsFalse (type.IsPointer, "#V34");
 381                         Assert.IsTrue (type.IsPublic, "#V35");
 382                         Assert.IsTrue (type.IsSealed, "#V36");
 383                         Assert.IsFalse (type.IsUnicodeClass, "#V37");
 384                         Assert.IsFalse (type.IsSpecialName, "#V38");
 385                         Assert.IsTrue (type.IsValueType, "#V39");
 386                 }
 387
 388                 public static bool MyInterfaceFilter (Type t, object filterCriteria)
 389                 {
 390                         if (t.ToString () == filterCriteria.ToString ())
 391                                 return true;
 392                         else
 393                                 return false;
 394                 }
 395
 396                 public static bool MemberNameFilter (MemberInfo m, object filterCriteria)
 397                 {
 398                         if (m.Name == filterCriteria.ToString ())
 399                                 return true;
 400                         else
 401                                 return false;
 402                 }
 403
 404                 private static AssemblyName GetAssemblyName ()
 405                 {
 406                         AssemblyName assemblyName = new AssemblyName ();
 407                         assemblyName.Name = _assemblyName;
 408                         return assemblyName;
 409                 }
 410
 411                 private static AssemblyBuilder GenerateAssembly ()
 412                 {
 413                         return AppDomain.CurrentDomain.DefineDynamicAssembly (
 414                                 GetAssemblyName (), AssemblyBuilderAccess.RunAndSave);
 415                 }
 416
 417                 private static ModuleBuilder GenerateModule ()
 418                 {
 419                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 420                         return assemblyBuilder.DefineDynamicModule (_moduleName);
 421                 }
 422
 423                 private static ModuleBuilder GenerateModule (AssemblyBuilder assemblyBuilder)
 424                 {
 425                         return assemblyBuilder.DefineDynamicModule (_moduleName);
 426                 }
 427
 428                 private static EnumBuilder GenerateEnum ()
 429                 {
 430                         ModuleBuilder modBuilder = GenerateModule ();
 431                         return modBuilder.DefineEnum (_enumNamespace + "."
 432                                 + _enumName, TypeAttributes.Public, _enumType);
 433                 }
 434
 435                 private static EnumBuilder GenerateEnum (ModuleBuilder modBuilder)
 436                 {
 437                         return modBuilder.DefineEnum (_enumNamespace + "."
 438                                 + _enumName, TypeAttributes.Public, _enumType);
 439                 }
 440
 441                 private static FieldBuilder GenerateField ()
 442                 {
 443                         EnumBuilder enumBuilder = GenerateEnum ();
 444                         return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 445                 }
 446
 447                 private static FieldBuilder GenerateField (EnumBuilder enumBuilder)
 448                 {
 449                         return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 450                 }
 451         }
 452 }