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                 [Category ("NotWorking")]
  59                 public void TestHasElementTypeEnumBuilderIncomplete ()
  60                 {
  61                         EnumBuilder enumBuilder = GenerateEnum ();
  62                         bool hasElementType = enumBuilder.HasElementType;
  63                         Assert.IsFalse (hasElementType);
  64                 }
  65
  66                 [Test]
  67                 public void TestHasElementTypeEnumBuilderComplete ()
  68                 {
  69                         EnumBuilder enumBuilder = GenerateEnum ();
  70                         enumBuilder.CreateType ();
  71                         bool hasElementType = enumBuilder.HasElementType;
  72                         Assert.IsFalse (hasElementType);
  73                 }
  74
  75                 [Test]
  76                 [ExpectedException (typeof (InvalidOperationException))]
  77                 public void TestDefineLiteralTypeComplete ()
  78                 {
  79                         EnumBuilder enumBuilder = GenerateEnum ();
  80                         Type enumType = enumBuilder.CreateType ();
  81                         // you should not be able to define literal after type
  82                         // has been created
  83                         enumBuilder.DefineLiteral (_fieldName, _fieldValue);
  84                 }
  85
  86                 [Test]
  87                 public void TestDefineLiteralTypeIncomplete ()
  88                 {
  89                         EnumBuilder enumBuilder = GenerateEnum ();
  90                         FieldBuilder fieldBuilder = enumBuilder.DefineLiteral (_fieldName, _fieldValue);
  91                         Type enumType = enumBuilder.CreateType ();
  92
  93                         Assert.IsTrue (fieldBuilder.IsPublic, "#1");
  94                         Assert.IsTrue (fieldBuilder.IsStatic, "#2");
  95                         Assert.IsTrue (fieldBuilder.IsLiteral, "#3");
  96                         Assert.AreEqual (_fieldName, fieldBuilder.Name, "#4");
  97                         Assert.IsFalse (enumType == fieldBuilder.DeclaringType, "#5");
  98                         Assert.IsFalse (enumBuilder == fieldBuilder.DeclaringType, "#6");
  99                         Assert.AreEqual (enumType.FullName, fieldBuilder.DeclaringType.FullName, "#7");
 100                         Assert.IsFalse (enumType == fieldBuilder.FieldType, "#8");
 101                         Assert.AreEqual (enumBuilder, fieldBuilder.FieldType, "#9");
 102                 }
 103
 104                 [Test]
 105                 public void TestEnumType ()
 106                 {
 107                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 108
 109                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 110                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 111                         enumBuilder.CreateType ();
 112
 113                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 114
 115                         VerifyType (enumType);
 116                 }
 117
 118                 [Test]
 119                 [ExpectedException (typeof (NotSupportedException))]
 120                 public void TestEnumBuilderGUIDIncomplete ()
 121                 {
 122                         EnumBuilder enumBuilder = GenerateEnum ();
 123                         Guid guid = enumBuilder.GUID;
 124                 }
 125
 126                 [Test]
 127                 [Category ("NotWorking")] // Bug:71299
 128                 public void TestEnumBuilderGUIDComplete ()
 129                 {
 130                         EnumBuilder enumBuilder = GenerateEnum ();
 131                         enumBuilder.CreateType ();
 132                         Assert.IsTrue (enumBuilder.GUID != Guid.Empty);
 133                 }
 134
 135                 [Test]
 136                 public void TestEnumTypeGUID ()
 137                 {
 138                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 139                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 140                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 141                         enumBuilder.CreateType ();
 142
 143                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 144
 145                         // Tested in above test: Assert (enumType.GUID != Guid.Empty);
 146                         Assert.IsNull (enumType.DeclaringType);
 147                 }
 148
 149                 [Test]
 150                 public void TestFieldProperties ()
 151                 {
 152                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 153                         ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
 154                         EnumBuilder enumBuilder = GenerateEnum (modBuilder);
 155                         FieldBuilder fieldBuilder = GenerateField (enumBuilder);
 156                         enumBuilder.CreateType ();
 157
 158                         Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
 159                         FieldInfo fi = enumType.GetField (_fieldName);
 160                         Object o = fi.GetValue (enumType);
 161
 162                         Assert.IsTrue (fi.IsLiteral, "#1");
 163                         Assert.IsTrue (fi.IsPublic, "#2");
 164                         Assert.IsTrue (fi.IsStatic, "#3");
 165                         Assert.AreEqual (enumBuilder, fieldBuilder.FieldType, "#4");
 166                         Assert.IsFalse (enumType == fieldBuilder.FieldType, "#5");
 167                         Assert.AreEqual (enumType.FullName, fieldBuilder.FieldType.FullName, "#6");
 168                         Assert.IsFalse (_enumType == fieldBuilder.FieldType, "#7");
 169
 170                         object fieldValue = fi.GetValue (enumType);
 171                         Assert.IsFalse (_fieldValue == fieldValue, "#8");
 172                         Assert.IsTrue (fieldValue.GetType ().IsEnum, "#9");
 173                         Assert.AreEqual (enumType, fieldValue.GetType (), "#10");
 174                         Assert.AreEqual (_fieldValue, (int) fieldValue, "#11");
 175                 }
 176
 177                 [Test]
 178                 public void TestFindInterfaces ()
 179                 {
 180                         EnumBuilder enumBuilder = GenerateEnum ();
 181
 182                         Type [] interfaces = enumBuilder.FindInterfaces (
 183                                 new TypeFilter (MyInterfaceFilter),
 184                                 "System.Collections.IEnumerable");
 185                         Assert.AreEqual (0, interfaces.Length);
 186                 }
 187
 188                 [Test]
 189                 [ExpectedException (typeof (NotSupportedException))]
 190                 [Category ("ValueAdd")]
 191                 public void TestFindMembersIncomplete ()
 192                 {
 193                         EnumBuilder enumBuilder = GenerateEnum ();
 194                         GenerateField (enumBuilder);
 195
 196                         MemberInfo [] members = enumBuilder.FindMembers (
 197                                 MemberTypes.All, BindingFlags.Static |
 198                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 199                                 _fieldName);
 200                 }
 201
 202                 [Test]
 203                 public void GetEnumUnderlyingType ()
 204                 {
 205                         var @enum = GenerateEnum ();
 206
 207                         Assert.AreEqual (_enumType, @enum.GetEnumUnderlyingType ());
 208                 }
 209
 210                 [Test]
 211                 public void TestFindMembersComplete ()
 212                 {
 213                         EnumBuilder enumBuilder = GenerateEnum ();
 214                         GenerateField (enumBuilder);
 215                         enumBuilder.CreateType ();
 216
 217                         MemberInfo [] members = enumBuilder.FindMembers (
 218                                 MemberTypes.Field, BindingFlags.Static |
 219                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 220                                 _fieldName);
 221                         Assert.AreEqual (1, members.Length, "#1");
 222
 223                         members = enumBuilder.FindMembers (
 224                                 MemberTypes.Field, BindingFlags.Static |
 225                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 226                                 "doesntmatter");
 227                         Assert.AreEqual (0, members.Length, "#2");
 228                 }
 229
 230                 [Test]
 231                 [ExpectedException (typeof (NotSupportedException))]
 232                 [Category ("ValueAdd")]
 233                 public void TestGetConstructorIncomplete ()
 234                 {
 235                         EnumBuilder enumBuilder = GenerateEnum ();
 236                         enumBuilder.GetConstructor (BindingFlags.Public, null,
 237                                 CallingConventions.Any, Type.EmptyTypes, new ParameterModifier [0]);
 238                 }
 239
 240                 [Test]
 241                 public void TestGetConstructorComplete ()
 242                 {
 243                         EnumBuilder enumBuilder = GenerateEnum ();
 244                         enumBuilder.CreateType ();
 245                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 246                                 BindingFlags.Public, null, CallingConventions.Any,
 247                                 Type.EmptyTypes, new ParameterModifier [0]);
 248                         Assert.IsNull (ctor);
 249                 }
 250
 251                 [Test]
 252                 [ExpectedException (typeof (ArgumentNullException))]
 253                 public void TestGetConstructorNullTypes ()
 254                 {
 255                         EnumBuilder enumBuilder = GenerateEnum ();
 256                         enumBuilder.CreateType ();
 257                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 258                                 BindingFlags.Public, null, CallingConventions.Any,
 259                                 null, new ParameterModifier [0]);
 260                 }
 261
 262                 [Test]
 263                 [Category ("NotWorking")]
 264                 [ExpectedException (typeof (ArgumentNullException))]
 265                 public void TestGetConstructorNullElementType ()
 266                 {
 267                         EnumBuilder enumBuilder = GenerateEnum ();
 268                         enumBuilder.CreateType ();
 269                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 270                                 BindingFlags.Public, null, CallingConventions.Any,
 271                                 new Type [] { null }, new ParameterModifier [0]);
 272                 }
 273
 274                 [Test]
 275                 [ExpectedException (typeof (NotSupportedException))]
 276                 [Category ("NotWorking")]
 277                 public void TestGetConstructorsIncomplete ()
 278                 {
 279                         EnumBuilder enumBuilder = GenerateEnum ();
 280
 281                         ConstructorInfo [] ctors = enumBuilder.GetConstructors (
 282                                 BindingFlags.Instance | BindingFlags.Public);
 283                         Assert.AreEqual (0, ctors.Length);
 284                 }
 285
 286                 [Test]
 287                 public void TestGetConstructorsComplete ()
 288                 {
 289                         EnumBuilder enumBuilder = GenerateEnum ();
 290                         enumBuilder.CreateType ();
 291
 292                         ConstructorInfo [] ctors = enumBuilder.GetConstructors (
 293                                 BindingFlags.Instance | BindingFlags.Public);
 294                         Assert.AreEqual (0, ctors.Length);
 295                 }
 296
 297                 [Test]
 298                 public void TestIsValue__SpecialName ()
 299                 {
 300                         EnumBuilder enumBuilder = GenerateEnum ();
 301                         Type enumType = enumBuilder.CreateType ();
 302                         FieldInfo value = enumType.GetField ("value__", BindingFlags.Instance | BindingFlags.NonPublic);
 303                         Assert.AreEqual (FieldAttributes.RTSpecialName, value.Attributes & FieldAttributes.RTSpecialName);
 304                 }
 305
 306                 private static void VerifyType (Type type)
 307                 {
 308                         Assert.IsNotNull (type.Assembly, "#V1");
 309                         Assert.IsNotNull (type.AssemblyQualifiedName, "#V2");
 310                         Assert.IsNotNull (type.BaseType, "#V3");
 311                         Assert.IsNotNull (type.FullName, "#V4");
 312                         Assert.IsNotNull (type.Module, "#V5");
 313                         Assert.IsNotNull (type.Name, "#V6");
 314                         Assert.IsNotNull (type.Namespace, "#V7");
 315                         Assert.IsNotNull (type.UnderlyingSystemType, "#V8");
 316
 317                         Assert.AreEqual (_enumNamespace, type.Namespace, "#V10");
 318                         Assert.AreEqual (_enumName, type.Name, "#V11");
 319                         Assert.AreEqual (typeof (Enum), type.BaseType, "#V12");
 320                         Assert.AreEqual (MemberTypes.TypeInfo, type.MemberType, "#V13");
 321                         Assert.AreEqual (typeof (int), Enum.GetUnderlyingType (type), "#V14");
 322
 323                         Assert.IsFalse (type.IsArray, "#V15");
 324                         Assert.IsFalse (type.IsAutoClass, "#V16");
 325                         Assert.IsTrue (type.IsAutoLayout, "#V17");
 326                         Assert.IsFalse (type.IsByRef, "#V18");
 327                         Assert.IsFalse (type.IsClass, "#V19");
 328                         Assert.IsFalse (type.IsCOMObject, "#V20");
 329                         Assert.IsFalse (type.IsContextful, "#V21");
 330                         Assert.IsTrue (type.IsEnum, "#V22");
 331                         Assert.IsFalse (type.IsExplicitLayout, "#V23");
 332                         Assert.IsFalse (type.IsImport, "#V24");
 333                         Assert.IsFalse (type.IsInterface, "#V25");
 334                         Assert.IsFalse (type.IsLayoutSequential, "#V26");
 335                         Assert.IsFalse (type.IsMarshalByRef, "#V27");
 336                         Assert.IsFalse (type.IsNestedAssembly, "#V28");
 337                         Assert.IsFalse (type.IsNestedFamily, "#V29");
 338                         Assert.IsFalse (type.IsNestedPublic, "#V30");
 339                         Assert.IsFalse (type.IsNestedPrivate, "#V31");
 340                         Assert.IsFalse (type.IsNotPublic, "#V32");
 341                         Assert.IsFalse (type.IsPrimitive, "#V33");
 342                         Assert.IsFalse (type.IsPointer, "#V34");
 343                         Assert.IsTrue (type.IsPublic, "#V35");
 344                         Assert.IsTrue (type.IsSealed, "#V36");
 345                         Assert.IsFalse (type.IsUnicodeClass, "#V37");
 346                         Assert.IsFalse (type.IsSpecialName, "#V38");
 347                         Assert.IsTrue (type.IsValueType, "#V39");
 348                 }
 349
 350                 public static bool MyInterfaceFilter (Type t, object filterCriteria)
 351                 {
 352                         if (t.ToString () == filterCriteria.ToString ())
 353                                 return true;
 354                         else
 355                                 return false;
 356                 }
 357
 358                 public static bool MemberNameFilter (MemberInfo m, object filterCriteria)
 359                 {
 360                         if (m.Name == filterCriteria.ToString ())
 361                                 return true;
 362                         else
 363                                 return false;
 364                 }
 365
 366                 private static AssemblyName GetAssemblyName ()
 367                 {
 368                         AssemblyName assemblyName = new AssemblyName ();
 369                         assemblyName.Name = _assemblyName;
 370                         return assemblyName;
 371                 }
 372
 373                 private static AssemblyBuilder GenerateAssembly ()
 374                 {
 375                         return AppDomain.CurrentDomain.DefineDynamicAssembly (
 376                                 GetAssemblyName (), AssemblyBuilderAccess.RunAndSave);
 377                 }
 378
 379                 private static ModuleBuilder GenerateModule ()
 380                 {
 381                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 382                         return assemblyBuilder.DefineDynamicModule (_moduleName);
 383                 }
 384
 385                 private static ModuleBuilder GenerateModule (AssemblyBuilder assemblyBuilder)
 386                 {
 387                         return assemblyBuilder.DefineDynamicModule (_moduleName);
 388                 }
 389
 390                 private static EnumBuilder GenerateEnum ()
 391                 {
 392                         ModuleBuilder modBuilder = GenerateModule ();
 393                         return modBuilder.DefineEnum (_enumNamespace + "."
 394                                 + _enumName, TypeAttributes.Public, _enumType);
 395                 }
 396
 397                 private static EnumBuilder GenerateEnum (ModuleBuilder modBuilder)
 398                 {
 399                         return modBuilder.DefineEnum (_enumNamespace + "."
 400                                 + _enumName, TypeAttributes.Public, _enumType);
 401                 }
 402
 403                 private static FieldBuilder GenerateField ()
 404                 {
 405                         EnumBuilder enumBuilder = GenerateEnum ();
 406                         return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 407                 }
 408
 409                 private static FieldBuilder GenerateField (EnumBuilder enumBuilder)
 410                 {
 411                         return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 412                 }
 413         }
 414 }