Assert.AreEqual ("FOO", ((ObsoleteAttribute) attrs [0]).Message, "#B3");
}
}
-
+#if !NET_2_1
[Test]
[ExpectedException (typeof (InvalidOperationException))]
public void TestAddDeclarativeSecurityAlreadyCreated ()
mb.AddDeclarativeSecurity (SecurityAction.Demand, set);
mb.AddDeclarativeSecurity (SecurityAction.Demand, set);
}
-
+#endif
[AttributeUsage (AttributeTargets.Parameter)]
class ParamAttribute : Attribute
{
Assert.AreEqual (99, rt, "#1");
}
+ public static void VarargMethod (string headline, __arglist) {
+ ArgIterator ai = new ArgIterator (__arglist);
+
+ Console.Write (headline);
+ while (ai.GetRemainingCount () > 0)
+ Console.Write (TypedReference.ToObject (ai.GetNextArg ()));
+ Console.WriteLine ();
+ }
+
+ [Test]//bug #626441
+ public void CanCallVarargMethods ()
+ {
+ var tb = module.DefineType ("foo");
+ MethodBuilder mb = tb.DefineMethod ("CallVarargMethod",
+ MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard,
+ typeof (void), Type.EmptyTypes);
+
+ ILGenerator il = mb.GetILGenerator ();
+ MethodInfo miVarargMethod = typeof (MethodBuilderTest).GetMethod ("VarargMethod");
+
+ il.Emit (OpCodes.Ldstr, "Hello world from ");
+ il.Emit (OpCodes.Call, typeof(Assembly).GetMethod ("GetExecutingAssembly"));
+ il.EmitCall (OpCodes.Call, miVarargMethod, new Type[] { typeof(Assembly) });
+
+ il.Emit (OpCodes.Ldstr, "Current time: ");
+ il.Emit (OpCodes.Call, typeof(DateTime).GetMethod("get_Now"));
+ il.Emit (OpCodes.Ldstr, " (UTC ");
+ il.Emit (OpCodes.Call, typeof(DateTime).GetMethod("get_UtcNow"));
+ il.Emit (OpCodes.Ldstr, ")");
+ il.EmitCall (OpCodes.Call, miVarargMethod, new Type[] { typeof (DateTime), typeof (string), typeof (DateTime), typeof (string) });
+ il.Emit (OpCodes.Ret);
+
+ Type type = tb.CreateType ();
+ type.GetMethod ("CallVarargMethod").Invoke (null, null);
+ }
+
+ public static string GenericMethodWithOneArg<T> (T t)
+ {
+ return t.ToString ();
+ }
+
+ [Test]
+ public void ParamerersOfGenericArgumentsAreProperlyEncoded ()
+ {
+ var type = module.DefineType (
+ "Bar",
+ TypeAttributes.Public
+ | TypeAttributes.Abstract
+ | TypeAttributes.Sealed,
+ typeof (object));
+
+ var foo_method = typeof (MethodBuilderTest).GetMethod ("GenericMethodWithOneArg");
+
+ var method = type.DefineMethod (
+ "ReFoo",
+ MethodAttributes.Static | MethodAttributes.Public,
+ typeof (string),
+ new [] { foo_method.GetGenericArguments () [0] });
+ method.DefineGenericParameters ("K");
+
+ var il = method.GetILGenerator ();
+ il.Emit (OpCodes.Ldarga, 0);
+ il.Emit (OpCodes.Constrained, method.GetGenericArguments () [0]);
+ il.Emit (OpCodes.Callvirt, typeof (object).GetMethod ("ToString"));
+ il.Emit (OpCodes.Ret);
+
+ type.CreateType ();
+
+ var re_foo_open = module.GetType ("Bar").GetMethod ("ReFoo");
+
+ Assert.AreEqual (re_foo_open.GetGenericArguments ()[0], re_foo_open.GetParameters () [0].ParameterType, "#1");
+ }
+
+ [Test] // #628660
+ public void CanCallGetMethodBodyOnDynamicImageMethod ()
+ {
+ var type = module.DefineType (
+ "CanCallGetMethodBodyOnDynamicImageMethod",
+ TypeAttributes.Public,
+ typeof (object));
+
+ var baz = type.DefineMethod ("Foo", MethodAttributes.Public | MethodAttributes.Static, typeof (object), Type.EmptyTypes);
+
+ var il = baz.GetILGenerator ();
+ var temp = il.DeclareLocal (typeof (object));
+ il.Emit (OpCodes.Ldnull);
+ il.Emit (OpCodes.Stloc, temp);
+ il.Emit (OpCodes.Ldloc, temp);
+ il.Emit (OpCodes.Ret);
+
+ var body = type.CreateType ().GetMethod ("Foo").GetMethodBody ();
+
+ Assert.IsNotNull (body);
+ Assert.AreEqual (1, body.LocalVariables.Count);
+ Assert.AreEqual (typeof (object), body.LocalVariables [0].LocalType);
+ }
+
+
+ [Test] //#384127
+ public void GetGenericArgumentsReturnsNullForNonGenericMethod ()
+ {
+ var tb = module.DefineType ("Base");
+
+ var mb = tb.DefineMethod ("foo", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
+
+ Assert.IsNull (mb.GetGenericArguments ());
+
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void SetConstantIllegalType ()
+ {
+ var tb = module.DefineType ("Base");
+
+ var mb = tb.DefineMethod ("foo", MethodAttributes.Public, typeof (void), new Type [] { typeof (decimal) });
+ ParameterBuilder pb = mb.DefineParameter (1, ParameterAttributes.In, "foo");
+ pb.SetConstant (5m);
+ }
+
+ public interface ITest
+ {
+ T[] Method<T>(T[] value);
+ }
+
+ [Test]
+ // #7964
+ public void ArrayOfGenericParam ()
+ {
+ var tb = module.DefineType ("Base");
+
+ tb.AddInterfaceImplementation (typeof (ITest));
+
+ var testMethod = tb.DefineMethod ("Method", MethodAttributes.Public | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.HideBySig, CallingConventions.HasThis);
+
+ var testParameters = Array.ConvertAll (testMethod.DefineGenericParameters("T"), b => (Type)b);
+
+ var returnType = testParameters[0].MakeArrayType();
+
+ testMethod.SetParameters (testParameters[0].MakeArrayType());
+ testMethod.SetReturnType (returnType);
+
+ var testIl = testMethod.GetILGenerator ();
+ testIl.Emit (OpCodes.Ldarg_1);
+ testIl.Emit (OpCodes.Castclass, returnType);
+ testIl.Emit (OpCodes.Ret);
+
+ var t = tb.CreateType ();
+
+ var test = (ITest) Activator.CreateInstance (t);
+
+ var o = new int[0];
+ var returnValue = test.Method (o);
+
+ Assert.AreEqual (o, returnValue);
+ }
}
}