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         [TestFixture]
  22         public class EnumBuilderTest : Assertion {
  23                 private static string _assemblyName = "MonoTests.System.Reflection.Emit.EnumBuilder";
  24                 private static string _moduleName = "EmittedModule";
  25                 private static string _enumNamespace = "MyNameSpace";
  26                 private static string _enumName = "MyEnum";
  27                 private static Type _enumType = typeof(Int32);
  28                 private static string _fieldName = "MyField";
  29                 private static object _fieldValue = 1;
  30
  31                 [Test]
  32                 public void TestEnumBuilder()
  33                 {
  34                         EnumBuilder enumBuilder = GenerateEnum ();
  35                         VerifyType (enumBuilder);
  36
  37                         AssertNotNull (enumBuilder.TypeToken);
  38                         AssertNotNull (enumBuilder.UnderlyingField);
  39                         AssertNull ("type.DeclaringType of toplevel type should be null", enumBuilder.DeclaringType);
  40                         AssertNull ("type.ReflectedType should be null", enumBuilder.ReflectedType);
  41                         AssertEquals (_enumType, enumBuilder.UnderlyingSystemType);
  42                 }
  43
  44                 [Test][Category("ValueAdd")]
  45                 public void TestEnumBuilder_NotInMono ()
  46                 {
  47                         // If we decide to fix this (I dont see why we should),
  48                         // move to the routine above
  49
  50                         EnumBuilder enumBuilder = GenerateEnum ();
  51                         AssertEquals ("Comparing the IsSerializable field", false, enumBuilder.IsSerializable);
  52                 }
  53
  54
  55                 [Test]
  56                 [ExpectedException (typeof(NotSupportedException))]
  57                 public void TestHasElementTypeEnumBuilderIncomplete ()
  58                 {
  59                         EnumBuilder enumBuilder = GenerateEnum ();
  60                         bool hasElementType = enumBuilder.HasElementType;
  61                 }
  62
  63                 [Test]
  64                 [ExpectedException (typeof(NotSupportedException))]
  65                 [Category("ValueAdd")]
  66                 // Is this worth fixing, or is this considered, "extra value"?
  67                 public void TestHasElementTypeEnumBuilderComplete ()
  68                 {
  69                         EnumBuilder enumBuilder = GenerateEnum ();
  70                         enumBuilder.CreateType ();
  71                         bool hasElementType = enumBuilder.HasElementType;
  72                 }
  73
  74                 [Test]
  75                 [ExpectedException (typeof(InvalidOperationException))]
  76                 public void TestDefineLiteralTypeComplete ()
  77                 {
  78                         EnumBuilder enumBuilder = GenerateEnum ();
  79                         Type enumType = enumBuilder.CreateType ();
  80                         // you should not be able to define literal after type
  81                         // has been created
  82                         FieldBuilder fieldBuilder = enumBuilder.DefineLiteral (_fieldName, _fieldValue);
  83                 }
  84
  85                 [Test]
  86                 public void TestDefineLiteralTypeIncomplete ()
  87                 {
  88                         EnumBuilder enumBuilder = GenerateEnum ();
  89                         FieldBuilder fieldBuilder = enumBuilder.DefineLiteral (_fieldName, _fieldValue);
  90                         Type enumType = enumBuilder.CreateType ();
  91
  92                         AssertEquals (enumType, fieldBuilder.DeclaringType);
  93                         AssertEquals (_enumType, fieldBuilder.FieldType);
  94                         AssertEquals (true, fieldBuilder.IsPublic);
  95                         AssertEquals (true, fieldBuilder.IsStatic);
  96                         AssertEquals (true, fieldBuilder.IsLiteral);
  97                         AssertEquals (_fieldName, fieldBuilder.Name);
  98                 }
  99
 100                 [Test]
 101                 public void TestEnumType()
 102                 {
 103                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 104
 105                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 106                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 107                         enumBuilder.CreateType ();
 108
 109                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 110
 111                         VerifyType (enumType);
 112                 }
 113
 114                 [Test]
 115                 [ExpectedException (typeof(NotSupportedException))]
 116                 public void TestEnumBuilderGUIDIncomplete ()
 117                 {
 118                         EnumBuilder enumBuilder = GenerateEnum ();
 119                         Guid guid =  enumBuilder.GUID;
 120                 }
 121
 122                 [Test]
 123                 [Category("NotWorking")] // Bug:71299
 124                 public void TestEnumBuilderGUIDComplete ()
 125                 {
 126                         EnumBuilder enumBuilder = GenerateEnum ();
 127                         enumBuilder.CreateType ();
 128                         Assert (enumBuilder.GUID != Guid.Empty);
 129                 }
 130
 131                 [Test]
 132                 public void TestEnumTypeGUID ()
 133                 {
 134                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 135                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 136                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 137                         enumBuilder.CreateType ();
 138
 139                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 140
 141                         // Tested in above test: Assert (enumType.GUID != Guid.Empty);
 142                         AssertNull ("type.DeclaringType of toplevel type should be null", enumType.DeclaringType);
 143                 }
 144
 145                 [Test]
 146                 public void TestFieldProperties() {
 147                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 148                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 149                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 150                         FieldBuilder fieldBuilder = GenerateField (enumBuilder);
 151                         enumBuilder.CreateType ();
 152
 153                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 154                         FieldInfo fi = enumType.GetField (_fieldName);
 155                         Object o = fi.GetValue(enumType);
 156
 157                         AssertEquals ("Checking the value of the Field to be 1", _fieldValue, fi.GetValue (enumType));
 158                         AssertEquals ("Checking if the field is a Literal", true, fi.IsLiteral);
 159                         AssertEquals ("Checking if the field is Public", true, fi.IsPublic);
 160                         AssertEquals ("Checking if the field is Static", true, fi.IsStatic);
 161                 }
 162
 163                 [Test]
 164                 public void TestFindInterfaces ()
 165                 {
 166                         EnumBuilder enumBuilder = GenerateEnum ();
 167
 168                         Type[] interfaces = enumBuilder.FindInterfaces (
 169                                 new TypeFilter (MyInterfaceFilter),
 170                                 "System.Collections.IEnumerable");
 171                         AssertEquals (0, interfaces.Length);
 172                 }
 173
 174                 [Test]
 175                 [ExpectedException (typeof(NotSupportedException))]
 176                 [Category("ValueAdd")]
 177                 public void TestFindMembersIncomplete ()
 178                 {
 179                         EnumBuilder enumBuilder = GenerateEnum ();
 180                         GenerateField (enumBuilder);
 181
 182                         MemberInfo[] members = enumBuilder.FindMembers (
 183                                 MemberTypes.All, BindingFlags.Static |
 184                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 185                                 _fieldName);
 186                 }
 187
 188                 [Test]
 189                 public void TestFindMembersComplete ()
 190                 {
 191                         EnumBuilder enumBuilder = GenerateEnum ();
 192                         GenerateField (enumBuilder);
 193                         enumBuilder.CreateType ();
 194
 195                         MemberInfo[] members = enumBuilder.FindMembers (
 196                                 MemberTypes.Field, BindingFlags.Static |
 197                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 198                                 _fieldName);
 199                         AssertEquals (1, members.Length);
 200
 201                         members = enumBuilder.FindMembers (
 202                                 MemberTypes.Field, BindingFlags.Static |
 203                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 204                                 "doesntmatter");
 205                         AssertEquals (0, members.Length);
 206                 }
 207
 208                 [Test]
 209                 [ExpectedException (typeof(NotSupportedException))]
 210                 [Category("ValueAdd")]
 211                 public void TestGetConstructorIncomplete ()
 212                 {
 213                         EnumBuilder enumBuilder = GenerateEnum ();
 214                         enumBuilder.GetConstructor (BindingFlags.Public, null,
 215                                 CallingConventions.Any, Type.EmptyTypes, new ParameterModifier[0]);
 216                 }
 217
 218                 [Test]
 219                 public void TestGetConstructorComplete ()
 220                 {
 221                         EnumBuilder enumBuilder = GenerateEnum ();
 222                         enumBuilder.CreateType ();
 223                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 224                                 BindingFlags.Public, null, CallingConventions.Any,
 225                                 Type.EmptyTypes, new ParameterModifier[0]);
 226                         AssertNull (ctor);
 227                 }
 228
 229                 [Test]
 230                 [ExpectedException (typeof(ArgumentNullException))]
 231                 public void TestGetConstructorNullTypes ()
 232                 {
 233                         EnumBuilder enumBuilder = GenerateEnum ();
 234                         enumBuilder.CreateType ();
 235                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 236                                 BindingFlags.Public, null, CallingConventions.Any,
 237                                 null, new ParameterModifier[0]);
 238                 }
 239
 240                 [Test]
 241                 [Category ("NotWorking")]
 242                 [ExpectedException (typeof(ArgumentNullException))]
 243                 public void TestGetConstructorNullElementType ()
 244                 {
 245                         EnumBuilder enumBuilder = GenerateEnum ();
 246                         enumBuilder.CreateType ();
 247                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 248                                 BindingFlags.Public, null, CallingConventions.Any,
 249                                 new Type[] { null }, new ParameterModifier[0]);
 250                 }
 251
 252                 [Test]
 253                 [ExpectedException (typeof(NotSupportedException))]
 254                 [Category("NotWorking")]
 255                 public void TestGetConstructorsIncomplete ()
 256                 {
 257                         EnumBuilder enumBuilder = GenerateEnum ();
 258
 259                         ConstructorInfo[] ctors = enumBuilder.GetConstructors (
 260                                 BindingFlags.Instance | BindingFlags.Public);
 261                         AssertEquals (0, ctors.Length);
 262                 }
 263
 264                 [Test]
 265                 public void TestGetConstructorsComplete ()
 266                 {
 267                         EnumBuilder enumBuilder = GenerateEnum ();
 268                         enumBuilder.CreateType ();
 269
 270                         ConstructorInfo[] ctors = enumBuilder.GetConstructors (
 271                                 BindingFlags.Instance | BindingFlags.Public);
 272                         AssertEquals (0, ctors.Length);
 273                 }
 274
 275                 [Test]
 276                 public void TestIsValue__SpecialName ()
 277                 {
 278                         EnumBuilder enumBuilder = GenerateEnum ();
 279                         Type enumType = enumBuilder.CreateType ();
 280                         FieldInfo value = enumType.GetField ("value__", BindingFlags.Instance | BindingFlags.NonPublic);
 281                         AssertEquals ("value__ must have FieldAttributes.RTSpecialName set", FieldAttributes.RTSpecialName, value.Attributes & FieldAttributes.RTSpecialName);
 282                 }
 283
 284                 private static void VerifyType (Type type)
 285                 {
 286                         AssertNotNull ("type.Assembly should not be null", type.Assembly);
 287                         AssertNotNull ("type.AssemblyQualifiedName should not be null", type.AssemblyQualifiedName);
 288                         AssertNotNull ("type.BaseType should not be null", type.BaseType);
 289                         AssertNotNull ("type.FullName should not be null", type.FullName);
 290                         AssertNotNull ("type.Module should not be null", type.Module);
 291                         AssertNotNull ("type.Name should not be null", type.Name);
 292                         AssertNotNull ("type.Namespace should not be null", type.Namespace);
 293                         AssertNotNull ("type.UnderlyingSystemType should not be null", type.UnderlyingSystemType);
 294
 295                         AssertEquals (_moduleName, type.Module.Name);
 296                         AssertEquals (_enumNamespace, type.Namespace);
 297                         AssertEquals (_enumName, type.Name);
 298                         AssertEquals (typeof(Enum), type.BaseType);
 299                         AssertEquals (MemberTypes.TypeInfo, type.MemberType);
 300                         AssertEquals (typeof(int), Enum.GetUnderlyingType (type));
 301
 302                         AssertEquals ("Comparing the IsArray field", false, type.IsArray);
 303                         AssertEquals ("Comparing the IsAutoClass field", false, type.IsAutoClass);
 304                         AssertEquals ("Comparing the IsAutoLayout field", true, type.IsAutoLayout);
 305                         AssertEquals ("Comparing the IsByRef field", false, type.IsByRef);
 306                         AssertEquals ("Comparing the IsClass field", false, type.IsClass);
 307                         AssertEquals ("Comparing the IsComObject field", false, type.IsCOMObject);
 308                         AssertEquals ("Comparing the IsContextful field", false, type.IsContextful);
 309                         AssertEquals ("Comparing the IsEnum field", true, type.IsEnum);
 310                         AssertEquals ("Comparing the IsExplicitLayout field", false, type.IsExplicitLayout);
 311                         AssertEquals ("Comparing the IsImport field", false, type.IsImport);
 312                         AssertEquals ("Comparing the IsInterface field", false, type.IsInterface);
 313                         AssertEquals ("Comparing the IsLayoutSequential field", false, type.IsLayoutSequential);
 314                         AssertEquals ("Comparing the IsMarshalByRef field", false, type.IsMarshalByRef);
 315                         AssertEquals ("Comparing the IsNestedAssembly field", false, type.IsNestedAssembly);
 316                         AssertEquals ("Comparing the IsNestedFamily field", false, type.IsNestedFamily);
 317                         AssertEquals ("Comparing the IsNestedPublic field", false, type.IsNestedPublic);
 318                         AssertEquals ("Comparing the IsNestedPrivate field", false, type.IsNestedPrivate);
 319                         AssertEquals ("Comparing the IsNotPublic field", false, type.IsNotPublic);
 320                         AssertEquals ("Comparing the IsPrimitive field", false, type.IsPrimitive);
 321                         AssertEquals ("Comparing the IsPointer field", false, type.IsPointer);
 322                         AssertEquals ("Comparing the IsPublic field", true, type.IsPublic);
 323                         AssertEquals ("Comparing the IsSealed field", true, type.IsSealed);
 324                         AssertEquals ("Comparing the IsUnicode field", false, type.IsUnicodeClass);
 325                         AssertEquals ("Comparing the requires special handling field", false, type.IsSpecialName);
 326                         AssertEquals ("Comparing the IsValueType field", true, type.IsValueType);
 327                 }
 328
 329                 public static bool MyInterfaceFilter (Type t, object filterCriteria)
 330                 {
 331                         if (t.ToString () == filterCriteria.ToString ())
 332                                 return true;
 333                         else
 334                                 return false;
 335                 }
 336
 337                 public static bool MemberNameFilter (MemberInfo m, object filterCriteria)
 338                 {
 339                         if (m.Name == filterCriteria.ToString ())
 340                                 return true;
 341                         else
 342                                 return false;
 343                 }
 344
 345                 private static AssemblyName GetAssemblyName ()
 346                 {
 347                         AssemblyName assemblyName = new AssemblyName ();
 348                         assemblyName.Name = _assemblyName;
 349                         return assemblyName;
 350                 }
 351
 352                 private static AssemblyBuilder GenerateAssembly ()
 353                 {
 354                         return AppDomain.CurrentDomain.DefineDynamicAssembly (
 355                                 GetAssemblyName (), AssemblyBuilderAccess.RunAndSave);
 356                 }
 357
 358                 private static ModuleBuilder GenerateModule ()
 359                 {
 360                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 361                         return assemblyBuilder.DefineDynamicModule (_moduleName);
 362                 }
 363
 364                 private static ModuleBuilder GenerateModule (AssemblyBuilder assemblyBuilder)
 365                 {
 366                         return assemblyBuilder.DefineDynamicModule (_moduleName);
 367                 }
 368
 369                 private static EnumBuilder GenerateEnum ()
 370                 {
 371                         ModuleBuilder modBuilder = GenerateModule ();
 372                         return modBuilder.DefineEnum (_enumNamespace + "."
 373                                 + _enumName, TypeAttributes.Public, _enumType);
 374                 }
 375
 376                 private static EnumBuilder GenerateEnum (ModuleBuilder modBuilder)
 377                 {
 378                         return modBuilder.DefineEnum (_enumNamespace + "."
 379                                 + _enumName, TypeAttributes.Public, _enumType);
 380                 }
 381
 382                 private static FieldBuilder GenerateField ()
 383                 {
 384                         EnumBuilder enumBuilder = GenerateEnum ();
 385                         return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 386                 }
 387
 388                 private static FieldBuilder GenerateField (EnumBuilder enumBuilder)
 389                 {
 390                         return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 391                 }
 392         }
 393 }