tests/dtest-003.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using System.Reflection;
   5 using System.Dynamic;
   6 using System.Linq.Expressions;
   7 using Microsoft.CSharp.RuntimeBinder;
   8
   9 enum Enum
  10 {
  11         A = 3
  12 }
  13
  14 class AssertDynamicObject : DynamicMetaObject
  15 {
  16         DynamicObjectMock mock;
  17
  18         public AssertDynamicObject (DynamicObjectMock mock, Expression parameter)
  19                 : base (parameter, BindingRestrictions.Empty, mock)
  20         {
  21                 this.mock = mock;
  22         }
  23
  24         DynamicMetaObject GetFakeMetaObject (object value)
  25         {
  26                 Type t = value == null ? typeof (object) : value.GetType ();
  27                 var v = Expression.Variable (t);
  28                 Expression e = Expression.Block (new[] { v }, Expression.Default (t));
  29
  30                 Expression restr = Expression.Constant (true);
  31                 return new DynamicMetaObject (e, BindingRestrictions.GetExpressionRestriction (restr));
  32         }
  33
  34         public override DynamicMetaObject BindBinaryOperation (BinaryOperationBinder binder, DynamicMetaObject arg)
  35         {
  36                 if (mock.BinaryOperation == null)
  37                         throw new ApplicationException ("Unexpected BindBinaryOperation");
  38
  39                 mock.BinaryOperation ((CSharpBinaryOperationBinder) binder, arg.Value);
  40
  41                 return GetFakeMetaObject (new object ());
  42         }
  43
  44         public override DynamicMetaObject BindConvert (ConvertBinder binder)
  45         {
  46                 if (mock.ConvertOperation == null)
  47                         throw new ApplicationException ("Unexpected BindConvert");
  48
  49                 var r = mock.ConvertOperation ((CSharpConvertBinder) binder);
  50
  51                 return GetFakeMetaObject (r);
  52         }
  53
  54         public override DynamicMetaObject BindGetIndex (GetIndexBinder binder, DynamicMetaObject[] indexes)
  55         {
  56                 if (mock.GetIndexOperation == null)
  57                         throw new ApplicationException ("Unexpected TryGetIndex");
  58
  59                 mock.GetIndexOperation ((CSharpGetIndexBinder) binder, indexes.Select (l => l.Value).ToArray ());
  60
  61                 return GetFakeMetaObject (new object ());
  62         }
  63
  64         public override DynamicMetaObject BindGetMember (GetMemberBinder binder)
  65         {
  66                 if (mock.GetMemberOperation == null)
  67                         throw new ApplicationException ("Unexpected BindGetMember");
  68
  69                 mock.GetMemberOperation ((CSharpGetMemberBinder) binder);
  70
  71                 return GetFakeMetaObject (new object ());
  72         }
  73
  74         public override DynamicMetaObject BindInvoke (InvokeBinder binder, DynamicMetaObject[] args)
  75         {
  76                 if (mock.InvokeOperation == null)
  77                         throw new ApplicationException ("Unexpected BindInvoke");
  78
  79                 mock.InvokeOperation ((CSharpInvokeBinder) binder, args.Select (l => l.Value).ToArray ());
  80
  81                 return GetFakeMetaObject (new object ());
  82         }
  83
  84         public override DynamicMetaObject BindInvokeMember (InvokeMemberBinder binder, DynamicMetaObject[] args)
  85         {
  86                 if (mock.InvokeMemberOperation == null)
  87                         throw new ApplicationException ("Unexpected BindInvokeMember");
  88
  89                 mock.InvokeMemberOperation ((CSharpInvokeMemberBinder) binder, args.Select (l => l.Value).ToArray ());
  90
  91                 return GetFakeMetaObject (new object ());
  92         }
  93
  94         public override DynamicMetaObject BindSetIndex (SetIndexBinder binder, DynamicMetaObject[] indexes, DynamicMetaObject value)
  95         {
  96                 if (mock.SetIndexOperation == null)
  97                         throw new ApplicationException ("Unexpected TrySetIndex");
  98
  99                 mock.SetIndexOperation ((CSharpSetIndexBinder) binder, indexes.Select (l => l.Value).ToArray (), value.Value);
 100
 101                 return GetFakeMetaObject (new object ());
 102         }
 103
 104         public override DynamicMetaObject BindSetMember (SetMemberBinder binder, DynamicMetaObject value)
 105         {
 106                 if (mock.SetMemberOperation == null)
 107                         throw new ApplicationException ("Unexpected BindSetMember");
 108
 109                 mock.SetMemberOperation ((CSharpSetMemberBinder) binder, value.Value);
 110
 111                 return GetFakeMetaObject (new object ());
 112         }
 113
 114         public override DynamicMetaObject BindUnaryOperation (UnaryOperationBinder binder)
 115         {
 116                 if (mock.UnaryOperation == null)
 117                         throw new ApplicationException ("Unexpected BindUnaryOperation");
 118
 119                 var r = mock.UnaryOperation ((CSharpUnaryOperationBinder) binder);
 120
 121                 return GetFakeMetaObject (r);
 122         }
 123
 124 }
 125
 126 class DynamicObjectMock : DynamicObject
 127 {
 128         public int HitCounter;
 129
 130         public DynamicObjectMock ()
 131         {
 132         }
 133
 134         public override DynamicMetaObject GetMetaObject (System.Linq.Expressions.Expression parameter)
 135         {
 136                 HitCounter++;
 137                 return new AssertDynamicObject (this, parameter);
 138         }
 139
 140         public Action<CSharpBinaryOperationBinder, object> BinaryOperation;
 141         public Func<CSharpConvertBinder, object> ConvertOperation;
 142         public Action<CSharpGetIndexBinder, object[]> GetIndexOperation;
 143         public Action<CSharpGetMemberBinder> GetMemberOperation;
 144         public Action<CSharpInvokeBinder, object[]> InvokeOperation;
 145         public Action<CSharpInvokeMemberBinder, object[]> InvokeMemberOperation;
 146         public Action<CSharpSetIndexBinder, object[], object> SetIndexOperation;
 147         public Action<CSharpSetMemberBinder, object> SetMemberOperation;
 148         public Func<CSharpUnaryOperationBinder, object> UnaryOperation;
 149
 150         // Dynamic arguments methods
 151         public DynamicObjectMock (int i)
 152         {
 153         }
 154
 155         public void DMethod (int a)
 156         {
 157         }
 158
 159         public static void DStaticMethod (object t)
 160         {
 161         }
 162
 163         public int this[int i] {
 164                 get {
 165                         return i;
 166                 }
 167                 set { }
 168         }
 169
 170 }
 171
 172 class Tester : DynamicObjectMock
 173 {
 174         static readonly int field = 7;
 175
 176         public Tester ()
 177         {
 178         }
 179
 180         public Tester (dynamic d)
 181         {
 182         }
 183
 184         static void Assert<T> (T expected, T value, string name)
 185         {
 186                 if (!EqualityComparer<T>.Default.Equals (expected, value)) {
 187                         if (!string.IsNullOrEmpty (name))
 188                                 name += ": ";
 189                         throw new ApplicationException (name + expected + " != " + value);
 190                 }
 191         }
 192
 193         static void Assert<T> (IList<T> expected, IList<T> value, string name)
 194         {
 195                 if (expected == null) {
 196                         if (value != null)
 197                                 throw new ApplicationException (name + ": Both arrays expected to be null");
 198                         return;
 199                 }
 200
 201                 if (expected.Count != value.Count)
 202                         throw new ApplicationException (name + ": Array length does not match " + expected.Count + " != " + value.Count);
 203
 204                 for (int i = 0; i < expected.Count; ++i) {
 205                         if (!EqualityComparer<T>.Default.Equals (expected[i], value[i]))
 206                                 throw new ApplicationException (name + ": Index " + i + ": " + expected[i] + " != " + value[i]);
 207                 }
 208         }
 209
 210 #pragma warning disable 168, 169, 219
 211
 212         void BinaryAdd_1 (dynamic d, DynamicObjectMock mock)
 213         {
 214                 mock.BinaryOperation = (binder, arg) => {
 215                         Assert (binder.Operation, ExpressionType.Add, "Operation");
 216                         Assert (binder.IsChecked, false, "IsChecked");
 217                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 218                         Assert (binder.ArgumentInfo, new [] {
 219                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 220                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 221                                 "ArgumentInfo");
 222
 223                         Assert (arg, 1, "arg");
 224                 };
 225
 226                 d = d + 1;
 227         }
 228
 229         void BinaryAdd_2 (dynamic d, DynamicObjectMock mock)
 230         {
 231                 mock.BinaryOperation = (binder, arg) => {
 232                         Assert (binder.Operation, ExpressionType.Add, "Operation");
 233                         Assert (binder.IsChecked, false, "IsChecked");
 234                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 235                         Assert (binder.ArgumentInfo, new[] {
 236                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 237                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 238                                 "ArgumentInfo");
 239
 240                         Assert (arg, null, "arg");
 241                 };
 242
 243                 int? v = null;
 244                 d = d + v;
 245         }
 246
 247         void BinaryAdd_3 (dynamic d, DynamicObjectMock mock)
 248         {
 249                 mock.BinaryOperation = (binder, arg) => {
 250                         Assert (binder.Operation, ExpressionType.Add, "Operation");
 251                         Assert (binder.IsChecked, false, "IsChecked");
 252                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 253                         Assert (binder.ArgumentInfo, new[] {
 254                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 255                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.LiteralConstant, null)     // CSC bug?
 256                         }, "ArgumentInfo");
 257
 258                         Assert (arg, Enum.A, "arg");
 259                 };
 260
 261                 d = d + Enum.A;
 262         }
 263
 264         void BinaryAdd_4 (dynamic d, DynamicObjectMock mock)
 265         {
 266                 mock.BinaryOperation = (binder, arg) => {
 267                         Assert (binder.Operation, ExpressionType.Add, "Operation");
 268                         Assert (binder.IsChecked, false, "IsChecked");
 269                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 270                         Assert (binder.ArgumentInfo, new[] {
 271                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 272                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 273                                 "ArgumentInfo");
 274
 275                         Assert (arg, 7, "arg");
 276                 };
 277
 278                 d = d + Tester.field;
 279         }
 280
 281         void BinaryAddChecked_1 (dynamic d, DynamicObjectMock mock)
 282         {
 283                 mock.BinaryOperation = (binder, arg) => {
 284                         Assert (binder.Operation, ExpressionType.Add, "Operation");
 285                         Assert (binder.IsChecked, true, "IsChecked");
 286                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 287                         Assert (binder.ArgumentInfo, new[] {
 288                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 289                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.LiteralConstant, null) },
 290                                 "ArgumentInfo");
 291
 292                         Assert (arg, 3, "arg");
 293                 };
 294
 295                 d = checked (d + 3);
 296         }
 297
 298         void BinaryAddChecked_2 (dynamic d, DynamicObjectMock mock)
 299         {
 300                 mock.BinaryOperation = (binder, arg) => {
 301                         Assert (binder.Operation, ExpressionType.Add, "Operation");
 302                         Assert (binder.IsChecked, true, "IsChecked");
 303                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 304                         Assert (binder.ArgumentInfo, new[] {
 305                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 306                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.LiteralConstant, null) },
 307                                 "ArgumentInfo");
 308
 309                         Assert (arg, 3, "arg");
 310                 };
 311
 312                 Func<dynamic> r;
 313                 checked {
 314                         r = () => d + 3;
 315                 }
 316
 317                 r ();
 318         }
 319
 320         void BinaryAddAssign_1 (dynamic d, DynamicObjectMock mock)
 321         {
 322                 mock.BinaryOperation = (binder, arg) => {
 323                         Assert (binder.Operation, ExpressionType.AddAssign, "Operation");
 324                         Assert (binder.IsChecked, false, "IsChecked");
 325                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 326                         Assert (binder.ArgumentInfo, new[] {
 327                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 328                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 329                                 "ArgumentInfo");
 330
 331                         Assert (arg, 1, "arg");
 332                 };
 333
 334                 d += 1;
 335         }
 336
 337         void BinaryAddAssignChecked_1 (dynamic d, DynamicObjectMock mock)
 338         {
 339                 mock.BinaryOperation = (binder, arg) => {
 340                         Assert (binder.Operation, ExpressionType.AddAssign, "Operation");
 341                         Assert (binder.IsChecked, true, "IsChecked");
 342                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 343                         Assert (binder.ArgumentInfo, new[] {
 344                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 345                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 346                                 "ArgumentInfo");
 347
 348                         Assert (arg, 1, "arg");
 349                 };
 350
 351                 checked {
 352                         d += 1;
 353                 }
 354         }
 355
 356         void BinaryAnd_1 (dynamic d, DynamicObjectMock mock)
 357         {
 358                 mock.BinaryOperation = (binder, arg) => {
 359                         Assert (binder.Operation, ExpressionType.And, "Operation");
 360                         Assert (binder.IsChecked, false, "IsChecked");
 361                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 362                         Assert (binder.ArgumentInfo, new[] {
 363                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 364                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 365                                 "ArgumentInfo");
 366
 367                         Assert (arg, 1, "arg");
 368                 };
 369
 370                 d = d & 1;
 371         }
 372
 373         void BinaryAndAssign_1 (dynamic d, DynamicObjectMock mock)
 374         {
 375                 mock.BinaryOperation = (binder, arg) => {
 376                         Assert (binder.Operation, ExpressionType.AndAssign, "Operation");
 377                         Assert (binder.IsChecked, false, "IsChecked");
 378                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 379                         Assert (binder.ArgumentInfo, new[] {
 380                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 381                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 382                                 "ArgumentInfo");
 383
 384                         Assert (arg, 1, "arg");
 385                 };
 386
 387                 d &= 1;
 388         }
 389
 390         void BinaryDivide_1 (dynamic d, DynamicObjectMock mock)
 391         {
 392                 mock.BinaryOperation = (binder, arg) => {
 393                         Assert (binder.Operation, ExpressionType.Divide, "Operation");
 394                         Assert (binder.IsChecked, false, "IsChecked");
 395                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 396                         Assert (binder.ArgumentInfo, new[] {
 397                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 398                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 399                                 "ArgumentInfo");
 400
 401                         Assert (arg, 1, "arg");
 402                 };
 403
 404                 d = d / 1;
 405         }
 406
 407         void BinaryDivideAssign_1 (dynamic d, DynamicObjectMock mock)
 408         {
 409                 mock.BinaryOperation = (binder, arg) => {
 410                         Assert (binder.Operation, ExpressionType.DivideAssign, "Operation");
 411                         Assert (binder.IsChecked, false, "IsChecked");
 412                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 413                         Assert (binder.ArgumentInfo, new[] {
 414                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 415                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 416                                 "ArgumentInfo");
 417
 418                         Assert (arg, 1, "arg");
 419                 };
 420
 421                 d /= 1;
 422         }
 423
 424         void BinaryEqual_1 (dynamic d, DynamicObjectMock mock)
 425         {
 426                 mock.BinaryOperation = (binder, arg) => {
 427                         Assert (binder.Operation, ExpressionType.Equal, "Operation");
 428                         Assert (binder.IsChecked, false, "IsChecked");
 429                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 430                         Assert (binder.ArgumentInfo, new[] {
 431                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 432                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 433                                 "ArgumentInfo");
 434
 435                         Assert (arg, 1, "arg");
 436                 };
 437
 438                 d = d == 1;
 439         }
 440
 441         void BinaryExclusiveOr_1 (dynamic d, DynamicObjectMock mock)
 442         {
 443                 mock.BinaryOperation = (binder, arg) => {
 444                         Assert (binder.Operation, ExpressionType.ExclusiveOr, "Operation");
 445                         Assert (binder.IsChecked, false, "IsChecked");
 446                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 447                         Assert (binder.ArgumentInfo, new[] {
 448                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 449                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 450                                 "ArgumentInfo");
 451
 452                         Assert (arg, 1, "arg");
 453                 };
 454
 455                 d = d ^ 1;
 456         }
 457
 458         void BinaryExclusiveOrAssign_1 (dynamic d, DynamicObjectMock mock)
 459         {
 460                 mock.BinaryOperation = (binder, arg) => {
 461                         Assert (binder.Operation, ExpressionType.ExclusiveOrAssign, "Operation");
 462                         Assert (binder.IsChecked, false, "IsChecked");
 463                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 464                         Assert (binder.ArgumentInfo, new[] {
 465                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 466                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 467                                 "ArgumentInfo");
 468
 469                         Assert (arg, 1, "arg");
 470                 };
 471
 472                 d ^= 1;
 473         }
 474
 475         void BinaryGreaterThan_1 (dynamic d, DynamicObjectMock mock)
 476         {
 477                 mock.BinaryOperation = (binder, arg) => {
 478                         Assert (binder.Operation, ExpressionType.GreaterThan, "Operation");
 479                         Assert (binder.IsChecked, false, "IsChecked");
 480                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 481                         Assert (binder.ArgumentInfo, new[] {
 482                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 483                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 484                                 "ArgumentInfo");
 485
 486                         Assert (arg, 1, "arg");
 487                 };
 488
 489                 d = d > 1;
 490         }
 491
 492         void BinaryGreaterThanOrEqual_1 (dynamic d, DynamicObjectMock mock)
 493         {
 494                 mock.BinaryOperation = (binder, arg) => {
 495                         Assert (binder.Operation, ExpressionType.GreaterThanOrEqual, "Operation");
 496                         Assert (binder.IsChecked, false, "IsChecked");
 497                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 498                         Assert (binder.ArgumentInfo, new[] {
 499                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 500                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 501                                 "ArgumentInfo");
 502
 503                         Assert (arg, 1, "arg");
 504                 };
 505
 506                 d = d >= 1;
 507         }
 508
 509         void BinaryLeftShift_1 (dynamic d, DynamicObjectMock mock)
 510         {
 511                 mock.BinaryOperation = (binder, arg) => {
 512                         Assert (binder.Operation, ExpressionType.LeftShift, "Operation");
 513                         Assert (binder.IsChecked, false, "IsChecked");
 514                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 515                         Assert (binder.ArgumentInfo, new[] {
 516                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 517                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 518                                 "ArgumentInfo");
 519
 520                         Assert (arg, 1, "arg");
 521                 };
 522
 523                 d = d << 1;
 524         }
 525
 526         void BinaryLeftShiftAssign_1 (dynamic d, DynamicObjectMock mock)
 527         {
 528                 mock.BinaryOperation = (binder, arg) => {
 529                         Assert (binder.Operation, ExpressionType.LeftShiftAssign, "Operation");
 530                         Assert (binder.IsChecked, false, "IsChecked");
 531                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 532                         Assert (binder.ArgumentInfo, new[] {
 533                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 534                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 535                                 "ArgumentInfo");
 536
 537                         Assert (arg, 1, "arg");
 538                 };
 539
 540                 d <<= 1;
 541         }
 542
 543         void BinaryLessThan_1 (dynamic d, DynamicObjectMock mock)
 544         {
 545                 mock.BinaryOperation = (binder, arg) => {
 546                         Assert (binder.Operation, ExpressionType.LessThan, "Operation");
 547                         Assert (binder.IsChecked, false, "IsChecked");
 548                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 549                         Assert (binder.ArgumentInfo, new[] {
 550                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 551                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 552                                 "ArgumentInfo");
 553
 554                         Assert (arg, 1, "arg");
 555                 };
 556
 557                 d = d < 1;
 558         }
 559
 560         void BinaryLessThanOrEqual_1 (dynamic d, DynamicObjectMock mock)
 561         {
 562                 mock.BinaryOperation = (binder, arg) => {
 563                         Assert (binder.Operation, ExpressionType.LessThanOrEqual, "Operation");
 564                         Assert (binder.IsChecked, false, "IsChecked");
 565                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 566                         Assert (binder.ArgumentInfo, new[] {
 567                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 568                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 569                                 "ArgumentInfo");
 570
 571                         Assert (arg, 1, "arg");
 572                 };
 573
 574                 d = d <= 1;
 575         }
 576
 577         void BinaryModulo_1 (dynamic d, DynamicObjectMock mock)
 578         {
 579                 mock.BinaryOperation = (binder, arg) => {
 580                         Assert (binder.Operation, ExpressionType.Modulo, "Operation");
 581                         Assert (binder.IsChecked, false, "IsChecked");
 582                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 583                         Assert (binder.ArgumentInfo, new[] {
 584                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 585                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 586                                 "ArgumentInfo");
 587
 588                         Assert (arg, 1, "arg");
 589                 };
 590
 591                 d = d % 1;
 592         }
 593
 594         void BinaryModuloAssign_1 (dynamic d, DynamicObjectMock mock)
 595         {
 596                 mock.BinaryOperation = (binder, arg) => {
 597                         Assert (binder.Operation, ExpressionType.ModuloAssign, "Operation");
 598                         Assert (binder.IsChecked, false, "IsChecked");
 599                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 600                         Assert (binder.ArgumentInfo, new[] {
 601                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 602                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 603                                 "ArgumentInfo");
 604
 605                         Assert (arg, 1, "arg");
 606                 };
 607
 608                 d %= 1;
 609         }
 610
 611         void BinaryMultiply_1 (dynamic d, DynamicObjectMock mock)
 612         {
 613                 mock.BinaryOperation = (binder, arg) => {
 614                         Assert (binder.Operation, ExpressionType.Multiply, "Operation");
 615                         Assert (binder.IsChecked, false, "IsChecked");
 616                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 617                         Assert (binder.ArgumentInfo, new[] {
 618                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 619                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 620                                 "ArgumentInfo");
 621
 622                         Assert (arg, 1, "arg");
 623                 };
 624
 625                 d = d * 1;
 626         }
 627
 628         void BinaryMultiplyAssign_1 (dynamic d, DynamicObjectMock mock)
 629         {
 630                 mock.BinaryOperation = (binder, arg) => {
 631                         Assert (binder.Operation, ExpressionType.MultiplyAssign, "Operation");
 632                         Assert (binder.IsChecked, false, "IsChecked");
 633                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 634                         Assert (binder.ArgumentInfo, new[] {
 635                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 636                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 637                                 "ArgumentInfo");
 638
 639                         Assert (arg, 1, "arg");
 640                 };
 641
 642                 d *= 1;
 643         }
 644
 645         void BinaryNotEqual_1 (dynamic d, DynamicObjectMock mock)
 646         {
 647                 mock.BinaryOperation = (binder, arg) => {
 648                         Assert (binder.Operation, ExpressionType.NotEqual, "Operation");
 649                         Assert (binder.IsChecked, false, "IsChecked");
 650                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 651                         Assert (binder.ArgumentInfo, new[] {
 652                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 653                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 654                                 "ArgumentInfo");
 655
 656                         Assert (arg, 4, "arg");
 657                 };
 658
 659                 d = d != 4;
 660         }
 661
 662         void BinaryOr_1 (dynamic d, DynamicObjectMock mock)
 663         {
 664                 mock.BinaryOperation = (binder, arg) => {
 665                         Assert (binder.Operation, ExpressionType.Or, "Operation");
 666                         Assert (binder.IsChecked, false, "IsChecked");
 667                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 668                         Assert (binder.ArgumentInfo, new[] {
 669                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 670                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 671                                 "ArgumentInfo");
 672
 673                         Assert (arg, 2, "arg");
 674                 };
 675
 676                 d = d | 2;
 677         }
 678
 679         void BinaryOrAssign_1 (dynamic d, DynamicObjectMock mock)
 680         {
 681                 mock.BinaryOperation = (binder, arg) => {
 682                         Assert (binder.Operation, ExpressionType.OrAssign, "Operation");
 683                         Assert (binder.IsChecked, false, "IsChecked");
 684                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 685                         Assert (binder.ArgumentInfo, new[] {
 686                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 687                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 688                                 "ArgumentInfo");
 689
 690                         Assert (arg, 2, "arg");
 691                 };
 692
 693                 d |= 2;
 694         }
 695
 696         void BinaryRightShift_1 (dynamic d, DynamicObjectMock mock)
 697         {
 698                 mock.BinaryOperation = (binder, arg) => {
 699                         Assert (binder.Operation, ExpressionType.RightShift, "Operation");
 700                         Assert (binder.IsChecked, false, "IsChecked");
 701                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 702                         Assert (binder.ArgumentInfo, new[] {
 703                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 704                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 705                                 "ArgumentInfo");
 706
 707                         Assert (arg, 1, "arg");
 708                 };
 709
 710                 d = d >> 1;
 711         }
 712
 713         void BinaryRightShiftAssign_1 (dynamic d, DynamicObjectMock mock)
 714         {
 715                 mock.BinaryOperation = (binder, arg) => {
 716                         Assert (binder.Operation, ExpressionType.RightShiftAssign, "Operation");
 717                         Assert (binder.IsChecked, false, "IsChecked");
 718                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 719                         Assert (binder.ArgumentInfo, new[] {
 720                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 721                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 722                                 "ArgumentInfo");
 723
 724                         Assert (arg, 1, "arg");
 725                 };
 726
 727                 d >>= 1;
 728         }
 729
 730         void BinarySubtract_1 (dynamic d, DynamicObjectMock mock)
 731         {
 732                 mock.BinaryOperation = (binder, arg) => {
 733                         Assert (binder.Operation, ExpressionType.Subtract, "Operation");
 734                         Assert (binder.IsChecked, false, "IsChecked");
 735                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 736                         Assert (binder.ArgumentInfo, new[] {
 737                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 738                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 739                                 "ArgumentInfo");
 740
 741                         Assert (arg, 1, "arg");
 742                 };
 743
 744                 d = d - 1;
 745         }
 746
 747         void BinarySubtractAssign_1 (dynamic d, DynamicObjectMock mock)
 748         {
 749                 mock.BinaryOperation = (binder, arg) => {
 750                         Assert (binder.Operation, ExpressionType.SubtractAssign, "Operation");
 751                         Assert (binder.IsChecked, false, "IsChecked");
 752                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
 753                         Assert (binder.ArgumentInfo, new[] {
 754                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 755                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 756                                 "ArgumentInfo");
 757
 758                         Assert (arg, 1, "arg");
 759                 };
 760
 761                 d -= 1;
 762         }
 763
 764         void Convert_1 (dynamic d, DynamicObjectMock mock)
 765         {
 766                 mock.ConvertOperation = (binder) => {
 767                         Assert (binder.Explicit, true, "Explicit");
 768                         Assert (binder.IsChecked, false, "IsChecked");
 769                         Assert (binder.Type, typeof (byte), "Type");
 770                         return (byte) 1;
 771                 };
 772
 773                 object b = (byte) d;
 774         }
 775
 776         void Convert_2 (dynamic d, DynamicObjectMock mock)
 777         {
 778                 mock.ConvertOperation = (binder) => {
 779                         Assert (binder.Explicit, false, "Explicit");
 780                         Assert (binder.IsChecked, false, "IsChecked");
 781                         Assert (binder.Type, typeof (int), "Type");
 782                         return 2;
 783                 };
 784
 785                 object[] o = new object [2];
 786                 d = o[d];
 787         }
 788
 789         void Convert_3 (dynamic d, DynamicObjectMock mock)
 790         {
 791                 mock.ConvertOperation = (binder) => {
 792                         Assert (binder.Explicit, true, "Explicit");
 793                         Assert (binder.IsChecked, true, "IsChecked");
 794                         Assert (binder.Type, typeof (byte), "Type");
 795                         return (byte) 2;
 796                 };
 797
 798                 object b = checked((byte) d);
 799         }
 800
 801         void Convert_4 (dynamic d, DynamicObjectMock mock)
 802         {
 803                 mock.ConvertOperation = (binder) => {
 804                         Assert (binder.Explicit, false, "Explicit");
 805                         Assert (binder.IsChecked, false, "IsChecked");
 806                         Assert (binder.Type, typeof (int), "Type");
 807                         return 5;
 808                 };
 809
 810                 var g = new int[d];
 811         }
 812
 813         void GetIndex_1 (dynamic d, DynamicObjectMock mock)
 814         {
 815                 mock.GetIndexOperation = (binder, args) => {
 816                         Assert (binder.CallInfo, new CallInfo (1, new string[0]), "CallInfo");
 817                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 818                         Assert (binder.ArgumentInfo, new[] {
 819                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 820                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 821                                 "ArgumentInfo");
 822
 823                         Assert ((IList<object>)args, new object[] { 0 }, "args");
 824                 };
 825
 826                 var o = d [0];
 827         }
 828
 829         void GetIndex_2 (dynamic d, DynamicObjectMock mock)
 830         {
 831                 mock.GetIndexOperation = (binder, args) => {
 832                         Assert (binder.CallInfo, new CallInfo (2, new string[0]), "CallInfo");
 833                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 834                         Assert (binder.ArgumentInfo, new[] {
 835                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 836                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null),
 837                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 838                         "ArgumentInfo");
 839
 840                         Assert ((IList<object>) args, new object[] { 2, 3 }, "args");
 841                 };
 842
 843                 object i = 3;
 844                 var o = d[2, i];
 845         }
 846
 847         void GetIndex_3 (dynamic d, DynamicObjectMock mock)
 848         {
 849                 mock.GetIndexOperation = (binder, args) => {
 850                         Assert (binder.CallInfo, new CallInfo (1, new string[0]), "CallInfo");
 851                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 852                         Assert (binder.ArgumentInfo, new[] {
 853                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null),
 854                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null) },
 855                                 "ArgumentInfo");
 856
 857                         Assert ((IList<object>) args, new object[] { d }, "args");
 858                 };
 859
 860                 var o = mock[d];
 861         }
 862
 863         void GetMember_1 (dynamic d, DynamicObjectMock mock)
 864         {
 865                 mock.GetMemberOperation = (binder) => {
 866                         Assert (binder.Name, "Foo", "Name");
 867                         Assert (binder.IgnoreCase, false, "IgnoreCase");
 868                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 869                         Assert (binder.ArgumentInfo, new[] {
 870                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null) },
 871                                 "ArgumentInfo");
 872                 };
 873
 874                 var g = d.Foo;
 875         }
 876
 877         void Invoke_1 (dynamic d, DynamicObjectMock mock)
 878         {
 879                 mock.InvokeOperation = (binder, args) => {
 880                         Assert (binder.CallInfo, new CallInfo (2, new string[0]), "CallInfo");
 881                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 882                         Assert (binder.ArgumentInfo, new[] {
 883                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 884                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null),
 885                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null)
 886                         },      "ArgumentInfo");
 887
 888                         Assert ((IList<object>) args, new object[] { "foo", null }, "args");
 889                 };
 890
 891                 d ("foo", null);
 892         }
 893
 894         void Invoke_2 (dynamic d, DynamicObjectMock mock)
 895         {
 896                 mock.InvokeOperation = (binder, args) => {
 897                         Assert (binder.CallInfo, new CallInfo (0, new string[0]), "CallInfo");
 898                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 899                         Assert (binder.ArgumentInfo, new[] {
 900                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null) },
 901                                 "ArgumentInfo");
 902
 903                         Assert ((IList<object>) args, new object[0], "args");
 904                 };
 905
 906                 d ();
 907         }
 908
 909         void Invoke_3 (dynamic d, DynamicObjectMock mock)
 910         {
 911                 try {
 912                         Math.Max (d, d);
 913                         Assert (true, false, "No hook expected to be hit");
 914                 } catch (RuntimeBinderException) {
 915                 }
 916         }
 917
 918         void Invoke_4 (dynamic d, DynamicObjectMock mock)
 919         {
 920                 mock.InvokeOperation = (binder, args) => {
 921                         Assert (binder.CallInfo, new CallInfo (2, new string[] { "name" }), "CallInfo");
 922                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 923                         Assert (binder.ArgumentInfo, new[] {
 924                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 925                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null),
 926                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.NamedArgument | CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.LiteralConstant, "name")   // CSC bug?
 927                         }, "ArgumentInfo");
 928
 929                         Assert ((IList<object>) args, new object[] { typeof (bool), -1 }, "args");
 930                 };
 931
 932                 d (typeof (bool), name:-1);
 933         }
 934
 935         void InvokeMember_1 (dynamic d, DynamicObjectMock mock)
 936         {
 937                 mock.InvokeMemberOperation = (binder, args) => {
 938                         Assert (binder.CallInfo, new CallInfo (1, new string[0]), "CallInfo");
 939                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 940                         Assert (binder.ArgumentInfo, new[] {
 941                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 942                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null)},
 943                                 "ArgumentInfo");
 944
 945                         Assert (binder.Flags, CSharpCallFlags.None, "Flags");
 946                         Assert (binder.IgnoreCase, false, "IgnoreCase");
 947                         Assert (binder.TypeArguments, new Type[0], "TypeArguments");
 948
 949                         Assert ((IList<object>) args, new object[] { 'a' }, "args");
 950                 };
 951
 952                 d.Max ('a');
 953         }
 954
 955         void InvokeMember_2 (dynamic d, DynamicObjectMock mock)
 956         {
 957                 mock.InvokeMemberOperation = (binder, args) => {
 958                         Assert (binder.CallInfo, new CallInfo (1, new string[0]), "CallInfo");
 959                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 960                         Assert (binder.ArgumentInfo, new[] {
 961                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null),
 962                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)},
 963                                 "ArgumentInfo");
 964
 965                         Assert (binder.Flags, CSharpCallFlags.None, "Flags");
 966                         Assert (binder.IgnoreCase, false, "IgnoreCase");
 967                         Assert (binder.TypeArguments, new Type[0], "TypeArguments");
 968
 969                         Assert ((IList<object>) args, new object[] { mock }, "args");
 970                 };
 971
 972                 mock.DMethod (d);
 973         }
 974
 975         void InvokeMember_3 (dynamic d, DynamicObjectMock mock)
 976         {
 977                 mock.InvokeMemberOperation = (binder, args) => {
 978                         Assert (binder.CallInfo, new CallInfo (1, new string[0]), "CallInfo");
 979                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
 980                         Assert (binder.ArgumentInfo, new[] {
 981                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
 982                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.IsRef | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
 983                                 "ArgumentInfo");
 984
 985                         Assert (binder.Flags, CSharpCallFlags.None, "Flags");
 986                         Assert (binder.IgnoreCase, false, "IgnoreCase");
 987                         Assert (binder.TypeArguments, new Type[0], "TypeArguments");
 988
 989                         Assert ((IList<object>) args, new object[] { 9 }, "args");
 990                 };
 991
 992                 int i = 9;
 993                 d.Max (ref i);
 994         }
 995
 996         void InvokeMember_4 (dynamic d, DynamicObjectMock mock)
 997         {
 998                 mock.InvokeMemberOperation = (binder, args) => {
 999                         Assert (binder.CallInfo, new CallInfo (1, new string[0]), "CallInfo");
1000                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
1001                         Assert (binder.ArgumentInfo, new[] {
1002                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1003                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.IsOut | CSharpArgumentInfoFlags.UseCompileTimeType, null)       },
1004                                 "ArgumentInfo");
1005
1006                         Assert (binder.Flags, CSharpCallFlags.None, "Flags");
1007                         Assert (binder.IgnoreCase, false, "IgnoreCase");
1008                         Assert (binder.TypeArguments, new Type[0], "TypeArguments");
1009
1010                         Assert ((IList<object>) args, new object[] { 0 }, "args");
1011                 };
1012
1013                 int i;
1014                 d.Max (out i);
1015         }
1016
1017         void InvokeMember_5 (dynamic d, DynamicObjectMock mock)
1018         {
1019                 DynamicObjectMock.DStaticMethod (d);
1020         }
1021
1022         void InvokeMember_6 (dynamic d, DynamicObjectMock mock)
1023         {
1024                 InvokeMemberOperation = (binder, args) => {
1025                         Assert (binder.CallInfo, new CallInfo (2, new string[0]), "CallInfo");
1026                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
1027                         Assert (binder.ArgumentInfo, new[] {
1028                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null),
1029                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1030                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.LiteralConstant, null),
1031                         }, "ArgumentInfo");
1032                         Assert (binder.Flags, CSharpCallFlags.SimpleNameCall, "Flags");
1033                         Assert (binder.IgnoreCase, false, "IgnoreCase");
1034                         Assert (binder.TypeArguments, Type.EmptyTypes, "TypeArguments");
1035
1036                         Assert ((IList<object>) args, new object[] { d, null }, "args");
1037                 };
1038
1039                 InvokeMember_5 (d, null);
1040         }
1041
1042         void InvokeMember_7 (dynamic d, DynamicObjectMock mock)
1043         {
1044                 mock.InvokeMemberOperation = (binder, args) => {
1045                         Assert (binder.CallInfo, new CallInfo (0, new string[0]), "CallInfo");
1046                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
1047                         Assert (binder.ArgumentInfo, new[] {
1048                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1049                         }, "ArgumentInfo");
1050                         Assert (binder.Flags, CSharpCallFlags.None, "Flags");
1051                         Assert (binder.IgnoreCase, false, "IgnoreCase");
1052                         Assert (binder.TypeArguments, new Type[] { typeof (object) }, "TypeArguments");
1053
1054                         Assert ((IList<object>) args, new object[0], "args");
1055                 };
1056
1057                 d.Max<dynamic> ();
1058         }
1059
1060         void SetIndex_1 (dynamic d, DynamicObjectMock mock)
1061         {
1062                 mock.SetIndexOperation = (binder, args, value) => {
1063                         Assert (binder.CallInfo, new CallInfo (1, new string[0]), "CallInfo");
1064                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
1065                         Assert (binder.ArgumentInfo, new[] {
1066                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1067                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null),
1068                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null)},
1069                                 "ArgumentInfo");
1070
1071                         Assert ((IList<object>) args, new object[] { 0 }, "args");
1072                         Assert (value, 2m, "value");
1073                 };
1074
1075                 d[0] = 2m;
1076         }
1077
1078         void SetIndex_2 (dynamic d, DynamicObjectMock mock)
1079         {
1080                 mock.SetIndexOperation = (binder, args, value) => {
1081                         Assert (binder.CallInfo, new CallInfo (2, new string[0]), "CallInfo");
1082                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
1083                         Assert (binder.ArgumentInfo, new[] {
1084                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1085                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null),
1086                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null),
1087                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null)
1088                         }, "ArgumentInfo");
1089
1090                         Assert ((IList<object>) args, new object[] { 2, 3 }, "args");
1091                         Assert (value, -8, "value");
1092                 };
1093
1094                 object i = 3;
1095                 d[2, i] = -8;
1096         }
1097
1098         void SetIndex_3 (dynamic d, DynamicObjectMock mock)
1099         {
1100                 mock.SetIndexOperation = (binder, args, value) => {
1101                         Assert (binder.CallInfo, new CallInfo (1, new string[0]), "CallInfo");
1102                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
1103                         Assert (binder.ArgumentInfo, new[] {
1104                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null),
1105                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1106                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType, null)
1107                         }, "ArgumentInfo");
1108
1109                         Assert ((IList<object>) args, new object[] { d }, "args");
1110                         Assert (value, this, "value");
1111                 };
1112
1113                 mock[d] = this;
1114         }
1115
1116         void SetMember_1 (dynamic d, DynamicObjectMock mock)
1117         {
1118                 const double d_const = 2.4;
1119
1120                 mock.SetMemberOperation = (binder, value) => {
1121                         Assert (binder.Name, "Foo", "Name");
1122                         Assert (binder.IgnoreCase, false, "IgnoreCase");
1123                         Assert (binder.CallingContext, typeof (Tester), "CallingContext");
1124                         Assert (binder.ArgumentInfo, new[] {
1125                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1126                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.LiteralConstant, null)     // CSC bug?
1127                         },      "ArgumentInfo");
1128
1129                         Assert (value, d_const, "value");
1130                 };
1131
1132                 d.Foo = d_const;
1133         }
1134
1135         void UnaryPlus_1 (dynamic d, DynamicObjectMock mock)
1136         {
1137                 mock.UnaryOperation = (binder) => {
1138                         Assert (binder.Operation, ExpressionType.UnaryPlus, "Operation");
1139                         Assert (binder.IsChecked, false, "IsChecked");
1140                         Assert (binder.ArgumentInfo, new[] {
1141                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1142                         }, "ArgumentInfo");
1143
1144                         return null;
1145                 };
1146
1147                 d = +d;
1148         }
1149
1150         void UnaryMinus_1 (dynamic d, DynamicObjectMock mock)
1151         {
1152                 mock.UnaryOperation = (binder) => {
1153                         Assert (binder.Operation, ExpressionType.Negate, "Operation");
1154                         Assert (binder.IsChecked, false, "IsChecked");
1155                         Assert (binder.ArgumentInfo, new[] {
1156                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1157                         }, "ArgumentInfo");
1158
1159                         return null;
1160                 };
1161
1162                 d = -d;
1163         }
1164
1165         void UnaryNot_1 (dynamic d, DynamicObjectMock mock)
1166         {
1167                 mock.UnaryOperation = (binder) => {
1168                         Assert (binder.Operation, ExpressionType.Not, "Operation");
1169                         Assert (binder.IsChecked, false, "IsChecked");
1170                         Assert (binder.ArgumentInfo, new[] {
1171                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1172                         }, "ArgumentInfo");
1173
1174                         return null;
1175                 };
1176
1177                 d = !d;
1178         }
1179
1180         void UnaryOnesComplement_1 (dynamic d, DynamicObjectMock mock)
1181         {
1182                 mock.UnaryOperation = (binder) => {
1183                         Assert (binder.Operation, ExpressionType.OnesComplement, "Operation");
1184                         Assert (binder.IsChecked, false, "IsChecked");
1185                         Assert (binder.ArgumentInfo, new[] {
1186                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1187                         }, "ArgumentInfo");
1188
1189                         return null;
1190                 };
1191
1192                 d = ~d;
1193         }
1194
1195         void UnaryDecrement_1 (dynamic d, DynamicObjectMock mock)
1196         {
1197                 mock.UnaryOperation = (binder) => {
1198                         Assert (binder.Operation, ExpressionType.Decrement, "Operation");
1199                         Assert (binder.IsChecked, false, "IsChecked");
1200                         Assert (binder.ArgumentInfo, new[] {
1201                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1202                         }, "ArgumentInfo");
1203
1204                         return null;
1205                 };
1206
1207                 d = --d;
1208         }
1209
1210         void UnaryDecrement_2 (dynamic d, DynamicObjectMock mock)
1211         {
1212                 mock.UnaryOperation = (binder) => {
1213                         Assert (binder.Operation, ExpressionType.Decrement, "Operation");
1214                         Assert (binder.IsChecked, false, "IsChecked");
1215                         Assert (binder.ArgumentInfo, new[] {
1216                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1217                         }, "ArgumentInfo");
1218
1219                         return new object ();
1220                 };
1221
1222                 d = d--;
1223         }
1224
1225         void UnaryIncrement_1 (dynamic d, DynamicObjectMock mock)
1226         {
1227                 mock.UnaryOperation = (binder) => {
1228                         Assert (binder.Operation, ExpressionType.Increment, "Operation");
1229                         Assert (binder.IsChecked, false, "IsChecked");
1230                         Assert (binder.ArgumentInfo, new[] {
1231                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1232                         }, "ArgumentInfo");
1233
1234                         return null;
1235                 };
1236
1237                 d = ++d;
1238         }
1239
1240         void UnaryIncrement_2 (dynamic d, DynamicObjectMock mock)
1241         {
1242                 mock.UnaryOperation = (binder) => {
1243                         Assert (binder.Operation, ExpressionType.Increment, "Operation");
1244                         Assert (binder.IsChecked, false, "IsChecked");
1245                         Assert (binder.ArgumentInfo, new[] {
1246                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1247                         }, "ArgumentInfo");
1248
1249                         return new object ();
1250                 };
1251
1252                 d = d++;
1253         }
1254
1255         void UnaryIsFalse_1 (dynamic d, DynamicObjectMock mock)
1256         {
1257                 mock.UnaryOperation = (binder) => {
1258                         Assert (binder.Operation, ExpressionType.IsFalse, "Operation");
1259                         Assert (binder.IsChecked, false, "IsChecked");
1260                         Assert (binder.ArgumentInfo, new[] {
1261                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1262                         }, "ArgumentInfo");
1263
1264                         return true;
1265                 };
1266
1267                 mock.BinaryOperation = (binder, arg) => {
1268                         Assert (binder.Operation, ExpressionType.Equal, "Operation");
1269                         Assert (binder.IsChecked, false, "IsChecked");
1270                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
1271                         Assert (binder.ArgumentInfo, new[] {
1272                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1273                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
1274                                 "ArgumentInfo");
1275
1276                         Assert (arg, null, "arg");
1277                 };
1278
1279                 object x = d == null;
1280         }
1281
1282         void UnaryIsFalse_2 (dynamic d, DynamicObjectMock mock)
1283         {
1284                 mock.UnaryOperation = (binder) => {
1285                         Assert (binder.Operation, ExpressionType.IsFalse, "Operation");
1286                         Assert (binder.IsChecked, false, "IsChecked");
1287                         Assert (binder.ArgumentInfo, new[] {
1288                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1289                         }, "ArgumentInfo");
1290
1291                         return true;
1292                 };
1293
1294                 mock.BinaryOperation = (binder, arg) => {
1295                         Assert (binder.Operation, ExpressionType.NotEqual, "Operation");
1296                         Assert (binder.IsChecked, false, "IsChecked");
1297                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
1298                         Assert (binder.ArgumentInfo, new[] {
1299                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1300                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
1301                                 "ArgumentInfo");
1302
1303                         Assert (arg, null, "arg");
1304                 };
1305
1306                 object x = d != null;
1307         }
1308
1309         void UnaryIsFalse_3 (dynamic d, DynamicObjectMock mock)
1310         {
1311                 mock.UnaryOperation = (binder) => {
1312                         Assert (binder.Operation, ExpressionType.IsFalse, "Operation");
1313                         Assert (binder.IsChecked, false, "IsChecked");
1314                         Assert (binder.ArgumentInfo, new[] {
1315                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1316                         }, "ArgumentInfo");
1317
1318                         return true;
1319                 };
1320
1321                 mock.BinaryOperation = (binder, arg) => {
1322                         Assert (binder.Operation, ExpressionType.And, "Operation");
1323                         Assert (binder.IsChecked, false, "IsChecked");
1324                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
1325                         Assert (binder.ArgumentInfo, new[] {
1326                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1327                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
1328                                 "ArgumentInfo");
1329
1330                         Assert (arg, null, "arg");
1331                 };
1332
1333                 object x = d && null;
1334         }
1335
1336         void UnaryIsTrue_1 (dynamic d, DynamicObjectMock mock)
1337         {
1338                 mock.UnaryOperation = (binder) => {
1339                         Assert (binder.Operation, ExpressionType.IsTrue, "Operation");
1340                         Assert (binder.IsChecked, false, "IsChecked");
1341                         Assert (binder.ArgumentInfo, new[] {
1342                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1343                         }, "ArgumentInfo");
1344
1345                         return true;
1346                 };
1347
1348                 object g = d ? 1 :4;
1349         }
1350
1351         void UnaryIsTrue_2 (dynamic d, DynamicObjectMock mock)
1352         {
1353                 mock.UnaryOperation = (binder) => {
1354                         Assert (binder.Operation, ExpressionType.IsTrue, "Operation");
1355                         Assert (binder.IsChecked, false, "IsChecked");
1356                         Assert (binder.ArgumentInfo, new[] {
1357                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null)
1358                         }, "ArgumentInfo");
1359
1360                         return false;
1361                 };
1362
1363                 mock.BinaryOperation = (binder, arg) => {
1364                         Assert (binder.Operation, ExpressionType.Or, "Operation");
1365                         Assert (binder.IsChecked, false, "IsChecked");
1366                         Assert (binder.IsMemberAccess, false, "IsMemberAccess");
1367                         Assert (binder.ArgumentInfo, new[] {
1368                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.None, null),
1369                                 new CSharpArgumentInfo (CSharpArgumentInfoFlags.LiteralConstant | CSharpArgumentInfoFlags.UseCompileTimeType, null) },
1370                                 "ArgumentInfo");
1371
1372                         Assert (arg, null, "arg");
1373                 };
1374
1375                 object x = d || null;
1376         }
1377
1378 #pragma warning restore 168, 169, 219
1379
1380         static bool RunTest (MethodInfo test)
1381         {
1382                 Console.Write ("Running test {0, -25}", test.Name);
1383                 try {
1384                         var d = new DynamicObjectMock ();
1385                         test.Invoke (new Tester (), new [] { d, d });
1386                         if (d.HitCounter < 1)
1387                                 Assert (true, false, "HitCounter");
1388
1389                         Console.WriteLine ("OK");
1390                         return true;
1391                 } catch (Exception e) {
1392                         Console.WriteLine ("FAILED");
1393                         Console.WriteLine (e.ToString ());
1394                         return false;
1395                 }
1396         }
1397
1398         public static int Main ()
1399         {
1400                 var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
1401                                         where test.GetParameters ().Length == 2
1402                                         orderby test.Name
1403                                         select RunTest (test);
1404
1405                 int failures = tests.Count (a => !a);
1406                 Console.WriteLine (failures + " tests failed");
1407                 return failures;
1408         }
1409 }