tests/dtest-007.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using System.Reflection;
   5 using Microsoft.CSharp.RuntimeBinder;
   6
   7 // Dynamic member lookup tests
   8
   9 delegate void D ();
  10 delegate void D2 (decimal d);
  11
  12 class Class
  13 {
  14         internal int IntValue = 5;
  15         internal string StringStatic = "hi";
  16
  17         public const decimal Decimal = -0.3m;
  18
  19         public Class ()
  20         {
  21         }
  22
  23         public Class (sbyte extra)
  24         {
  25                 IntValue = extra;
  26         }
  27
  28         uint s = 77;
  29         protected internal uint this[byte i] {
  30                 get {
  31                         return s * i;
  32                 }
  33                 set {
  34                         s = value;
  35                 }
  36         }
  37
  38         byte b = 180;
  39         internal byte Prop {
  40                 get {
  41                         return b;
  42                 }
  43                 set {
  44                         b = value;
  45                 }
  46         }
  47
  48         public int FixedValue
  49         {
  50                 set { }
  51                 get { return 823; }
  52         }
  53
  54         internal string Method (string value)
  55         {
  56                 return value;
  57         }
  58
  59         public int Method (int a, byte b)
  60         {
  61                 return a * b;
  62         }
  63
  64         public void MethodInOut (ref int refValue, out string outValue)
  65         {
  66                 refValue = 3;
  67                 outValue = "4";
  68         }
  69
  70         public static void GenericVoid<T> (T i)
  71         {
  72         }
  73
  74         public static int StaticMethod (params int[] i)
  75         {
  76                 return i [0] * i.Length;
  77         }
  78 }
  79
  80 class Tester
  81 {
  82         static void Assert<T> (T expected, T value, string name)
  83         {
  84                 if (!EqualityComparer<T>.Default.Equals (expected, value)) {
  85                         name += ": ";
  86                         throw new ApplicationException (name + expected + " != " + value);
  87                 }
  88         }
  89
  90         static void AssertError (Action expected, string name)
  91         {
  92                 try {
  93                         expected ();
  94                         throw new ApplicationException (name + ": RuntimeBinderException expected");
  95                 } catch (RuntimeBinderException) {
  96                         // passed
  97                 }
  98         }
  99
 100 #pragma warning disable 169
 101
 102         void GetIndexTest ()
 103         {
 104                 dynamic d = new[] { 5, 8, 2 };
 105                 Assert (8, d[1], "#1");
 106
 107                 d = new int[,] { { 1, 2 }, { 3, 4 } };
 108                 Assert (3, d[1, 0], "#2");
 109
 110                 dynamic d2 = new Class ();
 111                 Assert<uint> (154, d2[2], "#3");
 112                 Assert<uint> (154, d2[i:2], "#3a");
 113         }
 114
 115         void GetIndexError_Null ()
 116         {
 117                 dynamic d = null;
 118                 AssertError (() => { var v = d[1]; }, "#1");
 119         }
 120
 121         void InvokeTest ()
 122         {
 123                 Func<string, string> f = new Class().Method;
 124                 dynamic d = f;
 125                 Assert ("bar", d ("bar"), "#1");
 126
 127                 Action<bool> f2 = Class.GenericVoid;
 128                 d = f2;
 129                 d (true);
 130
 131                 Func<string, int> f3 = (s) => 3;
 132                 d = f3;
 133                 d ("go");
 134         }
 135
 136         void InvokeMember ()
 137         {
 138                 dynamic d = new Class ();
 139                 Assert ("vv", d.Method ("vv"), "#1");
 140
 141                 byte b = 2;
 142                 Assert (6, d.Method (b: b++, a: b), "#1a");
 143
 144                 var arg1 = 1;
 145                 var arg2 = "a";
 146                 d.MethodInOut (ref arg1, out arg2);
 147
 148                 d = 2;
 149                 Assert (2, Class.StaticMethod (d), "#2");
 150                 Class.StaticMethod (d);
 151         }
 152
 153         void InvokeConstructor ()
 154         {
 155                 dynamic d = (sbyte) 8;
 156                 var r = new Class (d);
 157                 Assert (8, r.IntValue, "#1");
 158
 159                 D2 method = (decimal e) => { };
 160                 d = method;
 161                 var r2 = new D2 (d);
 162         }
 163
 164         event Func<int> e;
 165         int field;
 166         void IsEvent ()
 167         {
 168                 dynamic d = this;
 169                 d.e += new Func<int> (() => 3);
 170
 171                 // FIXME:
 172                 //Assert (3, d.e (), "#1");
 173
 174                 d.field += 5;
 175                 Assert (5, d.field, "#2");
 176         }
 177
 178         void MemberGetTest ()
 179         {
 180                 dynamic d = new Class ();
 181                 Assert (5, d.IntValue, "#1");
 182                 Assert (180, d.Prop, "#1a");
 183
 184                 Assert ("hi", d.StringStatic, "#2");
 185
 186                 d = new int[4];
 187                 Assert (4, d.Length, "#3");
 188         }
 189
 190         void MemberGetError_Null ()
 191         {
 192                 dynamic d = null;
 193                 AssertError (() => { var v = d.Foo; }, "#1");
 194         }
 195
 196         void MemberSetTest ()
 197         {
 198                 dynamic d = new Class ();
 199
 200                 d.IntValue = 22;
 201                 Assert (22, d.IntValue, "#1");
 202                 d.Prop = 19;
 203                 Assert (19, d.Prop, "#1a");
 204
 205                 d.Prop = byte.MaxValue;
 206                 Assert (byte.MaxValue, d.Prop++, "#1b");
 207                 Assert (1, ++d.Prop, "#1c");
 208                 d.Prop++;
 209                 Assert (2, d.Prop, "#1d");
 210
 211                 d.Prop += 5;
 212                 Assert (7, d.Prop, "#1e");
 213
 214                 d.StringStatic = "no";
 215                 Assert ("no", d.StringStatic, "#2");
 216
 217                 var r = d.FixedValue = 44;
 218                 Assert (44, r, "#3");
 219         }
 220
 221         void MemberSetError_Null ()
 222         {
 223                 dynamic d = null;
 224                 AssertError (() => { d.Fo1 = 1; }, "#1");
 225         }
 226
 227         void SetIndexTest ()
 228         {
 229                 dynamic d = new[] { "b", "v" };
 230                 d[1] = "c";
 231                 Assert ("c", d[1], "#1");
 232
 233                 d = new int[,] { { 1, 2 }, { 3, 4 } };
 234                 d[1, 0] = 100;
 235                 Assert (100, d[1, 0], "#2");
 236                 d[1, 0]++;
 237                 Assert (101, d[1, 0], "#2a");
 238
 239                 d [0, 0] = d [1, 0] = 55;
 240                 Assert (55, d [0, 0], "#2a");
 241
 242                 dynamic d2 = new Class ();
 243                 d2[2] = 500;
 244                 Assert<uint> (1000, d2[2], "#3");
 245                 d2[2]++;
 246                 Assert<uint> (2002, d2[2], "#3a");
 247                 d2[i:1] = 3;
 248                 Assert<uint> (3, d2[1], "#3b");
 249
 250                 uint r = d2 [1] = 200;
 251                 Assert<uint> (200, r, "#4");
 252         }
 253
 254         void SetIndexError_Null ()
 255         {
 256                 dynamic d = null;
 257                 AssertError (() => { d [1] = 0; }, "#1");
 258         }
 259
 260 #pragma warning restore 169
 261
 262         static bool RunTest (MethodInfo test)
 263         {
 264                 Console.Write ("Running test {0, -25}", test.Name);
 265                 try {
 266                         test.Invoke (new Tester (), null);
 267                         Console.WriteLine ("OK");
 268                         return true;
 269                 } catch (Exception e) {
 270                         Console.WriteLine ("FAILED");
 271                         Console.WriteLine (e.ToString ());
 272                         //                      Console.WriteLine (e.InnerException.Message);
 273                         return false;
 274                 }
 275         }
 276
 277         public static int Main ()
 278         {
 279                 var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
 280                                         where test.GetParameters ().Length == 0
 281                                         orderby test.Name
 282                                         select RunTest (test);
 283
 284                 int failures = tests.Count (a => !a);
 285                 Console.WriteLine (failures + " tests failed");
 286                 return failures;
 287         }
 288 }
 289