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 PropertyInfo flags
= typeof (CSharpArgumentInfo
).GetProperty ("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
);
216 throw new ApplicationException ("Could not find 'argumentInfo' private field on " + obj
.GetType ());
218 IList
<CSharpArgumentInfo
> values
= (IList
<CSharpArgumentInfo
>) ai
.GetValue (obj
);
219 if (values
.Count
!= expected
.Length
)
220 throw new ApplicationException (name
+ ": Array length does not match " + values
.Count
+ " != " + expected
.Length
);
222 for (int i
= 0; i
< expected
.Length
; i
++) {
223 Assert (flags
.GetValue (expected
[i
]), flags
.GetValue (values
[i
]), "flags");
227 #pragma warning disable 168, 169, 219
229 void BinaryAdd_1 (dynamic d
, DynamicObjectMock mock
)
231 mock
.BinaryOperation
= (binder
, arg
) => {
232 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
233 AssertArgument (binder
, new[] {
234 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
235 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
238 Assert (arg
, 1, "arg");
244 void BinaryAdd_2 (dynamic d
, DynamicObjectMock mock
)
246 mock
.BinaryOperation
= (binder
, arg
) => {
247 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
248 AssertArgument (binder
, new[] {
249 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
250 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
253 Assert (arg
, null, "arg");
260 void BinaryAdd_3 (dynamic d
, DynamicObjectMock mock
)
262 mock
.BinaryOperation
= (binder
, arg
) => {
263 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
264 AssertArgument (binder
, new[] {
265 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
266 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null)
269 Assert (arg
, Enum
.A
, "arg");
275 void BinaryAdd_4 (dynamic d
, DynamicObjectMock mock
)
277 mock
.BinaryOperation
= (binder
, arg
) => {
278 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
279 AssertArgument (binder
, new[] {
280 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
281 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
284 Assert (arg
, 7, "arg");
287 d
= d
+ Tester
.field
;
290 void BinaryAddChecked_1 (dynamic d
, DynamicObjectMock mock
)
292 mock
.BinaryOperation
= (binder
, arg
) => {
293 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
294 AssertArgument (binder
, new[] {
295 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
296 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null) },
299 Assert (arg
, 3, "arg");
305 void BinaryAddChecked_2 (dynamic d
, DynamicObjectMock mock
)
307 mock
.BinaryOperation
= (binder
, arg
) => {
308 Assert (binder
.Operation
, ExpressionType
.Add
, "Operation");
309 AssertArgument (binder
, new[] {
310 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
311 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null) },
314 Assert (arg
, 3, "arg");
325 void BinaryAddAssign_1 (dynamic d
, DynamicObjectMock mock
)
327 mock
.BinaryOperation
= (binder
, arg
) => {
328 Assert (binder
.Operation
, ExpressionType
.AddAssign
, "Operation");
329 AssertArgument (binder
, new[] {
330 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
331 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
334 Assert (arg
, 1, "arg");
340 void BinaryAddAssignChecked_1 (dynamic d
, DynamicObjectMock mock
)
342 mock
.BinaryOperation
= (binder
, arg
) => {
343 Assert (binder
.Operation
, ExpressionType
.AddAssign
, "Operation");
344 AssertArgument (binder
, new[] {
345 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
346 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
349 Assert (arg
, 1, "arg");
357 void BinaryAnd_1 (dynamic d
, DynamicObjectMock mock
)
359 mock
.BinaryOperation
= (binder
, arg
) => {
360 Assert (binder
.Operation
, ExpressionType
.And
, "Operation");
361 AssertArgument (binder
, new[] {
362 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
363 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
366 Assert (arg
, 1, "arg");
372 void BinaryAndAssign_1 (dynamic d
, DynamicObjectMock mock
)
374 mock
.BinaryOperation
= (binder
, arg
) => {
375 Assert (binder
.Operation
, ExpressionType
.AndAssign
, "Operation");
376 AssertArgument (binder
, new[] {
377 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
378 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
381 Assert (arg
, 1, "arg");
387 void BinaryDivide_1 (dynamic d
, DynamicObjectMock mock
)
389 mock
.BinaryOperation
= (binder
, arg
) => {
390 Assert (binder
.Operation
, ExpressionType
.Divide
, "Operation");
391 AssertArgument (binder
, new[] {
392 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
393 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
396 Assert (arg
, 1, "arg");
402 void BinaryDivideAssign_1 (dynamic d
, DynamicObjectMock mock
)
404 mock
.BinaryOperation
= (binder
, arg
) => {
405 Assert (binder
.Operation
, ExpressionType
.DivideAssign
, "Operation");
406 AssertArgument (binder
, new[] {
407 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
408 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
411 Assert (arg
, 1, "arg");
417 void BinaryEqual_1 (dynamic d
, DynamicObjectMock mock
)
419 mock
.BinaryOperation
= (binder
, arg
) => {
420 Assert (binder
.Operation
, ExpressionType
.Equal
, "Operation");
421 AssertArgument (binder
, new[] {
422 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
423 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
426 Assert (arg
, 1, "arg");
432 void BinaryExclusiveOr_1 (dynamic d
, DynamicObjectMock mock
)
434 mock
.BinaryOperation
= (binder
, arg
) => {
435 Assert (binder
.Operation
, ExpressionType
.ExclusiveOr
, "Operation");
436 AssertArgument (binder
, new[] {
437 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
438 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
441 Assert (arg
, 1, "arg");
447 void BinaryExclusiveOrAssign_1 (dynamic d
, DynamicObjectMock mock
)
449 mock
.BinaryOperation
= (binder
, arg
) => {
450 Assert (binder
.Operation
, ExpressionType
.ExclusiveOrAssign
, "Operation");
451 AssertArgument (binder
, new[] {
452 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
453 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
456 Assert (arg
, 1, "arg");
462 void BinaryGreaterThan_1 (dynamic d
, DynamicObjectMock mock
)
464 mock
.BinaryOperation
= (binder
, arg
) => {
465 Assert (binder
.Operation
, ExpressionType
.GreaterThan
, "Operation");
466 AssertArgument (binder
, new[] {
467 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
468 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
471 Assert (arg
, 1, "arg");
477 void BinaryGreaterThanOrEqual_1 (dynamic d
, DynamicObjectMock mock
)
479 mock
.BinaryOperation
= (binder
, arg
) => {
480 Assert (binder
.Operation
, ExpressionType
.GreaterThanOrEqual
, "Operation");
481 AssertArgument (binder
, new[] {
482 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
483 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
486 Assert (arg
, 1, "arg");
492 void BinaryLeftShift_1 (dynamic d
, DynamicObjectMock mock
)
494 mock
.BinaryOperation
= (binder
, arg
) => {
495 Assert (binder
.Operation
, ExpressionType
.LeftShift
, "Operation");
496 AssertArgument (binder
, new[] {
497 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
498 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
501 Assert (arg
, 1, "arg");
507 void BinaryLeftShiftAssign_1 (dynamic d
, DynamicObjectMock mock
)
509 mock
.BinaryOperation
= (binder
, arg
) => {
510 Assert (binder
.Operation
, ExpressionType
.LeftShiftAssign
, "Operation");
511 AssertArgument (binder
, new[] {
512 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
513 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
516 Assert (arg
, 1, "arg");
522 void BinaryLessThan_1 (dynamic d
, DynamicObjectMock mock
)
524 mock
.BinaryOperation
= (binder
, arg
) => {
525 Assert (binder
.Operation
, ExpressionType
.LessThan
, "Operation");
526 AssertArgument (binder
, new[] {
527 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
528 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
531 Assert (arg
, 1, "arg");
537 void BinaryLessThanOrEqual_1 (dynamic d
, DynamicObjectMock mock
)
539 mock
.BinaryOperation
= (binder
, arg
) => {
540 Assert (binder
.Operation
, ExpressionType
.LessThanOrEqual
, "Operation");
541 AssertArgument (binder
, new[] {
542 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
543 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
546 Assert (arg
, 1, "arg");
552 void BinaryLogicalAnd_1 (dynamic d
, DynamicObjectMock mock
)
559 void BinaryLogicalOr_1 (dynamic d
, DynamicObjectMock mock
)
566 void BinaryModulo_1 (dynamic d
, DynamicObjectMock mock
)
568 mock
.BinaryOperation
= (binder
, arg
) => {
569 Assert (binder
.Operation
, ExpressionType
.Modulo
, "Operation");
570 AssertArgument (binder
, new[] {
571 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
572 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
575 Assert (arg
, 1, "arg");
581 void BinaryModuloAssign_1 (dynamic d
, DynamicObjectMock mock
)
583 mock
.BinaryOperation
= (binder
, arg
) => {
584 Assert (binder
.Operation
, ExpressionType
.ModuloAssign
, "Operation");
585 AssertArgument (binder
, new[] {
586 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
587 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
590 Assert (arg
, 1, "arg");
596 void BinaryMultiply_1 (dynamic d
, DynamicObjectMock mock
)
598 mock
.BinaryOperation
= (binder
, arg
) => {
599 Assert (binder
.Operation
, ExpressionType
.Multiply
, "Operation");
600 AssertArgument (binder
, new[] {
601 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
602 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
605 Assert (arg
, 1, "arg");
611 void BinaryMultiplyAssign_1 (dynamic d
, DynamicObjectMock mock
)
613 mock
.BinaryOperation
= (binder
, arg
) => {
614 Assert (binder
.Operation
, ExpressionType
.MultiplyAssign
, "Operation");
615 AssertArgument (binder
, new[] {
616 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
617 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
620 Assert (arg
, 1, "arg");
626 void BinaryNotEqual_1 (dynamic d
, DynamicObjectMock mock
)
628 mock
.BinaryOperation
= (binder
, arg
) => {
629 Assert (binder
.Operation
, ExpressionType
.NotEqual
, "Operation");
630 AssertArgument (binder
, new[] {
631 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
632 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
635 Assert (arg
, 4, "arg");
641 void BinaryOr_1 (dynamic d
, DynamicObjectMock mock
)
643 mock
.BinaryOperation
= (binder
, arg
) => {
644 Assert (binder
.Operation
, ExpressionType
.Or
, "Operation");
645 AssertArgument (binder
, new[] {
646 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
647 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
650 Assert (arg
, 2, "arg");
656 void BinaryOrAssign_1 (dynamic d
, DynamicObjectMock mock
)
658 mock
.BinaryOperation
= (binder
, arg
) => {
659 Assert (binder
.Operation
, ExpressionType
.OrAssign
, "Operation");
660 AssertArgument (binder
, new[] {
661 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
662 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
665 Assert (arg
, 2, "arg");
671 void BinaryRightShift_1 (dynamic d
, DynamicObjectMock mock
)
673 mock
.BinaryOperation
= (binder
, arg
) => {
674 Assert (binder
.Operation
, ExpressionType
.RightShift
, "Operation");
675 AssertArgument (binder
, new[] {
676 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
677 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
680 Assert (arg
, 1, "arg");
686 void BinaryRightShiftAssign_1 (dynamic d
, DynamicObjectMock mock
)
688 mock
.BinaryOperation
= (binder
, arg
) => {
689 Assert (binder
.Operation
, ExpressionType
.RightShiftAssign
, "Operation");
690 AssertArgument (binder
, new[] {
691 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
692 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
695 Assert (arg
, 1, "arg");
701 void BinarySubtract_1 (dynamic d
, DynamicObjectMock mock
)
703 mock
.BinaryOperation
= (binder
, arg
) => {
704 Assert (binder
.Operation
, ExpressionType
.Subtract
, "Operation");
705 AssertArgument (binder
, new[] {
706 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
707 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
710 Assert (arg
, 1, "arg");
716 void BinarySubtractAssign_1 (dynamic d
, DynamicObjectMock mock
)
718 mock
.BinaryOperation
= (binder
, arg
) => {
719 Assert (binder
.Operation
, ExpressionType
.SubtractAssign
, "Operation");
720 AssertArgument (binder
, new[] {
721 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
722 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
725 Assert (arg
, 1, "arg");
731 void Convert_1 (dynamic d
, DynamicObjectMock mock
)
733 mock
.ConvertOperation
= (binder
) => {
734 Assert (binder
.Explicit
, true, "Explicit");
735 Assert (binder
.Type
, typeof (byte), "Type");
742 void Convert_2 (dynamic d
, DynamicObjectMock mock
)
744 mock
.ConvertOperation
= (binder
) => {
745 Assert (binder
.Explicit
, false, "Explicit");
746 Assert (binder
.Type
, typeof (int), "Type");
750 object[] o
= new object[2];
754 void Convert_3 (dynamic d
, DynamicObjectMock mock
)
756 mock
.ConvertOperation
= (binder
) => {
757 Assert (binder
.Explicit
, true, "Explicit");
758 // Assert (binder.IsChecked, true, "IsChecked");
759 Assert (binder
.Type
, typeof (byte), "Type");
763 object b
= checked ((byte) d
);
766 void Convert_4 (dynamic d
, DynamicObjectMock mock
)
768 mock
.ConvertOperation
= (binder
) => {
769 Assert (binder
.Explicit
, false, "Explicit");
770 Assert (binder
.Type
, typeof (int), "Type");
777 void Convert_5 (dynamic d
, DynamicObjectMock mock
)
780 mock
.ConvertOperation
= (binder
) => {
781 Assert (binder
.Explicit
, false, "Explicit");
782 Assert (binder
.Type
, typeof (System
.Collections
.IEnumerable
), "Type");
783 return new object[] { 1 }
;
786 foreach (int v
in d
) {
787 // Console.WriteLine (v);
791 void GetIndex_1 (dynamic d
, DynamicObjectMock mock
)
793 mock
.GetIndexOperation
= (binder
, args
) => {
794 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
795 AssertArgument (binder
, new[] {
796 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
797 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
800 Assert ((IList
<object>) args
, new object[] { 0 }
, "args");
806 void GetIndex_2 (dynamic d
, DynamicObjectMock mock
)
808 mock
.GetIndexOperation
= (binder
, args
) => {
809 Assert (binder
.CallInfo
, new CallInfo (2, new string[0]), "CallInfo");
810 AssertArgument (binder
, new[] {
811 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
812 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
813 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
816 Assert ((IList
<object>) args
, new object[] { 2, 3 }
, "args");
823 void GetIndex_3 (dynamic d
, DynamicObjectMock mock
)
825 mock
.GetIndexOperation
= (binder
, args
) => {
826 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
827 AssertArgument (binder
, new[] {
828 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
829 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null) },
832 Assert ((IList
<object>) args
, new object[] { d }
, "args");
838 void GetMember_1 (dynamic d
, DynamicObjectMock mock
)
840 mock
.GetMemberOperation
= (binder
) => {
841 Assert (binder
.Name
, "Foo", "Name");
842 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
843 AssertArgument (binder
, new[] {
844 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null) },
853 void Invoke_1 (dynamic d
, DynamicObjectMock mock
)
855 mock
.InvokeOperation
= (binder
, args
) => {
856 Assert (binder
.CallInfo
, new CallInfo (2, new string[0]), "CallInfo");
857 AssertArgument (binder
, new[] {
858 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
859 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
860 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null)
863 Assert ((IList
<object>) args
, new object[] { "foo", null }
, "args");
869 void Invoke_2 (dynamic d
, DynamicObjectMock mock
)
871 mock
.InvokeOperation
= (binder
, args
) => {
872 Assert (binder
.CallInfo
, new CallInfo (0, new string[0]), "CallInfo");
873 AssertArgument (binder
, new[] {
874 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null) },
877 Assert ((IList
<object>) args
, new object[0], "args");
883 void Invoke_3 (dynamic d
, DynamicObjectMock mock
)
887 Assert (true, false, "No hook expected to be hit");
888 } catch (RuntimeBinderException
) {
892 void Invoke_4 (dynamic d
, DynamicObjectMock mock
)
894 mock
.InvokeOperation
= (binder
, args
) => {
895 Assert (binder
.CallInfo
, new CallInfo (2, new string[] { "name" }
), "CallInfo");
896 AssertArgument (binder
, new[] {
897 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
898 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
899 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.NamedArgument
| CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, "name")
902 Assert ((IList
<object>) args
, new object[] { typeof (bool), -1 }
, "args");
905 d (typeof (bool), name
: -1);
908 void Invoke_5 (dynamic d
, DynamicObjectMock mock
)
910 mock
.InvokeOperation
= (binder
, args
) => {
911 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
912 AssertArgument (binder
, new[] {
913 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
914 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null)
917 Assert ((IList
<object>) args
, new object[] { "a" }
, "args");
920 Action
<dynamic> a
= (i
) => { i ("a"); }
;
924 void Invoke_6 (dynamic d
, DynamicObjectMock mock
)
926 mock
.InvokeOperation
= (binder
, args
) => {
927 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
928 AssertArgument (binder
, new[] {
929 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
930 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null)
933 Assert ((IList
<object>) args
, new object[] { 3 }
, "args");
939 void InvokeMember_1 (dynamic d
, DynamicObjectMock mock
)
941 mock
.InvokeMemberOperation
= (binder
, args
) => {
942 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
943 AssertArgument (binder
, new[] {
944 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
945 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null)},
948 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
949 Assert ((IList
<object>) args
, new object[] { 'a' }
, "args");
955 void InvokeMember_2 (dynamic d
, DynamicObjectMock mock
)
957 mock
.InvokeMemberOperation
= (binder
, args
) => {
958 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
959 AssertArgument (binder
, new[] {
960 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
961 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)},
964 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
965 Assert ((IList
<object>) args
, new object[] { mock }
, "args");
971 void InvokeMember_3 (dynamic d
, DynamicObjectMock mock
)
973 mock
.InvokeMemberOperation
= (binder
, args
) => {
974 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
975 AssertArgument (binder
, new[] {
976 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
977 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.IsRef
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
980 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
981 Assert ((IList
<object>) args
, new object[] { 9 }
, "args");
988 void InvokeMember_4 (dynamic d
, DynamicObjectMock mock
)
990 mock
.InvokeMemberOperation
= (binder
, args
) => {
991 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
992 AssertArgument (binder
, new[] {
993 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
994 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.IsOut
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
997 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
998 Assert ((IList
<object>) args
, new object[] { 0 }
, "args");
1005 void InvokeMember_5 (dynamic d
, DynamicObjectMock mock
)
1007 DynamicObjectMock
.DStaticMethod (d
);
1010 void InvokeMember_6 (dynamic d
, DynamicObjectMock mock
)
1012 InvokeMemberOperation
= (binder
, args
) => {
1013 Assert (binder
.CallInfo
, new CallInfo (2, new string[0]), "CallInfo");
1014 AssertArgument (binder
, new[] {
1015 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1016 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1017 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null),
1020 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1021 Assert ((IList
<object>) args
, new object[] { d, null }
, "args");
1024 InvokeMember_5 (d
, null);
1027 void InvokeMember_7 (dynamic d
, DynamicObjectMock mock
)
1029 mock
.InvokeMemberOperation
= (binder
, args
) => {
1030 Assert (binder
.CallInfo
, new CallInfo (0, new string[0]), "CallInfo");
1031 AssertArgument (binder
, new[] {
1032 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1035 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1036 Assert ((IList
<object>) args
, new object[0], "args");
1042 void InvokeMember_8 (dynamic d
, DynamicObjectMock mock
)
1044 mock
.InvokeMemberOperation
= (binder
, args
) => {
1045 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
1046 AssertArgument (binder
, new[] {
1047 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1048 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.IsRef
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
1051 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1052 Assert ((IList
<object>) args
, new object[] { 9 }
, "args");
1059 void SetIndex_1 (dynamic d
, DynamicObjectMock mock
)
1061 mock
.SetIndexOperation
= (binder
, args
, value) => {
1062 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
1063 AssertArgument (binder
, new[] {
1064 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1065 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1066 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null)},
1069 Assert ((IList
<object>) args
, new object[] { 0 }
, "args");
1070 Assert (value, 2m
, "value");
1076 void SetIndex_2 (dynamic d
, DynamicObjectMock mock
)
1078 mock
.SetIndexOperation
= (binder
, args
, value) => {
1079 Assert (binder
.CallInfo
, new CallInfo (2, new string[0]), "CallInfo");
1080 AssertArgument (binder
, new[] {
1081 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1082 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1083 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1084 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
| CSharpArgumentInfoFlags
.UseCompileTimeType
, null)
1087 Assert ((IList
<object>) args
, new object[] { 2, 3 }
, "args");
1088 Assert (value, -8, "value");
1095 void SetIndex_3 (dynamic d
, DynamicObjectMock mock
)
1097 mock
.SetIndexOperation
= (binder
, args
, value) => {
1098 Assert (binder
.CallInfo
, new CallInfo (1, new string[0]), "CallInfo");
1099 AssertArgument (binder
, new[] {
1100 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null),
1101 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1102 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null)
1105 Assert ((IList
<object>) args
, new object[] { d }
, "args");
1106 Assert (value, this, "value");
1112 void SetMember_1 (dynamic d
, DynamicObjectMock mock
)
1114 const double d_const
= 2.4;
1116 mock
.SetMemberOperation
= (binder
, value) => {
1117 Assert (binder
.Name
, "Foo", "Name");
1118 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1119 AssertArgument (binder
, new[] {
1120 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1121 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
| CSharpArgumentInfoFlags
.Constant
, null)
1124 Assert (value, d_const
, "value");
1130 void SetMember_2 (dynamic d
, DynamicObjectMock mock
)
1132 mock
.GetMemberOperation
= (binder
) => {
1133 Assert (binder
.Name
, "Foo", "Name");
1134 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1135 AssertArgument (binder
, new[] {
1136 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null) },
1142 mock
.BinaryOperation
= (binder
, arg
) => {
1143 Assert (binder
.Operation
, ExpressionType
.MultiplyAssign
, "Operation");
1144 AssertArgument (binder
, new[] {
1145 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1146 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1149 Assert (arg
, null, "arg");
1152 mock
.SetMemberOperation
= (binder
, value) => {
1153 Assert (binder
.Name
, "Foo", "Name");
1154 Assert (binder
.IgnoreCase
, false, "IgnoreCase");
1155 AssertArgument (binder
, new[] {
1156 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1157 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1164 void UnaryPlus_1 (dynamic d
, DynamicObjectMock mock
)
1166 mock
.UnaryOperation
= (binder
) => {
1167 Assert (binder
.Operation
, ExpressionType
.UnaryPlus
, "Operation");
1168 AssertArgument (binder
, new[] {
1169 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1178 void UnaryMinus_1 (dynamic d
, DynamicObjectMock mock
)
1180 mock
.UnaryOperation
= (binder
) => {
1181 Assert (binder
.Operation
, ExpressionType
.Negate
, "Operation");
1182 AssertArgument (binder
, new[] {
1183 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1192 void UnaryNot_1 (dynamic d
, DynamicObjectMock mock
)
1194 mock
.UnaryOperation
= (binder
) => {
1195 Assert (binder
.Operation
, ExpressionType
.Not
, "Operation");
1196 AssertArgument (binder
, new[] {
1197 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1206 void UnaryOnesComplement_1 (dynamic d
, DynamicObjectMock mock
)
1208 mock
.UnaryOperation
= (binder
) => {
1209 Assert (binder
.Operation
, ExpressionType
.OnesComplement
, "Operation");
1210 AssertArgument (binder
, new[] {
1211 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1220 void UnaryDecrement_1 (dynamic d
, DynamicObjectMock mock
)
1222 mock
.UnaryOperation
= (binder
) => {
1223 Assert (binder
.Operation
, ExpressionType
.Decrement
, "Operation");
1224 AssertArgument (binder
, new[] {
1225 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1234 void UnaryDecrement_2 (dynamic d
, DynamicObjectMock mock
)
1236 mock
.UnaryOperation
= (binder
) => {
1237 Assert (binder
.Operation
, ExpressionType
.Decrement
, "Operation");
1238 AssertArgument (binder
, new[] {
1239 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1242 return new object ();
1248 void UnaryIncrement_1 (dynamic d
, DynamicObjectMock mock
)
1250 mock
.UnaryOperation
= (binder
) => {
1251 Assert (binder
.Operation
, ExpressionType
.Increment
, "Operation");
1252 AssertArgument (binder
, new[] {
1253 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1262 void UnaryIncrement_2 (dynamic d
, DynamicObjectMock mock
)
1264 mock
.UnaryOperation
= (binder
) => {
1265 Assert (binder
.Operation
, ExpressionType
.Increment
, "Operation");
1266 AssertArgument (binder
, new[] {
1267 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1270 return new object ();
1276 void UnaryIsFalse_1 (dynamic d
, DynamicObjectMock mock
)
1278 mock
.UnaryOperation
= (binder
) => {
1279 Assert (binder
.Operation
, ExpressionType
.IsFalse
, "Operation");
1280 AssertArgument (binder
, new[] {
1281 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1287 mock
.BinaryOperation
= (binder
, arg
) => {
1288 Assert (binder
.Operation
, ExpressionType
.Equal
, "Operation");
1289 AssertArgument (binder
, new[] {
1290 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1291 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1294 Assert (arg
, null, "arg");
1297 object x
= d
== null;
1300 void UnaryIsFalse_2 (dynamic d
, DynamicObjectMock mock
)
1302 mock
.UnaryOperation
= (binder
) => {
1303 Assert (binder
.Operation
, ExpressionType
.IsFalse
, "Operation");
1304 AssertArgument (binder
, new[] {
1305 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1311 mock
.BinaryOperation
= (binder
, arg
) => {
1312 Assert (binder
.Operation
, ExpressionType
.NotEqual
, "Operation");
1313 AssertArgument (binder
, new[] {
1314 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1315 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1318 Assert (arg
, null, "arg");
1321 object x
= d
!= null;
1324 void UnaryIsFalse_3 (dynamic d
, DynamicObjectMock mock
)
1326 mock
.UnaryOperation
= (binder
) => {
1327 Assert (binder
.Operation
, ExpressionType
.IsFalse
, "Operation");
1328 AssertArgument (binder
, new[] {
1329 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1335 mock
.BinaryOperation
= (binder
, arg
) => {
1336 Assert (binder
.Operation
, ExpressionType
.And
, "Operation");
1337 AssertArgument (binder
, new[] {
1338 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1339 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1342 Assert (arg
, null, "arg");
1345 object x
= d
&& null;
1348 void UnaryIsTrue_1 (dynamic d
, DynamicObjectMock mock
)
1350 mock
.UnaryOperation
= (binder
) => {
1351 Assert (binder
.Operation
, ExpressionType
.IsTrue
, "Operation");
1352 AssertArgument (binder
, new[] {
1353 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1359 object g
= d
? 1 : 4;
1362 void UnaryIsTrue_2 (dynamic d
, DynamicObjectMock mock
)
1364 mock
.UnaryOperation
= (binder
) => {
1365 Assert (binder
.Operation
, ExpressionType
.IsTrue
, "Operation");
1366 AssertArgument (binder
, new[] {
1367 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1373 mock
.BinaryOperation
= (binder
, arg
) => {
1374 Assert (binder
.Operation
, ExpressionType
.Or
, "Operation");
1375 AssertArgument (binder
, new[] {
1376 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1377 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.Constant
, null) },
1380 Assert (arg
, null, "arg");
1383 object x
= d
|| null;
1386 void UnaryIsTrue_3 (dynamic d
, DynamicObjectMock mock
)
1388 mock
.UnaryOperation
= (binder
) => {
1389 Assert (binder
.Operation
, ExpressionType
.IsTrue
, "Operation");
1390 AssertArgument (binder
, new[] {
1391 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null)
1397 mock
.BinaryOperation
= (binder
, arg
) => {
1398 Assert (binder
.Operation
, ExpressionType
.Or
, "Operation");
1399 AssertArgument (binder
, new[] {
1400 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.None
, null),
1401 CSharpArgumentInfo
.Create (CSharpArgumentInfoFlags
.UseCompileTimeType
, null) },
1404 Assert (arg
, false, "arg");
1411 #pragma warning restore 168, 169, 219
1413 static bool RunTest (MethodInfo test
)
1415 Console
.Write ("Running test {0, -25}", test
.Name
);
1417 var d
= new DynamicObjectMock ();
1418 test
.Invoke (new Tester (), new[] { d, d }
);
1419 if (d
.HitCounter
< 1)
1420 Assert (true, false, "HitCounter");
1422 Console
.WriteLine ("OK");
1424 } catch (Exception e
) {
1425 Console
.WriteLine ("FAILED");
1426 Console
.WriteLine (e
.ToString ());
1431 public static int Main ()
1433 var tests
= from test
in typeof (Tester
).GetMethods (BindingFlags
.Instance
| BindingFlags
.NonPublic
| BindingFlags
.DeclaredOnly
)
1434 where test
.GetParameters ().Length
== 2
1436 select RunTest (test
);
1438 int failures
= tests
.Count (a
=> !a
);
1439 Console
.WriteLine (failures
+ " tests failed");