[msbuild] Install a `deniedAssembliesList.txt` to support denied ... (#5358)

[mono.git] / mono / tests / delegate.cs

diff --git a/mono/tests/delegate.cs b/mono/tests/delegate.cs
index 8dcfcea0589e1022eabdab84207de9ca266b8f3b..fda09b6ccf12a0bd5e88a17fb60345e0c895bec2 100644 (file)
--- a/mono/tests/delegate.cs
+++ b/mono/tests/delegate.cs
@@ -1,8 +1,30 @@
 using System;
+using System.Runtime.InteropServices;
+
+class A {
+       public static bool b_cctor_run = false;
+}
+
+class B {
+       static B () {
+               A.b_cctor_run = true;
+       }
+       public static void method () {
+       }
+}
+
+delegate void DoIt ();
+
 namespace Bah {
-class Test {
+class Tests {
+       [DllImport("cygwin1.dll", EntryPoint="puts", CharSet=CharSet.Ansi)]
+       public static extern int puts (string name);
+
        delegate void SimpleDelegate ();
        delegate string NotSimpleDelegate (int a);
+       delegate int AnotherDelegate (string s);
+
+       delegate string StringDelegate (); 
        
        public int data;
        
@@ -19,15 +41,32 @@ class Test {
                        throw new Exception ("Something went wrong in H");
                return "H got: " + a.ToString () + " and " + data.ToString ();
        }
-       public Test () {
+
+       public virtual void VF () {
+               Console.WriteLine ("Test.VF from delegate");
+       }
+       
+       public Tests () {
                data = 5;
        }
-       static int Main () {
-               Test test = new Test ();
+
+       static int Main (String[] args) {
+               return TestDriver.RunTests (typeof (Tests), args);
+       }
+
+       public static int test_0_tests () {
+               // Check that creation of delegates do not runs the class cctor
+               DoIt doit = new DoIt (B.method);
+               if (A.b_cctor_run)
+                       return 1;
+
+               Tests test = new Tests ();
                SimpleDelegate d = new SimpleDelegate (F);
+               SimpleDelegate d1 = new SimpleDelegate (test.VF);
                NotSimpleDelegate d2 = new NotSimpleDelegate (G);
                NotSimpleDelegate d3 = new NotSimpleDelegate (test.H);
                d ();
+               d1 ();
                // we run G() and H() before and after using them as delegates
                // to be sure we don't corrupt them.
                G (2);
@@ -36,6 +75,138 @@ class Test {
                Console.WriteLine (d3 (3));
                G (2);
                test.H (3);
+
+               if (d.Method.Name != "F")
+                       return 1;
+
+               if (d3.Method == null)
+                       return 1;
+               
+               object [] args = {3};
+               Console.WriteLine (d3.DynamicInvoke (args));
+
+               AnotherDelegate d4 = new AnotherDelegate (puts);
+               if (d4.Method == null)
+                       return 1;
+
+               Console.WriteLine (d4.Method);
+               Console.WriteLine (d4.Method.Name);
+               Console.WriteLine (d4.Method.DeclaringType);
+               
+               return 0;
+       }
+
+       public static int test_0_unbox_this () {
+               int x = 10;
+               StringDelegate d5 = new StringDelegate (x.ToString);
+               return d5 () == "10" ? 0 : 1;
+       }
+
+       delegate long LongDelegate (long l);
+
+       static long long_delegate (long l) {
+               return l + 1;
+       }
+
+       public static int test_56_long () {
+               LongDelegate l = new LongDelegate (long_delegate);
+
+               return (int)l (55);
+       }
+
+       delegate float FloatDelegate (float l);
+
+       static float float_delegate (float l) {
+               return l + 1;
+       }
+
+       public static int test_56_float () {
+               FloatDelegate l = new FloatDelegate (float_delegate);
+
+               return (int)l (55);
+       }
+
+       delegate double DoubleDelegate (double l);
+
+       static double double_delegate (double l) {
+               return l + 1;
+       }
+
+       public static int test_56_double () {
+               DoubleDelegate l = new DoubleDelegate (double_delegate);
+
+               return (int)l (55);
+       }
+
+       static int count = 0;
+
+       public static void inc_count () {
+               count ++;
+       }
+
+       public static int test_0_multicast () {
+               SimpleDelegate d = new SimpleDelegate (inc_count);
+
+               d += inc_count;
+
+               d ();
+               return count == 2 ? 0 : 1;
+       }
+
+       public delegate int Delegate0 ();
+
+       public delegate int Delegate1 (int i);
+
+       public delegate int Delegate2 (int i, int j);
+
+       public int int_field;
+
+       public int adder0 () {
+               return int_field;
+       }
+
+       public static int adder0_static () {
+               return 1;
+       }
+
+       public int adder1 (int i) {
+               return int_field + i;
+       }
+
+       public static int adder1_static (int i) {
+               return i;
+       }
+
+       public int adder2 (int i, int j) {
+               return int_field + i + j;
+       }
+
+       public static int adder2_static (int i, int j) {
+               return i + j;
+       }
+
+       public static int test_0_delegate_opt () {
+               Tests d = new Tests ();
+               d.int_field = 1;
+
+               if (new Delegate0 (d.adder0) () != 1)
+                       return 1;
+
+               if (new Delegate1 (d.adder1) (2) != 3)
+                       return 2;
+
+               if (new Delegate2 (d.adder2) (2, 3) != 6)
+                       return 3;
+
+               if (new Delegate0 (adder0_static) () != 1)
+                       return 4;
+
+               if (new Delegate1 (adder1_static) (2) != 2)
+                       return 5;
+
+               if (new Delegate2 (adder2_static) (2, 3) != 5)
+                       return 6;
+
                return 0;
        }
 }