1 // Compiler options: -unsafe
4 using System
.Collections
.Generic
;
6 using System
.Linq
.Expressions
;
7 using System
.Reflection
;
9 public struct InverseLogicalOperator
12 public InverseLogicalOperator (bool value)
17 public static bool operator true (InverseLogicalOperator u
)
22 public static bool operator false (InverseLogicalOperator u
)
28 /* TODO: Add tests for every numeric expression where a type has only 1 implicit
30 public struct MyType<T>
34 public MyType (T value)
39 public static implicit operator T (MyType<T> o)
47 // TODO: Create a clone which uses +(MyType, int) pattern and an implicit conversion
48 // is required to do the user-conversion
54 public MyType (int value) : this ()
59 public short ShortProp { get; set; }
61 public override int GetHashCode ()
63 throw new NotImplementedException ();
66 public static implicit operator int (MyType o
)
71 public static bool operator true (MyType a
)
76 public static bool operator false (MyType a
)
81 public static MyType
operator + (MyType a
, MyType b
)
83 return new MyType (a
.value + b
.value);
86 public static MyType
operator - (MyType a
, MyType b
)
88 return new MyType (a
.value - b
.value);
91 public static MyType
operator / (MyType a
, MyType b
)
93 return new MyType (a
.value / b
.value);
96 public static MyType
operator * (MyType a
, MyType b
)
98 return new MyType (a
.value * b
.value);
101 public static MyType
operator % (MyType a
, MyType b
)
103 return new MyType (a
.value % b
.value);
106 public static MyType
operator &(MyType a
, MyType b
)
108 return new MyType (a
.value & b
.value);
111 public static MyType
operator | (MyType a
, MyType b
)
113 return new MyType (a
.value | b
.value);
116 public static MyType
operator ^
(MyType a
, MyType b
)
118 return new MyType (a
.value ^ b
.value);
121 public static bool operator == (MyType a
, MyType b
)
123 return a
.value == b
.value;
126 public static bool operator != (MyType a
, MyType b
)
128 return a
.value != b
.value;
131 public static bool operator > (MyType a
, MyType b
)
133 return a
.value > b
.value;
136 public static bool operator < (MyType a
, MyType b
)
138 return a
.value < b
.value;
141 public static bool operator >= (MyType a
, MyType b
)
143 return a
.value >= b
.value;
146 public static bool operator <= (MyType a
, MyType b
)
148 return a
.value <= b
.value;
151 public static bool operator ! (MyType a
)
156 public static int operator >> (MyType a
, int b
)
161 public static int operator << (MyType a
, int b
)
166 public static MyType
operator - (MyType a
)
168 return new MyType (-a
.value);
171 public static MyType
operator + (MyType a
)
173 return new MyType (+a
.value);
176 public override string ToString ()
178 return value.ToString ();
187 public MyTypeExplicit (int value)
192 public static explicit operator int (MyTypeExplicit m
)
198 struct MyTypeImplicitOnly
202 public MyTypeImplicitOnly (short b
)
207 public static implicit operator short (MyTypeImplicitOnly m
)
213 class MemberAccessData
215 public bool BoolValue
;
216 public static decimal DecimalValue
= decimal.MinValue
;
217 public volatile uint VolatileValue
;
218 public string [] StringValues
;
219 public List
<string> ListValues
;
221 event Func
<bool> EventField
;
222 public Expression
<Func
<Func
<bool>>> GetEvent ()
224 return () => EventField
;
228 public MyType MyTypeProperty
{
237 public static string StaticProperty
{
243 public object SetOnly { set { }
}
252 enum MyEnumUlong
: ulong
272 public NewTest (params T
[] t
)
277 public override int GetHashCode ()
279 return base.GetHashCode ();
282 public override bool Equals (object obj
)
284 NewTest
<T
> obj_t
= obj
as NewTest
<T
>;
288 for (int i
= 0; i
< t
.Length
; ++i
) {
289 if (!t
[i
].Equals (obj_t
.t
[i
]))
299 public int this [int i
] { get { return i; }
set { }
}
300 public string this [params string[] i
] { get { return string.Concat (i); }
}
306 // TODO: Add more nullable tests, follow AddTest pattern.
310 delegate void EmptyDelegate ();
311 delegate int IntDelegate ();
312 static int ReturnNumber ()
317 static void AssertNodeType (LambdaExpression e
, ExpressionType et
)
319 if (e
.Body
.NodeType
!= et
)
320 throw new ApplicationException (e
.Body
.NodeType
+ " != " + et
);
323 static void Assert
<T
> (T expected
, T
value)
325 Assert (expected
, value, null);
328 static void Assert
<T
> (T expected
, T
value, string name
)
330 if (!EqualityComparer
<T
>.Default
.Equals (expected
, value)) {
331 if (!string.IsNullOrEmpty (name
))
333 throw new ApplicationException (name
+ expected
+ " != " + value);
337 static void Assert
<T
> (T
[] expected
, T
[] value)
339 if (expected
== null) {
341 throw new ApplicationException ("Both arrays expected to be null");
345 if (expected
.Length
!= value.Length
)
346 throw new ApplicationException ("Array length does not match " + expected
.Length
+ " != " + value.Length
);
348 for (int i
= 0; i
< expected
.Length
; ++i
) {
349 if (!EqualityComparer
<T
>.Default
.Equals (expected
[i
], value [i
]))
350 throw new ApplicationException ("Index " + i
+ ": " + expected
[i
] + " != " + value [i
]);
354 #pragma warning disable 169
358 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
+ b
;
359 AssertNodeType (e
, ExpressionType
.Add
);
360 Assert (50, e
.Compile ().Invoke (20, 30));
365 Expression
<Func
<int?, int?, int?>> e2
= (a
, b
) => a
+ b
;
366 AssertNodeType (e2
, ExpressionType
.Add
);
367 Assert (null, e2
.Compile ().Invoke (null, 3));
372 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
+ b
;
373 AssertNodeType (e3
, ExpressionType
.Add
);
374 Assert (10, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
379 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
+ b
;
380 AssertNodeType (e4
, ExpressionType
.Add
);
381 Assert (new MyType (10), e4
.Compile ().Invoke (new MyType (-20), new MyType (30)));
382 Assert (null, e4
.Compile ().Invoke (null, new MyType (30)));
387 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
+ b
;
388 AssertNodeType (e5
, ExpressionType
.Add
);
389 Assert (31, e5
.Compile ().Invoke (1, new MyType (30)));
394 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
+ b
;
395 AssertNodeType (e6
, ExpressionType
.Add
);
396 Assert (-1, e6
.Compile ().Invoke (-31, new MyType (30)));
401 Expression
<Func
<MyEnum
, byte, MyEnum
>> e7
= (a
, b
) => a
+ b
;
402 AssertNodeType (e7
, ExpressionType
.Convert
);
403 Assert (MyEnum
.Value_2
, e7
.Compile ().Invoke (MyEnum
.Value_1
, 1));
408 // CSC BUG: probably due to missing numeric promotion
409 Expression
<Func
<MyEnum
?, byte?, MyEnum
?>> e8
= (a
, b
) => a
+ b
;
410 AssertNodeType (e8
, ExpressionType
.Convert
);
411 Assert
<MyEnum
?> (0, e8
.Compile ().Invoke (MyEnum
.Value_1
, 255));
412 Assert (null, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
413 Assert (null, e8
.Compile ().Invoke (null, null));
418 Expression
<Func
<byte, MyEnum
, MyEnum
>> e9
= (a
, b
) => a
+ b
;
419 AssertNodeType (e9
, ExpressionType
.Convert
);
420 Assert (MyEnum
.Value_2
, e9
.Compile ().Invoke (1, MyEnum
.Value_1
));
423 void AddCheckedTest ()
426 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
+ b
;
427 AssertNodeType (e
, ExpressionType
.AddChecked
);
428 Assert (50, e
.Compile ().Invoke (20, 30));
432 void AddCheckedTest_2 ()
435 Expression
<Func
<int?, int?, int?>> e2
= (a
, b
) => a
+ b
;
436 AssertNodeType (e2
, ExpressionType
.AddChecked
);
437 Assert (null, e2
.Compile ().Invoke (null, 3));
441 void AddCheckedTest_3 ()
444 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
+ b
;
445 AssertNodeType (e3
, ExpressionType
.Add
);
446 Assert (10, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
450 void AddStringTest ()
452 Expression
<Func
<string, string>> e6
= (a
) => 1 + a
;
453 AssertNodeType (e6
, ExpressionType
.Add
);
454 Assert ("1to", e6
.Compile ().Invoke ("to"));
457 void AddStringTest_2 ()
459 Expression
<Func
<object, string, string>> e7
= (object a
, string b
) => a
+ b
;
460 AssertNodeType (e7
, ExpressionType
.Add
);
461 Assert ("testme", e7
.Compile ().Invoke ("test", "me"));
462 Assert ("test", e7
.Compile ().Invoke ("test", null));
463 Assert ("", e7
.Compile ().Invoke (null, null));
466 void AddStringTest_3 ()
468 Expression
<Func
<string, int, string>> e8
= (a
, b
) => a
+ " " + "-" + "> " + b
;
469 AssertNodeType (e8
, ExpressionType
.Add
);
470 Assert ("test -> 2", e8
.Compile ().Invoke ("test", 2));
473 void AddStringTest_4 ()
475 Expression
<Func
<string, ushort?, string>> e9
= (a
, b
) => a
+ b
;
476 AssertNodeType (e9
, ExpressionType
.Add
);
477 Assert ("test2", e9
.Compile ().Invoke ("test", 2));
478 Assert ("test", e9
.Compile ().Invoke ("test", null));
483 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
& b
;
485 AssertNodeType (e
, ExpressionType
.And
);
486 Func
<bool, bool, bool> c
= e
.Compile ();
488 Assert (true, c (true, true));
489 Assert (false, c (true, false));
490 Assert (false, c (false, true));
491 Assert (false, c (false, false));
496 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
& b
;
498 AssertNodeType (e2
, ExpressionType
.And
);
499 var c2
= e2
.Compile ();
501 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
502 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
507 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e3
= (a
, b
) => a
& b
;
508 AssertNodeType (e3
, ExpressionType
.Convert
);
509 Assert
<MyEnum
> (0, e3
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
510 Assert (MyEnum
.Value_2
, e3
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
515 Expression
<Func
<int, int>> e
= (a
) => a
& 0;
516 AssertNodeType (e
, ExpressionType
.And
);
517 var c
= e
.Compile ();
522 void AndNullableTest ()
524 Expression
<Func
<bool?, bool?, bool?>> e
= (bool? a
, bool? b
) => a
& b
;
526 AssertNodeType (e
, ExpressionType
.And
);
527 Func
<bool?, bool?, bool?> c
= e
.Compile ();
529 Assert (true, c (true, true));
530 Assert (false, c (true, false));
531 Assert (false, c (false, true));
532 Assert (false, c (false, false));
534 Assert (null, c (true, null));
535 Assert (false, c (false, null));
536 Assert (false, c (null, false));
537 Assert (null, c (true, null));
538 Assert (null, c (null, null));
541 void AndNullableTest_2 ()
543 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e2
= (MyType
? a
, MyType
? b
) => a
& b
;
545 AssertNodeType (e2
, ExpressionType
.And
);
546 var c2
= e2
.Compile ();
548 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
549 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
550 Assert (null, c2 (new MyType (0xFF), null));
553 void AndNullableTest_3 ()
555 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e3
= (a
, b
) => a
& b
;
556 AssertNodeType (e3
, ExpressionType
.Convert
);
557 Assert (null, e3
.Compile ().Invoke (null, MyEnum
.Value_2
));
558 Assert (MyEnum
.Value_2
, e3
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
563 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
&& b
;
564 AssertNodeType (e
, ExpressionType
.AndAlso
);
565 Assert (false, e
.Compile ().Invoke (true, false));
568 void AndAlsoTest_2 ()
570 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
&& b
;
571 AssertNodeType (e2
, ExpressionType
.AndAlso
);
572 Assert (new MyType (64), e2
.Compile ().Invoke (new MyType (64), new MyType (64)));
573 Assert (new MyType (0), e2
.Compile ().Invoke (new MyType (32), new MyType (64)));
576 void AndAlsoTest_3 ()
578 Expression
<Func
<bool, bool>> e3
= (bool a
) => a
&& true;
579 AssertNodeType (e3
, ExpressionType
.AndAlso
);
580 Assert (false, e3
.Compile ().Invoke (false));
581 Assert (true, e3
.Compile ().Invoke (true));
584 void ArrayIndexTest ()
586 Expression
<Func
<string [], long, string>> e
= (string [] a
, long i
) => a
[i
];
587 AssertNodeType (e
, ExpressionType
.ArrayIndex
);
588 Assert ("b", e
.Compile ().Invoke (new string [] { "a", "b", "c" }
, 1));
591 void ArrayIndexTest_2 ()
593 Expression
<Func
<string [], string>> e2
= (string [] a
) => a
[0];
594 AssertNodeType (e2
, ExpressionType
.ArrayIndex
);
595 Assert ("a", e2
.Compile ().Invoke (new string [] { "a", "b" }
));
598 void ArrayIndexTest_3 ()
600 Expression
<Func
<object [,], int, int, object>> e3
= (object [,] a
, int i
, int j
) => a
[i
, j
];
601 AssertNodeType (e3
, ExpressionType
.Call
);
603 Assert ("z", e3
.Compile ().Invoke (
604 new object [,] { { 1, 2 }
, { "x", "z" }
}, 1, 1));
607 void ArrayIndexTest_4 ()
609 Expression
<Func
<decimal [] [], byte, decimal>> e4
= (decimal [] [] a
, byte b
) => a
[b
] [1];
610 AssertNodeType (e4
, ExpressionType
.ArrayIndex
);
612 decimal [] [] array
= { new decimal [] { 1, 9 }
, new decimal [] { 10, 90 }
};
613 Assert (90, e4
.Compile ().Invoke (array
, 1));
616 void ArrayIndexTest_5 ()
618 Expression
<Func
<int>> e5
= () => (new int [1]) [0];
619 AssertNodeType (e5
, ExpressionType
.ArrayIndex
);
620 Assert (0, e5
.Compile ().Invoke ());
623 void ArrayIndexTest_6 ()
627 Expression
<Func
<int[], int>> e
= a
=> a
[max
];
628 AssertNodeType (e
, ExpressionType
.ArrayIndex
);
629 Assert (4, e
.Compile ().Invoke (new int [] { 1, 2, 3, 4, 5 }
));
632 void ArrayIndexTest_7 ()
634 const ulong max
= uint.MaxValue
;
636 Expression
<Func
<int[], int>> e
= a
=> a
[max
];
637 AssertNodeType (e
, ExpressionType
.ArrayIndex
);
640 e
.Compile ().Invoke (new int [0]);
641 throw new ApplicationException ("ArrayIndexTest_7");
642 } catch (System
.OverflowException
) {
643 // Check whether CheckedConversion was generated
647 void ArrayLengthTest ()
649 Expression
<Func
<double [], int>> e
= (double [] a
) => a
.Length
;
650 AssertNodeType (e
, ExpressionType
.ArrayLength
);
651 Assert (0, e
.Compile ().Invoke (new double [0]));
652 Assert (9, e
.Compile ().Invoke (new double [9]));
655 void ArrayLengthTest_2 ()
657 Expression
<Func
<string [,], int>> e2
= (string [,] a
) => a
.Length
;
658 AssertNodeType (e2
, ExpressionType
.MemberAccess
);
659 Assert (0, e2
.Compile ().Invoke (new string [0, 0]));
664 Expression
<Func
<int, int>> e
= (int a
) => Math
.Max (a
, 5);
665 AssertNodeType (e
, ExpressionType
.Call
);
666 Assert (5, e
.Compile ().Invoke (2));
667 Assert (9, e
.Compile ().Invoke (9));
672 Expression
<Func
<string, string>> e2
= (string a
) => InstanceMethod (a
);
673 AssertNodeType (e2
, ExpressionType
.Call
);
674 Assert ("abc", e2
.Compile ().Invoke ("abc"));
679 Expression
<Func
<int, string, int, object>> e3
= (int index
, string a
, int b
) => InstanceParamsMethod (index
, a
, b
);
680 AssertNodeType (e3
, ExpressionType
.Call
);
681 Assert
<object> (4, e3
.Compile ().Invoke (1, "a", 4));
686 Expression
<Func
<object>> e4
= () => InstanceParamsMethod (0);
687 AssertNodeType (e4
, ExpressionType
.Call
);
688 Assert
<object> ("<empty>", e4
.Compile ().Invoke ());
693 Expression
<Func
<int, int>> e5
= (int a
) => GenericMethod (a
);
694 AssertNodeType (e5
, ExpressionType
.Call
);
695 Assert (5, e5
.Compile ().Invoke (5));
700 Expression
<Action
> e6
= () => Console
.WriteLine ("call test");
701 AssertNodeType (e6
, ExpressionType
.Call
);
706 Expression
<Func
<Indexer
, int, int>> e7
= (a
, b
) => a
[b
];
707 AssertNodeType (e7
, ExpressionType
.Call
);
708 Assert (3, e7
.Compile ().Invoke (new Indexer (), 3));
713 Expression
<Func
<Indexer
, string, string, string, string>> e8
= (a
, b
, c
, d
) => a
[b
, c
, d
];
714 AssertNodeType (e8
, ExpressionType
.Call
);
715 Assert ("zyb", e8
.Compile ().Invoke (new Indexer (), "z", "y", "b"));
720 Expression
<Action
<int>> e9
= (a
) => RefMethod (ref a
);
721 AssertNodeType (e9
, ExpressionType
.Call
);
722 e9
.Compile ().Invoke (1);
727 Expression
<Func
<string>> e
= () => $"{int.MaxValue}";
728 AssertNodeType (e
, ExpressionType
.Call
);
729 Assert (int.MaxValue
.ToString (), e
.Compile ().Invoke ());
734 Expression
<Func
<uint?, uint>> e
= (uint? a
) => a
?? 99;
735 AssertNodeType (e
, ExpressionType
.Coalesce
);
736 var r
= e
.Compile ();
737 Assert ((uint) 5, r
.Invoke (5));
738 Assert ((uint) 99, r
.Invoke (null));
741 void CoalesceTest_2 ()
743 Expression
<Func
<MyType
?, int>> e2
= (MyType
? a
) => a
?? -3;
744 AssertNodeType (e2
, ExpressionType
.Coalesce
);
745 var r2
= e2
.Compile ();
746 Assert (2, r2
.Invoke (new MyType (2)));
747 Assert (-3, r2
.Invoke (null));
750 void ConditionTest ()
752 Expression
<Func
<bool, byte, int, int>> e
= (bool a
, byte b
, int c
) => (a
? b
: c
);
753 AssertNodeType (e
, ExpressionType
.Conditional
);
754 var r
= e
.Compile ();
755 Assert (3, r
.Invoke (true, 3, 999999));
756 Assert (999999, r
.Invoke (false, 3, 999999));
759 void ConditionTest_2 ()
761 Expression
<Func
<int, decimal, decimal?>> e2
= (int a
, decimal d
) => (a
> 0 ? d
: a
< 0 ? -d
: (decimal?) null);
762 AssertNodeType (e2
, ExpressionType
.Conditional
);
763 var r2
= e2
.Compile ();
764 Assert (null, r2
.Invoke (0, 10));
765 Assert (50, r2
.Invoke (1, 50));
766 Assert (30, r2
.Invoke (-7, -30));
769 void ConditionTest_3 ()
771 Expression
<Func
<bool?, int?>> e3
= (bool? a
) => ((bool) a
? 3 : -2);
772 AssertNodeType (e3
, ExpressionType
.Convert
);
773 var r3
= e3
.Compile ();
774 Assert (3, r3
.Invoke (true));
775 Assert (-2, r3
.Invoke (false));
778 void ConditionTest_4 ()
780 Expression
<Func
<InverseLogicalOperator
, byte, byte, byte>> e4
= (InverseLogicalOperator a
, byte b
, byte c
) => (a
? b
: c
);
781 AssertNodeType (e4
, ExpressionType
.Conditional
);
782 var r4
= e4
.Compile ();
783 Assert (3, r4
.Invoke (new InverseLogicalOperator (true), 3, 4));
784 Assert (4, r4
.Invoke (new InverseLogicalOperator (false), 3, 4));
787 void ConditionTest_5 ()
790 Expression
<Func
<int>> e
= () => false ? 1 : 4;
791 AssertNodeType (e
, ExpressionType
.Conditional
);
792 var r
= e
.Compile ();
793 Assert (4, r
.Invoke ());
798 Expression
<Func
<int>> e1
= () => default (int);
799 AssertNodeType (e1
, ExpressionType
.Constant
);
800 Assert (0, e1
.Compile ().Invoke ());
803 void ConstantTest_2 ()
805 Expression
<Func
<int?>> e2
= () => default (int?);
806 AssertNodeType (e2
, ExpressionType
.Constant
);
807 Assert (null, e2
.Compile ().Invoke ());
810 void ConstantTest_3 ()
812 Expression
<Func
<Tester
>> e3
= () => default (Tester
);
813 AssertNodeType (e3
, ExpressionType
.Constant
);
814 Assert (null, e3
.Compile ().Invoke ());
817 void ConstantTest_4 ()
819 Expression
<Func
<object>> e4
= () => null;
820 AssertNodeType (e4
, ExpressionType
.Constant
);
821 Assert (null, e4
.Compile ().Invoke ());
824 void ConstantTest_5 ()
826 Expression
<Func
<int>> e5
= () => 8 / 4;
827 AssertNodeType (e5
, ExpressionType
.Constant
);
828 Assert (2, e5
.Compile ().Invoke ());
831 void ConstantTest_6 ()
833 Expression
<Func
<int>> e6
= () => 0xFFFFFF >> 0x40;
834 AssertNodeType (e6
, ExpressionType
.Constant
);
835 Assert (0xFFFFFF, e6
.Compile ().Invoke ());
838 void ConstantTest_7 ()
840 Expression
<Func
<object>> e7
= () => "Alleluia";
841 AssertNodeType (e7
, ExpressionType
.Constant
);
842 Assert ("Alleluia", e7
.Compile ().Invoke ());
845 void ConstantTest_8 ()
847 Expression
<Func
<Type
>> e8
= () => typeof (int);
848 AssertNodeType (e8
, ExpressionType
.Constant
);
849 Assert (typeof (int), e8
.Compile ().Invoke ());
852 void ConstantTest_9 ()
854 Expression
<Func
<Type
>> e9
= () => typeof (void);
855 AssertNodeType (e9
, ExpressionType
.Constant
);
856 Assert (typeof (void), e9
.Compile ().Invoke ());
859 void ConstantTest_10 ()
861 Expression
<Func
<Type
>> e10
= () => typeof (Func
<,>);
862 AssertNodeType (e10
, ExpressionType
.Constant
);
863 Assert (typeof (Func
<,>), e10
.Compile ().Invoke ());
866 void ConstantTest_11 ()
868 Expression
<Func
<MyEnum
>> e11
= () => MyEnum
.Value_2
;
869 AssertNodeType (e11
, ExpressionType
.Constant
);
870 Assert (MyEnum
.Value_2
, e11
.Compile ().Invoke ());
873 void ConstantTest_13 ()
875 Expression
<Func
<int>> e13
= () => sizeof (byte);
876 AssertNodeType (e13
, ExpressionType
.Constant
);
877 Assert (1, e13
.Compile ().Invoke ());
881 void ConstantTest_14 ()
883 Expression
<Func
<Type
>> e14
= () => typeof (bool*);
884 AssertNodeType (e14
, ExpressionType
.Constant
);
885 Assert (typeof (bool*), e14
.Compile ().Invoke ());
888 void ConstantTest_15 ()
890 Expression
<Func
<int?>> e15
= () => null;
891 AssertNodeType (e15
, ExpressionType
.Constant
);
892 Assert (null, e15
.Compile ().Invoke ());
897 Expression
<Func
<int, byte>> e
= (int a
) => ((byte) a
);
898 AssertNodeType (e
, ExpressionType
.Convert
);
899 Assert (100, e
.Compile ().Invoke (100));
902 void ConvertTest_2 ()
904 Expression
<Func
<long, ushort>> e2
= (long a
) => ((ushort) a
);
905 AssertNodeType (e2
, ExpressionType
.Convert
);
906 Assert (100, e2
.Compile ().Invoke (100));
909 void ConvertTest_3 ()
911 Expression
<Func
<float?, float>> e3
= (float? a
) => ((float) a
);
912 AssertNodeType (e3
, ExpressionType
.Convert
);
913 Assert (-0.456f
, e3
.Compile ().Invoke (-0.456f
));
916 void ConvertTest_4 ()
918 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => (a
);
919 AssertNodeType (e4
, ExpressionType
.Convert
);
920 Assert (-9, e4
.Compile ().Invoke (new MyType (-9)));
923 void ConvertTest_5 ()
925 Expression
<Func
<MyType
, MyType
, bool?>> e5
= (MyType a
, MyType b
) => a
== b
;
926 AssertNodeType (e5
, ExpressionType
.Convert
);
929 void ConvertTest_6 ()
931 Expression
<Func
<MyType
?, MyType
?, bool?>> e6
= (MyType
? a
, MyType
? b
) => a
== b
;
932 AssertNodeType (e6
, ExpressionType
.Convert
);
933 Assert (false, e6
.Compile ().Invoke (null, new MyType (-20)));
934 Assert (true, e6
.Compile ().Invoke (null, null));
935 Assert (true, e6
.Compile ().Invoke (new MyType (120), new MyType (120)));
938 void ConvertTest_7 ()
940 Expression
<Func
<MyTypeExplicit
, int?>> e7
= x
=> (int?)x
;
941 AssertNodeType (e7
, ExpressionType
.Convert
);
942 Assert (33, e7
.Compile ().Invoke (new MyTypeExplicit (33)));
945 void ConvertTest_8 ()
947 Expression
<Func
<int?, object>> e8
= x
=> (object)x
;
948 AssertNodeType (e8
, ExpressionType
.Convert
);
949 Assert (null, e8
.Compile ().Invoke (null));
950 Assert (-100, e8
.Compile ().Invoke (-100));
953 unsafe void ConvertTest_9 ()
955 int*[] p
= new int* [1];
956 Expression
<Func
<object>> e9
= () => (object)p
;
957 AssertNodeType (e9
, ExpressionType
.Convert
);
958 Assert (p
, e9
.Compile ().Invoke ());
961 void ConvertTest_10 ()
963 Expression
<Func
<Func
<int>, Delegate
>> e10
= (a
) => a
+ a
;
964 AssertNodeType (e10
, ExpressionType
.Convert
);
965 Assert (null, e10
.Compile ().Invoke (null));
966 Assert (new Func
<int> (TestInt
) + new Func
<int> (TestInt
), e10
.Compile ().Invoke (TestInt
));
969 void ConvertTest_11 ()
971 Expression
<Func
<Func
<int>, Delegate
>> e11
= (a
) => a
- a
;
972 AssertNodeType (e11
, ExpressionType
.Convert
);
973 Assert (null, e11
.Compile ().Invoke (null));
976 void ConvertTest_12 ()
978 Expression
<Func
<Func
<int>>> e12
= () => TestInt
;
979 AssertNodeType (e12
, ExpressionType
.Convert
);
980 Assert (29, e12
.Compile ().Invoke () ());
983 void ConvertTest_13 ()
985 Expression
<Func
<decimal, sbyte>> e13
= a
=> (sbyte)a
;
986 AssertNodeType (e13
, ExpressionType
.Convert
);
987 Assert (6, e13
.Compile ().Invoke (6));
990 void ConvertTest_14 ()
992 Expression
<Func
<long, decimal>> e14
= a
=> a
;
993 AssertNodeType (e14
, ExpressionType
.Convert
);
994 Assert (-66, e14
.Compile ().Invoke (-66));
997 void ConvertTest_15 ()
999 Expression
<Func
<ulong?, decimal?>> e15
= a
=> a
;
1000 AssertNodeType (e15
, ExpressionType
.Convert
);
1001 Assert (null, e15
.Compile ().Invoke (null));
1002 Assert (9, e15
.Compile ().Invoke (9));
1005 void ConvertTest_16 ()
1007 Expression
<Func
<sbyte, sbyte>> e16
= a
=> (sbyte)a
;
1008 AssertNodeType (e16
, ExpressionType
.Convert
);
1009 Assert (6, e16
.Compile ().Invoke (6));
1012 void ConvertCheckedTest ()
1014 Expression
<Func
<int, byte>> e
= (int a
) => checked((byte) a
);
1015 AssertNodeType (e
, ExpressionType
.ConvertChecked
);
1016 Assert (100, e
.Compile ().Invoke (100));
1019 void ConvertCheckedTest_2 ()
1022 Expression
<Func
<long, ushort>> e2
= (long a
) => unchecked((ushort) a
);
1023 AssertNodeType (e2
, ExpressionType
.Convert
);
1024 Assert (100, e2
.Compile ().Invoke (100));
1028 void ConvertCheckedTest_3 ()
1031 Expression
<Func
<float?, float>> e3
= (float? a
) => ((float) a
);
1032 AssertNodeType (e3
, ExpressionType
.ConvertChecked
);
1033 Assert (-0.456f
, e3
.Compile ().Invoke (-0.456f
));
1037 void ConvertCheckedTest_4 ()
1040 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => (a
);
1041 AssertNodeType (e4
, ExpressionType
.Convert
);
1042 Assert (-9, e4
.Compile ().Invoke (new MyType (-9)));
1048 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
/ b
;
1049 AssertNodeType (e
, ExpressionType
.Divide
);
1050 Assert (2, e
.Compile ().Invoke (60, 30));
1053 void DivideTest_2 ()
1055 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
/ b
;
1056 AssertNodeType (e2
, ExpressionType
.Divide
);
1057 Assert (null, e2
.Compile ().Invoke (null, 3));
1058 Assert (1.5, e2
.Compile ().Invoke (3, 2));
1061 void DivideTest_3 ()
1063 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
/ b
;
1064 AssertNodeType (e3
, ExpressionType
.Divide
);
1065 Assert (1, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1068 void DivideTest_4 ()
1070 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
/ b
;
1071 AssertNodeType (e4
, ExpressionType
.Divide
);
1072 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1073 Assert (new MyType (-6), e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1076 void DivideTest_5 ()
1078 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
/ b
;
1079 AssertNodeType (e5
, ExpressionType
.Divide
);
1080 Assert (50, e5
.Compile ().Invoke (100, new MyType (2)));
1083 void DivideTest_6 ()
1085 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
/ b
;
1086 AssertNodeType (e6
, ExpressionType
.Divide
);
1087 Assert (50, e6
.Compile ().Invoke (100, new MyType (2)));
1088 Assert (null, e6
.Compile ().Invoke (20, null));
1091 void DivideTest_7 ()
1093 Expression
<Func
<float, uint?, float?>> e
= (a
, b
) => a
/ b
;
1094 AssertNodeType (e
, ExpressionType
.Divide
);
1095 Assert (50, e
.Compile () (100, 2));
1096 Assert (null, e
.Compile () (20, null));
1101 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
== b
;
1102 AssertNodeType (e
, ExpressionType
.Equal
);
1103 Assert (false, e
.Compile ().Invoke (60, 30));
1104 Assert (true, e
.Compile ().Invoke (-1, -1));
1109 Expression
<Func
<double?, double?, bool>> e2
= (a
, b
) => a
== b
;
1110 AssertNodeType (e2
, ExpressionType
.Equal
);
1111 Assert (true, e2
.Compile ().Invoke (3, 3));
1112 Assert (false, e2
.Compile ().Invoke (3, 2));
1117 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
== b
;
1118 AssertNodeType (e3
, ExpressionType
.Equal
);
1119 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1124 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
== b
;
1125 AssertNodeType (e4
, ExpressionType
.Equal
);
1126 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1127 Assert (true, e4
.Compile ().Invoke (null, null));
1128 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (120)));
1133 Expression
<Func
<bool?, bool?, bool>> e5
= (bool? a
, bool? b
) => a
== b
;
1134 AssertNodeType (e5
, ExpressionType
.Equal
);
1135 Assert (false, e5
.Compile ().Invoke (true, null));
1136 Assert (true, e5
.Compile ().Invoke (null, null));
1137 Assert (true, e5
.Compile ().Invoke (false, false));
1142 Expression
<Func
<bool, bool>> e6
= (bool a
) => a
== null;
1143 AssertNodeType (e6
, ExpressionType
.Equal
);
1144 Assert (false, e6
.Compile ().Invoke (true));
1145 Assert (false, e6
.Compile ().Invoke (false));
1150 Expression
<Func
<string, string, bool>> e7
= (string a
, string b
) => a
== b
;
1151 AssertNodeType (e7
, ExpressionType
.Equal
);
1152 Assert (true, e7
.Compile ().Invoke (null, null));
1153 Assert (false, e7
.Compile ().Invoke ("a", "A"));
1154 Assert (true, e7
.Compile ().Invoke ("a", "a"));
1159 Expression
<Func
<object, bool>> e8
= (object a
) => null == a
;
1160 AssertNodeType (e8
, ExpressionType
.Equal
);
1161 Assert (true, e8
.Compile ().Invoke (null));
1162 Assert (false, e8
.Compile ().Invoke ("a"));
1163 Assert (false, e8
.Compile ().Invoke (this));
1168 Expression
<Func
<MyEnum
, MyEnum
, bool>> e9
= (a
, b
) => a
== b
;
1169 AssertNodeType (e9
, ExpressionType
.Equal
);
1170 Assert (false, e9
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
1171 Assert (true, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1174 void EqualTest_10 ()
1176 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e10
= (a
, b
) => a
== b
;
1177 AssertNodeType (e10
, ExpressionType
.Equal
);
1178 Assert (false, e10
.Compile ().Invoke (MyEnum
.Value_1
, null));
1179 Assert (true, e10
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1182 void EqualTest_11 ()
1184 Expression
<Func
<MyEnum
?, bool>> e11
= (a
) => a
== null;
1185 AssertNodeType (e11
, ExpressionType
.Equal
);
1186 Assert (false, e11
.Compile ().Invoke (MyEnum
.Value_1
));
1187 Assert (true, e11
.Compile ().Invoke (null));
1190 void EqualTest_12 ()
1192 Expression
<Func
<MyEnumUlong
, bool>> e12
= (a
) => a
== 0;
1193 AssertNodeType (e12
, ExpressionType
.Equal
);
1194 Assert (false, e12
.Compile ().Invoke (MyEnumUlong
.Value_1
));
1195 Assert (true, e12
.Compile ().Invoke (0));
1198 void EqualTest_13 ()
1200 Expression
<Func
<MyEnum
, bool>> e13
= (a
) => a
== MyEnum
.Value_2
;
1201 AssertNodeType (e13
, ExpressionType
.Equal
);
1202 Assert (true, e13
.Compile ().Invoke (MyEnum
.Value_2
));
1203 Assert (false, e13
.Compile ().Invoke (0));
1206 void EqualTest_14 ()
1208 Expression
<Func
<MyEnum
, bool>> e
= (a
) => a
== null;
1209 AssertNodeType (e
, ExpressionType
.Equal
);
1210 Assert (false, e
.Compile ().Invoke (MyEnum
.Value_1
));
1213 void EqualTest_15 ()
1215 Expression
<Func
<int?, uint, bool>> e
= (a
, b
) => a
== b
;
1216 AssertNodeType (e
, ExpressionType
.Equal
);
1217 Assert (false, e
.Compile ().Invoke (null, 0));
1218 Assert (true, e
.Compile ().Invoke (4, 4));
1221 void EqualTest_16 ()
1223 Expression
<Func
<EnumInt
?, EnumInt
, bool?>> e
= (x
, y
) => x
== y
;
1224 AssertNodeType (e
, ExpressionType
.Convert
);
1225 Assert (false, e
.Compile () (null, 0));
1226 Assert (true, e
.Compile () (EnumInt
.B
, EnumInt
.B
));
1229 void EqualTestDelegate ()
1231 Expression
<Func
<Delegate
, Delegate
, bool>> e1
= (a
, b
) => a
== b
;
1232 AssertNodeType (e1
, ExpressionType
.Equal
);
1233 Assert (true, e1
.Compile ().Invoke (null, null));
1236 void EqualTestDelegate_2 ()
1238 EmptyDelegate ed
= delegate () {};
1240 Expression
<Func
<EmptyDelegate
, EmptyDelegate
, bool>> e2
= (a
, b
) => a
== b
;
1241 AssertNodeType (e2
, ExpressionType
.Equal
);
1242 Assert (false, e2
.Compile ().Invoke (delegate () {}, null));
1243 Assert (false, e2
.Compile ().Invoke (delegate () {}, delegate {}
));
1244 Assert (false, e2
.Compile ().Invoke (ed
, delegate {}));
1245 Assert (true, e2
.Compile ().Invoke (ed
, ed
));
1248 void EqualTestDelegate_3 ()
1250 Expression
<Func
<Func
<int>, bool>> e1
= (a
) => a
== ReturnNumber
;
1251 AssertNodeType (e1
, ExpressionType
.Equal
);
1252 Assert (false, e1
.Compile ().Invoke (null));
1253 Assert (true, e1
.Compile ().Invoke (ReturnNumber
));
1256 void ExclusiveOrTest ()
1258 Expression
<Func
<int, short, int>> e
= (int a
, short b
) => a ^ b
;
1259 AssertNodeType (e
, ExpressionType
.ExclusiveOr
);
1260 Assert (34, e
.Compile ().Invoke (60, 30));
1263 void ExclusiveOrTest_2 ()
1265 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a ^ b
;
1266 AssertNodeType (e2
, ExpressionType
.ExclusiveOr
);
1267 Assert (null, e2
.Compile ().Invoke (null, 3));
1268 Assert (1, e2
.Compile ().Invoke (3, 2));
1271 void ExclusiveOrTest_3 ()
1273 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a ^ b
;
1274 AssertNodeType (e3
, ExpressionType
.ExclusiveOr
);
1275 Assert (0, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1278 void ExclusiveOrTest_4 ()
1280 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a ^ b
;
1281 AssertNodeType (e4
, ExpressionType
.ExclusiveOr
);
1282 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1283 Assert (new MyType (-108), e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1286 void ExclusiveOrTest_5 ()
1288 Expression
<Func
<MyType
?, byte, int?>> e5
= (MyType
? a
, byte b
) => a ^ b
;
1289 AssertNodeType (e5
, ExpressionType
.ExclusiveOr
);
1290 Assert (null, e5
.Compile ().Invoke (null, 64));
1291 Assert (96, e5
.Compile ().Invoke (new MyType (64), 32));
1294 void ExclusiveOrTest_6 ()
1296 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e6
= (a
, b
) => a ^ b
;
1297 AssertNodeType (e6
, ExpressionType
.Convert
);
1298 Assert ((MyEnum
)3, e6
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
1299 Assert
<MyEnum
> (0, e6
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1302 void ExclusiveOrTest_7 ()
1304 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e7
= (a
, b
) => a ^ b
;
1305 AssertNodeType (e7
, ExpressionType
.Convert
);
1306 Assert (null, e7
.Compile ().Invoke (MyEnum
.Value_1
, null));
1307 Assert
<MyEnum
?> (0, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1310 void ExclusiveOrTest_8 ()
1312 Expression
<Func
<MyEnum
?, MyEnum
?>> e8
= (a
) => a ^
null;
1313 AssertNodeType (e8
, ExpressionType
.Convert
);
1314 Assert (null, e8
.Compile ().Invoke (MyEnum
.Value_1
));
1315 Assert (null, e8
.Compile ().Invoke (null));
1318 void GreaterThanTest ()
1320 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
> b
;
1321 AssertNodeType (e
, ExpressionType
.GreaterThan
);
1322 Assert (true, e
.Compile ().Invoke (60, 30));
1325 void GreaterThanTest_2 ()
1327 Expression
<Func
<uint?, byte?, bool>> e2
= (a
, b
) => a
> b
;
1328 AssertNodeType (e2
, ExpressionType
.GreaterThan
);
1329 Assert (false, e2
.Compile ().Invoke (null, 3));
1330 Assert (false, e2
.Compile ().Invoke (2, 2));
1333 void GreaterThanTest_3 ()
1335 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
> b
;
1336 AssertNodeType (e3
, ExpressionType
.GreaterThan
);
1337 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1340 void GreaterThanTest_4 ()
1342 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
> b
;
1343 AssertNodeType (e4
, ExpressionType
.GreaterThan
);
1344 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1345 Assert (false, e4
.Compile ().Invoke (null, null));
1346 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1349 void GreaterThanTest_5 ()
1351 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
> b
;
1352 AssertNodeType (e5
, ExpressionType
.GreaterThan
);
1353 Assert (false, e5
.Compile ().Invoke (null, 33));
1354 Assert (false, e5
.Compile ().Invoke (null, 0));
1355 Assert (true, e5
.Compile ().Invoke (new MyType (120), 3));
1358 void GreaterThanTest_6 ()
1360 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
> null;
1361 AssertNodeType (e6
, ExpressionType
.GreaterThan
);
1362 Assert (false, e6
.Compile ().Invoke (60));
1365 void GreaterThanTest_7 ()
1367 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
> b
;
1368 AssertNodeType (e7
, ExpressionType
.GreaterThan
);
1369 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1370 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1373 void GreaterThanTest_8 ()
1375 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
> b
;
1376 AssertNodeType (e8
, ExpressionType
.GreaterThan
);
1377 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1378 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1381 void GreaterThanOrEqualTest ()
1383 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
>= b
;
1384 AssertNodeType (e
, ExpressionType
.GreaterThanOrEqual
);
1385 Assert (true, e
.Compile ().Invoke (60, 30));
1388 void GreaterThanOrEqualTest_2 ()
1390 Expression
<Func
<byte?, byte?, bool>> e2
= (a
, b
) => a
>= b
;
1391 AssertNodeType (e2
, ExpressionType
.GreaterThanOrEqual
);
1392 Assert (false, e2
.Compile ().Invoke (null, 3));
1393 Assert (true, e2
.Compile ().Invoke (2, 2));
1396 void GreaterThanOrEqualTest_3 ()
1398 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
>= b
;
1399 AssertNodeType (e3
, ExpressionType
.GreaterThanOrEqual
);
1400 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
1403 void GreaterThanOrEqualTest_4 ()
1405 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
>= b
;
1406 AssertNodeType (e4
, ExpressionType
.GreaterThanOrEqual
);
1407 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1408 Assert (false, e4
.Compile ().Invoke (null, null));
1409 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1412 void GreaterThanOrEqualTest_5 ()
1414 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
>= b
;
1415 AssertNodeType (e5
, ExpressionType
.GreaterThanOrEqual
);
1416 Assert (false, e5
.Compile ().Invoke (null, 33));
1417 Assert (false, e5
.Compile ().Invoke (null, 0));
1418 Assert (true, e5
.Compile ().Invoke (new MyType (120), 3));
1421 void GreaterThanOrEqualTest_6 ()
1423 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
>= null;
1424 AssertNodeType (e6
, ExpressionType
.GreaterThanOrEqual
);
1425 Assert (false, e6
.Compile ().Invoke (60));
1428 void GreaterThanOrEqualTest_7 ()
1430 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
>= b
;
1431 AssertNodeType (e7
, ExpressionType
.GreaterThanOrEqual
);
1432 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1433 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1436 void GreaterThanOrEqualTest_8 ()
1438 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
>= b
;
1439 AssertNodeType (e8
, ExpressionType
.GreaterThanOrEqual
);
1440 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1441 Assert (true, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1446 var del
= new IntDelegate (TestInt
);
1447 Expression
<Func
<IntDelegate
, int>> e
= (a
) => a ();
1448 AssertNodeType (e
, ExpressionType
.Invoke
);
1449 Assert (29, e
.Compile ().Invoke (del
));
1452 void InvokeTest_2 ()
1454 Expression
<Func
<Func
<int, string>, int, string>> e2
= (a
, b
) => a (b
);
1455 AssertNodeType (e2
, ExpressionType
.Invoke
);
1456 Assert ("4", e2
.Compile ().Invoke ((a
) => (a
+1).ToString (), 3));
1461 Expression
<Func
<string, Func
<string>>> e
= (string s
) => () => s
;
1462 AssertNodeType (e
, ExpressionType
.Lambda
);
1463 Assert ("xx", e
.Compile ().Invoke ("xx") ());
1466 void LeftShiftTest ()
1468 Expression
<Func
<ulong, short, ulong>> e
= (ulong a
, short b
) => a
<< b
;
1469 AssertNodeType (e
, ExpressionType
.LeftShift
);
1470 Assert ((ulong) 0x7F000, e
.Compile ().Invoke (0xFE, 11));
1471 Assert ((ulong) 0x1FFFFFFFE, e
.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1473 // .net produces a strange result
1474 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
1475 // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1478 void LeftShiftTest_2 ()
1480 Expression
<Func
<MyType
, MyType
, int>> e2
= (MyType a
, MyType b
) => a
<< b
;
1481 AssertNodeType (e2
, ExpressionType
.LeftShift
);
1482 var c2
= e2
.Compile ();
1483 Assert (1024, c2 (new MyType (256), new MyType (2)));
1486 void LeftShiftTest_3 ()
1488 Expression
<Func
<long?, sbyte, long?>> e3
= (long? a
, sbyte b
) => a
<< b
;
1489 AssertNodeType (e3
, ExpressionType
.LeftShift
);
1490 Assert (null, e3
.Compile ().Invoke (null, 11));
1491 Assert (2048, e3
.Compile ().Invoke (1024, 1));
1494 void LeftShiftTest_4 ()
1496 Expression
<Func
<MyType
?, MyType
?, int?>> e4
= (MyType
? a
, MyType
? b
) => a
<< b
;
1497 AssertNodeType (e4
, ExpressionType
.LeftShift
);
1498 var c4
= e4
.Compile ();
1499 Assert (null, c4 (new MyType (8), null));
1500 Assert (null, c4 (null, new MyType (8)));
1501 Assert (1024, c4 (new MyType (256), new MyType (2)));
1504 void LeftShiftTest_5 ()
1506 Expression
<Func
<ushort, int?>> e5
= (ushort a
) => a
<< null;
1507 AssertNodeType (e5
, ExpressionType
.LeftShift
);
1508 Assert (null, e5
.Compile ().Invoke (30));
1511 void LeftShiftTest_6 ()
1513 Expression
<Func
<int, MyTypeImplicitOnly
, int>> e
= (a
, b
) => a
<< b
;
1514 AssertNodeType (e
, ExpressionType
.LeftShift
);
1515 Assert (0x7F0, e
.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
1518 void LessThanTest ()
1520 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
< b
;
1521 AssertNodeType (e
, ExpressionType
.LessThan
);
1522 Assert (false, e
.Compile ().Invoke (60, 30));
1525 void LessThanTest_2 ()
1527 Expression
<Func
<uint?, byte?, bool>> e2
= (a
, b
) => a
< b
;
1528 AssertNodeType (e2
, ExpressionType
.LessThan
);
1529 Assert (false, e2
.Compile ().Invoke (null, 3));
1530 Assert (false, e2
.Compile ().Invoke (2, 2));
1533 void LessThanTest_3 ()
1535 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
< b
;
1536 AssertNodeType (e3
, ExpressionType
.LessThan
);
1537 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1540 void LessThanTest_4 ()
1542 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
< b
;
1543 AssertNodeType (e4
, ExpressionType
.LessThan
);
1544 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1545 Assert (false, e4
.Compile ().Invoke (null, null));
1546 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1549 void LessThanTest_5 ()
1551 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
< b
;
1552 AssertNodeType (e5
, ExpressionType
.LessThan
);
1553 Assert (false, e5
.Compile ().Invoke (null, 33));
1554 Assert (false, e5
.Compile ().Invoke (null, 0));
1555 Assert (false, e5
.Compile ().Invoke (new MyType (120), 3));
1558 void LessThanTest_6 ()
1560 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
< null;
1561 AssertNodeType (e6
, ExpressionType
.LessThan
);
1562 Assert (false, e6
.Compile ().Invoke (60));
1565 void LessThanTest_7 ()
1567 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
< b
;
1568 AssertNodeType (e7
, ExpressionType
.LessThan
);
1569 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1570 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1573 void LessThanTest_8 ()
1575 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
< b
;
1576 AssertNodeType (e8
, ExpressionType
.LessThan
);
1577 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1578 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1581 void LessThanTest_9 ()
1583 Expression
<Func
<object, int?, bool>> e
= (a
, b
) => (int) a
< b
;
1584 AssertNodeType (e
, ExpressionType
.LessThan
);
1585 Assert (false, e
.Compile ().Invoke (1, null));
1586 Assert (false, e
.Compile ().Invoke (3, 3));
1587 Assert (true, e
.Compile ().Invoke (1, 3));
1590 void LessThanOrEqualTest ()
1592 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
<= b
;
1593 AssertNodeType (e
, ExpressionType
.LessThanOrEqual
);
1594 Assert (false, e
.Compile ().Invoke (60, 30));
1597 void LessThanOrEqualTest_2 ()
1599 Expression
<Func
<byte?, byte?, bool>> e2
= (a
, b
) => a
<= b
;
1600 AssertNodeType (e2
, ExpressionType
.LessThanOrEqual
);
1601 Assert (false, e2
.Compile ().Invoke (null, 3));
1602 Assert (true, e2
.Compile ().Invoke (2, 2));
1605 void LessThanOrEqualTest_3 ()
1607 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
<= b
;
1608 AssertNodeType (e3
, ExpressionType
.LessThanOrEqual
);
1609 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1612 void LessThanOrEqualTest_4 ()
1614 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
<= b
;
1615 AssertNodeType (e4
, ExpressionType
.LessThanOrEqual
);
1616 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1617 Assert (false, e4
.Compile ().Invoke (null, null));
1618 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1621 void LessThanOrEqualTest_5 ()
1623 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
<= b
;
1624 AssertNodeType (e5
, ExpressionType
.LessThanOrEqual
);
1625 Assert (false, e5
.Compile ().Invoke (null, 33));
1626 Assert (false, e5
.Compile ().Invoke (null, 0));
1627 Assert (false, e5
.Compile ().Invoke (new MyType (120), 3));
1630 void LessThanOrEqualTest_6 ()
1632 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
<= null;
1633 AssertNodeType (e6
, ExpressionType
.LessThanOrEqual
);
1634 Assert (false, e6
.Compile ().Invoke (60));
1637 void LessThanOrEqualTest_7 ()
1639 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
<= b
;
1640 AssertNodeType (e7
, ExpressionType
.LessThanOrEqual
);
1641 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1642 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1645 void LessThanOrEqualTest_8 ()
1647 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
<= b
;
1648 AssertNodeType (e8
, ExpressionType
.LessThanOrEqual
);
1649 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1650 Assert (true, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1653 void ListInitTest ()
1655 Expression
<Func
<List
<object>>> e1
= () => new List
<object> { "Hello", "", null, "World", 5 }
;
1656 AssertNodeType (e1
, ExpressionType
.ListInit
);
1657 var re1
= e1
.Compile ().Invoke ();
1658 Assert (null, re1
[2]);
1659 Assert ("World", re1
[3]);
1660 Assert (5, re1
[4]);
1663 void ListInitTest_2 ()
1665 Expression
<Func
<int, Dictionary
<string, int>>> e2
= (int value) => new Dictionary
<string, int> (3) { { "A", value }
, { "B", 2 }
};
1666 AssertNodeType (e2
, ExpressionType
.ListInit
);
1667 var re2
= e2
.Compile ().Invoke (3456);
1668 Assert (3456, re2
["A"]);
1671 void MemberAccessTest ()
1673 MemberAccessData d
= new MemberAccessData ();
1675 Expression
<Func
<bool>> e
= () => d
.BoolValue
;
1676 AssertNodeType (e
, ExpressionType
.MemberAccess
);
1677 Assert (true, e
.Compile ().Invoke ());
1678 d
.BoolValue
= false;
1679 Assert (false, e
.Compile ().Invoke ());
1682 void MemberAccessTest_2 ()
1684 Expression
<Func
<decimal>> e2
= () => MemberAccessData
.DecimalValue
;
1685 AssertNodeType (e2
, ExpressionType
.MemberAccess
);
1686 Assert (decimal.MinValue
, e2
.Compile ().Invoke ());
1689 void MemberAccessTest_3 ()
1691 MemberAccessData d
= new MemberAccessData ();
1692 d
.VolatileValue
= 492;
1693 Expression
<Func
<uint>> e3
= () => d
.VolatileValue
;
1694 AssertNodeType (e3
, ExpressionType
.MemberAccess
);
1695 Assert
<uint> (492, e3
.Compile ().Invoke ());
1698 void MemberAccessTest_4 ()
1700 MemberAccessData d
= new MemberAccessData ();
1701 Expression
<Func
<string[]>> e4
= () => d
.StringValues
;
1702 AssertNodeType (e4
, ExpressionType
.MemberAccess
);
1703 Assert (null, e4
.Compile ().Invoke ());
1706 void MemberAccessTest_5 ()
1708 MemberAccessData d
= new MemberAccessData ();
1709 var e5
= d
.GetEvent ();
1710 AssertNodeType (e5
, ExpressionType
.MemberAccess
);
1711 Assert (null, e5
.Compile ().Invoke ());
1714 void MemberAccessTest_6 ()
1716 MemberAccessData d
= new MemberAccessData ();
1717 Expression
<Func
<MyType
>> e6
= () => d
.MyTypeProperty
;
1718 AssertNodeType (e6
, ExpressionType
.MemberAccess
);
1719 Assert (new MyType (), e6
.Compile ().Invoke ());
1722 void MemberAccessTest_7 ()
1724 MemberAccessData d
= new MemberAccessData ();
1725 Expression
<Func
<MyType
, short>> e7
= a
=> a
.ShortProp
;
1726 AssertNodeType (e7
, ExpressionType
.MemberAccess
);
1727 MyType mt
= new MyType ();
1729 Assert (124, e7
.Compile ().Invoke (mt
));
1732 void MemberAccessTest_8 ()
1734 Expression
<Func
<string>> e8
= () => MemberAccessData
.StaticProperty
;
1735 AssertNodeType (e8
, ExpressionType
.MemberAccess
);
1736 Assert ("alo", e8
.Compile ().Invoke ());
1739 void MemberAccessTest_9 ()
1741 string s
= "localvar";
1742 Expression
<Func
<string>> e9
= () => s
;
1745 AssertNodeType (e9
, ExpressionType
.MemberAccess
);
1746 Assert ("changed", e9
.Compile ().Invoke ());
1749 void MemberInitTest ()
1751 Expression
<Func
<MemberAccessData
>> e
= () => new MemberAccessData
{
1752 VolatileValue
= 2, StringValues
= new string [] { "sv" }
, MyTypeProperty
= new MyType (692)
1754 AssertNodeType (e
, ExpressionType
.MemberInit
);
1755 var r1
= e
.Compile ().Invoke ();
1756 Assert
<uint> (2, r1
.VolatileValue
);
1757 Assert (new string[] { "sv" }
, r1
.StringValues
);
1758 Assert (new MyType (692), r1
.MyTypeProperty
);
1761 void MemberInitTest_2 ()
1763 Expression
<Func
<MemberAccessData
>> e2
= () => new MemberAccessData
{
1764 ListValues
= new List
<string> { "a", null }
1767 AssertNodeType (e2
, ExpressionType
.MemberInit
);
1768 var r2
= e2
.Compile ().Invoke ();
1769 Assert ("a", r2
.ListValues
[0]);
1772 void MemberInitTest_3 ()
1774 Expression
<Func
<short, MyType
>> e3
= a
=> new MyType { ShortProp = a }
;
1775 AssertNodeType (e3
, ExpressionType
.MemberInit
);
1776 var r3
= e3
.Compile ().Invoke (33);
1777 Assert (33, r3
.ShortProp
);
1780 void MemberInitTest_4 ()
1782 Expression
<Func
<int>> e
= () => new int { }
;
1784 AssertNodeType (e
, ExpressionType
.MemberInit
);
1785 var r
= e
.Compile ().Invoke ();
1789 void MemberInitTest_5 ()
1791 Expression
<Func
<MemberAccessData
>> e
= () => new MemberAccessData { SetOnly = new object { }
};
1793 AssertNodeType (e
, ExpressionType
.MemberInit
);
1799 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
% b
;
1800 AssertNodeType (e
, ExpressionType
.Modulo
);
1801 Assert (29, e
.Compile ().Invoke (60, 31));
1804 void ModuloTest_2 ()
1806 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
% b
;
1807 AssertNodeType (e2
, ExpressionType
.Modulo
);
1808 Assert (null, e2
.Compile ().Invoke (null, 3));
1809 Assert (1.1, e2
.Compile ().Invoke (3.1, 2));
1812 void ModuloTest_3 ()
1814 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
% b
;
1815 AssertNodeType (e3
, ExpressionType
.Modulo
);
1816 Assert (0, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1819 void ModuloTest_4 ()
1821 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
% b
;
1822 AssertNodeType (e4
, ExpressionType
.Modulo
);
1823 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1824 Assert (new MyType (12), e4
.Compile ().Invoke (new MyType (12), new MyType (-20)));
1827 void ModuloTest_5 ()
1829 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
% b
;
1830 AssertNodeType (e5
, ExpressionType
.Modulo
);
1831 Assert (1, e5
.Compile ().Invoke (99, new MyType (2)));
1834 void ModuloTest_6 ()
1836 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
% b
;
1837 AssertNodeType (e6
, ExpressionType
.Modulo
);
1838 Assert (100, e6
.Compile ().Invoke (100, new MyType (200)));
1839 Assert (null, e6
.Compile ().Invoke (20, null));
1842 void ModuloTest_7 ()
1844 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => a
% null;
1845 AssertNodeType (e7
, ExpressionType
.Modulo
);
1846 Assert (null, e7
.Compile ().Invoke (60));
1849 void MultiplyTest ()
1851 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
* b
;
1852 AssertNodeType (e
, ExpressionType
.Multiply
);
1853 Assert (1860, e
.Compile ().Invoke (60, 31));
1854 Assert (2147483617, e
.Compile ().Invoke (int.MaxValue
, 31));
1857 void MultiplyTest_2 ()
1859 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
* b
;
1860 AssertNodeType (e2
, ExpressionType
.Multiply
);
1861 Assert (null, e2
.Compile ().Invoke (null, 3));
1862 Assert (6.2, e2
.Compile ().Invoke (3.1, 2));
1865 void MultiplyTest_3 ()
1867 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
* b
;
1868 AssertNodeType (e3
, ExpressionType
.Multiply
);
1869 Assert (400, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1872 void MultiplyTest_4 ()
1874 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
* b
;
1875 AssertNodeType (e4
, ExpressionType
.Multiply
);
1876 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1877 Assert (new MyType (-240), e4
.Compile ().Invoke (new MyType (12), new MyType (-20)));
1880 void MultiplyTest_5 ()
1882 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
* b
;
1883 AssertNodeType (e5
, ExpressionType
.Multiply
);
1884 Assert (198, e5
.Compile ().Invoke (99, new MyType (2)));
1887 void MultiplyTest_6 ()
1889 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
* b
;
1890 AssertNodeType (e6
, ExpressionType
.Multiply
);
1891 Assert (0, e6
.Compile ().Invoke (int.MinValue
, new MyType (200)));
1892 Assert (null, e6
.Compile ().Invoke (20, null));
1895 void MultiplyTest_7 ()
1897 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => a
* null;
1898 AssertNodeType (e7
, ExpressionType
.Multiply
);
1899 Assert (null, e7
.Compile ().Invoke (60));
1902 void MultiplyTest_8 ()
1904 Expression
<Func
<double, ulong?, double?>> e
= (a
, b
) => a
* b
;
1905 AssertNodeType (e
, ExpressionType
.Multiply
);
1906 Assert (180, e
.Compile () (60, 3));
1907 Assert (null, e
.Compile () (60, null));
1910 void MultiplyCheckedTest ()
1913 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
* b
;
1914 AssertNodeType (e
, ExpressionType
.MultiplyChecked
);
1916 e
.Compile ().Invoke (int.MaxValue
, 309);
1917 throw new ApplicationException ("MultiplyCheckedTest #1");
1918 } catch (OverflowException
) { }
1922 void MultiplyCheckedTest_2 ()
1925 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a
* b
;
1926 AssertNodeType (e2
, ExpressionType
.MultiplyChecked
);
1927 Assert (null, e2
.Compile ().Invoke (null, 3));
1928 Assert (14025, e2
.Compile ().Invoke (byte.MaxValue
, 55));
1932 void MultiplyCheckedTest_3 ()
1935 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
* b
;
1936 AssertNodeType (e3
, ExpressionType
.Multiply
);
1937 Assert (-600, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
1941 void MultiplyCheckedTest_4 ()
1944 Expression
<Func
<double, double, double>> e4
= (a
, b
) => a
* b
;
1945 AssertNodeType (e4
, ExpressionType
.Multiply
);
1946 Assert (double.PositiveInfinity
, e4
.Compile ().Invoke (double.MaxValue
, int.MaxValue
));
1950 void MultiplyCheckedTest_5 ()
1953 Expression
<Func
<float?, float?, float?>> e5
= (a
, b
) => b
* a
;
1954 AssertNodeType (e5
, ExpressionType
.MultiplyChecked
);
1955 Assert (float.PositiveInfinity
, e5
.Compile ().Invoke (float.Epsilon
, float.PositiveInfinity
));
1961 Expression
<Func
<int, int>> e
= (a
) => -a
;
1962 AssertNodeType (e
, ExpressionType
.Negate
);
1963 Assert (30, e
.Compile ().Invoke (-30));
1966 void NegateTest_2 ()
1968 Expression
<Func
<sbyte, int>> e2
= (a
) => -(-a
);
1969 AssertNodeType (e2
, ExpressionType
.Negate
);
1970 Assert (-10, e2
.Compile ().Invoke (-10));
1973 void NegateTest_3 ()
1975 Expression
<Func
<long?, long?>> e3
= (a
) => -a
;
1976 AssertNodeType (e3
, ExpressionType
.Negate
);
1977 Assert (long.MinValue
+ 1, e3
.Compile ().Invoke (long.MaxValue
));
1978 Assert (null, e3
.Compile ().Invoke (null));
1981 void NegateTest_4 ()
1983 Expression
<Func
<MyType
, MyType
>> e4
= (a
) => -a
;
1984 AssertNodeType (e4
, ExpressionType
.Negate
);
1985 Assert (new MyType (14), e4
.Compile ().Invoke (new MyType (-14)));
1988 void NegateTest_5 ()
1990 Expression
<Func
<MyType
?, MyType
?>> e5
= (a
) => -a
;
1991 AssertNodeType (e5
, ExpressionType
.Negate
);
1992 Assert (new MyType (-33), e5
.Compile ().Invoke (new MyType (33)));
1993 Assert (null, e5
.Compile ().Invoke (null));
1996 void NegateTest_6 ()
1998 Expression
<Func
<MyTypeImplicitOnly
, int>> e6
= (MyTypeImplicitOnly a
) => -a
;
1999 AssertNodeType (e6
, ExpressionType
.Negate
);
2000 Assert (-4, e6
.Compile ().Invoke (new MyTypeImplicitOnly (4)));
2003 void NegateTest_7 ()
2005 Expression
<Func
<MyTypeImplicitOnly
?, int?>> e7
= (MyTypeImplicitOnly
? a
) => -a
;
2006 AssertNodeType (e7
, ExpressionType
.Negate
);
2007 Assert (-46, e7
.Compile ().Invoke (new MyTypeImplicitOnly (46)));
2009 // Another version of MS bug when predefined conversion is required on nullable user operator
2010 // Assert (null, e7.Compile ().Invoke (null));
2013 void NegateTest_8 ()
2015 Expression
<Func
<sbyte?, int?>> e8
= (a
) => -a
;
2016 AssertNodeType (e8
, ExpressionType
.Negate
);
2017 Assert (11, e8
.Compile ().Invoke (-11));
2020 void NegateTest_9 ()
2022 Expression
<Func
<uint, long>> e9
= (a
) => -a
;
2023 AssertNodeType (e9
, ExpressionType
.Negate
);
2024 Assert (-2, e9
.Compile ().Invoke (2));
2027 void NegateTestChecked ()
2030 Expression
<Func
<int, int>> e
= (int a
) => -a
;
2031 AssertNodeType (e
, ExpressionType
.NegateChecked
);
2033 e
.Compile ().Invoke (int.MinValue
);
2034 throw new ApplicationException ("NegateTestChecked #1");
2035 } catch (OverflowException
) { }
2039 void NegateTestChecked_2 ()
2042 Expression
<Func
<byte?, int?>> e2
= (a
) => -a
;
2043 AssertNodeType (e2
, ExpressionType
.NegateChecked
);
2044 Assert (null, e2
.Compile ().Invoke (null));
2045 Assert (-255, e2
.Compile ().Invoke (byte.MaxValue
));
2049 void NegateTestChecked_3 ()
2052 Expression
<Func
<MyType
, MyType
>> e3
= (MyType a
) => -a
;
2053 AssertNodeType (e3
, ExpressionType
.Negate
);
2054 Assert (20, e3
.Compile ().Invoke (new MyType (-20)));
2058 void NegateTestChecked_4 ()
2061 Expression
<Func
<double, double>> e4
= (a
) => -a
;
2062 AssertNodeType (e4
, ExpressionType
.Negate
);
2063 Assert (double.NegativeInfinity
, e4
.Compile ().Invoke (double.PositiveInfinity
));
2067 void NewArrayInitTest ()
2069 Expression
<Func
<int []>> e
= () => new int [1] { 5 }
;
2070 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
2071 Assert (new int [1] { 5 }
, e
.Compile ().Invoke ());
2074 void NewArrayInitTest_2 ()
2076 Expression
<Func
<int []>> e1
= () => new int [] { }
;
2077 AssertNodeType (e1
, ExpressionType
.NewArrayInit
);
2078 Assert (new int [0], e1
.Compile ().Invoke ());
2081 void NewArrayInitTest_3 ()
2083 Expression
<Func
<ushort, ulong? []>> e2
= (ushort a
) => new ulong? [] { a }
;
2084 AssertNodeType (e2
, ExpressionType
.NewArrayInit
);
2085 Assert (new ulong? [1] { ushort.MaxValue }
, e2
.Compile ().Invoke (ushort.MaxValue
));
2088 void NewArrayInitTest_4 ()
2090 Expression
<Func
<char [] []>> e3
= () => new char [] [] { new char [] { 'a' }
};
2091 AssertNodeType (e3
, ExpressionType
.NewArrayInit
);
2092 Assert (new char [] { 'a' }
, e3
.Compile ().Invoke () [0]);
2095 void NewArrayInitTest_5 ()
2097 Expression
<Func
<int?[]>> e
= () => new int?[] { null, 3, 4 }
;
2098 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
2099 Assert (3, e
.Compile ().Invoke ().Length
);
2102 void NewArrayInitTest_6 ()
2104 Expression
<Func
<string []>> e
= () => new [] { null, "a" }
;
2105 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
2106 Assert (2, e
.Compile ().Invoke ().Length
);
2109 void NewArrayBoundsTest ()
2111 Expression
<Func
<int [,]>> e
= () => new int [2,3];
2112 AssertNodeType (e
, ExpressionType
.NewArrayBounds
);
2113 Assert (new int [2,3].Length
, e
.Compile ().Invoke ().Length
);
2116 void NewArrayBoundsTest_2 ()
2118 Expression
<Func
<int[,]>> e2
= () => new int [0,0];
2119 AssertNodeType (e2
, ExpressionType
.NewArrayBounds
);
2120 Assert (new int [0, 0].Length
, e2
.Compile ().Invoke ().Length
);
2123 void NewArrayBoundsTest_3 ()
2125 Expression
<Func
<int []>> e
= () => new int [0];
2126 AssertNodeType (e
, ExpressionType
.NewArrayBounds
);
2127 Assert (0, e
.Compile ().Invoke ().Length
);
2130 void NewArrayBoundsTest_4 ()
2132 const ulong max
= ulong.MaxValue
;
2134 Expression
<Func
<bool[]>> e
= () => new bool [max
];
2135 AssertNodeType (e
, ExpressionType
.NewArrayBounds
);
2140 Expression
<Func
<MyType
>> e
= () => new MyType (2);
2141 AssertNodeType (e
, ExpressionType
.New
);
2142 Assert (new MyType (2), e
.Compile ().Invoke ());
2147 Expression
<Func
<MyType
>> e2
= () => new MyType ();
2148 AssertNodeType (e2
, ExpressionType
.New
);
2149 Assert (new MyType (), e2
.Compile ().Invoke ());
2154 Expression
<Func
<NewTest
<bool>>> e3
= () => new NewTest
<bool> (true);
2155 AssertNodeType (e3
, ExpressionType
.New
);
2156 Assert (new NewTest
<bool> (true), e3
.Compile ().Invoke ());
2161 Expression
<Func
<decimal, NewTest
<decimal>>> e4
= (decimal d
) => new NewTest
<decimal> (1, 5, d
);
2162 AssertNodeType (e4
, ExpressionType
.New
);
2163 Assert (new NewTest
<decimal> (1, 5, -9), e4
.Compile ().Invoke (-9));
2168 Expression
<Func
<object>> e5
= () => new { A = 9, Value = "a" }
;
2169 AssertNodeType (e5
, ExpressionType
.New
);
2170 var ne
= ((NewExpression
) e5
.Body
);
2172 Assert (2, ne
.Members
.Count
, "members count");
2174 // Behaviour is different between .NET 3.5 and .NET 4.0
2175 if (ne
.Members
[0].MemberType
== MemberTypes
.Property
) {
2176 Assert ("A", ne
.Members
[0].Name
, "Name #1");
2177 Assert ("Value", ne
.Members
[1].Name
, "Name #2");
2179 Assert ("get_A", ne
.Members
[0].Name
, "Name #1");
2180 Assert ("get_Value", ne
.Members
[1].Name
, "Name #2");
2183 Assert (new { A = 9, Value = "a" }
, e5
.Compile ().Invoke ());
2188 Expression
<Func
<object>> e5
= () => new { A = 9, Value = new MyType (5) }
;
2189 AssertNodeType (e5
, ExpressionType
.New
);
2192 // CSC bug: emits new MyEnum as a constant
2195 Expression
<Func
<MyEnum
>> e
= () => new MyEnum ();
2196 AssertNodeType (e
, ExpressionType
.New
);
2197 Assert
<MyEnum
> (0, e
.Compile ().Invoke ());
2202 Expression
<Func
<DateTime
>> e
= () => new DateTime ();
2203 AssertNodeType (e
, ExpressionType
.New
);
2204 Assert (null, ((NewExpression
)e
.Body
).Constructor
, "default ctor");
2209 Expression
<Func
<bool, bool>> e
= (bool a
) => !a
;
2210 AssertNodeType (e
, ExpressionType
.Not
);
2211 Assert (false, e
.Compile ().Invoke (true));
2216 Expression
<Func
<MyType
, bool>> e2
= (MyType a
) => !a
;
2217 AssertNodeType (e2
, ExpressionType
.Not
);
2218 Assert (true, e2
.Compile ().Invoke (new MyType (1)));
2219 Assert (false, e2
.Compile ().Invoke (new MyType (-1)));
2224 Expression
<Func
<int, int>> e3
= (int a
) => ~a
;
2225 AssertNodeType (e3
, ExpressionType
.Not
);
2226 Assert (-8, e3
.Compile ().Invoke (7));
2231 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => ~a
;
2232 AssertNodeType (e4
, ExpressionType
.Not
);
2233 Assert (0, e4
.Compile ().Invoke (new MyType (-1)));
2238 Expression
<Func
<ulong, ulong>> e5
= (ulong a
) => ~a
;
2239 AssertNodeType (e5
, ExpressionType
.Not
);
2240 Assert
<ulong> (18446744073709551608, e5
.Compile ().Invoke (7));
2245 Expression
<Func
<MyEnum
, MyEnum
>> e6
= (MyEnum a
) => ~a
;
2246 AssertNodeType (e6
, ExpressionType
.Convert
);
2247 Assert ((MyEnum
)254, e6
.Compile ().Invoke (MyEnum
.Value_1
));
2250 void NotNullableTest ()
2252 Expression
<Func
<bool?, bool?>> e
= (bool? a
) => !a
;
2253 AssertNodeType (e
, ExpressionType
.Not
);
2254 Assert (false, e
.Compile ().Invoke (true));
2255 Assert (null, e
.Compile ().Invoke (null));
2258 void NotNullableTest_2 ()
2260 Expression
<Func
<MyType
?, bool?>> e2
= (MyType
? a
) => !a
;
2261 AssertNodeType (e2
, ExpressionType
.Not
);
2262 Assert (true, e2
.Compile ().Invoke (new MyType (1)));
2263 Assert (null, e2
.Compile ().Invoke (null));
2266 void NotNullableTest_3 ()
2268 Expression
<Func
<sbyte?, int?>> e3
= (sbyte? a
) => ~a
;
2269 AssertNodeType (e3
, ExpressionType
.Not
);
2270 Assert (-5, e3
.Compile ().Invoke (4));
2271 Assert (null, e3
.Compile ().Invoke (null));
2274 void NotNullableTest_4 ()
2276 Expression
<Func
<MyType
?, int?>> e4
= (MyType
? a
) => ~a
;
2277 AssertNodeType (e4
, ExpressionType
.Not
);
2278 Assert (0, e4
.Compile ().Invoke (new MyType (-1)));
2279 Assert (null, e4
.Compile ().Invoke (null));
2282 void NotNullableTest_5 ()
2284 Expression
<Func
<MyEnum
?, MyEnum
?>> e5
= (MyEnum
? a
) => ~a
;
2285 AssertNodeType (e5
, ExpressionType
.Convert
);
2286 Assert ((MyEnum
) 254, e5
.Compile ().Invoke (MyEnum
.Value_1
));
2287 Assert (null, e5
.Compile ().Invoke (null));
2290 void NotEqualTest ()
2292 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
!= b
;
2293 AssertNodeType (e
, ExpressionType
.NotEqual
);
2294 Assert (true, e
.Compile ().Invoke (60, 30));
2295 Assert (false, e
.Compile ().Invoke (-1, -1));
2298 void NotEqualTest_2 ()
2300 Expression
<Func
<sbyte?, sbyte?, bool>> e2
= (a
, b
) => a
!= b
;
2301 AssertNodeType (e2
, ExpressionType
.NotEqual
);
2302 Assert (false, e2
.Compile ().Invoke (3, 3));
2303 Assert (true, e2
.Compile ().Invoke (3, 2));
2306 void NotEqualTest_3 ()
2308 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
!= b
;
2309 AssertNodeType (e3
, ExpressionType
.NotEqual
);
2310 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
2313 void NotEqualTest_4 ()
2315 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
!= b
;
2316 AssertNodeType (e4
, ExpressionType
.NotEqual
);
2317 Assert (true, e4
.Compile ().Invoke (null, new MyType (-20)));
2318 Assert (false, e4
.Compile ().Invoke (null, null));
2319 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (120)));
2322 void NotEqualTest_5 ()
2324 Expression
<Func
<bool?, bool?, bool>> e5
= (bool? a
, bool? b
) => a
!= b
;
2325 AssertNodeType (e5
, ExpressionType
.NotEqual
);
2326 Assert (true, e5
.Compile ().Invoke (true, null));
2327 Assert (false, e5
.Compile ().Invoke (null, null));
2328 Assert (false, e5
.Compile ().Invoke (false, false));
2331 void NotEqualTest_6 ()
2333 Expression
<Func
<bool, bool>> e6
= (bool a
) => a
!= null;
2334 AssertNodeType (e6
, ExpressionType
.NotEqual
);
2335 Assert (true, e6
.Compile ().Invoke (true));
2336 Assert (true, e6
.Compile ().Invoke (false));
2339 void NotEqualTest_7 ()
2341 Expression
<Func
<string, string, bool>> e7
= (string a
, string b
) => a
!= b
;
2342 AssertNodeType (e7
, ExpressionType
.NotEqual
);
2343 Assert (false, e7
.Compile ().Invoke (null, null));
2344 Assert (true, e7
.Compile ().Invoke ("a", "A"));
2345 Assert (false, e7
.Compile ().Invoke ("a", "a"));
2348 void NotEqualTest_8 ()
2350 Expression
<Func
<object, bool>> e8
= (object a
) => null != a
;
2351 AssertNodeType (e8
, ExpressionType
.NotEqual
);
2352 Assert (false, e8
.Compile ().Invoke (null));
2353 Assert (true, e8
.Compile ().Invoke ("a"));
2354 Assert (true, e8
.Compile ().Invoke (this));
2357 void NotEqualTest_9 ()
2359 Expression
<Func
<MyEnum
, MyEnum
, bool>> e9
= (a
, b
) => a
!= b
;
2360 AssertNodeType (e9
, ExpressionType
.NotEqual
);
2361 Assert (true, e9
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2362 Assert (false, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2365 void NotEqualTest_10 ()
2367 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e10
= (a
, b
) => a
!= b
;
2368 AssertNodeType (e10
, ExpressionType
.NotEqual
);
2369 Assert (true, e10
.Compile ().Invoke (MyEnum
.Value_1
, null));
2370 Assert (false, e10
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2373 void NotEqualTest_11 ()
2375 Expression
<Func
<MyEnum
?, bool>> e11
= (a
) => a
!= null;
2376 AssertNodeType (e11
, ExpressionType
.NotEqual
);
2377 Assert (true, e11
.Compile ().Invoke (MyEnum
.Value_1
));
2378 Assert (false, e11
.Compile ().Invoke (null));
2383 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
| b
;
2385 AssertNodeType (e
, ExpressionType
.Or
);
2386 Func
<bool, bool, bool> c
= e
.Compile ();
2388 Assert (true, c (true, true));
2389 Assert (true, c (true, false));
2390 Assert (true, c (false, true));
2391 Assert (false, c (false, false));
2396 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
| b
;
2397 AssertNodeType (e2
, ExpressionType
.Or
);
2398 var c2
= e2
.Compile ();
2399 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2404 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e3
= (a
, b
) => a
| b
;
2405 AssertNodeType (e3
, ExpressionType
.Convert
);
2406 Assert ((MyEnum
)3, e3
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2407 Assert (MyEnum
.Value_2
, e3
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2410 void OrNullableTest ()
2412 Expression
<Func
<bool?, bool?, bool?>> e
= (bool? a
, bool? b
) => a
| b
;
2414 AssertNodeType (e
, ExpressionType
.Or
);
2415 Func
<bool?, bool?, bool?> c
= e
.Compile ();
2417 Assert (true, c (true, true));
2418 Assert (true, c (true, false));
2419 Assert (true, c (false, true));
2420 Assert (false, c (false, false));
2422 Assert (true, c (true, null));
2423 Assert (null, c (false, null));
2424 Assert (null, c (null, false));
2425 Assert (true, c (true, null));
2426 Assert (null, c (null, null));
2429 void OrNullableTest_2 ()
2431 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e2
= (MyType
? a
, MyType
? b
) => a
| b
;
2432 AssertNodeType (e2
, ExpressionType
.Or
);
2433 var c2
= e2
.Compile ();
2434 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2435 Assert (null, c2 (new MyType (1), null));
2438 void OrNullableTest_3 ()
2440 Expression
<Func
<MyType
?, uint, long?>> e3
= (MyType
? a
, uint b
) => a
| b
;
2441 AssertNodeType (e3
, ExpressionType
.Or
);
2442 var c3
= e3
.Compile ();
2443 Assert (9, c3 (new MyType (1), 8));
2446 void OrNullableTest_4 ()
2448 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e4
= (a
, b
) => a
| b
;
2449 AssertNodeType (e4
, ExpressionType
.Convert
);
2450 Assert (null, e4
.Compile ().Invoke (null, MyEnum
.Value_2
));
2451 Assert ((MyEnum
)3, e4
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2456 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
|| b
;
2457 AssertNodeType (e
, ExpressionType
.OrElse
);
2458 Assert (true, e
.Compile ().Invoke (true, false));
2461 void OrElseTest_2 ()
2463 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
|| b
;
2464 AssertNodeType (e2
, ExpressionType
.OrElse
);
2465 Assert (new MyType (64), e2
.Compile ().Invoke (new MyType (64), new MyType (64)));
2466 Assert (new MyType (32), e2
.Compile ().Invoke (new MyType (32), new MyType (64)));
2469 void ParameterTest ()
2471 Expression
<Func
<string, string>> e
= (string a
) => a
;
2472 AssertNodeType (e
, ExpressionType
.Parameter
);
2473 Assert ("t", e
.Compile ().Invoke ("t"));
2476 void ParameterTest_2 ()
2478 Expression
<Func
<object[], object[]>> e2
= (object[] a
) => a
;
2479 AssertNodeType (e2
, ExpressionType
.Parameter
);
2480 Assert (new object [0], e2
.Compile ().Invoke (new object [0]));
2483 void ParameterTest_3 ()
2485 Expression
<Func
<IntPtr
, IntPtr
>> e3
= a
=> a
;
2486 AssertNodeType (e3
, ExpressionType
.Parameter
);
2487 Assert (IntPtr
.Zero
, e3
.Compile ().Invoke (IntPtr
.Zero
));
2490 unsafe void ParameterTest_4 ()
2492 Expression
<Func
<int*[], int* []>> e4
= (a
) => a
;
2493 AssertNodeType (e4
, ExpressionType
.Parameter
);
2494 Assert
<int*[]> (null, e4
.Compile ().Invoke (null));
2495 int* e4_el
= stackalloc int [5];
2496 int*[] ptr
= new int*[] { e4_el }
;
2497 Assert
<int*[]> (ptr
, e4
.Compile ().Invoke (ptr
));
2502 Expression
<Func
<Expression
<Func
<int>>>> e
= () => () => 2;
2503 AssertNodeType (e
, ExpressionType
.Quote
);
2504 Assert (2, e
.Compile ().Invoke ().Compile ().Invoke ());
2509 Expression
<Func
<string, Expression
<Func
<string>>>> e
= (string s
) => () => s
;
2510 AssertNodeType (e
, ExpressionType
.Quote
);
2512 Assert ("data", e
.Compile ().Invoke ("data").Compile ().Invoke ());
2515 void RightShiftTest ()
2517 Expression
<Func
<ulong, short, ulong>> e
= (ulong a
, short b
) => a
>> b
;
2518 AssertNodeType (e
, ExpressionType
.RightShift
);
2519 Assert ((ulong) 0x1FD940L
, e
.Compile ().Invoke (0xFECA0000, 11));
2520 Assert ((ulong) 0x7FFFFFFF, e
.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2522 // .net produces a strange result
2523 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
2524 // Assert ((ulong)0, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2527 void RightShiftTest_2 ()
2529 Expression
<Func
<MyType
, MyType
, int>> e2
= (MyType a
, MyType b
) => a
>> b
;
2530 AssertNodeType (e2
, ExpressionType
.RightShift
);
2531 var c2
= e2
.Compile ();
2532 Assert (64, c2 (new MyType (256), new MyType (2)));
2535 void RightShiftTest_3 ()
2537 Expression
<Func
<long?, sbyte, long?>> e3
= (long? a
, sbyte b
) => a
>> b
;
2538 AssertNodeType (e3
, ExpressionType
.RightShift
);
2539 Assert (null, e3
.Compile ().Invoke (null, 11));
2540 Assert (512, e3
.Compile ().Invoke (1024, 1));
2543 void RightShiftTest_4 ()
2545 Expression
<Func
<MyType
?, MyType
?, int?>> e4
= (MyType
? a
, MyType
? b
) => a
>> b
;
2546 AssertNodeType (e4
, ExpressionType
.RightShift
);
2547 var c4
= e4
.Compile ();
2548 Assert (null, c4 (new MyType (8), null));
2549 Assert (null, c4 (null, new MyType (8)));
2550 Assert (64, c4 (new MyType (256), new MyType (2)));
2553 void RightShiftTest_5 ()
2555 Expression
<Func
<int, MyTypeImplicitOnly
, int>> e
= (a
, b
) => a
>> b
;
2556 AssertNodeType (e
, ExpressionType
.RightShift
);
2557 Assert (31, e
.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
2560 void RightShiftTest_6 ()
2562 Expression
<Func
<ulong, byte?, ulong?>> e
= (a
, b
) => a
>> b
;
2563 AssertNodeType (e
, ExpressionType
.RightShift
);
2564 Assert (null, e
.Compile () (2, null));
2567 void SubtractTest ()
2569 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
- b
;
2570 AssertNodeType (e
, ExpressionType
.Subtract
);
2571 Assert (-10, e
.Compile ().Invoke (20, 30));
2574 void SubtractTest_2 ()
2576 Expression
<Func
<int?, int?, int?>> e2
= (a
, b
) => a
- b
;
2577 AssertNodeType (e2
, ExpressionType
.Subtract
);
2578 Assert (null, e2
.Compile ().Invoke (null, 3));
2581 void SubtractTest_3 ()
2583 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
- b
;
2584 AssertNodeType (e3
, ExpressionType
.Subtract
);
2585 Assert (-50, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2588 void SubtractTest_4 ()
2590 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
- b
;
2591 AssertNodeType (e4
, ExpressionType
.Subtract
);
2592 Assert (new MyType (-50), e4
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2593 Assert (null, e4
.Compile ().Invoke (null, new MyType (30)));
2596 void SubtractTest_5 ()
2598 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
- b
;
2599 AssertNodeType (e5
, ExpressionType
.Subtract
);
2600 Assert (-29, e5
.Compile ().Invoke (1, new MyType (30)));
2603 void SubtractTest_6 ()
2605 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
- b
;
2606 AssertNodeType (e6
, ExpressionType
.Subtract
);
2607 Assert (-61, e6
.Compile ().Invoke (-31, new MyType (30)));
2610 void SubtractTest_7 ()
2612 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => null - a
;
2613 AssertNodeType (e7
, ExpressionType
.Subtract
);
2614 Assert (null, e7
.Compile ().Invoke (690));
2617 void SubtractTest_8 ()
2619 Expression
<Func
<MyEnum
, byte, MyEnum
>> e8
= (a
, b
) => a
- b
;
2620 AssertNodeType (e8
, ExpressionType
.Convert
);
2621 Assert ((MyEnum
)255, e8
.Compile ().Invoke (MyEnum
.Value_1
, 2));
2624 void SubtractTest_9 ()
2626 Expression
<Func
<MyEnum
, MyEnum
, byte>> e9
= (a
, b
) => a
- b
;
2627 AssertNodeType (e9
, ExpressionType
.Convert
);
2628 Assert (1, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
2631 void SubtractTest_10 ()
2633 Expression
<Func
<MyEnum
?, byte?, MyEnum
?>> e10
= (a
, b
) => a
- b
;
2634 AssertNodeType (e10
, ExpressionType
.Convert
);
2635 Assert ((MyEnum
) 255, e10
.Compile ().Invoke (MyEnum
.Value_1
, 2));
2639 void SubtractTest_11 ()
2641 Expression
<Func
<MyEnum
?, MyEnum
?, byte?>> e11
= (a
, b
) => a
- b
;
2642 AssertNodeType (e11
, ExpressionType
.Convert
);
2643 Assert
<byte?> (1, e11
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
2646 void SubtractCheckedTest ()
2649 Expression
<Func
<long, long, long>> e
= (long a
, long b
) => a
- b
;
2650 AssertNodeType (e
, ExpressionType
.SubtractChecked
);
2652 e
.Compile ().Invoke (long.MinValue
, 309);
2653 throw new ApplicationException ("SubtractCheckedTest #1");
2654 } catch (OverflowException
) { }
2658 void SubtractCheckedTest_2 ()
2661 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a
- b
;
2662 AssertNodeType (e2
, ExpressionType
.SubtractChecked
);
2663 Assert (null, e2
.Compile ().Invoke (null, 3));
2664 Assert (-55, e2
.Compile ().Invoke (byte.MinValue
, 55));
2668 void SubtractCheckedTest_3 ()
2671 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
- b
;
2672 AssertNodeType (e3
, ExpressionType
.Subtract
);
2673 Assert (-50, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2677 void SubtractCheckedTest_4 ()
2680 Expression
<Func
<double, double, double>> e4
= (a
, b
) => a
- b
;
2681 AssertNodeType (e4
, ExpressionType
.Subtract
);
2682 Assert (double.PositiveInfinity
, e4
.Compile ().Invoke (double.MinValue
, double.NegativeInfinity
));
2688 Expression
<Func
<object, Tester
>> e
= (object a
) => a
as Tester
;
2689 AssertNodeType (e
, ExpressionType
.TypeAs
);
2690 Assert (this, e
.Compile ().Invoke (this));
2693 void TypeAsTest_2 ()
2695 Expression
<Func
<object, int?>> e2
= (object a
) => a
as int?;
2696 AssertNodeType (e2
, ExpressionType
.TypeAs
);
2697 Assert (null, e2
.Compile ().Invoke (null));
2698 Assert (null, e2
.Compile ().Invoke (this));
2699 Assert (44, e2
.Compile ().Invoke (44));
2702 void TypeAsTest_3 ()
2704 Expression
<Func
<object, object>> e3
= (object a
) => null as object;
2705 AssertNodeType (e3
, ExpressionType
.TypeAs
);
2706 Assert (null, e3
.Compile ().Invoke (null));
2709 void TypeAsTest_4 ()
2711 Expression
<Func
<int, IConvertible
>> e
= a
=> a
as IConvertible
;
2712 AssertNodeType (e
, ExpressionType
.TypeAs
);
2713 Assert (ExpressionType
.Parameter
, ((UnaryExpression
) e
.Body
).Operand
.NodeType
);
2714 Assert (5, e
.Compile ().Invoke (5));
2719 Expression
<Func
<object, bool>> e
= (object a
) => a
is Tester
;
2720 AssertNodeType (e
, ExpressionType
.TypeIs
);
2721 Assert (true, e
.Compile ().Invoke (this));
2722 Assert (false, e
.Compile ().Invoke (1));
2725 void TypeIsTest_2 ()
2727 Expression
<Func
<object, bool>> e2
= (object a
) => a
is int?;
2728 AssertNodeType (e2
, ExpressionType
.TypeIs
);
2729 Assert (false, e2
.Compile ().Invoke (null));
2730 Assert (true, e2
.Compile ().Invoke (1));
2733 void TypeIsTest_3 ()
2735 Expression
<Func
<object, bool>> e3
= (object a
) => null is object;
2736 AssertNodeType (e3
, ExpressionType
.TypeIs
);
2737 Assert (false, e3
.Compile ().Invoke (null));
2740 void TypeIsTest_4 ()
2742 Expression
<Func
<B
, bool>> e
= l
=> l
is A
;
2743 AssertNodeType (e
, ExpressionType
.TypeIs
);
2744 Assert (false, e
.Compile ().Invoke (null));
2747 void TypeIsTest_5 ()
2749 Expression
<Func
<bool>> e5
= () => 1 is int;
2750 AssertNodeType (e5
, ExpressionType
.TypeIs
);
2751 Assert (true, e5
.Compile ().Invoke ());
2754 void TypeIsTest_6 ()
2756 Expression
<Func
<int?, bool>> e6
= (a
) => a
is int;
2757 AssertNodeType (e6
, ExpressionType
.TypeIs
);
2758 Assert (true, e6
.Compile ().Invoke (1));
2759 Assert (false, e6
.Compile ().Invoke (null));
2762 void UnaryPlusTest ()
2764 Expression
<Func
<int, int>> e
= (a
) => +a
;
2765 AssertNodeType (e
, ExpressionType
.Parameter
);
2766 Assert (-30, e
.Compile ().Invoke (-30));
2769 void UnaryPlusTest_2 ()
2771 Expression
<Func
<long?, long?>> e2
= (a
) => +a
;
2772 AssertNodeType (e2
, ExpressionType
.Parameter
);
2775 void UnaryPlusTest_3 ()
2777 Expression
<Func
<MyType
, MyType
>> e4
= (a
) => +a
;
2778 AssertNodeType (e4
, ExpressionType
.UnaryPlus
);
2779 Assert (new MyType (-14), e4
.Compile ().Invoke (new MyType (-14)));
2782 void UnaryPlusTest_4 ()
2784 Expression
<Func
<MyType
?, MyType
?>> e5
= (a
) => +a
;
2785 AssertNodeType (e5
, ExpressionType
.UnaryPlus
);
2786 Assert (new MyType (33), e5
.Compile ().Invoke (new MyType (33)));
2787 Assert (null, e5
.Compile ().Invoke (null));
2790 void UnaryPlusTest_5 ()
2792 Expression
<Func
<sbyte?, long?>> e6
= (a
) => +a
;
2793 AssertNodeType (e6
, ExpressionType
.Convert
);
2794 Assert (3, e6
.Compile ().Invoke (3));
2795 Assert (null, e6
.Compile ().Invoke (null));
2798 #pragma warning restore 169
2803 string InstanceMethod (string arg
)
2808 object InstanceParamsMethod (int index
, params object [] args
)
2812 if (args
.Length
== 0)
2814 return args
[index
];
2817 static int TestInt ()
2822 T GenericMethod
<T
> (T t
)
2827 static void RefMethod (ref int i
)
2832 static bool RunTest (MethodInfo test
)
2834 Console
.Write ("Running test {0, -25}", test
.Name
);
2836 test
.Invoke (new Tester (), null);
2837 Console
.WriteLine ("OK");
2839 } catch (Exception e
) {
2840 Console
.WriteLine ("FAILED");
2841 Console
.WriteLine (e
.ToString ());
2846 public static int Main ()
2848 var tests
= from test
in typeof (Tester
).GetMethods (BindingFlags
.Instance
| BindingFlags
.NonPublic
| BindingFlags
.DeclaredOnly
)
2849 where test
.GetParameters ().Length
== 0
2851 select RunTest (test
);
2853 int failures
= tests
.Count (a
=> !a
);
2854 Console
.WriteLine (failures
+ " tests failed");