}
[Test]
+ [Category("NotWorking")]
public void TestGlobalMethods ()
{
AssemblyBuilder builder = genAssembly ();
CharSet.Auto);
method.SetImplementationFlags (MethodImplAttributes.PreserveSig |
method.GetMethodImplementationFlags ());
+
+ Assert.IsNull (module.GetMethod ("printf"), "#1");
+
module.CreateGlobalFunctions ();
- Assert.IsNotNull (module.GetMethod ("printf"));
+ Assert.IsNotNull (module.GetMethod ("printf"), "#2");
}
[Test]
+ [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
public void DefineType_Name_Null ()
{
AssemblyBuilder ab = genAssembly ();
}
[Test]
+ [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
public void DefineType_Name_Empty ()
{
AssemblyBuilder ab = genAssembly ();
}
[Test]
+ [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
public void DefineType_Name_NullChar ()
{
AssemblyBuilder ab = genAssembly ();
}
[Test]
+ [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
public void DefineType_InterfaceNotAbstract ()
{
AssemblyBuilder ab = genAssembly ();
}
// fail on MS .NET 1.1
-#if NET_2_0
TypeBuilder tb = mb.DefineType ("ITest2", TypeAttributes.Interface,
typeof (object));
Assert.AreEqual (typeof (object), tb.BaseType, "#C1");
tb = mb.DefineType ("ITest3", TypeAttributes.Interface,
typeof (IDisposable));
Assert.AreEqual (typeof (IDisposable), tb.BaseType, "#D1");
-#endif
}
[Test]
-#if ONLY_1_1
- [Category ("NotDotNet")] // Parent type was not extensible by the given type
-#endif
+ [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
public void DefineType_Parent_Interface ()
{
TypeBuilder tb;
}
[Test]
+ [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
+ public void DefineType_TypeSize ()
+ {
+ AssemblyBuilder ab = genAssembly ();
+ ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
+
+ TypeBuilder tb = mb.DefineType ("Foo", TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.SequentialLayout,
+ typeof (ValueType), 1);
+ Assert.AreEqual (1, tb.Size);
+ }
+
+ [Test]
+ [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
+ [ExpectedException (typeof (ArgumentException))]
+ public void DuplicateTypeName () {
+ AssemblyBuilder ab = genAssembly ();
+ ModuleBuilder module = ab.DefineDynamicModule ("foo.dll", "foo.dll", true);
+
+ var itb = module.DefineType ("TBase", TypeAttributes.Public);
+
+ itb.SetParent (typeof(ValueType));
+
+ var ptb = module.DefineType ("TBase", TypeAttributes.Public);
+
+ ptb.SetParent (typeof(Enum));
+ }
+
+ [Test]
+ [Category ("AndroidNotWorking")] // Missing Mono.CompilerServices.SymbolWriter assembly
public void DuplicateSymbolDocument ()
{
AssemblyBuilder ab = genAssembly ();
Assert.AreEqual (s1.GetValue (i), s2.GetValue (i), "#2: " + i);
}
-#if NET_2_0
[Test]
public void ResolveFieldTokenFieldBuilder ()
{
FieldBuilder fb = tb.DefineField ("foo", typeof (int), 0);
tb.CreateType ();
- FieldInfo fi = mb.ResolveField (fb.GetToken ().Token);
+ FieldInfo fi = mb.ResolveField (0x04000001);
+ Assert.IsNotNull (fi);
+ Assert.AreEqual ("foo", fi.Name);
+ }
+
+ [Test]
+ public void ResolveGenericFieldBuilderOnGenericTypeBuilder ()
+ {
+ AssemblyBuilder ab = genAssembly ();
+ ModuleBuilder mb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ TypeBuilder tb = mb.DefineType ("Foo`1");
+ var t = tb.DefineGenericParameters ("T") [0];
+ FieldBuilder fb = tb.DefineField ("foo", t, 0);
+ tb.CreateType ();
+
+ FieldInfo fi = mb.ResolveField (0x04000001);
Assert.IsNotNull (fi);
Assert.AreEqual ("foo", fi.Name);
}
Assert.IsNotNull (mi);
Assert.AreEqual ("Frub", mi.Name);
}
-#endif
+
+ [Test]
+ public void GetMethodTokenCrossMethodBuilders ()
+ {
+ AssemblyBuilder ab = genAssembly ();
+ ModuleBuilder moduleb = ab.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ TypeBuilder tb = moduleb.DefineType ("foo");
+ MethodBuilder mb = tb.DefineMethod("Frub", MethodAttributes.Static, null, new Type[] { typeof(IntPtr) });
+ int tok = mb.GetToken().Token;
+ mb.SetImplementationFlags(MethodImplAttributes.NoInlining);
+ ILGenerator ilgen = mb.GetILGenerator();
+ ilgen.Emit(OpCodes.Ret);
+
+ tb.CreateType ();
+
+ var mi = (MethodInfo) moduleb.ResolveMember (tok);
+ Assert.IsNotNull (mi);
+
+ ModuleBuilder moduleb2 = ab.DefineDynamicModule ("foo2.dll", "foo2.dll");
+ var tok2 = moduleb2.GetMethodToken (mi).Token;
+
+ MethodBase mi2 = moduleb.ResolveMethod (tok2);
+ Assert.IsNotNull (mi2);
+ Assert.AreEqual ("Frub", mi.Name);
+ }
+
+ [Test]
+ public void ResolveMemberField ()
+ {
+ var assembly = genAssembly ();
+ var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ var type = module.DefineType ("Foo");
+ var method = type.DefineMethod ("Str", MethodAttributes.Static, typeof (string), Type.EmptyTypes);
+ var il = method.GetILGenerator ();
+
+ il.Emit (OpCodes.Ldsfld, typeof (string).GetField ("Empty"));
+ il.Emit (OpCodes.Ret);
+
+ type.CreateType ();
+
+ var string_empty = (FieldInfo) module.ResolveMember (0x0a000001);
+ Assert.IsNotNull (string_empty);
+ Assert.AreEqual ("Empty", string_empty.Name);
+ Assert.AreEqual (typeof (string), string_empty.DeclaringType);
+ }
+
+ [Test]
+ public void ResolveMemberMethod ()
+ {
+ var assembly = genAssembly ();
+ var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ var type = module.DefineType ("Foo");
+ var method = type.DefineMethod ("Str", MethodAttributes.Static, typeof (void), Type.EmptyTypes);
+ var il = method.GetILGenerator ();
+
+ il.Emit (OpCodes.Call, typeof (Console).GetMethod ("WriteLine", Type.EmptyTypes));
+ il.Emit (OpCodes.Ret);
+
+ type.CreateType ();
+
+ var writeline = (MethodInfo) module.ResolveMember (0x0a000001);
+ Assert.IsNotNull (writeline);
+ Assert.AreEqual ("WriteLine", writeline.Name);
+ Assert.AreEqual (typeof (Console), writeline.DeclaringType);
+ }
+
+ [Test]
+ public void ResolveMethodDefWithGenericArguments ()
+ {
+ var assembly = genAssembly ();
+ var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ var type = module.DefineType ("Foo`1");
+ var t = type.DefineGenericParameters ("T") [0];
+
+ var method = type.DefineMethod ("Method", MethodAttributes.Static, typeof (void), new Type [] { t });
+ method.GetILGenerator ().Emit (OpCodes.Ret);
+
+ type.DefineDefaultConstructor (MethodAttributes.Public);
+
+ type.CreateType ();
+
+ var resolved_method = (MethodInfo) module.ResolveMember (0x06000001, new [] { typeof (string) }, Type.EmptyTypes);
+ Assert.IsNotNull (resolved_method);
+ Assert.AreEqual ("Method", resolved_method.Name);
+ Assert.IsTrue (resolved_method.GetParameters () [0].ParameterType.IsGenericParameter);
+ }
+
+ [Test]
+ public void ResolveFieldDefWithGenericArguments ()
+ {
+ var assembly = genAssembly ();
+ var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ var type = module.DefineType ("Foo`1");
+ var t = type.DefineGenericParameters ("T") [0];
+
+ var field = type.DefineField ("field", t, FieldAttributes.Public);
+
+ type.CreateType ();
+
+ var resolved_field = (FieldInfo) module.ResolveMember (0x04000001, new [] { typeof (string) }, Type.EmptyTypes);
+ Assert.IsNotNull (resolved_field);
+ Assert.AreEqual ("field", resolved_field.Name);
+ Assert.IsTrue (resolved_field.FieldType.IsGenericParameter);
+ }
+
+ [Test]
+ public void ResolveTypeDefWithGenericArguments ()
+ {
+ var assembly = genAssembly ();
+ var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ var type = module.DefineType ("Foo`1");
+ var t = type.DefineGenericParameters ("T") [0];
+
+ type.CreateType ();
+
+ var foo = (Type) module.ResolveMember (0x02000002, new [] { typeof (string) }, Type.EmptyTypes);
+ Assert.IsNotNull (foo);
+ Assert.AreEqual ("Foo`1", foo.Name);
+ Assert.IsTrue (foo.IsGenericTypeDefinition);
+ }
+
+ [Test]
+ public void ResolveFieldMemberRefWithGenericArguments ()
+ {
+ var assembly = genAssembly ();
+ var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ var type = module.DefineType ("Foo`1");
+ var t = type.DefineGenericParameters ("T") [0];
+
+ var field = type.DefineField ("field", t, FieldAttributes.Public);
+
+ var method = type.DefineMethod ("Method", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
+ var il = method.GetILGenerator ();
+
+ il.Emit (OpCodes.Ldarg_0);
+ il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
+ il.Emit (OpCodes.Pop);
+ il.Emit (OpCodes.Ret);
+
+ type.CreateType ();
+
+ var resolved_field = (FieldInfo) module.ResolveMember (0x0a000001, new [] { typeof (string) }, null);
+ Assert.IsNotNull (resolved_field);
+ Assert.AreEqual ("field", resolved_field.Name);
+ Assert.AreEqual (typeof (string), resolved_field.FieldType);
+ }
+
+ [Test]
+ public void ResolveMethodMemberRefWithGenericArguments ()
+ {
+ var assembly = genAssembly ();
+ var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ var type = module.DefineType ("Foo`1");
+ var t = type.DefineGenericParameters ("T") [0];
+
+ var field = type.DefineField ("field", t, FieldAttributes.Public);
+
+ var method = type.DefineMethod ("Method", MethodAttributes.Public, typeof (void), new Type [] { t });
+ method.GetILGenerator ().Emit (OpCodes.Ret);
+
+ var ctor = type.DefineMethod ("Caller", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
+ var il = ctor.GetILGenerator ();
+
+ il.Emit (OpCodes.Ldarg_0);
+ il.Emit (OpCodes.Ldarg_0);
+ il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
+ il.Emit (OpCodes.Callvirt, method); // this too
+ il.Emit (OpCodes.Ret);
+
+ type.DefineDefaultConstructor (MethodAttributes.Public);
+
+ type.CreateType ();
+
+ var resolved_method = (MethodInfo) module.ResolveMember (0x0a000002, new [] { typeof (string) }, null);
+ Assert.IsNotNull (resolved_method);
+ Assert.AreEqual ("Method", resolved_method.Name);
+ Assert.AreEqual (typeof (string), resolved_method.GetParameters () [0].ParameterType);
+ }
+
+ [Test]
+ public void ResolveMethodSpecWithGenericArguments ()
+ {
+ var assembly = genAssembly ();
+ var module = assembly.DefineDynamicModule ("foo.dll", "foo.dll");
+
+ var type = module.DefineType ("Foo`1");
+ var t = type.DefineGenericParameters ("T") [0];
+
+ var field = type.DefineField ("field", t, FieldAttributes.Public);
+
+ var method = type.DefineMethod ("Method", MethodAttributes.Public);
+ var s = method.DefineGenericParameters ("S") [0];
+ method.SetReturnType (typeof (void));
+ method.SetParameters (t, s);
+ method.GetILGenerator ().Emit (OpCodes.Ret);
+
+ var ctor = type.DefineMethod ("Caller", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
+ var il = ctor.GetILGenerator ();
+
+ il.Emit (OpCodes.Ldarg_0);
+ il.Emit (OpCodes.Ldarg_0);
+ il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
+ il.Emit (OpCodes.Ldarg_0);
+ il.Emit (OpCodes.Ldfld, field); // this triggers the creation of a MemberRef on a generic TypeSpec
+ il.Emit (OpCodes.Callvirt, method); // this triggers the creation of a MethodSpec
+ il.Emit (OpCodes.Ret);
+
+ type.DefineDefaultConstructor (MethodAttributes.Public);
+
+ type.CreateType ();
+
+ var resolved_method = (MethodInfo) module.ResolveMember (0x2b000001, new [] { typeof (string) }, new [] { typeof (int) });
+ Assert.IsNotNull (resolved_method);
+ Assert.AreEqual ("Method", resolved_method.Name);
+ Assert.AreEqual (typeof (string), resolved_method.GetParameters () [0].ParameterType);
+ Assert.AreEqual (typeof (int), resolved_method.GetParameters () [1].ParameterType);
+ }
[Test]
public void GetTypes ()
}
[Test] // GetTypeToken (Type)
-#if NET_2_0
[Category ("NotDotNet")] // http://support.microsoft.com/kb/950986
-#endif
public void GetTypeToken2_Type_Array ()
{
Type type;
type = typeof (object []);
typeToken = mb.GetTypeToken (type);
-#if NET_2_0
Assert.IsFalse (typeToken == TypeToken.Empty, "#A1");
resolved_type = mb.ResolveType (typeToken.Token);
Assert.AreEqual (type, resolved_type, "#A2");
-#else
- Assert.IsFalse (typeToken.Token == TypeToken.Empty.Token, "#A1");
-#endif
-#if NET_2_0
type = typeof (object).MakeArrayType ();
typeToken = mb.GetTypeToken (type);
Assert.IsFalse (typeToken == TypeToken.Empty, "#B1");
resolved_type = mb.ResolveType (typeToken.Token);
Assert.AreEqual (type, resolved_type, "#B2");
-#endif
}
[Test] // GetTypeToken (Type)
ModuleBuilder mb = ab.DefineDynamicModule ("MyModule");
Type type = typeof (string);
TypeToken typeToken = mb.GetTypeToken (type);
-#if NET_2_0
Assert.IsFalse (typeToken == TypeToken.Empty, "#1");
Type resolved_type = mb.ResolveType (typeToken.Token);
Assert.AreEqual (type, resolved_type, "#2");
-#else
- Assert.IsFalse (typeToken.Token == TypeToken.Empty.Token, "#1");
-#endif
}
-
-
+
+ [Test] // bug #471302
+ public void ModuleBuilder_ModuleVersionId ()
+ {
+ var name = new AssemblyName () { Name = "Foo" };
+ var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly (
+ name, AssemblyBuilderAccess.Run);
+
+ var module = assembly.DefineDynamicModule ("Foo");
+
+ Assert.AreNotEqual (new Guid (), module.ModuleVersionId);
+ }
+
[Test]
- public void GetGenericArguments_Returns_Null_For_Non_Generic_Methods ()
+ public void GetType_String_Null ()
{
-
+ AssemblyName an = genAssemblyName ();
+ AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
+ ModuleBuilder module = ab.DefineDynamicModule ("GetTypeNullCheck");
+
+ try {
+ module.GetType (null);
+ Assert.Fail ("Expected ArgumentNullException for GetType(string)");
+ }
+ catch (ArgumentNullException) {
+ }
+ try {
+ module.GetType (null, true); // ignoreCase
+ Assert.Fail ("Expected ArgumentNullException for GetType(string,bool)");
+ }
+ catch (ArgumentNullException) {
+ }
+ try {
+ module.GetType (null, true, true); // throwOnError, ignoreCase
+ Assert.Fail ("Expected ArgumentNullException for GetType(string,bool,bool)");
+ }
+ catch (ArgumentNullException) {
+ }
+ }
+
+ [Test]
+ public void GetType_String_Empty ()
+ {
+ AssemblyName an = genAssemblyName ();
+ AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
+ ModuleBuilder module = ab.DefineDynamicModule ("GetTypeEmptyCheck");
+
+ try {
+ module.GetType (String.Empty);
+ Assert.Fail ("Expected ArgumentNullException for GetType(string)");
+ }
+ catch (ArgumentException) {
+ }
+ try {
+ module.GetType (String.Empty, true); // ignoreCase
+ Assert.Fail ("Expected ArgumentNullException for GetType(string,bool)");
+ }
+ catch (ArgumentException) {
+ }
+ try {
+ module.GetType (String.Empty, true, true); // throwOnError, ignoreCase
+ Assert.Fail ("Expected ArgumentNullException for GetType(string,bool,bool)");
+ }
+ catch (ArgumentException) {
+ }
+ }
+
+ [Test]
+ public void GetMethodTokenNullParam ()
+ {
+ AssemblyName an = genAssemblyName ();
+ AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
+ ModuleBuilder module = ab.DefineDynamicModule ("mod");
+
+ var method = typeof (object).GetMethod ("GetType");
+
+ // ArgumentNullException should not occur.
+ module.GetMethodToken (method, null);
+ }
+
+ [Test]
+ public void GetConstructorTokenNullParam ()
+ {
+ AssemblyName an = genAssemblyName ();
+ AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly (an, AssemblyBuilderAccess.Run);
+ ModuleBuilder module = ab.DefineDynamicModule ("mod");
+
+ var method = typeof (object).GetConstructor (Type.EmptyTypes);
+
+ // ArgumentNullException should not occur.
+ module.GetConstructorToken (method, null);
}
}
}
projects / mono.git / blobdiff