mcs/class/corlib/Test/System.Reflection/ModuleTest.cs

   1 //
   2 // ModuleTest - NUnit Test Cases for the Module class
   3 //
   4 // Zoltan Varga (vargaz@freemail.hu)
   5 //
   6 // (C) Ximian, Inc.  http://www.ximian.com
   7 //
   8 //
   9
  10
  11 using System;
  12 using System.Threading;
  13 using System.Reflection;
  14 using System.Reflection.Emit;
  15 using System.IO;
  16 using System.Collections;
  17
  18 using NUnit.Framework;
  19
  20 namespace MonoTests.System.Reflection
  21 {
  22
  23 [TestFixture]
  24 public class ModuleTest : Assertion
  25 {
  26         static string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.Reflection.ModuleTest");
  27
  28         [SetUp]
  29         public void SetUp () {
  30                 while (Directory.Exists (TempFolder))
  31                         TempFolder = Path.Combine (TempFolder, "2");
  32                 Directory.CreateDirectory (TempFolder);
  33         }
  34
  35         [TearDown]
  36         public void TearDown () {
  37                 try {
  38                         // This throws an exception under MS.NET, since the directory contains loaded
  39                         // assemblies.
  40                         Directory.Delete (TempFolder, true);
  41                 }
  42                 catch (Exception) {
  43                 }
  44         }
  45
  46         // Some of these tests overlap with the tests for ModuleBuilder
  47
  48         [Test]
  49         public void TestGlobalData () {
  50
  51                 string name = "moduletest-assembly";
  52                 string fileName = name + ".dll";
  53
  54                 AssemblyName assemblyName = new AssemblyName();
  55                 assemblyName.Name = name;
  56
  57                 AssemblyBuilder ab
  58                         = Thread.GetDomain().DefineDynamicAssembly(
  59                                 assemblyName, AssemblyBuilderAccess.RunAndSave, TempFolder);
  60
  61                 string resfile = Path.Combine (TempFolder, "res");
  62                 using (StreamWriter sw = new StreamWriter (resfile)) {
  63                         sw.WriteLine ("FOO");
  64                 }
  65
  66                 ab.AddResourceFile ("res", "res");
  67
  68                 ModuleBuilder mb = ab.DefineDynamicModule(fileName, fileName);
  69
  70                 mb.DefineInitializedData ("DATA", new byte [100], FieldAttributes.Public);
  71                 mb.DefineInitializedData ("DATA2", new byte [100], FieldAttributes.Public);
  72                 mb.DefineInitializedData ("DATA3", new byte [99], FieldAttributes.Public);
  73                 mb.DefineUninitializedData ("DATA4", 101, FieldAttributes.Public);
  74                 mb.DefineInitializedData ("DATA_PRIVATE", new byte [100], 0);
  75                 mb.CreateGlobalFunctions ();
  76
  77                 ab.Save (fileName);
  78
  79                 Assembly assembly = Assembly.LoadFrom (Path.Combine (TempFolder, fileName));
  80
  81                 Module module = assembly.GetLoadedModules ()[0];
  82
  83                 string[] expectedFieldNames = new string [] {
  84                         "DATA", "DATA2", "DATA3", "DATA4"
  85                 };
  86                 ArrayList fieldNames = new ArrayList ();
  87                 foreach (FieldInfo fi in module.GetFields ()) {
  88                         fieldNames.Add (fi.Name);
  89                 }
  90                 AssertArrayEqualsSorted (expectedFieldNames, fieldNames.ToArray (typeof (string)));
  91
  92                 try {
  93                         module.GetField (null);
  94                         Fail ();
  95                 }
  96                 catch (ArgumentNullException) {
  97                 }
  98
  99                 try {
 100                         module.GetField (null, 0);
 101                         Fail ();
 102                 }
 103                 catch (ArgumentNullException) {
 104                 }
 105
 106                 AssertEquals (module.GetField ("DATA") != null, true);
 107                 AssertEquals (module.GetField ("DATA2") != null, true);
 108                 AssertEquals (module.GetField ("DATA3") != null, true);
 109                 AssertEquals (module.GetField ("DATA4") != null, true);
 110                 AssertEquals (module.GetField ("DATA_PRIVATE"), null);
 111                 AssertEquals (module.GetField ("DATA_PRIVATE", BindingFlags.NonPublic | BindingFlags.Static) != null, true);
 112
 113                 // Check that these methods work correctly on resource modules
 114                 Module m2 = assembly.GetModule ("res");
 115                 AssertEquals (m2 != null, true);
 116                 AssertEquals (m2.GetFields ().Length, 0);
 117                 AssertEquals (m2.GetField ("DATA"), null);
 118                 AssertEquals (m2.GetField ("DATA", BindingFlags.Public), null);
 119         }
 120
 121 #if NET_2_0
 122
 123         [Test]
 124         public void ResolveType () {
 125                 Type t = typeof (ModuleTest);
 126                 Module module = t.Module;
 127
 128                 AssertEquals (t, module.ResolveType (t.MetadataToken));
 129
 130                 /* We currently throw ArgumentException for this one */
 131                 try {
 132                         module.ResolveType (1234);
 133                         Fail ();
 134                 }
 135                 catch (ArgumentException) {
 136                 }
 137
 138                 try {
 139                         module.ResolveType (t.GetMethod ("ResolveType").MetadataToken);
 140                         Fail ();
 141                 }
 142                 catch (ArgumentException) {
 143                 }
 144
 145                 try {
 146                         module.ResolveType (t.MetadataToken + 10000);
 147                         Fail ();
 148                 }
 149                 catch (ArgumentOutOfRangeException) {
 150                 }
 151         }
 152
 153         [Test]
 154         public void ResolveMethod () {
 155                 Type t = typeof (ModuleTest);
 156                 Module module = t.Module;
 157
 158                 AssertEquals (t.GetMethod ("ResolveMethod"), module.ResolveMethod (t.GetMethod ("ResolveMethod").MetadataToken));
 159
 160                 try {
 161                         module.ResolveMethod (1234);
 162                         Fail ();
 163                 }
 164                 catch (ArgumentException) {
 165                 }
 166
 167                 try {
 168                         module.ResolveMethod (t.MetadataToken);
 169                         Fail ();
 170                 }
 171                 catch (ArgumentException) {
 172                 }
 173
 174                 try {
 175                         module.ResolveMethod (t.GetMethod ("ResolveMethod").MetadataToken + 10000);
 176                         Fail ();
 177                 }
 178                 catch (ArgumentOutOfRangeException) {
 179                 }
 180         }
 181
 182         public int aField;
 183
 184         [Test]
 185         public void ResolveField () {
 186                 Type t = typeof (ModuleTest);
 187                 Module module = t.Module;
 188
 189                 AssertEquals (t.GetField ("aField"), module.ResolveField (t.GetField ("aField").MetadataToken));
 190
 191                 try {
 192                         module.ResolveField (1234);
 193                         Fail ();
 194                 }
 195                 catch (ArgumentException) {
 196                 }
 197
 198                 try {
 199                         module.ResolveField (t.MetadataToken);
 200                         Fail ();
 201                 }
 202                 catch (ArgumentException) {
 203                 }
 204
 205                 try {
 206                         module.ResolveField (t.GetField ("aField").MetadataToken + 10000);
 207                         Fail ();
 208                 }
 209                 catch (ArgumentOutOfRangeException) {
 210                 }
 211         }
 212
 213         [Test]
 214         public void ResolveString () {
 215                 Type t = typeof (ModuleTest);
 216                 Module module = t.Module;
 217
 218                 for (int i = 1; i < 10000; ++i) {
 219                         try {
 220                                 module.ResolveString (0x70000000 + i);
 221                         }
 222                         catch (Exception) {
 223                         }
 224                 }
 225
 226                 try {
 227                         module.ResolveString (1234);
 228                         Fail ();
 229                 }
 230                 catch (ArgumentException) {
 231                 }
 232
 233                 try {
 234                         module.ResolveString (t.MetadataToken);
 235                         Fail ();
 236                 }
 237                 catch (ArgumentException) {
 238                 }
 239
 240                 try {
 241                         module.ResolveString (0x70000000 | 10000);
 242                         Fail ();
 243                 }
 244                 catch (ArgumentOutOfRangeException) {
 245                 }
 246         }
 247
 248
 249         [Test]
 250         public void ResolveMember () {
 251                 Type t = typeof (ModuleTest);
 252                 Module module = t.Module;
 253
 254                 AssertEquals (t, module.ResolveMember (t.MetadataToken));
 255                 AssertEquals (t.GetField ("aField"), module.ResolveMember (t.GetField ("aField").MetadataToken));
 256                 AssertEquals (t.GetMethod ("ResolveMember"), module.ResolveMember (t.GetMethod ("ResolveMember").MetadataToken));
 257
 258                 try {
 259                         module.ResolveMember (module.MetadataToken);
 260                 }
 261                 catch (ArgumentException) {
 262                 }
 263         }
 264 #endif
 265
 266         [Test]
 267         public void FindTypes () {
 268                 Module m = typeof (ModuleTest).Module;
 269
 270                 Type[] t;
 271
 272                 t = m.FindTypes (Module.FilterTypeName, "FindTypesTest*");
 273                 AssertEquals (2, t.Length);
 274                 AssertEquals ("FindTypesTestFirstClass", t [0].Name);
 275                 AssertEquals ("FindTypesTestSecondClass", t [1].Name);
 276                 t = m.FindTypes (Module.FilterTypeNameIgnoreCase, "findtypestest*");
 277                 AssertEquals (2, t.Length);
 278                 AssertEquals ("FindTypesTestFirstClass", t [0].Name);
 279                 AssertEquals ("FindTypesTestSecondClass", t [1].Name);
 280         }
 281
 282         class FindTypesTestFirstClass {
 283         }
 284
 285         class FindTypesTestSecondClass {
 286         }
 287
 288     private static void AssertArrayEqualsSorted (Array o1, Array o2) {
 289                 Array s1 = (Array)o1.Clone ();
 290                 Array s2 = (Array)o2.Clone ();
 291
 292                 Array.Sort (s1);
 293                 Array.Sort (s2);
 294
 295                 AssertEquals (s1.Length, s2.Length);
 296                 for (int i = 0; i < s1.Length; ++i)
 297                         AssertEquals (s1.GetValue (i), s2.GetValue (i));
 298         }
 299 }
 300 }
 301