Merge pull request #5675 from mono/glib-debug-symbols

[mono.git] / mcs / tests / dtest-007.cs

diff --git a/mcs/tests/dtest-007.cs b/mcs/tests/dtest-007.cs
index 8ef69011fbdbc18ea165003ff6a2087d27d0f637..ec92b623dbf4639437df32248944c3eb0d267e40 100644 (file)
--- a/mcs/tests/dtest-007.cs
+++ b/mcs/tests/dtest-007.cs
@@ -7,6 +7,7 @@ using Microsoft.CSharp.RuntimeBinder;
 // Dynamic member lookup tests
 
 delegate void D ();
+delegate void D2 (decimal d);
 
 class Class
 {
@@ -15,6 +16,15 @@ class Class
 
        public const decimal Decimal = -0.3m;
 
+       public Class ()
+       {
+       }
+
+       public Class (sbyte extra)
+       {
+               IntValue = extra;
+       }
+
        uint s = 77;
        protected internal uint this[byte i] {
                get {
@@ -45,6 +55,17 @@ class Class
        {
                return value;
        }
+       
+       public int Method (int a, byte b)
+       {
+               return a * b;
+       }
+
+       public void MethodInOut (ref int refValue, out string outValue)
+       {
+               refValue = 3;
+               outValue = "4";
+       }
 
        public static void GenericVoid<T> (T i)
        {
@@ -54,13 +75,24 @@ class Class
        {
                return i [0] * i.Length;
        }
+       
+       public static void ArglistMethod (__arglist)
+       {
+       }
 }
 
-class Tester
+class EventClass
 {
-       delegate void EmptyDelegate ();
-       delegate int IntDelegate ();
+       internal event Func<int> OutEvent;
+       
+       public int CallEvent ()
+       {
+               return OutEvent ();
+       }
+}
 
+class Tester
+{
        static void Assert<T> (T expected, T value, string name)
        {
                if (!EqualityComparer<T>.Default.Equals (expected, value)) {
@@ -78,6 +110,10 @@ class Tester
                        // passed
                }
        }
+       
+       event Func<int> e;
+       int field;
+
 
 #pragma warning disable 169
 
@@ -108,16 +144,65 @@ class Tester
 
                Action<bool> f2 = Class.GenericVoid;
                d = f2;
-               Assert<object> (null, d (true), "#2");
+               d (true);
+               
+               Func<string, int> f3 = (s) => 3;
+               d = f3;
+               d ("go");
        }
 
        void InvokeMember ()
        {
-//             dynamic d = new Class ();
-//             Assert ("vv", d.Method ("vv"), "#1");
+               dynamic d = new Class ();
+               Assert ("vv", d.Method ("vv"), "#1");
+               
+               byte b = 2;
+               Assert (6, d.Method (b: b++, a: b), "#1a");
+
+               var arg1 = 1;
+               var arg2 = "a";
+               d.MethodInOut (ref arg1, out arg2);
 
-               dynamic d = 2;
+               d = 2;
                Assert (2, Class.StaticMethod (d), "#2");
+               Class.StaticMethod (d); 
+       }
+       
+       void InvokeMember_Error ()
+       {
+               AssertError (() => {
+                               dynamic d_arg = "a";
+                               Class.ArglistMethod (d_arg);
+                       }, "#1");
+       }
+
+       void InvokeConstructor ()
+       {
+               dynamic d = (sbyte) 8;
+               var r = new Class (d);
+               Assert (8, r.IntValue, "#1");
+
+               D2 method = (decimal e) => { };
+               d = method;
+               var r2 = new D2 (d);
+       }
+
+       void IsEvent ()
+       {
+               dynamic d = this;
+               d.e += new Func<int> (() => 3);
+               Assert (3, d.e (), "#1");
+               
+               d.field += 5;
+               Assert (5, d.field, "#2");
+               
+               int r = d.field += 7;
+               Assert (12, r, "#2a");
+               Assert (12, d.field, "#2b");
+               
+               d = new EventClass ();
+               d.OutEvent += new Func<int> (() => 100);
+               Assert (100, d.CallEvent (), "#3");
        }
 
        void MemberGetTest ()
@@ -130,8 +215,6 @@ class Tester
 
                d = new int[4];
                Assert (4, d.Length, "#3");
-
-               // d.Event += delegate () { }; CS0019
        }
 
        void MemberGetError_Null ()
@@ -150,8 +233,13 @@ class Tester
                Assert (19, d.Prop, "#1a");
 
                d.Prop = byte.MaxValue;
+               Assert (byte.MaxValue, d.Prop++, "#1b");
+               Assert (1, ++d.Prop, "#1c");
                d.Prop++;
-               Assert (0, d.Prop, "#1b");
+               Assert (2, d.Prop, "#1d");
+               
+               d.Prop += 5;
+               Assert (7, d.Prop, "#1e");
 
                d.StringStatic = "no";
                Assert ("no", d.StringStatic, "#2");