2 using System
.Collections
.Generic
;
4 using System
.Reflection
;
6 using System
.Linq
.Expressions
;
7 using Microsoft
.CSharp
.RuntimeBinder
;
8 using System
.Runtime
.CompilerServices
;
15 class AssertDynamicObject
: DynamicMetaObject
17 DynamicObjectMock mock
;
19 public AssertDynamicObject (DynamicObjectMock mock
, Expression parameter
)
20 : base (parameter
, BindingRestrictions
.Empty
, mock
)
25 DynamicMetaObject
GetFakeMetaObject (object value)
27 Type t
= value == null ? typeof (object) : value.GetType ();
28 Expression
<Func
<object>> et
= () => value;
30 Expression restr
= Expression
.Constant (true);
31 return new DynamicMetaObject (Expression
.Convert (et
.Body
, t
), BindingRestrictions
.GetExpressionRestriction (restr
));
34 public override DynamicMetaObject
BindBinaryOperation (BinaryOperationBinder binder
, DynamicMetaObject arg
)
36 if (mock
.BinaryOperation
== null)
37 throw new ApplicationException ("Unexpected BindBinaryOperation");
39 mock
.BinaryOperation (binder
, arg
.Value
);
41 return GetFakeMetaObject (new object ());
44 public override DynamicMetaObject
BindConvert (ConvertBinder binder
)
46 if (mock
.ConvertOperation
== null)
47 throw new ApplicationException ("Unexpected BindConvert");
49 var r
= mock
.ConvertOperation (binder
);
51 return GetFakeMetaObject (r
);
54 public override DynamicMetaObject
BindGetIndex (GetIndexBinder binder
, DynamicMetaObject
[] indexes
)
56 if (mock
.GetIndexOperation
== null)
57 throw new ApplicationException ("Unexpected TryGetIndex");
59 mock
.GetIndexOperation (binder
, indexes
.Select (l
=> l
.Value
).ToArray ());
61 return GetFakeMetaObject (new object ());
64 public override DynamicMetaObject
BindGetMember (GetMemberBinder binder
)
66 if (mock
.GetMemberOperation
== null)
67 throw new ApplicationException ("Unexpected BindGetMember");
69 var r
= mock
.GetMemberOperation (binder
);
71 return GetFakeMetaObject (r
);
74 public override DynamicMetaObject
BindInvoke (InvokeBinder binder
, DynamicMetaObject
[] args
)
76 if (mock
.InvokeOperation
== null)
77 throw new ApplicationException ("Unexpected BindInvoke");
79 mock
.InvokeOperation (binder
, args
.Select (l
=> l
.Value
).ToArray ());
81 return GetFakeMetaObject (new object ());
84 public override DynamicMetaObject
BindInvokeMember (InvokeMemberBinder binder
, DynamicMetaObject
[] args
)
86 if (mock
.InvokeMemberOperation
== null)
87 throw new ApplicationException ("Unexpected BindInvokeMember");
89 mock
.InvokeMemberOperation (binder
, args
.Select (l
=> l
.Value
).ToArray ());
91 return GetFakeMetaObject (new object ());
94 public override DynamicMetaObject
BindSetIndex (SetIndexBinder binder
, DynamicMetaObject
[] indexes
, DynamicMetaObject
value)
96 if (mock
.SetIndexOperation
== null)
97 throw new ApplicationException ("Unexpected TrySetIndex");
99 mock
.SetIndexOperation (binder
, indexes
.Select (l
=> l
.Value
).ToArray (), value.Value
);
101 return GetFakeMetaObject (new object ());
104 public override DynamicMetaObject
BindSetMember (SetMemberBinder binder
, DynamicMetaObject
value)
106 if (mock
.SetMemberOperation
== null)
107 throw new ApplicationException ("Unexpected BindSetMember");
109 mock
.SetMemberOperation (binder
, value.Value
);
111 return GetFakeMetaObject (new object ());
114 public override DynamicMetaObject
BindUnaryOperation (UnaryOperationBinder binder
)
116 if (mock
.UnaryOperation
== null)
117 throw new ApplicationException ("Unexpected BindUnaryOperation");
119 var r
= mock
.UnaryOperation (binder
);
121 return GetFakeMetaObject (r
);
126 class DynamicObjectMock
: DynamicObject
128 public int HitCounter
;
130 public DynamicObjectMock ()
134 public override DynamicMetaObject
GetMetaObject (System
.Linq
.Expressions
.Expression parameter
)
137 return new AssertDynamicObject (this, parameter
);
140 public Action
<BinaryOperationBinder
, object> BinaryOperation
;
141 public Func
<ConvertBinder
, object> ConvertOperation
;
142 public Action
<GetIndexBinder
, object[]> GetIndexOperation
;
143 public Func
<GetMemberBinder
, object> GetMemberOperation
;
144 public Action
<InvokeBinder
, object[]> InvokeOperation
;
145 public Action
<InvokeMemberBinder
, object[]> InvokeMemberOperation
;
146 public Action
<SetIndexBinder
, object[], object> SetIndexOperation
;
147 public Action
<SetMemberBinder
, object> SetMemberOperation
;
148 public Func
<UnaryOperationBinder
, object> UnaryOperation
;
150 // Dynamic arguments methods
151 public DynamicObjectMock (int i
)
155 public void DMethod (int a
)
159 public static void DStaticMethod (object t
)
163 public int this[int i
] {
172 class Tester
: DynamicObjectMock
174 static readonly int field
= 7;
180 public Tester (dynamic d
)
184 static void Assert
<T
> (T expected
, T
value, string name
)
186 if (!EqualityComparer
<T
>.Default
.Equals (expected
, value)) {
187 if (!string.IsNullOrEmpty (name
))
189 throw new ApplicationException (name
+ "Expected " + expected
+ " != " + value);
193 static void Assert
<T
> (IList
<T
> expected
, IList
<T
> value, string name
)
195 if (expected
== null) {
197 throw new ApplicationException (name
+ ": Both arrays expected to be null");
201 if (expected
.Count
!= value.Count
)
202 throw new ApplicationException (name
+ ": Array length does not match " + expected
.Count
+ " != " + value.Count
);
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
]);
210 static FieldInfo flags
= typeof (CSharpArgumentInfo
).GetField ("flags", BindingFlags
.NonPublic
| BindingFlags
.Instance
);
212 static void AssertArgument (CallSiteBinder obj
, CSharpArgumentInfo
[] expected
, string name
)
214 var ai
= obj
.GetType ().GetField ("argumentInfo", BindingFlags
.NonPublic
| BindingFlags
.Instance
);
215 IList
<CSharpArgumentInfo
> values
= (IList
<CSharpArgumentInfo
>) ai
.GetValue (obj
);
216 if (values
.Count
!= expected
.Length
)
217 throw new ApplicationException (name
+ ": Array length does not match " + values
.Count
+ " != " + expected
.Length
);
219 for (int i
= 0; i
< expected
.Length
; i
++) {
220 Assert (flags
.GetValue (expected
[i
]), flags
.GetValue (values
[i
]), "flags");
224 #pragma warning disable 168, 169, 219
226 void BinaryAdd_1 (dynamic d
, DynamicObjectMock mock
)
228 mock
.BinaryOperation
= (binder
, arg
) => {
229 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
230 AssertArgument (binder
, new[] {
231 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
232 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
235 Assert (arg
, 1, "arg");
241 void BinaryAdd_2 (dynamic d
, DynamicObjectMock mock
)
243 mock
.BinaryOperation
= (binder
, arg
) => {
244 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
245 AssertArgument (binder
, new[] {
246 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
247 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
250 Assert (arg
, null, "arg");
257 void BinaryAdd_3 (dynamic d
, DynamicObjectMock mock
)
259 mock
.BinaryOperation
= (binder
, arg
) => {
260 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
261 AssertArgument (binder
, new[] {
262 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
263 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null)
266 Assert (arg
, Enum
.A
, "arg");
272 void BinaryAdd_4 (dynamic d
, DynamicObjectMock mock
)
274 mock
.BinaryOperation
= (binder
, arg
) => {
275 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
276 AssertArgument (binder
, new[] {
277 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
278 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
281 Assert (arg
, 7, "arg");
284 d
= d
+ Tester
.field
;
287 void BinaryAddChecked_1 (dynamic d
, DynamicObjectMock mock
)
289 mock
.BinaryOperation
= (binder
, arg
) => {
290 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
291 AssertArgument (binder
, new[] {
292 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
293 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null) },
296 Assert (arg
, 3, "arg");
302 void BinaryAddChecked_2 (dynamic d
, DynamicObjectMock mock
)
304 mock
.BinaryOperation
= (binder
, arg
) => {
305 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
306 AssertArgument (binder
, new[] {
307 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
308 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null) },
311 Assert (arg
, 3, "arg");
322 void BinaryAddAssign_1 (dynamic d
, DynamicObjectMock mock
)
324 mock
.BinaryOperation
= (binder
, arg
) => {
325 Assert (binder
.Operation
, ExpressionType
.AddAssign
, "Operation");
326 AssertArgument (binder
, new[] {
327 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
328 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
331 Assert (arg
, 1, "arg");
337 void BinaryAddAssignChecked_1 (dynamic d
, DynamicObjectMock mock
)
339 mock
.BinaryOperation
= (binder
, arg
) => {
340 Assert (binder
.Operation
, ExpressionType
.AddAssign
, "Operation");
341 AssertArgument (binder
, new[] {
342 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
343 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
346 Assert (arg
, 1, "arg");
354 void BinaryAnd_1 (dynamic d
, DynamicObjectMock mock
)
356 mock
.BinaryOperation
= (binder
, arg
) => {
357 Assert (binder
.Operation
, ExpressionType
.And
, "Operation");
358 AssertArgument (binder
, new[] {
359 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
360 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
363 Assert (arg
, 1, "arg");
369 void BinaryAndAssign_1 (dynamic d
, DynamicObjectMock mock
)
371 mock
.BinaryOperation
= (binder
, arg
) => {
372 Assert (binder
.Operation
, ExpressionType
.AndAssign
, "Operation");
373 AssertArgument (binder
, new[] {
374 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
375 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
378 Assert (arg
, 1, "arg");
384 void BinaryDivide_1 (dynamic d
, DynamicObjectMock mock
)
386 mock
.BinaryOperation
= (binder
, arg
) => {
387 Assert (binder
.Operation
, ExpressionType
.Divide
, "Operation");
388 AssertArgument (binder
, new[] {
389 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
390 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
393 Assert (arg
, 1, "arg");
399 void BinaryDivideAssign_1 (dynamic d
, DynamicObjectMock mock
)
401 mock
.BinaryOperation
= (binder
, arg
) => {
402 Assert (binder
.Operation
, ExpressionType
.DivideAssign
, "Operation");
403 AssertArgument (binder
, new[] {
404 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
405 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
408 Assert (arg
, 1, "arg");
414 void BinaryEqual_1 (dynamic d
, DynamicObjectMock mock
)
416 mock
.BinaryOperation
= (binder
, arg
) => {
417 Assert (binder
.Operation
, ExpressionType
.Equal
, "Operation");
418 AssertArgument (binder
, new[] {
419 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
420 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
423 Assert (arg
, 1, "arg");
429 void BinaryExclusiveOr_1 (dynamic d
, DynamicObjectMock mock
)
431 mock
.BinaryOperation
= (binder
, arg
) => {
432 Assert (binder
.Operation
, ExpressionType
.ExclusiveOr
, "Operation");
433 AssertArgument (binder
, new[] {
434 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
435 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
438 Assert (arg
, 1, "arg");
444 void BinaryExclusiveOrAssign_1 (dynamic d
, DynamicObjectMock mock
)
446 mock
.BinaryOperation
= (binder
, arg
) => {
447 Assert (binder
.Operation
, ExpressionType
.ExclusiveOrAssign
, "Operation");
448 AssertArgument (binder
, new[] {
449 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
450 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
453 Assert (arg
, 1, "arg");
459 void BinaryGreaterThan_1 (dynamic d
, DynamicObjectMock mock
)
461 mock
.BinaryOperation
= (binder
, arg
) => {
462 Assert (binder
.Operation
, ExpressionType
.GreaterThan
, "Operation");
463 AssertArgument (binder
, new[] {
464 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
465 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
468 Assert (arg
, 1, "arg");
474 void BinaryGreaterThanOrEqual_1 (dynamic d
, DynamicObjectMock mock
)
476 mock
.BinaryOperation
= (binder
, arg
) => {
477 Assert (binder
.Operation
, ExpressionType
.GreaterThanOrEqual
, "Operation");
478 AssertArgument (binder
, new[] {
479 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
480 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
483 Assert (arg
, 1, "arg");
489 void BinaryLeftShift_1 (dynamic d
, DynamicObjectMock mock
)
491 mock
.BinaryOperation
= (binder
, arg
) => {
492 Assert (binder
.Operation
, ExpressionType
.LeftShift
, "Operation");
493 AssertArgument (binder
, new[] {
494 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
495 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
498 Assert (arg
, 1, "arg");
504 void BinaryLeftShiftAssign_1 (dynamic d
, DynamicObjectMock mock
)
506 mock
.BinaryOperation
= (binder
, arg
) => {
507 Assert (binder
.Operation
, ExpressionType
.LeftShiftAssign
, "Operation");
508 AssertArgument (binder
, new[] {
509 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
510 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
513 Assert (arg
, 1, "arg");
519 void BinaryLessThan_1 (dynamic d
, DynamicObjectMock mock
)
521 mock
.BinaryOperation
= (binder
, arg
) => {
522 Assert (binder
.Operation
, ExpressionType
.LessThan
, "Operation");
523 AssertArgument (binder
, new[] {
524 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
525 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
528 Assert (arg
, 1, "arg");
534 void BinaryLessThanOrEqual_1 (dynamic d
, DynamicObjectMock mock
)
536 mock
.BinaryOperation
= (binder
, arg
) => {
537 Assert (binder
.Operation
, ExpressionType
.LessThanOrEqual
, "Operation");
538 AssertArgument (binder
, new[] {
539 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
540 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
543 Assert (arg
, 1, "arg");
549 void BinaryLogicalAnd_1 (dynamic d
, DynamicObjectMock mock
)
556 void BinaryLogicalOr_1 (dynamic d
, DynamicObjectMock mock
)
563 void BinaryModulo_1 (dynamic d
, DynamicObjectMock mock
)
565 mock
.BinaryOperation
= (binder
, arg
) => {
566 Assert (binder
.Operation
, ExpressionType
.Modulo
, "Operation");
567 AssertArgument (binder
, new[] {
568 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
569 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
572 Assert (arg
, 1, "arg");
578 void BinaryModuloAssign_1 (dynamic d
, DynamicObjectMock mock
)
580 mock
.BinaryOperation
= (binder
, arg
) => {
581 Assert (binder
.Operation
, ExpressionType
.ModuloAssign
, "Operation");
582 AssertArgument (binder
, new[] {
583 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
584 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
587 Assert (arg
, 1, "arg");
593 void BinaryMultiply_1 (dynamic d
, DynamicObjectMock mock
)
595 mock
.BinaryOperation
= (binder
, arg
) => {
596 Assert (binder
.Operation
, ExpressionType
.Multiply
, "Operation");
597 AssertArgument (binder
, new[] {
598 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
599 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
602 Assert (arg
, 1, "arg");
608 void BinaryMultiplyAssign_1 (dynamic d
, DynamicObjectMock mock
)
610 mock
.BinaryOperation
= (binder
, arg
) => {
611 Assert (binder
.Operation
, ExpressionType
.MultiplyAssign
, "Operation");
612 AssertArgument (binder
, new[] {
613 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
614 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
617 Assert (arg
, 1, "arg");
623 void BinaryNotEqual_1 (dynamic d
, DynamicObjectMock mock
)
625 mock
.BinaryOperation
= (binder
, arg
) => {
626 Assert (binder
.Operation
, ExpressionType
.NotEqual
, "Operation");
627 AssertArgument (binder
, new[] {
628 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
629 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
632 Assert (arg
, 4, "arg");
638 void BinaryOr_1 (dynamic d
, DynamicObjectMock mock
)
640 mock
.BinaryOperation
= (binder
, arg
) => {
641 Assert (binder
.Operation
, ExpressionType
.Or
, "Operation");
642 AssertArgument (binder
, new[] {
643 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
644 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
647 Assert (arg
, 2, "arg");
653 void BinaryOrAssign_1 (dynamic d
, DynamicObjectMock mock
)
655 mock
.BinaryOperation
= (binder
, arg
) => {
656 Assert (binder
.Operation
, ExpressionType
.OrAssign
, "Operation");
657 AssertArgument (binder
, new[] {
658 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
659 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
662 Assert (arg
, 2, "arg");
668 void BinaryRightShift_1 (dynamic d
, DynamicObjectMock mock
)
670 mock
.BinaryOperation
= (binder
, arg
) => {
671 Assert (binder
.Operation
, ExpressionType
.RightShift
, "Operation");
672 AssertArgument (binder
, new[] {
673 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
674 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
677 Assert (arg
, 1, "arg");
683 void BinaryRightShiftAssign_1 (dynamic d
, DynamicObjectMock mock
)
685 mock
.BinaryOperation
= (binder
, arg
) => {
686 Assert (binder
.Operation
, ExpressionType
.RightShiftAssign
, "Operation");
687 AssertArgument (binder
, new[] {
688 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
689 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
692 Assert (arg
, 1, "arg");
698 void BinarySubtract_1 (dynamic d
, DynamicObjectMock mock
)
700 mock
.BinaryOperation
= (binder
, arg
) => {
701 Assert (binder
.Operation
, ExpressionType
.Subtract
, "Operation");
702 AssertArgument (binder
, new[] {
703 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
704 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
707 Assert (arg
, 1, "arg");
713 void BinarySubtractAssign_1 (dynamic d
, DynamicObjectMock mock
)
715 mock
.BinaryOperation
= (binder
, arg
) => {
716 Assert (binder
.Operation
, ExpressionType
.SubtractAssign
, "Operation");
717 AssertArgument (binder
, new[] {
718 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
719 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
722 Assert (arg
, 1, "arg");
728 void Convert_1 (dynamic d
, DynamicObjectMock mock
)
730 mock
.ConvertOperation
= (binder
) => {
731 Assert (binder
.Explicit
, true, "Explicit");
732 Assert (binder
.Type
, typeof (byte), "Type");
739 void Convert_2 (dynamic d
, DynamicObjectMock mock
)
741 mock
.ConvertOperation
= (binder
) => {
742 Assert (binder
.Explicit
, false, "Explicit");
743 Assert (binder
.Type
, typeof (int), "Type");
747 object[] o
= new object[2];
751 void Convert_3 (dynamic d
, DynamicObjectMock mock
)
753 mock
.ConvertOperation
= (binder
) => {
754 Assert (binder
.Explicit
, true, "Explicit");
755 // Assert (binder.IsChecked, true, "IsChecked");
756 Assert (binder
.Type
, typeof (byte), "Type");
760 object b
= checked ((byte) d
);
763 void Convert_4 (dynamic d
, DynamicObjectMock mock
)
765 mock
.ConvertOperation
= (binder
) => {
766 Assert (binder
.Explicit
, false, "Explicit");
767 Assert (binder
.Type
, typeof (int), "Type");
774 void Convert_5 (dynamic d
, DynamicObjectMock mock
)
777 mock
.ConvertOperation
= (binder
) => {
778 Assert (binder
.Explicit
, false, "Explicit");
779 Assert (binder
.Type
, typeof (System
.Collections
.IEnumerable
), "Type");
780 return new object[] { 1 }
;
783 foreach (int v
in d
) {
784 // Console.WriteLine (v);
788 void GetIndex_1 (dynamic d
, DynamicObjectMock mock
)
790 mock
.GetIndexOperation
= (binder
, args
) => {
791 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
792 AssertArgument (binder
, new[] {
793 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
794 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
797 Assert ((IList
<object>) args
, new object[] { 0 }
, "args");
803 void GetIndex_2 (dynamic d
, DynamicObjectMock mock
)
805 mock
.GetIndexOperation
= (binder
, args
) => {
806 Assert (binder
.CallInfo
, new CallInfo (2, new string[0]), "CallInfo");
807 AssertArgument (binder
, new[] {
808 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
809 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
810 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
813 Assert ((IList
<object>) args
, new object[] { 2, 3 }
, "args");
820 void GetIndex_3 (dynamic d
, DynamicObjectMock mock
)
822 mock
.GetIndexOperation
= (binder
, args
) => {
823 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
824 AssertArgument (binder
, new[] {
825 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
826 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null) },
829 Assert ((IList
<object>) args
, new object[] { d }
, "args");
835 void GetMember_1 (dynamic d
, DynamicObjectMock mock
)
837 mock
.GetMemberOperation
= (binder
) => {
838 Assert (binder
.Name
, "Foo", "Name");
839 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
840 AssertArgument (binder
, new[] {
841 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null) },
850 void Invoke_1 (dynamic d
, DynamicObjectMock mock
)
852 mock
.InvokeOperation
= (binder
, args
) => {
853 Assert (binder
.CallInfo
, new CallInfo (2, new string[0]), "CallInfo");
854 AssertArgument (binder
, new[] {
855 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
856 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
857 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null)
860 Assert ((IList
<object>) args
, new object[] { "foo", null }
, "args");
866 void Invoke_2 (dynamic d
, DynamicObjectMock mock
)
868 mock
.InvokeOperation
= (binder
, args
) => {
869 Assert (binder
.CallInfo
, new CallInfo (0, new string[0]), "CallInfo");
870 AssertArgument (binder
, new[] {
871 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null) },
874 Assert ((IList
<object>) args
, new object[0], "args");
880 void Invoke_3 (dynamic d
, DynamicObjectMock mock
)
884 Assert (true, false, "No hook expected to be hit");
885 } catch (RuntimeBinderException
) {
889 void Invoke_4 (dynamic d
, DynamicObjectMock mock
)
891 mock
.InvokeOperation
= (binder
, args
) => {
892 Assert (binder
.CallInfo
, new CallInfo (2, new string[] { "name" }
), "CallInfo");
893 AssertArgument (binder
, new[] {
894 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
895 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
896 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.NamedArgument
| CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, "name")
899 Assert ((IList
<object>) args
, new object[] { typeof (bool), -1 }
, "args");
902 d (typeof (bool), name
: -1);
905 void Invoke_5 (dynamic d
, DynamicObjectMock mock
)
907 mock
.InvokeOperation
= (binder
, args
) => {
908 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
909 AssertArgument (binder
, new[] {
910 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
911 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null)
914 Assert ((IList
<object>) args
, new object[] { "a" }
, "args");
917 Action
<dynamic> a
= (i
) => { i ("a"); }
;
921 void Invoke_6 (dynamic d
, DynamicObjectMock mock
)
923 mock
.InvokeOperation
= (binder
, args
) => {
924 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
925 AssertArgument (binder
, new[] {
926 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
927 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null)
930 Assert ((IList
<object>) args
, new object[] { 3 }
, "args");
936 void InvokeMember_1 (dynamic d
, DynamicObjectMock mock
)
938 mock
.InvokeMemberOperation
= (binder
, args
) => {
939 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
940 AssertArgument (binder
, new[] {
941 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
942 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null)},
945 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
946 Assert ((IList
<object>) args
, new object[] { 'a' }
, "args");
952 void InvokeMember_2 (dynamic d
, DynamicObjectMock mock
)
954 mock
.InvokeMemberOperation
= (binder
, args
) => {
955 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
956 AssertArgument (binder
, new[] {
957 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
958 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)},
961 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
962 Assert ((IList
<object>) args
, new object[] { mock }
, "args");
968 void InvokeMember_3 (dynamic d
, DynamicObjectMock mock
)
970 mock
.InvokeMemberOperation
= (binder
, args
) => {
971 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
972 AssertArgument (binder
, new[] {
973 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
974 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.IsRef
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
977 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
978 Assert ((IList
<object>) args
, new object[] { 9 }
, "args");
985 void InvokeMember_4 (dynamic d
, DynamicObjectMock mock
)
987 mock
.InvokeMemberOperation
= (binder
, args
) => {
988 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
989 AssertArgument (binder
, new[] {
990 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
991 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.IsOut
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
994 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
995 Assert ((IList
<object>) args
, new object[] { 0 }
, "args");
1002 void InvokeMember_5 (dynamic d
, DynamicObjectMock mock
)
1004 DynamicObjectMock
.DStaticMethod (d
);
1007 void InvokeMember_6 (dynamic d
, DynamicObjectMock mock
)
1009 InvokeMemberOperation
= (binder
, args
) => {
1010 Assert (binder
.CallInfo
, new CallInfo (2, new string[0]), "CallInfo");
1011 AssertArgument (binder
, new[] {
1012 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1013 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1014 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null),
1017 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1018 Assert ((IList
<object>) args
, new object[] { d, null }
, "args");
1021 InvokeMember_5 (d
, null);
1024 void InvokeMember_7 (dynamic d
, DynamicObjectMock mock
)
1026 mock
.InvokeMemberOperation
= (binder
, args
) => {
1027 Assert (binder
.CallInfo
, new CallInfo (0, new string[0]), "CallInfo");
1028 AssertArgument (binder
, new[] {
1029 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1032 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1033 Assert ((IList
<object>) args
, new object[0], "args");
1039 void InvokeMember_8 (dynamic d
, DynamicObjectMock mock
)
1041 mock
.InvokeMemberOperation
= (binder
, args
) => {
1042 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
1043 AssertArgument (binder
, new[] {
1044 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1045 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.IsRef
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
1048 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1049 Assert ((IList
<object>) args
, new object[] { 9 }
, "args");
1056 void SetIndex_1 (dynamic d
, DynamicObjectMock mock
)
1058 mock
.SetIndexOperation
= (binder
, args
, value) => {
1059 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
1060 AssertArgument (binder
, new[] {
1061 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1062 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1063 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null)},
1066 Assert ((IList
<object>) args
, new object[] { 0 }
, "args");
1067 Assert (value, 2m
, "value");
1073 void SetIndex_2 (dynamic d
, DynamicObjectMock mock
)
1075 mock
.SetIndexOperation
= (binder
, args
, value) => {
1076 Assert (binder
.CallInfo
, new CallInfo (2, new string[0]), "CallInfo");
1077 AssertArgument (binder
, new[] {
1078 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1079 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1080 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1081 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null)
1084 Assert ((IList
<object>) args
, new object[] { 2, 3 }
, "args");
1085 Assert (value, -8, "value");
1092 void SetIndex_3 (dynamic d
, DynamicObjectMock mock
)
1094 mock
.SetIndexOperation
= (binder
, args
, value) => {
1095 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
1096 AssertArgument (binder
, new[] {
1097 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1098 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1099 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null)
1102 Assert ((IList
<object>) args
, new object[] { d }
, "args");
1103 Assert (value, this, "value");
1109 void SetMember_1 (dynamic d
, DynamicObjectMock mock
)
1111 const double d_const
= 2.4;
1113 mock
.SetMemberOperation
= (binder
, value) => {
1114 Assert (binder
.Name
, "Foo", "Name");
1115 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1116 AssertArgument (binder
, new[] {
1117 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1118 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null)
1121 Assert (value, d_const
, "value");
1127 void SetMember_2 (dynamic d
, DynamicObjectMock mock
)
1129 mock
.GetMemberOperation
= (binder
) => {
1130 Assert (binder
.Name
, "Foo", "Name");
1131 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1132 AssertArgument (binder
, new[] {
1133 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null) },
1139 mock
.BinaryOperation
= (binder
, arg
) => {
1140 Assert (binder
.Operation
, ExpressionType
.MultiplyAssign
, "Operation");
1141 AssertArgument (binder
, new[] {
1142 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1143 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1146 Assert (arg
, null, "arg");
1149 mock
.SetMemberOperation
= (binder
, value) => {
1150 Assert (binder
.Name
, "Foo", "Name");
1151 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1152 AssertArgument (binder
, new[] {
1153 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1154 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1161 void UnaryPlus_1 (dynamic d
, DynamicObjectMock mock
)
1163 mock
.UnaryOperation
= (binder
) => {
1164 Assert (binder
.Operation
, ExpressionType
.UnaryPlus
, "Operation");
1165 AssertArgument (binder
, new[] {
1166 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1175 void UnaryMinus_1 (dynamic d
, DynamicObjectMock mock
)
1177 mock
.UnaryOperation
= (binder
) => {
1178 Assert (binder
.Operation
, ExpressionType
.Negate
, "Operation");
1179 AssertArgument (binder
, new[] {
1180 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1189 void UnaryNot_1 (dynamic d
, DynamicObjectMock mock
)
1191 mock
.UnaryOperation
= (binder
) => {
1192 Assert (binder
.Operation
, ExpressionType
.Not
, "Operation");
1193 AssertArgument (binder
, new[] {
1194 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1203 void UnaryOnesComplement_1 (dynamic d
, DynamicObjectMock mock
)
1205 mock
.UnaryOperation
= (binder
) => {
1206 Assert (binder
.Operation
, ExpressionType
.OnesComplement
, "Operation");
1207 AssertArgument (binder
, new[] {
1208 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1217 void UnaryDecrement_1 (dynamic d
, DynamicObjectMock mock
)
1219 mock
.UnaryOperation
= (binder
) => {
1220 Assert (binder
.Operation
, ExpressionType
.Decrement
, "Operation");
1221 AssertArgument (binder
, new[] {
1222 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1231 void UnaryDecrement_2 (dynamic d
, DynamicObjectMock mock
)
1233 mock
.UnaryOperation
= (binder
) => {
1234 Assert (binder
.Operation
, ExpressionType
.Decrement
, "Operation");
1235 AssertArgument (binder
, new[] {
1236 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1239 return new object ();
1245 void UnaryIncrement_1 (dynamic d
, DynamicObjectMock mock
)
1247 mock
.UnaryOperation
= (binder
) => {
1248 Assert (binder
.Operation
, ExpressionType
.Increment
, "Operation");
1249 AssertArgument (binder
, new[] {
1250 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1259 void UnaryIncrement_2 (dynamic d
, DynamicObjectMock mock
)
1261 mock
.UnaryOperation
= (binder
) => {
1262 Assert (binder
.Operation
, ExpressionType
.Increment
, "Operation");
1263 AssertArgument (binder
, new[] {
1264 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1267 return new object ();
1273 void UnaryIsFalse_1 (dynamic d
, DynamicObjectMock mock
)
1275 mock
.UnaryOperation
= (binder
) => {
1276 Assert (binder
.Operation
, ExpressionType
.IsFalse
, "Operation");
1277 AssertArgument (binder
, new[] {
1278 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1284 mock
.BinaryOperation
= (binder
, arg
) => {
1285 Assert (binder
.Operation
, ExpressionType
.Equal
, "Operation");
1286 AssertArgument (binder
, new[] {
1287 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1288 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1291 Assert (arg
, null, "arg");
1294 object x
= d
== null;
1297 void UnaryIsFalse_2 (dynamic d
, DynamicObjectMock mock
)
1299 mock
.UnaryOperation
= (binder
) => {
1300 Assert (binder
.Operation
, ExpressionType
.IsFalse
, "Operation");
1301 AssertArgument (binder
, new[] {
1302 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1308 mock
.BinaryOperation
= (binder
, arg
) => {
1309 Assert (binder
.Operation
, ExpressionType
.NotEqual
, "Operation");
1310 AssertArgument (binder
, new[] {
1311 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1312 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1315 Assert (arg
, null, "arg");
1318 object x
= d
!= null;
1321 void UnaryIsFalse_3 (dynamic d
, DynamicObjectMock mock
)
1323 mock
.UnaryOperation
= (binder
) => {
1324 Assert (binder
.Operation
, ExpressionType
.IsFalse
, "Operation");
1325 AssertArgument (binder
, new[] {
1326 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1332 mock
.BinaryOperation
= (binder
, arg
) => {
1333 Assert (binder
.Operation
, ExpressionType
.And
, "Operation");
1334 AssertArgument (binder
, new[] {
1335 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1336 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1339 Assert (arg
, null, "arg");
1342 object x
= d
&& null;
1345 void UnaryIsTrue_1 (dynamic d
, DynamicObjectMock mock
)
1347 mock
.UnaryOperation
= (binder
) => {
1348 Assert (binder
.Operation
, ExpressionType
.IsTrue
, "Operation");
1349 AssertArgument (binder
, new[] {
1350 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1356 object g
= d
? 1 : 4;
1359 void UnaryIsTrue_2 (dynamic d
, DynamicObjectMock mock
)
1361 mock
.UnaryOperation
= (binder
) => {
1362 Assert (binder
.Operation
, ExpressionType
.IsTrue
, "Operation");
1363 AssertArgument (binder
, new[] {
1364 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1370 mock
.BinaryOperation
= (binder
, arg
) => {
1371 Assert (binder
.Operation
, ExpressionType
.Or
, "Operation");
1372 AssertArgument (binder
, new[] {
1373 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1374 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1377 Assert (arg
, null, "arg");
1380 object x
= d
|| null;
1383 void UnaryIsTrue_3 (dynamic d
, DynamicObjectMock mock
)
1385 mock
.UnaryOperation
= (binder
) => {
1386 Assert (binder
.Operation
, ExpressionType
.IsTrue
, "Operation");
1387 AssertArgument (binder
, new[] {
1388 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1394 mock
.BinaryOperation
= (binder
, arg
) => {
1395 Assert (binder
.Operation
, ExpressionType
.Or
, "Operation");
1396 AssertArgument (binder
, new[] {
1397 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1398 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
1401 Assert (arg
, false, "arg");
1408 #pragma warning restore 168, 169, 219
1410 static bool RunTest (MethodInfo test
)
1412 Console
.Write ("Running test {0, -25}", test
.Name
);
1414 var d
= new DynamicObjectMock ();
1415 test
.Invoke (new Tester (), new[] { d, d }
);
1416 if (d
.HitCounter
< 1)
1417 Assert (true, false, "HitCounter");
1419 Console
.WriteLine ("OK");
1421 } catch (Exception e
) {
1422 Console
.WriteLine ("FAILED");
1423 Console
.WriteLine (e
.ToString ());
1428 public static int Main ()
1430 var tests
= from test
in typeof (Tester
).GetMethods (BindingFlags
.Instance
| BindingFlags
.NonPublic
| BindingFlags
.DeclaredOnly
)
1431 where test
.GetParameters ().Length
== 2
1433 select RunTest (test
);
1435 int failures
= tests
.Count (a
=> !a
);
1436 Console
.WriteLine (failures
+ " tests failed");