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