-//\r
-// ModuleTest - NUnit Test Cases for the Module class\r
-//\r
-// Zoltan Varga (vargaz@freemail.hu)\r
-//\r
-// (C) Ximian, Inc. http://www.ximian.com\r
+//
+// ModuleTest - NUnit Test Cases for the Module class
+//
+// Zoltan Varga (vargaz@freemail.hu)
+//
+// (C) Ximian, Inc. http://www.ximian.com
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
-//\r
-\r
-using System;\r
-using System.Threading;\r
-using System.Reflection;\r
-using System.Reflection.Emit;\r
+//
+
+using System;
+using System.Threading;
+using System.Reflection;
+#if !MONOTOUCH
+using System.Reflection.Emit;
+#endif
using System.Runtime.Serialization;
-using System.IO;\r
-using System.Collections;\r
-\r
-using NUnit.Framework;\r
-\r
-namespace MonoTests.System.Reflection\r
-{\r
-\r
-[TestFixture]\r
-public class ModuleTest : Assertion\r
-{ \r
- static string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.Reflection.ModuleTest");\r
-\r
- [SetUp]\r
- public void SetUp () {\r
- while (Directory.Exists (TempFolder))\r
- TempFolder = Path.Combine (TempFolder, "2");\r
- Directory.CreateDirectory (TempFolder);\r
- } \r
-\r
- [TearDown]\r
- public void TearDown () {\r
- try {\r
- // This throws an exception under MS.NET, since the directory contains loaded\r
- // assemblies.\r
- Directory.Delete (TempFolder, true);\r
- }\r
- catch (Exception) {\r
- }\r
- }\r
-\r
- // Some of these tests overlap with the tests for ModuleBuilder\r
-\r
- [Test]\r
- [Category("NotDotNet")] // path length can cause suprious failures\r
- public void TestGlobalData () {\r
-\r
- string name = "moduletest-assembly";\r
- string fileName = name + ".dll";\r
-\r
- AssemblyName assemblyName = new AssemblyName();\r
- assemblyName.Name = name;\r
-\r
- AssemblyBuilder ab\r
- = Thread.GetDomain().DefineDynamicAssembly(\r
- assemblyName, AssemblyBuilderAccess.RunAndSave, TempFolder);\r
-\r
- string resfile = Path.Combine (TempFolder, "res");\r
- using (StreamWriter sw = new StreamWriter (resfile)) {\r
- sw.WriteLine ("FOO");\r
- }\r
-\r
- ab.AddResourceFile ("res", "res");\r
-\r
- ModuleBuilder mb = ab.DefineDynamicModule(fileName, fileName);\r
-\r
- mb.DefineInitializedData ("DATA", new byte [100], FieldAttributes.Public);\r
- mb.DefineInitializedData ("DATA2", new byte [100], FieldAttributes.Public);\r
- mb.DefineInitializedData ("DATA3", new byte [99], FieldAttributes.Public);\r
- mb.DefineUninitializedData ("DATA4", 101, FieldAttributes.Public);\r
- mb.DefineInitializedData ("DATA_PRIVATE", new byte [100], 0);\r
- mb.CreateGlobalFunctions ();\r
-\r
- ab.Save (fileName);\r
-\r
- Assembly assembly = Assembly.LoadFrom (Path.Combine (TempFolder, fileName));\r
-\r
- Module module = assembly.GetLoadedModules ()[0];\r
-\r
- string[] expectedFieldNames = new string [] {\r
- "DATA", "DATA2", "DATA3", "DATA4"\r
- };\r
- ArrayList fieldNames = new ArrayList ();\r
- foreach (FieldInfo fi in module.GetFields ()) {\r
- fieldNames.Add (fi.Name);\r
- }\r
- AssertArrayEqualsSorted (expectedFieldNames, fieldNames.ToArray (typeof (string)));\r
-\r
- try {\r
- module.GetField (null);\r
- Fail ();\r
- }\r
- catch (ArgumentNullException) {\r
- }\r
-\r
- try {\r
- module.GetField (null, 0);\r
- Fail ();\r
- }\r
- catch (ArgumentNullException) {\r
- }\r
-\r
- AssertEquals (module.GetField ("DATA") != null, true);\r
- AssertEquals (module.GetField ("DATA2") != null, true);\r
- AssertEquals (module.GetField ("DATA3") != null, true);\r
- AssertEquals (module.GetField ("DATA4") != null, true);\r
- AssertEquals (module.GetField ("DATA_PRIVATE"), null);\r
- AssertEquals (module.GetField ("DATA_PRIVATE", BindingFlags.NonPublic | BindingFlags.Static) != null, true);\r
-\r
- // Check that these methods work correctly on resource modules\r
- Module m2 = assembly.GetModule ("res");\r
- AssertEquals (m2 != null, true);\r
- AssertEquals (m2.GetFields ().Length, 0);\r
- AssertEquals (m2.GetField ("DATA"), null);\r
- AssertEquals (m2.GetField ("DATA", BindingFlags.Public), null);\r
- }\r
-\r
-#if NET_2_0\r
-\r
- [Test]\r
- public void ResolveType () {\r
- Type t = typeof (ModuleTest);\r
- Module module = t.Module;\r
-\r
- AssertEquals (t, module.ResolveType (t.MetadataToken));\r
-\r
- /* We currently throw ArgumentException for this one */\r
- try {\r
- module.ResolveType (1234);\r
- Fail ();\r
- }\r
- catch (ArgumentException) {\r
- }\r
-\r
- try {\r
- module.ResolveType (t.GetMethod ("ResolveType").MetadataToken);\r
- Fail ();\r
- }\r
- catch (ArgumentException) {\r
- }\r
-\r
- try {\r
- module.ResolveType (t.MetadataToken + 10000);\r
- Fail ();\r
- }\r
- catch (ArgumentOutOfRangeException) {\r
- }\r
- }\r
-\r
- [Test]\r
- public void ResolveMethod () {\r
- Type t = typeof (ModuleTest);\r
- Module module = t.Module;\r
-\r
- AssertEquals (t.GetMethod ("ResolveMethod"), module.ResolveMethod (t.GetMethod ("ResolveMethod").MetadataToken));\r
-\r
- try {\r
- module.ResolveMethod (1234);\r
- Fail ();\r
- }\r
- catch (ArgumentException) {\r
- }\r
-\r
- try {\r
- module.ResolveMethod (t.MetadataToken);\r
- Fail ();\r
- }\r
- catch (ArgumentException) {\r
- }\r
-\r
- try {\r
- module.ResolveMethod (t.GetMethod ("ResolveMethod").MetadataToken + 10000);\r
- Fail ();\r
- }\r
- catch (ArgumentOutOfRangeException) {\r
- }\r
- }\r
-\r
- public int aField;\r
-\r
- [Test]\r
- public void ResolveField () {\r
- Type t = typeof (ModuleTest);\r
- Module module = t.Module;\r
-\r
- AssertEquals (t.GetField ("aField"), module.ResolveField (t.GetField ("aField").MetadataToken));\r
-\r
- try {\r
- module.ResolveField (1234);\r
- Fail ();\r
- }\r
- catch (ArgumentException) {\r
- }\r
-\r
- try {\r
- module.ResolveField (t.MetadataToken);\r
- Fail ();\r
- }\r
- catch (ArgumentException) {\r
- }\r
-\r
- try {\r
- module.ResolveField (t.GetField ("aField").MetadataToken + 10000);\r
- Fail ();\r
- }\r
- catch (ArgumentOutOfRangeException) {\r
- }\r
- }\r
-
- [Ignore ("it breaks nunit-console.exe execution under .NET 2.0")]\r
- [Test]\r
- public void ResolveString () {\r
- Type t = typeof (ModuleTest);\r
- Module module = t.Module;\r
-\r
- for (int i = 1; i < 10000; ++i) {\r
- try {\r
- module.ResolveString (0x70000000 + i);\r
- }\r
- catch (Exception) {\r
- }\r
- }\r
-\r
- try {\r
- module.ResolveString (1234);\r
- Fail ();\r
- }\r
- catch (ArgumentException) {\r
- }\r
-\r
- try {\r
- module.ResolveString (t.MetadataToken);\r
- Fail ();\r
- }\r
- catch (ArgumentException) {\r
- }\r
-\r
- try {\r
- module.ResolveString (0x70000000 | 10000);\r
- Fail ();\r
- }\r
- catch (ArgumentOutOfRangeException) {\r
- }\r
- }\r
-\r
-\r
- [Test]\r
- public void ResolveMember () {\r
- Type t = typeof (ModuleTest);\r
- Module module = t.Module;\r
-\r
- AssertEquals (t, module.ResolveMember (t.MetadataToken));\r
- AssertEquals (t.GetField ("aField"), module.ResolveMember (t.GetField ("aField").MetadataToken));\r
- AssertEquals (t.GetMethod ("ResolveMember"), module.ResolveMember (t.GetMethod ("ResolveMember").MetadataToken));\r
-\r
- try {\r
- module.ResolveMember (module.MetadataToken);\r
- }\r
- catch (ArgumentException) {\r
- }\r
- }\r
-#endif\r
-\r
- [Test]\r
- public void FindTypes () {\r
- Module m = typeof (ModuleTest).Module;\r
-\r
- Type[] t;\r
-\r
- t = m.FindTypes (Module.FilterTypeName, "FindTypesTest*");\r
- AssertEquals (2, t.Length);\r
- AssertEquals ("FindTypesTestFirstClass", t [0].Name);\r
- AssertEquals ("FindTypesTestSecondClass", t [1].Name);\r
- t = m.FindTypes (Module.FilterTypeNameIgnoreCase, "findtypestest*");\r
- AssertEquals (2, t.Length);\r
- AssertEquals ("FindTypesTestFirstClass", t [0].Name);\r
- AssertEquals ("FindTypesTestSecondClass", t [1].Name);\r
- }\r
+using System.IO;
+using System.Collections;
+
+using NUnit.Framework;
+
+namespace MonoTests.System.Reflection
+{
+[TestFixture]
+public class ModuleTest
+{
+ static string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.Reflection.ModuleTest");
+
+ [SetUp]
+ public void SetUp ()
+ {
+ while (Directory.Exists (TempFolder))
+ TempFolder = Path.Combine (TempFolder, "2");
+ Directory.CreateDirectory (TempFolder);
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ try {
+ // This throws an exception under MS.NET, since the directory contains loaded
+ // assemblies.
+ Directory.Delete (TempFolder, true);
+ } catch (Exception) {
+ }
+ }
+
+ [Test]
+ public void IsDefined_AttributeType_Null ()
+ {
+ Type t = typeof (ModuleTest);
+ Module module = t.Module;
+
+ try {
+ module.IsDefined ((Type) null, false);
+ Assert.Fail ("#1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
+ Assert.IsNull (ex.InnerException, "#3");
+ Assert.IsNotNull (ex.Message, "#4");
+ Assert.IsNotNull (ex.ParamName, "#5");
+ Assert.AreEqual ("attributeType", ex.ParamName, "#6");
+ }
+ }
+
+ [Test]
+ public void GetField_Name_Null ()
+ {
+ Type t = typeof (ModuleTest);
+ Module module = t.Module;
+
+ try {
+ module.GetField (null);
+ Assert.Fail ("#A1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
+ Assert.IsNull (ex.InnerException, "#A3");
+ Assert.IsNotNull (ex.Message, "#A4");
+ Assert.IsNotNull (ex.ParamName, "#A5");
+ Assert.AreEqual ("name", ex.ParamName, "#A6");
+ }
+
+ try {
+ module.GetField (null, 0);
+ Assert.Fail ("#B1");
+ } catch (ArgumentNullException ex) {
+ Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
+ Assert.IsNull (ex.InnerException, "#B3");
+ Assert.IsNotNull (ex.Message, "#B4");
+ Assert.IsNotNull (ex.ParamName, "#B5");
+ Assert.AreEqual ("name", ex.ParamName, "#B6");
+ }
+ }
+
+ // Some of these tests overlap with the tests for ModuleBuilder
+#if !MONOTOUCH
+ [Test]
+ [Category("NotDotNet")] // path length can cause suprious failures
+ public void TestGlobalData () {
+
+ string name = "moduletest-assembly";
+ string fileName = name + ".dll";
+
+ AssemblyName assemblyName = new AssemblyName();
+ assemblyName.Name = name;
+
+ AssemblyBuilder ab
+ = Thread.GetDomain().DefineDynamicAssembly(
+ assemblyName, AssemblyBuilderAccess.RunAndSave, TempFolder);
+
+ string resfile = Path.Combine (TempFolder, "res");
+ using (StreamWriter sw = new StreamWriter (resfile)) {
+ sw.WriteLine ("FOO");
+ }
+
+ ab.AddResourceFile ("res", "res");
+
+ ModuleBuilder mb = ab.DefineDynamicModule(fileName, fileName);
+
+ mb.DefineInitializedData ("DATA", new byte [100], FieldAttributes.Public);
+ mb.DefineInitializedData ("DATA2", new byte [100], FieldAttributes.Public);
+ mb.DefineInitializedData ("DATA3", new byte [99], FieldAttributes.Public);
+ mb.DefineUninitializedData ("DATA4", 101, FieldAttributes.Public);
+ mb.DefineInitializedData ("DATA_PRIVATE", new byte [100], 0);
+ mb.CreateGlobalFunctions ();
+
+ ab.Save (fileName);
+
+ Assembly assembly = Assembly.LoadFrom (Path.Combine (TempFolder, fileName));
+
+ Module module = assembly.GetLoadedModules ()[0];
+
+ string[] expectedFieldNames = new string [] {
+ "DATA", "DATA2", "DATA3", "DATA4"
+ };
+ ArrayList fieldNames = new ArrayList ();
+ foreach (FieldInfo fi in module.GetFields ()) {
+ fieldNames.Add (fi.Name);
+ }
+ AssertArrayEqualsSorted (expectedFieldNames, fieldNames.ToArray (typeof (string)));
+
+ Assert.IsNotNull (module.GetField ("DATA"), "#A1");
+ Assert.IsNotNull (module.GetField ("DATA2"), "#A2");
+ Assert.IsNotNull (module.GetField ("DATA3"), "#A3");
+ Assert.IsNotNull (module.GetField ("DATA4"), "#A4");
+ Assert.IsNull (module.GetField ("DATA_PRIVATE"), "#A5");
+ Assert.IsNotNull (module.GetField ("DATA_PRIVATE", BindingFlags.NonPublic | BindingFlags.Static), "#A6");
+
+ // Check that these methods work correctly on resource modules
+ Module m2 = assembly.GetModule ("res");
+ Assert.IsNotNull (m2, "#B1");
+ Assert.AreEqual (0, m2.GetFields ().Length, "#B2");
+ Assert.IsNull (m2.GetField ("DATA"), "#B3");
+ Assert.IsNull (m2.GetField ("DATA", BindingFlags.Public), "#B4");
+ }
+#endif
+
+ [Test]
+ public void ResolveType ()
+ {
+ Type t = typeof (ModuleTest);
+ Module module = t.Module;
+
+ Assert.AreEqual (t, module.ResolveType (t.MetadataToken), "#1");
+
+ /* We currently throw ArgumentException for this one */
+ try {
+ module.ResolveType (1234);
+ Assert.Fail ("#2");
+ } catch (ArgumentException) {
+ }
+
+ try {
+ module.ResolveType (t.GetMethod ("ResolveType").MetadataToken);
+ Assert.Fail ("#3");
+ } catch (ArgumentException) {
+ }
+
+ try {
+ module.ResolveType (t.MetadataToken + 10000);
+ Assert.Fail ("#4");
+ } catch (ArgumentOutOfRangeException) {
+ }
+ }
+
+ [Test]
+ public void ResolveMethod ()
+ {
+ Type t = typeof (ModuleTest);
+ Module module = t.Module;
+
+ Assert.AreEqual (t.GetMethod ("ResolveMethod"), module.ResolveMethod (t.GetMethod ("ResolveMethod").MetadataToken));
+
+ try {
+ module.ResolveMethod (1234);
+ Assert.Fail ("1234");
+ } catch (ArgumentException) {
+ }
+
+ try {
+ module.ResolveMethod (t.MetadataToken);
+ Assert.Fail ("MetadataToken");
+ } catch (ArgumentException) {
+ }
+
+ try {
+ module.ResolveMethod (t.GetMethod ("ResolveMethod").MetadataToken + 100000);
+ Assert.Fail ("GetMethod");
+ } catch (ArgumentOutOfRangeException) {
+ }
+ }
+
+ public int aField;
+
+ [Test]
+ public void ResolveField ()
+ {
+ Type t = typeof (ModuleTest);
+ Module module = t.Module;
+
+ Assert.AreEqual (t.GetField ("aField"), module.ResolveField (t.GetField ("aField").MetadataToken));
+
+ try {
+ module.ResolveField (1234);
+ Assert.Fail ();
+ } catch (ArgumentException) {
+ }
+
+ try {
+ module.ResolveField (t.MetadataToken);
+ Assert.Fail ();
+ } catch (ArgumentException) {
+ }
+
+ try {
+ module.ResolveField (t.GetField ("aField").MetadataToken + 10000);
+ Assert.Fail ();
+ } catch (ArgumentOutOfRangeException) {
+ }
+ }
+
+ [Ignore ("it breaks nunit-console.exe execution under .NET 2.0")]
+ [Test]
+ public void ResolveString ()
+ {
+ Type t = typeof (ModuleTest);
+ Module module = t.Module;
+
+ for (int i = 1; i < 10000; ++i) {
+ try {
+ module.ResolveString (0x70000000 + i);
+ } catch (Exception) {
+ }
+ }
+
+ try {
+ module.ResolveString (1234);
+ Assert.Fail ();
+ } catch (ArgumentException) {
+ }
+
+ try {
+ module.ResolveString (t.MetadataToken);
+ Assert.Fail ();
+ } catch (ArgumentException) {
+ }
+
+ try {
+ module.ResolveString (0x70000000 | 10000);
+ Assert.Fail ();
+ } catch (ArgumentOutOfRangeException) {
+ }
+ }
+
+
+ [Test]
+ public void ResolveMember ()
+ {
+ Type t = typeof (ModuleTest);
+ Module module = t.Module;
+
+ Assert.AreEqual (t, module.ResolveMember (t.MetadataToken), "#1");
+ Assert.AreEqual (t.GetField ("aField"), module.ResolveMember (t.GetField ("aField").MetadataToken), "#2");
+ Assert.AreEqual (t.GetMethod ("ResolveMember"), module.ResolveMember (t.GetMethod ("ResolveMember").MetadataToken), "#3");
+
+ try {
+ module.ResolveMember (module.MetadataToken);
+ Assert.Fail ("#4");
+ } catch (ArgumentException) {
+ }
+ }
+
+ public class Foo<T> {
+ public void Bar(T t) {}
+ }
+
+ [Test]
+ public void ResolveMethodOfGenericClass ()
+ {
+ Type type = typeof (Foo<>);
+ Module mod = type.Module;
+ MethodInfo method = type.GetMethod ("Bar");
+ MethodBase res = mod.ResolveMethod (method.MetadataToken);
+ Assert.AreEqual (method, res, "#1");
+ }
+
+ [Test]
+ public void FindTypes ()
+ {
+ Module m = typeof (ModuleTest).Module;
+
+ Type[] t;
+
+ t = m.FindTypes (Module.FilterTypeName, "FindTypesTest*");
+ Assert.AreEqual (2, t.Length, "#A1");
+ Assert.AreEqual ("FindTypesTestFirstClass", t [0].Name, "#A2");
+ Assert.AreEqual ("FindTypesTestSecondClass", t [1].Name, "#A3");
+ t = m.FindTypes (Module.FilterTypeNameIgnoreCase, "findtypestest*");
+ Assert.AreEqual (2, t.Length, "#B1");
+ Assert.AreEqual ("FindTypesTestFirstClass", t [0].Name, "#B2");
+ Assert.AreEqual ("FindTypesTestSecondClass", t [1].Name, "#B3");
+ }
[Test]
[ExpectedException (typeof (ArgumentNullException))]
public void GetObjectData_Null ()
{
- Module m = typeof (ModuleTest).Module;\r
- m.GetObjectData (null, new StreamingContext (StreamingContextStates.All));\r
- }\r
-\r
- class FindTypesTestFirstClass { \r
- }\r
-\r
- class FindTypesTestSecondClass {\r
- }\r
-\r
- private static void AssertArrayEqualsSorted (Array o1, Array o2) {\r
- Array s1 = (Array)o1.Clone ();\r
- Array s2 = (Array)o2.Clone ();\r
-\r
- Array.Sort (s1);\r
- Array.Sort (s2);\r
-\r
- AssertEquals (s1.Length, s2.Length);\r
- for (int i = 0; i < s1.Length; ++i)\r
- AssertEquals (s1.GetValue (i), s2.GetValue (i));\r
- }\r
-}\r
-}\r
-\r
+ Module m = typeof (ModuleTest).Module;
+ m.GetObjectData (null, new StreamingContext (StreamingContextStates.All));
+ }
+#if !MONOTOUCH
+ [Test]
+ [Category ("AndroidNotWorking")] // Mono.CompilerServices.SymbolWriter not available for Xamarin.Android
+ public void GetTypes ()
+ {
+ AssemblyName newName = new AssemblyName ();
+ newName.Name = "ModuleTest";
+
+ AssemblyBuilder ab = Thread.GetDomain().DefineDynamicAssembly (newName, AssemblyBuilderAccess.RunAndSave, TempFolder);
+
+ ModuleBuilder mb = ab.DefineDynamicModule ("myDynamicModule1", "myDynamicModule" + ".dll", true);
+
+ TypeBuilder tb = mb.DefineType ("Foo", TypeAttributes.Public);
+ tb.CreateType ();
+
+ ab.Save ("test_assembly.dll");
+
+ Assembly ass = Assembly.LoadFrom (Path.Combine (TempFolder, "test_assembly.dll"));
+ ArrayList types = new ArrayList ();
+ // The order of the modules is different between MS.NET and mono
+ foreach (Module m in ass.GetModules ()) {
+ Type[] t = m.GetTypes ();
+ types.AddRange (t);
+ }
+ Assert.AreEqual (1, types.Count);
+ Assert.AreEqual ("Foo", ((Type)(types [0])).Name);
+ }
+#endif
+ class FindTypesTestFirstClass {
+ }
+
+ class FindTypesTestSecondClass {
+ }
+
+ private static void AssertArrayEqualsSorted (Array o1, Array o2) {
+ Array s1 = (Array)o1.Clone ();
+ Array s2 = (Array)o2.Clone ();
+
+ Array.Sort (s1);
+ Array.Sort (s2);
+
+ Assert.AreEqual (s1.Length, s2.Length);
+ for (int i = 0; i < s1.Length; ++i)
+ Assert.AreEqual (s1.GetValue (i), s2.GetValue (i));
+ }
+}
+}
+
projects / mono.git / blobdiff