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
  11 class Class
  12 {
  13         internal int IntValue = 5;
  14         internal string StringStatic = "hi";
  15
  16         public const decimal Decimal = -0.3m;
  17
  18         uint s = 77;
  19         protected internal uint this[byte i] {
  20                 get {
  21                         return s * i;
  22                 }
  23                 set {
  24                         s = value;
  25                 }
  26         }
  27
  28         byte b = 180;
  29         internal byte Prop {
  30                 get {
  31                         return b;
  32                 }
  33                 set {
  34                         b = value;
  35                 }
  36         }
  37
  38         public int FixedValue
  39         {
  40                 set { }
  41                 get { return 823; }
  42         }
  43
  44         internal string Method (string value)
  45         {
  46                 return value;
  47         }
  48
  49         public static void GenericVoid<T> (T i)
  50         {
  51         }
  52
  53         public static int StaticMethod (params int[] i)
  54         {
  55                 return i [0] * i.Length;
  56         }
  57 }
  58
  59 class Tester
  60 {
  61         delegate void EmptyDelegate ();
  62         delegate int IntDelegate ();
  63
  64         static void Assert<T> (T expected, T value, string name)
  65         {
  66                 if (!EqualityComparer<T>.Default.Equals (expected, value)) {
  67                         name += ": ";
  68                         throw new ApplicationException (name + expected + " != " + value);
  69                 }
  70         }
  71
  72         static void AssertError (Action expected, string name)
  73         {
  74                 try {
  75                         expected ();
  76                         throw new ApplicationException (name + ": RuntimeBinderException expected");
  77                 } catch (RuntimeBinderException) {
  78                         // passed
  79                 }
  80         }
  81
  82 #pragma warning disable 169
  83
  84         void GetIndexTest ()
  85         {
  86                 dynamic d = new[] { 5, 8, 2 };
  87                 Assert (8, d[1], "#1");
  88
  89                 d = new int[,] { { 1, 2 }, { 3, 4 } };
  90                 Assert (3, d[1, 0], "#2");
  91
  92                 dynamic d2 = new Class ();
  93                 Assert<uint> (154, d2[2], "#3");
  94                 Assert<uint> (154, d2[i:2], "#3a");
  95         }
  96
  97         void GetIndexError_Null ()
  98         {
  99                 dynamic d = null;
 100                 AssertError (() => { var v = d[1]; }, "#1");
 101         }
 102
 103         void InvokeTest ()
 104         {
 105                 Func<string, string> f = new Class().Method;
 106                 dynamic d = f;
 107                 Assert ("bar", d ("bar"), "#1");
 108
 109                 Action<bool> f2 = Class.GenericVoid;
 110                 d = f2;
 111                 Assert<object> (null, d (true), "#2");
 112         }
 113
 114         void InvokeMember ()
 115         {
 116 //              dynamic d = new Class ();
 117 //              Assert ("vv", d.Method ("vv"), "#1");
 118
 119                 dynamic d = 2;
 120                 Assert (2, Class.StaticMethod (d), "#2");
 121         }
 122
 123         void MemberGetTest ()
 124         {
 125                 dynamic d = new Class ();
 126                 Assert (5, d.IntValue, "#1");
 127                 Assert (180, d.Prop, "#1a");
 128
 129                 Assert ("hi", d.StringStatic, "#2");
 130
 131                 d = new int[4];
 132                 Assert (4, d.Length, "#3");
 133
 134                 // d.Event += delegate () { }; CS0019
 135         }
 136
 137         void MemberGetError_Null ()
 138         {
 139                 dynamic d = null;
 140                 AssertError (() => { var v = d.Foo; }, "#1");
 141         }
 142
 143         void MemberSetTest ()
 144         {
 145                 dynamic d = new Class ();
 146
 147                 d.IntValue = 22;
 148                 Assert (22, d.IntValue, "#1");
 149                 d.Prop = 19;
 150                 Assert (19, d.Prop, "#1a");
 151
 152                 d.Prop = byte.MaxValue;
 153                 d.Prop++;
 154                 Assert (0, d.Prop, "#1b");
 155
 156                 d.StringStatic = "no";
 157                 Assert ("no", d.StringStatic, "#2");
 158
 159                 var r = d.FixedValue = 44;
 160                 Assert (44, r, "#3");
 161         }
 162
 163         void MemberSetError_Null ()
 164         {
 165                 dynamic d = null;
 166                 AssertError (() => { d.Fo1 = 1; }, "#1");
 167         }
 168
 169         void SetIndexTest ()
 170         {
 171                 dynamic d = new[] { "b", "v" };
 172                 d[1] = "c";
 173                 Assert ("c", d[1], "#1");
 174
 175                 d = new int[,] { { 1, 2 }, { 3, 4 } };
 176                 d[1, 0] = 100;
 177                 Assert (100, d[1, 0], "#2");
 178                 d[1, 0]++;
 179                 Assert (101, d[1, 0], "#2a");
 180
 181                 d [0, 0] = d [1, 0] = 55;
 182                 Assert (55, d [0, 0], "#2a");
 183
 184                 dynamic d2 = new Class ();
 185                 d2[2] = 500;
 186                 Assert<uint> (1000, d2[2], "#3");
 187                 d2[2]++;
 188                 Assert<uint> (2002, d2[2], "#3a");
 189                 d2[i:1] = 3;
 190                 Assert<uint> (3, d2[1], "#3b");
 191
 192                 uint r = d2 [1] = 200;
 193                 Assert<uint> (200, r, "#4");
 194         }
 195
 196         void SetIndexError_Null ()
 197         {
 198                 dynamic d = null;
 199                 AssertError (() => { d [1] = 0; }, "#1");
 200         }
 201
 202 #pragma warning restore 169
 203
 204         static bool RunTest (MethodInfo test)
 205         {
 206                 Console.Write ("Running test {0, -25}", test.Name);
 207                 try {
 208                         test.Invoke (new Tester (), null);
 209                         Console.WriteLine ("OK");
 210                         return true;
 211                 } catch (Exception e) {
 212                         Console.WriteLine ("FAILED");
 213                         Console.WriteLine (e.ToString ());
 214                         //                      Console.WriteLine (e.InnerException.Message);
 215                         return false;
 216                 }
 217         }
 218
 219         public static int Main ()
 220         {
 221                 var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
 222                                         where test.GetParameters ().Length == 0
 223                                         orderby test.Name
 224                                         select RunTest (test);
 225
 226                 int failures = tests.Count (a => !a);
 227                 Console.WriteLine (failures + " tests failed");
 228                 return failures;
 229         }
 230 }
 231