mcs/class/corlib/Test/System/ModuleHandleTest.cs

   1 //
   2 // ModuleHandleTest - NUnit Test Cases for the ModuleHandle class
   3 //
   4 // Zoltan Varga (vargaz@freemail.hu)
   5 //
   6 // (C) Ximian, Inc.  http://www.ximian.com
   7 //
   8 //
   9
  10 //
  11 // MISSING TESTS:
  12 // - dynamic assemblies
  13 //
  14
  15 #if NET_2_0
  16
  17 using System;
  18 using System.Threading;
  19 using System.Reflection;
  20 using System.IO;
  21 using System.Collections;
  22
  23 using NUnit.Framework;
  24
  25 namespace MonoTests.System
  26 {
  27
  28 [TestFixture]
  29 public class ModuleHandleTest
  30 {
  31         public static int foo;
  32
  33         public static int bar {
  34                 get {
  35                         return 0;
  36                 }
  37         }
  38
  39         public ModuleHandleTest () {
  40         }
  41
  42         public static void gnaf (int i, int j) {
  43         }
  44
  45         public ModuleHandle module;
  46
  47         [SetUp]
  48         public void SetUp () {
  49                 module = typeof (ModuleHandleTest).Assembly.GetModules ()[0].ModuleHandle;
  50         }
  51
  52         [Test]
  53         public void ResolveTypeToken () {
  54                 // A typedef
  55                 Assert.AreEqual (typeof (ModuleHandleTest), Type.GetTypeFromHandle (module.ResolveTypeHandle (typeof (ModuleHandleTest).MetadataToken)));
  56         }
  57
  58         [Test]
  59         [ExpectedException (typeof (ArgumentNullException))]
  60         public void ResolveTypeTokenInvalidHandle () {
  61                 ModuleHandle.EmptyHandle.ResolveTypeHandle (typeof (ModuleHandleTest).MetadataToken);
  62         }
  63
  64         [Test]
  65         [ExpectedException (typeof (TypeLoadException))]
  66         public void ResolveTypeTokenInvalidTokenType () {
  67                 module.ResolveTypeHandle (1234);
  68         }
  69
  70         [Test]
  71         [ExpectedException (typeof (TypeLoadException))]
  72         public void ResolveTypeTokenInvalidTokenType2 () {
  73                 module.ResolveTypeHandle (0x4000001);
  74         }
  75
  76
  77
  78         [Test]
  79         public void ResolveFieldToken () {
  80                 FieldInfo fi = typeof (ModuleHandleTest).GetField ("foo");
  81
  82                 Assert.AreEqual (fi, FieldInfo.GetFieldFromHandle (module.ResolveFieldHandle (fi.MetadataToken)));
  83         }
  84
  85         [Test]
  86         [ExpectedException (typeof (ArgumentNullException))]
  87         public void ResolveFieldTokenInvalidHandle () {
  88                 ModuleHandle.EmptyHandle.ResolveFieldHandle (typeof (ModuleHandleTest).MetadataToken);
  89         }
  90
  91         [Test]
  92         [ExpectedException (typeof (Exception))]
  93         public void ResolveFieldTokenInvalidTokenType () {
  94                 module.ResolveFieldHandle (1234);
  95         }
  96
  97         [Test]
  98         [ExpectedException (typeof (Exception))]
  99         public void ResolveFieldTokenInvalidTokenType2 () {
 100                 /* A typedef */
 101                 module.ResolveFieldHandle (0x2000002);
 102         }
 103
 104         [Test]
 105         [ExpectedException (typeof (Exception))]
 106         public void ResolveFieldTokenInvalidTokenType3 () {
 107                 /* A memberref which points to a method */
 108                 module.ResolveFieldHandle (typeof (Console).GetMethod ("ReadLine").MetadataToken);
 109         }
 110
 111         [Test]
 112         [ExpectedException (typeof (Exception))]
 113         public void ResolveFieldTokenInvalidToken () {
 114                 /* An out-of-range field def */
 115                 module.ResolveFieldHandle (0x40f0001);
 116         }
 117
 118
 119
 120
 121         [Test]
 122         public void ResolveMethodToken () {
 123                 MethodInfo mi = typeof (ModuleHandleTest).GetMethod ("ResolveMethodToken");
 124
 125                 Assert.AreEqual (mi, MethodInfo.GetMethodFromHandle (module.ResolveMethodHandle (mi.MetadataToken)));
 126         }
 127
 128         [Test]
 129         [ExpectedException (typeof (ArgumentNullException))]
 130         public void ResolveMethodTokenInvalidHandle () {
 131                 ModuleHandle.EmptyHandle.ResolveMethodHandle (typeof (ModuleHandleTest).GetMethod ("ResolveMethodToken").MetadataToken);
 132         }
 133
 134         [Test]
 135         [ExpectedException (typeof (Exception))]
 136         public void ResolveMethodTokenInvalidTokenType () {
 137                 module.ResolveMethodHandle (1234);
 138         }
 139
 140         [Test]
 141         [ExpectedException (typeof (Exception))]
 142         public void ResolveMethodTokenInvalidTokenType2 () {
 143                 /* A typedef */
 144                 module.ResolveMethodHandle (0x2000002);
 145         }
 146
 147         [Test]
 148         [ExpectedException (typeof (Exception))]
 149         public void ResolveMethodTokenInvalidTokenType3 () {
 150                 /* A memberref which points to a field */
 151                 module.ResolveMethodHandle (typeof (Type).GetField ("Delimiter").MetadataToken);
 152         }
 153
 154         [Test]
 155         [ExpectedException (typeof (Exception))]
 156         public void ResolveMethodTokenInvalidToken () {
 157                 /* An out-of-range method def */
 158                 module.ResolveMethodHandle (0x60f0001);
 159         }
 160
 161 /* it is not public in 2.0 RTM.
 162         [Test]
 163         public void GetPEKind () {
 164                 PortableExecutableKinds pe_kind;
 165                 ImageFileMachine machine;
 166
 167                 module.GetPEKind (out pe_kind, out machine);
 168
 169                 Assert.AreEqual (PortableExecutableKinds.ILOnly, pe_kind);
 170         }
 171
 172         [Test]
 173         [ExpectedException (typeof (ArgumentNullException))]
 174         public void GetPEKindInvalidHandle () {
 175                 PortableExecutableKinds pe_kind;
 176                 ImageFileMachine machine;
 177
 178                 ModuleHandle.EmptyHandle.GetPEKind (out pe_kind, out machine);
 179         }
 180 */
 181 }
 182 }
 183
 184 #endif