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 #if NET_4_0
 203                 [Test]
 204                 public void GetEnumUnderlyingType ()
 205                 {
 206                         var @enum = GenerateEnum ();
 207
 208                         Assert.AreEqual (_enumType, @enum.GetEnumUnderlyingType ());
 209                 }
 210 #endif
 211
 212                 [Test]
 213                 public void TestFindMembersComplete ()
 214                 {
 215                         EnumBuilder enumBuilder = GenerateEnum ();
 216                         GenerateField (enumBuilder);
 217                         enumBuilder.CreateType ();
 218
 219                         MemberInfo [] members = enumBuilder.FindMembers (
 220                                 MemberTypes.Field, BindingFlags.Static |
 221                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 222                                 _fieldName);
 223                         Assert.AreEqual (1, members.Length, "#1");
 224
 225                         members = enumBuilder.FindMembers (
 226                                 MemberTypes.Field, BindingFlags.Static |
 227                                 BindingFlags.Public, new MemberFilter (MemberNameFilter),
 228                                 "doesntmatter");
 229                         Assert.AreEqual (0, members.Length, "#2");
 230                 }
 231
 232                 [Test]
 233                 [ExpectedException (typeof (NotSupportedException))]
 234                 [Category ("ValueAdd")]
 235                 public void TestGetConstructorIncomplete ()
 236                 {
 237                         EnumBuilder enumBuilder = GenerateEnum ();
 238                         enumBuilder.GetConstructor (BindingFlags.Public, null,
 239                                 CallingConventions.Any, Type.EmptyTypes, new ParameterModifier [0]);
 240                 }
 241
 242                 [Test]
 243                 public void TestGetConstructorComplete ()
 244                 {
 245                         EnumBuilder enumBuilder = GenerateEnum ();
 246                         enumBuilder.CreateType ();
 247                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 248                                 BindingFlags.Public, null, CallingConventions.Any,
 249                                 Type.EmptyTypes, new ParameterModifier [0]);
 250                         Assert.IsNull (ctor);
 251                 }
 252
 253                 [Test]
 254                 [ExpectedException (typeof (ArgumentNullException))]
 255                 public void TestGetConstructorNullTypes ()
 256                 {
 257                         EnumBuilder enumBuilder = GenerateEnum ();
 258                         enumBuilder.CreateType ();
 259                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 260                                 BindingFlags.Public, null, CallingConventions.Any,
 261                                 null, new ParameterModifier [0]);
 262                 }
 263
 264                 [Test]
 265                 [Category ("NotWorking")]
 266                 [ExpectedException (typeof (ArgumentNullException))]
 267                 public void TestGetConstructorNullElementType ()
 268                 {
 269                         EnumBuilder enumBuilder = GenerateEnum ();
 270                         enumBuilder.CreateType ();
 271                         ConstructorInfo ctor = enumBuilder.GetConstructor (
 272                                 BindingFlags.Public, null, CallingConventions.Any,
 273                                 new Type [] { null }, new ParameterModifier [0]);
 274                 }
 275
 276                 [Test]
 277                 [ExpectedException (typeof (NotSupportedException))]
 278                 [Category ("NotWorking")]
 279                 public void TestGetConstructorsIncomplete ()
 280                 {
 281                         EnumBuilder enumBuilder = GenerateEnum ();
 282
 283                         ConstructorInfo [] ctors = enumBuilder.GetConstructors (
 284                                 BindingFlags.Instance | BindingFlags.Public);
 285                         Assert.AreEqual (0, ctors.Length);
 286                 }
 287
 288                 [Test]
 289                 public void TestGetConstructorsComplete ()
 290                 {
 291                         EnumBuilder enumBuilder = GenerateEnum ();
 292                         enumBuilder.CreateType ();
 293
 294                         ConstructorInfo [] ctors = enumBuilder.GetConstructors (
 295                                 BindingFlags.Instance | BindingFlags.Public);
 296                         Assert.AreEqual (0, ctors.Length);
 297                 }
 298
 299                 [Test]
 300                 public void TestIsValue__SpecialName ()
 301                 {
 302                         EnumBuilder enumBuilder = GenerateEnum ();
 303                         Type enumType = enumBuilder.CreateType ();
 304                         FieldInfo value = enumType.GetField ("value__", BindingFlags.Instance | BindingFlags.NonPublic);
 305                         Assert.AreEqual (FieldAttributes.RTSpecialName, value.Attributes & FieldAttributes.RTSpecialName);
 306                 }
 307
 308                 private static void VerifyType (Type type)
 309                 {
 310                         Assert.IsNotNull (type.Assembly, "#V1");
 311                         Assert.IsNotNull (type.AssemblyQualifiedName, "#V2");
 312                         Assert.IsNotNull (type.BaseType, "#V3");
 313                         Assert.IsNotNull (type.FullName, "#V4");
 314                         Assert.IsNotNull (type.Module, "#V5");
 315                         Assert.IsNotNull (type.Name, "#V6");
 316                         Assert.IsNotNull (type.Namespace, "#V7");
 317                         Assert.IsNotNull (type.UnderlyingSystemType, "#V8");
 318
 319                         Assert.AreEqual (_enumNamespace, type.Namespace, "#V10");
 320                         Assert.AreEqual (_enumName, type.Name, "#V11");
 321                         Assert.AreEqual (typeof (Enum), type.BaseType, "#V12");
 322                         Assert.AreEqual (MemberTypes.TypeInfo, type.MemberType, "#V13");
 323                         Assert.AreEqual (typeof (int), Enum.GetUnderlyingType (type), "#V14");
 324
 325                         Assert.IsFalse (type.IsArray, "#V15");
 326                         Assert.IsFalse (type.IsAutoClass, "#V16");
 327                         Assert.IsTrue (type.IsAutoLayout, "#V17");
 328                         Assert.IsFalse (type.IsByRef, "#V18");
 329                         Assert.IsFalse (type.IsClass, "#V19");
 330                         Assert.IsFalse (type.IsCOMObject, "#V20");
 331                         Assert.IsFalse (type.IsContextful, "#V21");
 332                         Assert.IsTrue (type.IsEnum, "#V22");
 333                         Assert.IsFalse (type.IsExplicitLayout, "#V23");
 334                         Assert.IsFalse (type.IsImport, "#V24");
 335                         Assert.IsFalse (type.IsInterface, "#V25");
 336                         Assert.IsFalse (type.IsLayoutSequential, "#V26");
 337                         Assert.IsFalse (type.IsMarshalByRef, "#V27");
 338                         Assert.IsFalse (type.IsNestedAssembly, "#V28");
 339                         Assert.IsFalse (type.IsNestedFamily, "#V29");
 340                         Assert.IsFalse (type.IsNestedPublic, "#V30");
 341                         Assert.IsFalse (type.IsNestedPrivate, "#V31");
 342                         Assert.IsFalse (type.IsNotPublic, "#V32");
 343                         Assert.IsFalse (type.IsPrimitive, "#V33");
 344                         Assert.IsFalse (type.IsPointer, "#V34");
 345                         Assert.IsTrue (type.IsPublic, "#V35");
 346                         Assert.IsTrue (type.IsSealed, "#V36");
 347                         Assert.IsFalse (type.IsUnicodeClass, "#V37");
 348                         Assert.IsFalse (type.IsSpecialName, "#V38");
 349                         Assert.IsTrue (type.IsValueType, "#V39");
 350                 }
 351
 352                 public static bool MyInterfaceFilter (Type t, object filterCriteria)
 353                 {
 354                         if (t.ToString () == filterCriteria.ToString ())
 355                                 return true;
 356                         else
 357                                 return false;
 358                 }
 359
 360                 public static bool MemberNameFilter (MemberInfo m, object filterCriteria)
 361                 {
 362                         if (m.Name == filterCriteria.ToString ())
 363                                 return true;
 364                         else
 365                                 return false;
 366                 }
 367
 368                 private static AssemblyName GetAssemblyName ()
 369                 {
 370                         AssemblyName assemblyName = new AssemblyName ();
 371                         assemblyName.Name = _assemblyName;
 372                         return assemblyName;
 373                 }
 374
 375                 private static AssemblyBuilder GenerateAssembly ()
 376                 {
 377                         return AppDomain.CurrentDomain.DefineDynamicAssembly (
 378                                 GetAssemblyName (), AssemblyBuilderAccess.RunAndSave);
 379                 }
 380
 381                 private static ModuleBuilder GenerateModule ()
 382                 {
 383                         AssemblyBuilder assemblyBuilder = GenerateAssembly ();
 384                         return assemblyBuilder.DefineDynamicModule (_moduleName);
 385                 }
 386
 387                 private static ModuleBuilder GenerateModule (AssemblyBuilder assemblyBuilder)
 388                 {
 389                         return assemblyBuilder.DefineDynamicModule (_moduleName);
 390                 }
 391
 392                 private static EnumBuilder GenerateEnum ()
 393                 {
 394                         ModuleBuilder modBuilder = GenerateModule ();
 395                         return modBuilder.DefineEnum (_enumNamespace + "."
 396                                 + _enumName, TypeAttributes.Public, _enumType);
 397                 }
 398
 399                 private static EnumBuilder GenerateEnum (ModuleBuilder modBuilder)
 400                 {
 401                         return modBuilder.DefineEnum (_enumNamespace + "."
 402                                 + _enumName, TypeAttributes.Public, _enumType);
 403                 }
 404
 405                 private static FieldBuilder GenerateField ()
 406                 {
 407                         EnumBuilder enumBuilder = GenerateEnum ();
 408                         return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 409                 }
 410
 411                 private static FieldBuilder GenerateField (EnumBuilder enumBuilder)
 412                 {
 413                         return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
 414                 }
 415         }
 416 }