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
{
250 enum MyEnumUlong
: ulong
264 public NewTest (params T
[] t
)
269 public override int GetHashCode ()
271 return base.GetHashCode ();
274 public override bool Equals (object obj
)
276 NewTest
<T
> obj_t
= obj
as NewTest
<T
>;
280 for (int i
= 0; i
< t
.Length
; ++i
) {
281 if (!t
[i
].Equals (obj_t
.t
[i
]))
291 public int this [int i
] { get { return i; }
set { }
}
292 public string this [params string[] i
] { get { return string.Concat (i); }
}
296 // TODO: Add more nullable tests, follow AddTest pattern.
300 delegate void EmptyDelegate ();
301 delegate int IntDelegate ();
303 static void AssertNodeType (LambdaExpression e
, ExpressionType et
)
305 if (e
.Body
.NodeType
!= et
)
306 throw new ApplicationException (e
.Body
.NodeType
+ " != " + et
);
309 static void Assert
<T
> (T expected
, T
value)
311 Assert (expected
, value, null);
314 static void Assert
<T
> (T expected
, T
value, string name
)
316 if (!EqualityComparer
<T
>.Default
.Equals (expected
, value)) {
317 if (!string.IsNullOrEmpty (name
))
319 throw new ApplicationException (name
+ expected
+ " != " + value);
323 static void Assert
<T
> (T
[] expected
, T
[] value)
325 if (expected
== null) {
327 throw new ApplicationException ("Both arrays expected to be null");
331 if (expected
.Length
!= value.Length
)
332 throw new ApplicationException ("Array length does not match " + expected
.Length
+ " != " + value.Length
);
334 for (int i
= 0; i
< expected
.Length
; ++i
) {
335 if (!EqualityComparer
<T
>.Default
.Equals (expected
[i
], value [i
]))
336 throw new ApplicationException ("Index " + i
+ ": " + expected
[i
] + " != " + value [i
]);
340 #pragma warning disable 169
344 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
+ b
;
345 AssertNodeType (e
, ExpressionType
.Add
);
346 Assert (50, e
.Compile ().Invoke (20, 30));
351 Expression
<Func
<int?, int?, int?>> e2
= (a
, b
) => a
+ b
;
352 AssertNodeType (e2
, ExpressionType
.Add
);
353 Assert (null, e2
.Compile ().Invoke (null, 3));
358 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
+ b
;
359 AssertNodeType (e3
, ExpressionType
.Add
);
360 Assert (10, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
365 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
+ b
;
366 AssertNodeType (e4
, ExpressionType
.Add
);
367 Assert (new MyType (10), e4
.Compile ().Invoke (new MyType (-20), new MyType (30)));
368 Assert (null, e4
.Compile ().Invoke (null, new MyType (30)));
373 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
+ b
;
374 AssertNodeType (e5
, ExpressionType
.Add
);
375 Assert (31, e5
.Compile ().Invoke (1, new MyType (30)));
380 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
+ b
;
381 AssertNodeType (e6
, ExpressionType
.Add
);
382 Assert (-1, e6
.Compile ().Invoke (-31, new MyType (30)));
387 Expression
<Func
<MyEnum
, byte, MyEnum
>> e7
= (a
, b
) => a
+ b
;
388 AssertNodeType (e7
, ExpressionType
.Convert
);
389 Assert (MyEnum
.Value_2
, e7
.Compile ().Invoke (MyEnum
.Value_1
, 1));
394 // CSC BUG: probably due to missing numeric promotion
395 Expression
<Func
<MyEnum
?, byte?, MyEnum
?>> e8
= (a
, b
) => a
+ b
;
396 AssertNodeType (e8
, ExpressionType
.Convert
);
397 Assert
<MyEnum
?> (0, e8
.Compile ().Invoke (MyEnum
.Value_1
, 255));
398 Assert (null, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
399 Assert (null, e8
.Compile ().Invoke (null, null));
404 Expression
<Func
<byte, MyEnum
, MyEnum
>> e9
= (a
, b
) => a
+ b
;
405 AssertNodeType (e9
, ExpressionType
.Convert
);
406 Assert (MyEnum
.Value_2
, e9
.Compile ().Invoke (1, MyEnum
.Value_1
));
409 void AddCheckedTest ()
412 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
+ b
;
413 AssertNodeType (e
, ExpressionType
.AddChecked
);
414 Assert (50, e
.Compile ().Invoke (20, 30));
418 void AddCheckedTest_2 ()
421 Expression
<Func
<int?, int?, int?>> e2
= (a
, b
) => a
+ b
;
422 AssertNodeType (e2
, ExpressionType
.AddChecked
);
423 Assert (null, e2
.Compile ().Invoke (null, 3));
427 void AddCheckedTest_3 ()
430 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
+ b
;
431 AssertNodeType (e3
, ExpressionType
.Add
);
432 Assert (10, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
436 void AddStringTest ()
438 Expression
<Func
<string, string>> e6
= (a
) => 1 + a
;
439 AssertNodeType (e6
, ExpressionType
.Add
);
440 Assert ("1to", e6
.Compile ().Invoke ("to"));
443 void AddStringTest_2 ()
445 Expression
<Func
<object, string, string>> e7
= (object a
, string b
) => a
+ b
;
446 AssertNodeType (e7
, ExpressionType
.Add
);
447 Assert ("testme", e7
.Compile ().Invoke ("test", "me"));
448 Assert ("test", e7
.Compile ().Invoke ("test", null));
449 Assert ("", e7
.Compile ().Invoke (null, null));
452 void AddStringTest_3 ()
454 Expression
<Func
<string, int, string>> e8
= (a
, b
) => a
+ " " + "-" + "> " + b
;
455 AssertNodeType (e8
, ExpressionType
.Add
);
456 Assert ("test -> 2", e8
.Compile ().Invoke ("test", 2));
459 void AddStringTest_4 ()
461 Expression
<Func
<string, ushort?, string>> e9
= (a
, b
) => a
+ b
;
462 AssertNodeType (e9
, ExpressionType
.Add
);
463 Assert ("test2", e9
.Compile ().Invoke ("test", 2));
464 Assert ("test", e9
.Compile ().Invoke ("test", null));
469 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
& b
;
471 AssertNodeType (e
, ExpressionType
.And
);
472 Func
<bool, bool, bool> c
= e
.Compile ();
474 Assert (true, c (true, true));
475 Assert (false, c (true, false));
476 Assert (false, c (false, true));
477 Assert (false, c (false, false));
482 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
& b
;
484 AssertNodeType (e2
, ExpressionType
.And
);
485 var c2
= e2
.Compile ();
487 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
488 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
493 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e3
= (a
, b
) => a
& b
;
494 AssertNodeType (e3
, ExpressionType
.Convert
);
495 Assert
<MyEnum
> (0, e3
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
496 Assert (MyEnum
.Value_2
, e3
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
501 Expression
<Func
<int, int>> e
= (a
) => a
& 0;
502 AssertNodeType (e
, ExpressionType
.And
);
503 var c
= e
.Compile ();
508 void AndNullableTest ()
510 Expression
<Func
<bool?, bool?, bool?>> e
= (bool? a
, bool? b
) => a
& b
;
512 AssertNodeType (e
, ExpressionType
.And
);
513 Func
<bool?, bool?, bool?> c
= e
.Compile ();
515 Assert (true, c (true, true));
516 Assert (false, c (true, false));
517 Assert (false, c (false, true));
518 Assert (false, c (false, false));
520 Assert (null, c (true, null));
521 Assert (false, c (false, null));
522 Assert (false, c (null, false));
523 Assert (null, c (true, null));
524 Assert (null, c (null, null));
527 void AndNullableTest_2 ()
529 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e2
= (MyType
? a
, MyType
? b
) => a
& b
;
531 AssertNodeType (e2
, ExpressionType
.And
);
532 var c2
= e2
.Compile ();
534 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
535 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
536 Assert (null, c2 (new MyType (0xFF), null));
539 void AndNullableTest_3 ()
541 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e3
= (a
, b
) => a
& b
;
542 AssertNodeType (e3
, ExpressionType
.Convert
);
543 Assert (null, e3
.Compile ().Invoke (null, MyEnum
.Value_2
));
544 Assert (MyEnum
.Value_2
, e3
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
549 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
&& b
;
550 AssertNodeType (e
, ExpressionType
.AndAlso
);
551 Assert (false, e
.Compile ().Invoke (true, false));
554 void AndAlsoTest_2 ()
556 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
&& b
;
557 AssertNodeType (e2
, ExpressionType
.AndAlso
);
558 Assert (new MyType (64), e2
.Compile ().Invoke (new MyType (64), new MyType (64)));
559 Assert (new MyType (0), e2
.Compile ().Invoke (new MyType (32), new MyType (64)));
562 void AndAlsoTest_3 ()
564 Expression
<Func
<bool, bool>> e3
= (bool a
) => a
&& true;
565 AssertNodeType (e3
, ExpressionType
.AndAlso
);
566 Assert (false, e3
.Compile ().Invoke (false));
567 Assert (true, e3
.Compile ().Invoke (true));
570 void ArrayIndexTest ()
572 Expression
<Func
<string [], long, string>> e
= (string [] a
, long i
) => a
[i
];
573 AssertNodeType (e
, ExpressionType
.ArrayIndex
);
574 Assert ("b", e
.Compile ().Invoke (new string [] { "a", "b", "c" }
, 1));
577 void ArrayIndexTest_2 ()
579 Expression
<Func
<string [], string>> e2
= (string [] a
) => a
[0];
580 AssertNodeType (e2
, ExpressionType
.ArrayIndex
);
581 Assert ("a", e2
.Compile ().Invoke (new string [] { "a", "b" }
));
584 void ArrayIndexTest_3 ()
586 Expression
<Func
<object [,], int, int, object>> e3
= (object [,] a
, int i
, int j
) => a
[i
, j
];
587 AssertNodeType (e3
, ExpressionType
.Call
);
589 Assert ("z", e3
.Compile ().Invoke (
590 new object [,] { { 1, 2 }
, { "x", "z" }
}, 1, 1));
593 void ArrayIndexTest_4 ()
595 Expression
<Func
<decimal [] [], byte, decimal>> e4
= (decimal [] [] a
, byte b
) => a
[b
] [1];
596 AssertNodeType (e4
, ExpressionType
.ArrayIndex
);
598 decimal [] [] array
= { new decimal [] { 1, 9 }
, new decimal [] { 10, 90 }
};
599 Assert (90, e4
.Compile ().Invoke (array
, 1));
602 void ArrayIndexTest_5 ()
604 Expression
<Func
<int>> e5
= () => (new int [1]) [0];
605 AssertNodeType (e5
, ExpressionType
.ArrayIndex
);
606 Assert (0, e5
.Compile ().Invoke ());
609 void ArrayIndexTest_6 ()
613 Expression
<Func
<int[], int>> e
= a
=> a
[max
];
614 AssertNodeType (e
, ExpressionType
.ArrayIndex
);
615 Assert (4, e
.Compile ().Invoke (new int [] { 1, 2, 3, 4, 5 }
));
618 void ArrayIndexTest_7 ()
620 const ulong max
= uint.MaxValue
;
622 Expression
<Func
<int[], int>> e
= a
=> a
[max
];
623 AssertNodeType (e
, ExpressionType
.ArrayIndex
);
626 e
.Compile ().Invoke (new int [0]);
627 throw new ApplicationException ("ArrayIndexTest_7");
628 } catch (System
.OverflowException
) {
629 // Check whether CheckedConversion was generated
633 void ArrayLengthTest ()
635 Expression
<Func
<double [], int>> e
= (double [] a
) => a
.Length
;
636 AssertNodeType (e
, ExpressionType
.ArrayLength
);
637 Assert (0, e
.Compile ().Invoke (new double [0]));
638 Assert (9, e
.Compile ().Invoke (new double [9]));
641 void ArrayLengthTest_2 ()
643 Expression
<Func
<string [,], int>> e2
= (string [,] a
) => a
.Length
;
644 AssertNodeType (e2
, ExpressionType
.MemberAccess
);
645 Assert (0, e2
.Compile ().Invoke (new string [0, 0]));
650 Expression
<Func
<int, int>> e
= (int a
) => Math
.Max (a
, 5);
651 AssertNodeType (e
, ExpressionType
.Call
);
652 Assert (5, e
.Compile ().Invoke (2));
653 Assert (9, e
.Compile ().Invoke (9));
658 Expression
<Func
<string, string>> e2
= (string a
) => InstanceMethod (a
);
659 AssertNodeType (e2
, ExpressionType
.Call
);
660 Assert ("abc", e2
.Compile ().Invoke ("abc"));
665 Expression
<Func
<int, string, int, object>> e3
= (int index
, string a
, int b
) => InstanceParamsMethod (index
, a
, b
);
666 AssertNodeType (e3
, ExpressionType
.Call
);
667 Assert
<object> (4, e3
.Compile ().Invoke (1, "a", 4));
672 Expression
<Func
<object>> e4
= () => InstanceParamsMethod (0);
673 AssertNodeType (e4
, ExpressionType
.Call
);
674 Assert
<object> ("<empty>", e4
.Compile ().Invoke ());
679 Expression
<Func
<int, int>> e5
= (int a
) => GenericMethod (a
);
680 AssertNodeType (e5
, ExpressionType
.Call
);
681 Assert (5, e5
.Compile ().Invoke (5));
686 Expression
<Action
> e6
= () => Console
.WriteLine ("call test");
687 AssertNodeType (e6
, ExpressionType
.Call
);
692 Expression
<Func
<Indexer
, int, int>> e7
= (a
, b
) => a
[b
];
693 AssertNodeType (e7
, ExpressionType
.Call
);
694 Assert (3, e7
.Compile ().Invoke (new Indexer (), 3));
699 Expression
<Func
<Indexer
, string, string, string, string>> e8
= (a
, b
, c
, d
) => a
[b
, c
, d
];
700 AssertNodeType (e8
, ExpressionType
.Call
);
701 Assert ("zyb", e8
.Compile ().Invoke (new Indexer (), "z", "y", "b"));
706 Expression
<Action
<int>> e9
= (a
) => RefMethod (ref a
);
707 AssertNodeType (e9
, ExpressionType
.Call
);
708 e9
.Compile ().Invoke (1);
713 Expression
<Func
<uint?, uint>> e
= (uint? a
) => a
?? 99;
714 AssertNodeType (e
, ExpressionType
.Coalesce
);
715 var r
= e
.Compile ();
716 Assert ((uint) 5, r
.Invoke (5));
717 Assert ((uint) 99, r
.Invoke (null));
720 void CoalesceTest_2 ()
722 Expression
<Func
<MyType
?, int>> e2
= (MyType
? a
) => a
?? -3;
723 AssertNodeType (e2
, ExpressionType
.Coalesce
);
724 var r2
= e2
.Compile ();
725 Assert (2, r2
.Invoke (new MyType (2)));
726 Assert (-3, r2
.Invoke (null));
729 void ConditionTest ()
731 Expression
<Func
<bool, byte, int, int>> e
= (bool a
, byte b
, int c
) => (a
? b
: c
);
732 AssertNodeType (e
, ExpressionType
.Conditional
);
733 var r
= e
.Compile ();
734 Assert (3, r
.Invoke (true, 3, 999999));
735 Assert (999999, r
.Invoke (false, 3, 999999));
738 void ConditionTest_2 ()
740 Expression
<Func
<int, decimal, decimal?>> e2
= (int a
, decimal d
) => (a
> 0 ? d
: a
< 0 ? -d
: (decimal?) null);
741 AssertNodeType (e2
, ExpressionType
.Conditional
);
742 var r2
= e2
.Compile ();
743 Assert (null, r2
.Invoke (0, 10));
744 Assert (50, r2
.Invoke (1, 50));
745 Assert (30, r2
.Invoke (-7, -30));
748 void ConditionTest_3 ()
750 Expression
<Func
<bool?, int?>> e3
= (bool? a
) => ((bool) a
? 3 : -2);
751 AssertNodeType (e3
, ExpressionType
.Convert
);
752 var r3
= e3
.Compile ();
753 Assert (3, r3
.Invoke (true));
754 Assert (-2, r3
.Invoke (false));
757 void ConditionTest_4 ()
759 Expression
<Func
<InverseLogicalOperator
, byte, byte, byte>> e4
= (InverseLogicalOperator a
, byte b
, byte c
) => (a
? b
: c
);
760 AssertNodeType (e4
, ExpressionType
.Conditional
);
761 var r4
= e4
.Compile ();
762 Assert (3, r4
.Invoke (new InverseLogicalOperator (true), 3, 4));
763 Assert (4, r4
.Invoke (new InverseLogicalOperator (false), 3, 4));
766 void ConditionTest_5 ()
769 Expression
<Func
<int>> e
= () => false ? 1 : 4;
770 AssertNodeType (e
, ExpressionType
.Conditional
);
771 var r
= e
.Compile ();
772 Assert (4, r
.Invoke ());
777 Expression
<Func
<int>> e1
= () => default (int);
778 AssertNodeType (e1
, ExpressionType
.Constant
);
779 Assert (0, e1
.Compile ().Invoke ());
782 void ConstantTest_2 ()
784 Expression
<Func
<int?>> e2
= () => default (int?);
785 AssertNodeType (e2
, ExpressionType
.Constant
);
786 Assert (null, e2
.Compile ().Invoke ());
789 void ConstantTest_3 ()
791 Expression
<Func
<Tester
>> e3
= () => default (Tester
);
792 AssertNodeType (e3
, ExpressionType
.Constant
);
793 Assert (null, e3
.Compile ().Invoke ());
796 void ConstantTest_4 ()
798 Expression
<Func
<object>> e4
= () => null;
799 AssertNodeType (e4
, ExpressionType
.Constant
);
800 Assert (null, e4
.Compile ().Invoke ());
803 void ConstantTest_5 ()
805 Expression
<Func
<int>> e5
= () => 8 / 4;
806 AssertNodeType (e5
, ExpressionType
.Constant
);
807 Assert (2, e5
.Compile ().Invoke ());
810 void ConstantTest_6 ()
812 Expression
<Func
<int>> e6
= () => 0xFFFFFF >> 0x40;
813 AssertNodeType (e6
, ExpressionType
.Constant
);
814 Assert (0xFFFFFF, e6
.Compile ().Invoke ());
817 void ConstantTest_7 ()
819 Expression
<Func
<object>> e7
= () => "Alleluia";
820 AssertNodeType (e7
, ExpressionType
.Constant
);
821 Assert ("Alleluia", e7
.Compile ().Invoke ());
824 void ConstantTest_8 ()
826 Expression
<Func
<Type
>> e8
= () => typeof (int);
827 AssertNodeType (e8
, ExpressionType
.Constant
);
828 Assert (typeof (int), e8
.Compile ().Invoke ());
831 void ConstantTest_9 ()
833 Expression
<Func
<Type
>> e9
= () => typeof (void);
834 AssertNodeType (e9
, ExpressionType
.Constant
);
835 Assert (typeof (void), e9
.Compile ().Invoke ());
838 void ConstantTest_10 ()
840 Expression
<Func
<Type
>> e10
= () => typeof (Func
<,>);
841 AssertNodeType (e10
, ExpressionType
.Constant
);
842 Assert (typeof (Func
<,>), e10
.Compile ().Invoke ());
845 void ConstantTest_11 ()
847 Expression
<Func
<MyEnum
>> e11
= () => MyEnum
.Value_2
;
848 AssertNodeType (e11
, ExpressionType
.Constant
);
849 Assert (MyEnum
.Value_2
, e11
.Compile ().Invoke ());
852 void ConstantTest_13 ()
854 Expression
<Func
<int>> e13
= () => sizeof (byte);
855 AssertNodeType (e13
, ExpressionType
.Constant
);
856 Assert (1, e13
.Compile ().Invoke ());
860 unsafe void ConstantTest_14 ()
862 Expression
<Func
<Type
>> e14
= () => typeof (bool*);
863 AssertNodeType (e14
, ExpressionType
.Constant
);
864 Assert (typeof (bool*), e14
.Compile ().Invoke ());
867 void ConstantTest_15 ()
869 Expression
<Func
<int?>> e15
= () => null;
870 AssertNodeType (e15
, ExpressionType
.Constant
);
871 Assert (null, e15
.Compile ().Invoke ());
876 Expression
<Func
<int, byte>> e
= (int a
) => ((byte) a
);
877 AssertNodeType (e
, ExpressionType
.Convert
);
878 Assert (100, e
.Compile ().Invoke (100));
881 void ConvertTest_2 ()
883 Expression
<Func
<long, ushort>> e2
= (long a
) => ((ushort) a
);
884 AssertNodeType (e2
, ExpressionType
.Convert
);
885 Assert (100, e2
.Compile ().Invoke (100));
888 void ConvertTest_3 ()
890 Expression
<Func
<float?, float>> e3
= (float? a
) => ((float) a
);
891 AssertNodeType (e3
, ExpressionType
.Convert
);
892 Assert (-0.456f
, e3
.Compile ().Invoke (-0.456f
));
895 void ConvertTest_4 ()
897 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => (a
);
898 AssertNodeType (e4
, ExpressionType
.Convert
);
899 Assert (-9, e4
.Compile ().Invoke (new MyType (-9)));
902 void ConvertTest_5 ()
904 Expression
<Func
<MyType
, MyType
, bool?>> e5
= (MyType a
, MyType b
) => a
== b
;
905 AssertNodeType (e5
, ExpressionType
.Convert
);
908 void ConvertTest_6 ()
910 Expression
<Func
<MyType
?, MyType
?, bool?>> e6
= (MyType
? a
, MyType
? b
) => a
== b
;
911 AssertNodeType (e6
, ExpressionType
.Convert
);
912 Assert (false, e6
.Compile ().Invoke (null, new MyType (-20)));
913 Assert (true, e6
.Compile ().Invoke (null, null));
914 Assert (true, e6
.Compile ().Invoke (new MyType (120), new MyType (120)));
917 void ConvertTest_7 ()
919 Expression
<Func
<MyTypeExplicit
, int?>> e7
= x
=> (int?)x
;
920 AssertNodeType (e7
, ExpressionType
.Convert
);
921 Assert (33, e7
.Compile ().Invoke (new MyTypeExplicit (33)));
924 void ConvertTest_8 ()
926 Expression
<Func
<int?, object>> e8
= x
=> (object)x
;
927 AssertNodeType (e8
, ExpressionType
.Convert
);
928 Assert (null, e8
.Compile ().Invoke (null));
929 Assert (-100, e8
.Compile ().Invoke (-100));
932 unsafe void ConvertTest_9 ()
934 int*[] p
= new int* [1];
935 Expression
<Func
<object>> e9
= () => (object)p
;
936 AssertNodeType (e9
, ExpressionType
.Convert
);
937 Assert (p
, e9
.Compile ().Invoke ());
940 void ConvertTest_10 ()
942 Expression
<Func
<Func
<int>, Delegate
>> e10
= (a
) => a
+ a
;
943 AssertNodeType (e10
, ExpressionType
.Convert
);
944 Assert (null, e10
.Compile ().Invoke (null));
945 Assert (new Func
<int> (TestInt
) + new Func
<int> (TestInt
), e10
.Compile ().Invoke (TestInt
));
948 void ConvertTest_11 ()
950 Expression
<Func
<Func
<int>, Delegate
>> e11
= (a
) => a
- a
;
951 AssertNodeType (e11
, ExpressionType
.Convert
);
952 Assert (null, e11
.Compile ().Invoke (null));
955 void ConvertTest_12 ()
957 Expression
<Func
<Func
<int>>> e12
= () => TestInt
;
958 AssertNodeType (e12
, ExpressionType
.Convert
);
959 Assert (29, e12
.Compile ().Invoke () ());
962 void ConvertTest_13 ()
964 Expression
<Func
<decimal, sbyte>> e13
= a
=> (sbyte)a
;
965 AssertNodeType (e13
, ExpressionType
.Convert
);
966 Assert (6, e13
.Compile ().Invoke (6));
969 void ConvertTest_14 ()
971 Expression
<Func
<long, decimal>> e14
= a
=> a
;
972 AssertNodeType (e14
, ExpressionType
.Convert
);
973 Assert (-66, e14
.Compile ().Invoke (-66));
976 void ConvertTest_15 ()
978 Expression
<Func
<ulong?, decimal?>> e15
= a
=> a
;
979 AssertNodeType (e15
, ExpressionType
.Convert
);
980 Assert (null, e15
.Compile ().Invoke (null));
981 Assert (9, e15
.Compile ().Invoke (9));
984 void ConvertTest_16 ()
986 Expression
<Func
<sbyte, sbyte>> e16
= a
=> (sbyte)a
;
987 AssertNodeType (e16
, ExpressionType
.Convert
);
988 Assert (6, e16
.Compile ().Invoke (6));
991 void ConvertCheckedTest ()
993 Expression
<Func
<int, byte>> e
= (int a
) => checked((byte) a
);
994 AssertNodeType (e
, ExpressionType
.ConvertChecked
);
995 Assert (100, e
.Compile ().Invoke (100));
998 void ConvertCheckedTest_2 ()
1001 Expression
<Func
<long, ushort>> e2
= (long a
) => unchecked((ushort) a
);
1002 AssertNodeType (e2
, ExpressionType
.Convert
);
1003 Assert (100, e2
.Compile ().Invoke (100));
1007 void ConvertCheckedTest_3 ()
1010 Expression
<Func
<float?, float>> e3
= (float? a
) => ((float) a
);
1011 AssertNodeType (e3
, ExpressionType
.ConvertChecked
);
1012 Assert (-0.456f
, e3
.Compile ().Invoke (-0.456f
));
1016 void ConvertCheckedTest_4 ()
1019 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => (a
);
1020 AssertNodeType (e4
, ExpressionType
.Convert
);
1021 Assert (-9, e4
.Compile ().Invoke (new MyType (-9)));
1027 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
/ b
;
1028 AssertNodeType (e
, ExpressionType
.Divide
);
1029 Assert (2, e
.Compile ().Invoke (60, 30));
1032 void DivideTest_2 ()
1034 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
/ b
;
1035 AssertNodeType (e2
, ExpressionType
.Divide
);
1036 Assert (null, e2
.Compile ().Invoke (null, 3));
1037 Assert (1.5, e2
.Compile ().Invoke (3, 2));
1040 void DivideTest_3 ()
1042 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
/ b
;
1043 AssertNodeType (e3
, ExpressionType
.Divide
);
1044 Assert (1, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1047 void DivideTest_4 ()
1049 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
/ b
;
1050 AssertNodeType (e4
, ExpressionType
.Divide
);
1051 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1052 Assert (new MyType (-6), e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1055 void DivideTest_5 ()
1057 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
/ b
;
1058 AssertNodeType (e5
, ExpressionType
.Divide
);
1059 Assert (50, e5
.Compile ().Invoke (100, new MyType (2)));
1062 void DivideTest_6 ()
1064 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
/ b
;
1065 AssertNodeType (e6
, ExpressionType
.Divide
);
1066 Assert (50, e6
.Compile ().Invoke (100, new MyType (2)));
1067 Assert (null, e6
.Compile ().Invoke (20, null));
1072 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
== b
;
1073 AssertNodeType (e
, ExpressionType
.Equal
);
1074 Assert (false, e
.Compile ().Invoke (60, 30));
1075 Assert (true, e
.Compile ().Invoke (-1, -1));
1080 Expression
<Func
<double?, double?, bool>> e2
= (a
, b
) => a
== b
;
1081 AssertNodeType (e2
, ExpressionType
.Equal
);
1082 Assert (true, e2
.Compile ().Invoke (3, 3));
1083 Assert (false, e2
.Compile ().Invoke (3, 2));
1088 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
== b
;
1089 AssertNodeType (e3
, ExpressionType
.Equal
);
1090 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1095 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
== b
;
1096 AssertNodeType (e4
, ExpressionType
.Equal
);
1097 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1098 Assert (true, e4
.Compile ().Invoke (null, null));
1099 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (120)));
1104 Expression
<Func
<bool?, bool?, bool>> e5
= (bool? a
, bool? b
) => a
== b
;
1105 AssertNodeType (e5
, ExpressionType
.Equal
);
1106 Assert (false, e5
.Compile ().Invoke (true, null));
1107 Assert (true, e5
.Compile ().Invoke (null, null));
1108 Assert (true, e5
.Compile ().Invoke (false, false));
1113 Expression
<Func
<bool, bool>> e6
= (bool a
) => a
== null;
1114 AssertNodeType (e6
, ExpressionType
.Equal
);
1115 Assert (false, e6
.Compile ().Invoke (true));
1116 Assert (false, e6
.Compile ().Invoke (false));
1121 Expression
<Func
<string, string, bool>> e7
= (string a
, string b
) => a
== b
;
1122 AssertNodeType (e7
, ExpressionType
.Equal
);
1123 Assert (true, e7
.Compile ().Invoke (null, null));
1124 Assert (false, e7
.Compile ().Invoke ("a", "A"));
1125 Assert (true, e7
.Compile ().Invoke ("a", "a"));
1130 Expression
<Func
<object, bool>> e8
= (object a
) => null == a
;
1131 AssertNodeType (e8
, ExpressionType
.Equal
);
1132 Assert (true, e8
.Compile ().Invoke (null));
1133 Assert (false, e8
.Compile ().Invoke ("a"));
1134 Assert (false, e8
.Compile ().Invoke (this));
1139 Expression
<Func
<MyEnum
, MyEnum
, bool>> e9
= (a
, b
) => a
== b
;
1140 AssertNodeType (e9
, ExpressionType
.Equal
);
1141 Assert (false, e9
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
1142 Assert (true, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1145 void EqualTest_10 ()
1147 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e10
= (a
, b
) => a
== b
;
1148 AssertNodeType (e10
, ExpressionType
.Equal
);
1149 Assert (false, e10
.Compile ().Invoke (MyEnum
.Value_1
, null));
1150 Assert (true, e10
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1153 void EqualTest_11 ()
1155 Expression
<Func
<MyEnum
?, bool>> e11
= (a
) => a
== null;
1156 AssertNodeType (e11
, ExpressionType
.Equal
);
1157 Assert (false, e11
.Compile ().Invoke (MyEnum
.Value_1
));
1158 Assert (true, e11
.Compile ().Invoke (null));
1161 void EqualTest_12 ()
1163 Expression
<Func
<MyEnumUlong
, bool>> e12
= (a
) => a
== 0;
1164 AssertNodeType (e12
, ExpressionType
.Equal
);
1165 Assert (false, e12
.Compile ().Invoke (MyEnumUlong
.Value_1
));
1166 Assert (true, e12
.Compile ().Invoke (0));
1169 void EqualTest_13 ()
1171 Expression
<Func
<MyEnum
, bool>> e13
= (a
) => a
== MyEnum
.Value_2
;
1172 AssertNodeType (e13
, ExpressionType
.Equal
);
1173 Assert (true, e13
.Compile ().Invoke (MyEnum
.Value_2
));
1174 Assert (false, e13
.Compile ().Invoke (0));
1177 void EqualTest_14 ()
1179 Expression
<Func
<MyEnum
, bool>> e
= (a
) => a
== null;
1180 AssertNodeType (e
, ExpressionType
.Equal
);
1181 Assert (false, e
.Compile ().Invoke (MyEnum
.Value_1
));
1184 void EqualTest_15 ()
1186 Expression
<Func
<int?, uint, bool>> e
= (a
, b
) => a
== b
;
1187 AssertNodeType (e
, ExpressionType
.Equal
);
1188 Assert (false, e
.Compile ().Invoke (null, 0));
1189 Assert (true, e
.Compile ().Invoke (4, 4));
1192 void EqualTestDelegate ()
1194 Expression
<Func
<Delegate
, Delegate
, bool>> e1
= (a
, b
) => a
== b
;
1195 AssertNodeType (e1
, ExpressionType
.Equal
);
1196 Assert (true, e1
.Compile ().Invoke (null, null));
1199 void EqualTestDelegate_2 ()
1201 EmptyDelegate ed
= delegate () {};
1203 Expression
<Func
<EmptyDelegate
, EmptyDelegate
, bool>> e2
= (a
, b
) => a
== b
;
1204 AssertNodeType (e2
, ExpressionType
.Equal
);
1205 Assert (false, e2
.Compile ().Invoke (delegate () {}, null));
1206 Assert (false, e2
.Compile ().Invoke (delegate () {}, delegate {}
));
1207 Assert (false, e2
.Compile ().Invoke (ed
, delegate {}));
1208 Assert (true, e2
.Compile ().Invoke (ed
, ed
));
1211 void ExclusiveOrTest ()
1213 Expression
<Func
<int, short, int>> e
= (int a
, short b
) => a ^ b
;
1214 AssertNodeType (e
, ExpressionType
.ExclusiveOr
);
1215 Assert (34, e
.Compile ().Invoke (60, 30));
1218 void ExclusiveOrTest_2 ()
1220 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a ^ b
;
1221 AssertNodeType (e2
, ExpressionType
.ExclusiveOr
);
1222 Assert (null, e2
.Compile ().Invoke (null, 3));
1223 Assert (1, e2
.Compile ().Invoke (3, 2));
1226 void ExclusiveOrTest_3 ()
1228 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a ^ b
;
1229 AssertNodeType (e3
, ExpressionType
.ExclusiveOr
);
1230 Assert (0, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1233 void ExclusiveOrTest_4 ()
1235 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a ^ b
;
1236 AssertNodeType (e4
, ExpressionType
.ExclusiveOr
);
1237 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1238 Assert (new MyType (-108), e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1241 void ExclusiveOrTest_5 ()
1243 Expression
<Func
<MyType
?, byte, int?>> e5
= (MyType
? a
, byte b
) => a ^ b
;
1244 AssertNodeType (e5
, ExpressionType
.ExclusiveOr
);
1245 Assert (null, e5
.Compile ().Invoke (null, 64));
1246 Assert (96, e5
.Compile ().Invoke (new MyType (64), 32));
1249 void ExclusiveOrTest_6 ()
1251 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e6
= (a
, b
) => a ^ b
;
1252 AssertNodeType (e6
, ExpressionType
.Convert
);
1253 Assert ((MyEnum
)3, e6
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
1254 Assert
<MyEnum
> (0, e6
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1257 void ExclusiveOrTest_7 ()
1259 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e7
= (a
, b
) => a ^ b
;
1260 AssertNodeType (e7
, ExpressionType
.Convert
);
1261 Assert (null, e7
.Compile ().Invoke (MyEnum
.Value_1
, null));
1262 Assert
<MyEnum
?> (0, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1265 void ExclusiveOrTest_8 ()
1267 Expression
<Func
<MyEnum
?, MyEnum
?>> e8
= (a
) => a ^
null;
1268 AssertNodeType (e8
, ExpressionType
.Convert
);
1269 Assert (null, e8
.Compile ().Invoke (MyEnum
.Value_1
));
1270 Assert (null, e8
.Compile ().Invoke (null));
1273 void GreaterThanTest ()
1275 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
> b
;
1276 AssertNodeType (e
, ExpressionType
.GreaterThan
);
1277 Assert (true, e
.Compile ().Invoke (60, 30));
1280 void GreaterThanTest_2 ()
1282 Expression
<Func
<uint?, byte?, bool>> e2
= (a
, b
) => a
> b
;
1283 AssertNodeType (e2
, ExpressionType
.GreaterThan
);
1284 Assert (false, e2
.Compile ().Invoke (null, 3));
1285 Assert (false, e2
.Compile ().Invoke (2, 2));
1288 void GreaterThanTest_3 ()
1290 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
> b
;
1291 AssertNodeType (e3
, ExpressionType
.GreaterThan
);
1292 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1295 void GreaterThanTest_4 ()
1297 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
> b
;
1298 AssertNodeType (e4
, ExpressionType
.GreaterThan
);
1299 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1300 Assert (false, e4
.Compile ().Invoke (null, null));
1301 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1304 void GreaterThanTest_5 ()
1306 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
> b
;
1307 AssertNodeType (e5
, ExpressionType
.GreaterThan
);
1308 Assert (false, e5
.Compile ().Invoke (null, 33));
1309 Assert (false, e5
.Compile ().Invoke (null, 0));
1310 Assert (true, e5
.Compile ().Invoke (new MyType (120), 3));
1313 void GreaterThanTest_6 ()
1315 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
> null;
1316 AssertNodeType (e6
, ExpressionType
.GreaterThan
);
1317 Assert (false, e6
.Compile ().Invoke (60));
1320 void GreaterThanTest_7 ()
1322 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
> b
;
1323 AssertNodeType (e7
, ExpressionType
.GreaterThan
);
1324 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1325 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1328 void GreaterThanTest_8 ()
1330 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
> b
;
1331 AssertNodeType (e8
, ExpressionType
.GreaterThan
);
1332 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1333 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1336 void GreaterThanOrEqualTest ()
1338 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
>= b
;
1339 AssertNodeType (e
, ExpressionType
.GreaterThanOrEqual
);
1340 Assert (true, e
.Compile ().Invoke (60, 30));
1343 void GreaterThanOrEqualTest_2 ()
1345 Expression
<Func
<byte?, byte?, bool>> e2
= (a
, b
) => a
>= b
;
1346 AssertNodeType (e2
, ExpressionType
.GreaterThanOrEqual
);
1347 Assert (false, e2
.Compile ().Invoke (null, 3));
1348 Assert (true, e2
.Compile ().Invoke (2, 2));
1351 void GreaterThanOrEqualTest_3 ()
1353 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
>= b
;
1354 AssertNodeType (e3
, ExpressionType
.GreaterThanOrEqual
);
1355 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
1358 void GreaterThanOrEqualTest_4 ()
1360 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
>= b
;
1361 AssertNodeType (e4
, ExpressionType
.GreaterThanOrEqual
);
1362 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1363 Assert (false, e4
.Compile ().Invoke (null, null));
1364 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1367 void GreaterThanOrEqualTest_5 ()
1369 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
>= b
;
1370 AssertNodeType (e5
, ExpressionType
.GreaterThanOrEqual
);
1371 Assert (false, e5
.Compile ().Invoke (null, 33));
1372 Assert (false, e5
.Compile ().Invoke (null, 0));
1373 Assert (true, e5
.Compile ().Invoke (new MyType (120), 3));
1376 void GreaterThanOrEqualTest_6 ()
1378 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
>= null;
1379 AssertNodeType (e6
, ExpressionType
.GreaterThanOrEqual
);
1380 Assert (false, e6
.Compile ().Invoke (60));
1383 void GreaterThanOrEqualTest_7 ()
1385 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
>= b
;
1386 AssertNodeType (e7
, ExpressionType
.GreaterThanOrEqual
);
1387 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1388 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1391 void GreaterThanOrEqualTest_8 ()
1393 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
>= b
;
1394 AssertNodeType (e8
, ExpressionType
.GreaterThanOrEqual
);
1395 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1396 Assert (true, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1401 var del
= new IntDelegate (TestInt
);
1402 Expression
<Func
<IntDelegate
, int>> e
= (a
) => a ();
1403 AssertNodeType (e
, ExpressionType
.Invoke
);
1404 Assert (29, e
.Compile ().Invoke (del
));
1407 void InvokeTest_2 ()
1409 Expression
<Func
<Func
<int, string>, int, string>> e2
= (a
, b
) => a (b
);
1410 AssertNodeType (e2
, ExpressionType
.Invoke
);
1411 Assert ("4", e2
.Compile ().Invoke ((a
) => (a
+1).ToString (), 3));
1416 Expression
<Func
<string, Func
<string>>> e
= (string s
) => () => s
;
1417 AssertNodeType (e
, ExpressionType
.Lambda
);
1418 Assert ("xx", e
.Compile ().Invoke ("xx") ());
1421 void LeftShiftTest ()
1423 Expression
<Func
<ulong, short, ulong>> e
= (ulong a
, short b
) => a
<< b
;
1424 AssertNodeType (e
, ExpressionType
.LeftShift
);
1425 Assert ((ulong) 0x7F000, e
.Compile ().Invoke (0xFE, 11));
1426 Assert ((ulong) 0x1FFFFFFFE, e
.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1428 // .net produces a strange result
1429 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
1430 // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1433 void LeftShiftTest_2 ()
1435 Expression
<Func
<MyType
, MyType
, int>> e2
= (MyType a
, MyType b
) => a
<< b
;
1436 AssertNodeType (e2
, ExpressionType
.LeftShift
);
1437 var c2
= e2
.Compile ();
1438 Assert (1024, c2 (new MyType (256), new MyType (2)));
1441 void LeftShiftTest_3 ()
1443 Expression
<Func
<long?, sbyte, long?>> e3
= (long? a
, sbyte b
) => a
<< b
;
1444 AssertNodeType (e3
, ExpressionType
.LeftShift
);
1445 Assert (null, e3
.Compile ().Invoke (null, 11));
1446 Assert (2048, e3
.Compile ().Invoke (1024, 1));
1449 void LeftShiftTest_4 ()
1451 Expression
<Func
<MyType
?, MyType
?, int?>> e4
= (MyType
? a
, MyType
? b
) => a
<< b
;
1452 AssertNodeType (e4
, ExpressionType
.LeftShift
);
1453 var c4
= e4
.Compile ();
1454 Assert (null, c4 (new MyType (8), null));
1455 Assert (null, c4 (null, new MyType (8)));
1456 Assert (1024, c4 (new MyType (256), new MyType (2)));
1459 void LeftShiftTest_5 ()
1461 Expression
<Func
<ushort, int?>> e5
= (ushort a
) => a
<< null;
1462 AssertNodeType (e5
, ExpressionType
.LeftShift
);
1463 Assert (null, e5
.Compile ().Invoke (30));
1466 void LeftShiftTest_6 ()
1468 Expression
<Func
<int, MyTypeImplicitOnly
, int>> e
= (a
, b
) => a
<< b
;
1469 AssertNodeType (e
, ExpressionType
.LeftShift
);
1470 Assert (0x7F0, e
.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
1473 void LessThanTest ()
1475 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
< b
;
1476 AssertNodeType (e
, ExpressionType
.LessThan
);
1477 Assert (false, e
.Compile ().Invoke (60, 30));
1480 void LessThanTest_2 ()
1482 Expression
<Func
<uint?, byte?, bool>> e2
= (a
, b
) => a
< b
;
1483 AssertNodeType (e2
, ExpressionType
.LessThan
);
1484 Assert (false, e2
.Compile ().Invoke (null, 3));
1485 Assert (false, e2
.Compile ().Invoke (2, 2));
1488 void LessThanTest_3 ()
1490 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
< b
;
1491 AssertNodeType (e3
, ExpressionType
.LessThan
);
1492 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1495 void LessThanTest_4 ()
1497 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
< b
;
1498 AssertNodeType (e4
, ExpressionType
.LessThan
);
1499 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1500 Assert (false, e4
.Compile ().Invoke (null, null));
1501 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1504 void LessThanTest_5 ()
1506 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
< b
;
1507 AssertNodeType (e5
, ExpressionType
.LessThan
);
1508 Assert (false, e5
.Compile ().Invoke (null, 33));
1509 Assert (false, e5
.Compile ().Invoke (null, 0));
1510 Assert (false, e5
.Compile ().Invoke (new MyType (120), 3));
1513 void LessThanTest_6 ()
1515 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
< null;
1516 AssertNodeType (e6
, ExpressionType
.LessThan
);
1517 Assert (false, e6
.Compile ().Invoke (60));
1520 void LessThanTest_7 ()
1522 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
< b
;
1523 AssertNodeType (e7
, ExpressionType
.LessThan
);
1524 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1525 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1528 void LessThanTest_8 ()
1530 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
< b
;
1531 AssertNodeType (e8
, ExpressionType
.LessThan
);
1532 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1533 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1536 void LessThanOrEqualTest ()
1538 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
<= b
;
1539 AssertNodeType (e
, ExpressionType
.LessThanOrEqual
);
1540 Assert (false, e
.Compile ().Invoke (60, 30));
1543 void LessThanOrEqualTest_2 ()
1545 Expression
<Func
<byte?, byte?, bool>> e2
= (a
, b
) => a
<= b
;
1546 AssertNodeType (e2
, ExpressionType
.LessThanOrEqual
);
1547 Assert (false, e2
.Compile ().Invoke (null, 3));
1548 Assert (true, e2
.Compile ().Invoke (2, 2));
1551 void LessThanOrEqualTest_3 ()
1553 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
<= b
;
1554 AssertNodeType (e3
, ExpressionType
.LessThanOrEqual
);
1555 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1558 void LessThanOrEqualTest_4 ()
1560 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
<= b
;
1561 AssertNodeType (e4
, ExpressionType
.LessThanOrEqual
);
1562 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1563 Assert (false, e4
.Compile ().Invoke (null, null));
1564 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1567 void LessThanOrEqualTest_5 ()
1569 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
<= b
;
1570 AssertNodeType (e5
, ExpressionType
.LessThanOrEqual
);
1571 Assert (false, e5
.Compile ().Invoke (null, 33));
1572 Assert (false, e5
.Compile ().Invoke (null, 0));
1573 Assert (false, e5
.Compile ().Invoke (new MyType (120), 3));
1576 void LessThanOrEqualTest_6 ()
1578 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
<= null;
1579 AssertNodeType (e6
, ExpressionType
.LessThanOrEqual
);
1580 Assert (false, e6
.Compile ().Invoke (60));
1583 void LessThanOrEqualTest_7 ()
1585 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
<= b
;
1586 AssertNodeType (e7
, ExpressionType
.LessThanOrEqual
);
1587 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1588 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1591 void LessThanOrEqualTest_8 ()
1593 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
<= b
;
1594 AssertNodeType (e8
, ExpressionType
.LessThanOrEqual
);
1595 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1596 Assert (true, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1599 void ListInitTest ()
1601 Expression
<Func
<List
<object>>> e1
= () => new List
<object> { "Hello", "", null, "World", 5 }
;
1602 AssertNodeType (e1
, ExpressionType
.ListInit
);
1603 var re1
= e1
.Compile ().Invoke ();
1604 Assert (null, re1
[2]);
1605 Assert ("World", re1
[3]);
1606 Assert (5, re1
[4]);
1609 void ListInitTest_2 ()
1611 Expression
<Func
<int, Dictionary
<string, int>>> e2
= (int value) => new Dictionary
<string, int> (3) { { "A", value }
, { "B", 2 }
};
1612 AssertNodeType (e2
, ExpressionType
.ListInit
);
1613 var re2
= e2
.Compile ().Invoke (3456);
1614 Assert (3456, re2
["A"]);
1617 void MemberAccessTest ()
1619 MemberAccessData d
= new MemberAccessData ();
1621 Expression
<Func
<bool>> e
= () => d
.BoolValue
;
1622 AssertNodeType (e
, ExpressionType
.MemberAccess
);
1623 Assert (true, e
.Compile ().Invoke ());
1624 d
.BoolValue
= false;
1625 Assert (false, e
.Compile ().Invoke ());
1628 void MemberAccessTest_2 ()
1630 Expression
<Func
<decimal>> e2
= () => MemberAccessData
.DecimalValue
;
1631 AssertNodeType (e2
, ExpressionType
.MemberAccess
);
1632 Assert (decimal.MinValue
, e2
.Compile ().Invoke ());
1635 void MemberAccessTest_3 ()
1637 MemberAccessData d
= new MemberAccessData ();
1638 d
.VolatileValue
= 492;
1639 Expression
<Func
<uint>> e3
= () => d
.VolatileValue
;
1640 AssertNodeType (e3
, ExpressionType
.MemberAccess
);
1641 Assert
<uint> (492, e3
.Compile ().Invoke ());
1644 void MemberAccessTest_4 ()
1646 MemberAccessData d
= new MemberAccessData ();
1647 Expression
<Func
<string[]>> e4
= () => d
.StringValues
;
1648 AssertNodeType (e4
, ExpressionType
.MemberAccess
);
1649 Assert (null, e4
.Compile ().Invoke ());
1652 void MemberAccessTest_5 ()
1654 MemberAccessData d
= new MemberAccessData ();
1655 var e5
= d
.GetEvent ();
1656 AssertNodeType (e5
, ExpressionType
.MemberAccess
);
1657 Assert (null, e5
.Compile ().Invoke ());
1660 void MemberAccessTest_6 ()
1662 MemberAccessData d
= new MemberAccessData ();
1663 Expression
<Func
<MyType
>> e6
= () => d
.MyTypeProperty
;
1664 AssertNodeType (e6
, ExpressionType
.MemberAccess
);
1665 Assert (new MyType (), e6
.Compile ().Invoke ());
1668 void MemberAccessTest_7 ()
1670 MemberAccessData d
= new MemberAccessData ();
1671 Expression
<Func
<MyType
, short>> e7
= a
=> a
.ShortProp
;
1672 AssertNodeType (e7
, ExpressionType
.MemberAccess
);
1673 MyType mt
= new MyType ();
1675 Assert (124, e7
.Compile ().Invoke (mt
));
1678 void MemberAccessTest_8 ()
1680 Expression
<Func
<string>> e8
= () => MemberAccessData
.StaticProperty
;
1681 AssertNodeType (e8
, ExpressionType
.MemberAccess
);
1682 Assert ("alo", e8
.Compile ().Invoke ());
1685 void MemberAccessTest_9 ()
1687 string s
= "localvar";
1688 Expression
<Func
<string>> e9
= () => s
;
1691 AssertNodeType (e9
, ExpressionType
.MemberAccess
);
1692 Assert ("changed", e9
.Compile ().Invoke ());
1695 void MemberInitTest ()
1697 Expression
<Func
<MemberAccessData
>> e
= () => new MemberAccessData
{
1698 VolatileValue
= 2, StringValues
= new string [] { "sv" }
, MyTypeProperty
= new MyType (692)
1700 AssertNodeType (e
, ExpressionType
.MemberInit
);
1701 var r1
= e
.Compile ().Invoke ();
1702 Assert
<uint> (2, r1
.VolatileValue
);
1703 Assert (new string[] { "sv" }
, r1
.StringValues
);
1704 Assert (new MyType (692), r1
.MyTypeProperty
);
1707 void MemberInitTest_2 ()
1709 Expression
<Func
<MemberAccessData
>> e2
= () => new MemberAccessData
{
1710 ListValues
= new List
<string> { "a", null }
1713 AssertNodeType (e2
, ExpressionType
.MemberInit
);
1714 var r2
= e2
.Compile ().Invoke ();
1715 Assert ("a", r2
.ListValues
[0]);
1718 void MemberInitTest_3 ()
1720 Expression
<Func
<short, MyType
>> e3
= a
=> new MyType { ShortProp = a }
;
1721 AssertNodeType (e3
, ExpressionType
.MemberInit
);
1722 var r3
= e3
.Compile ().Invoke (33);
1723 Assert (33, r3
.ShortProp
);
1726 void MemberInitTest_4 ()
1728 Expression
<Func
<int>> e
= () => new int { }
;
1730 AssertNodeType (e
, ExpressionType
.MemberInit
);
1731 var r
= e
.Compile ().Invoke ();
1737 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
% b
;
1738 AssertNodeType (e
, ExpressionType
.Modulo
);
1739 Assert (29, e
.Compile ().Invoke (60, 31));
1742 void ModuloTest_2 ()
1744 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
% b
;
1745 AssertNodeType (e2
, ExpressionType
.Modulo
);
1746 Assert (null, e2
.Compile ().Invoke (null, 3));
1747 Assert (1.1, e2
.Compile ().Invoke (3.1, 2));
1750 void ModuloTest_3 ()
1752 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
% b
;
1753 AssertNodeType (e3
, ExpressionType
.Modulo
);
1754 Assert (0, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1757 void ModuloTest_4 ()
1759 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
% b
;
1760 AssertNodeType (e4
, ExpressionType
.Modulo
);
1761 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1762 Assert (new MyType (12), e4
.Compile ().Invoke (new MyType (12), new MyType (-20)));
1765 void ModuloTest_5 ()
1767 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
% b
;
1768 AssertNodeType (e5
, ExpressionType
.Modulo
);
1769 Assert (1, e5
.Compile ().Invoke (99, new MyType (2)));
1772 void ModuloTest_6 ()
1774 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
% b
;
1775 AssertNodeType (e6
, ExpressionType
.Modulo
);
1776 Assert (100, e6
.Compile ().Invoke (100, new MyType (200)));
1777 Assert (null, e6
.Compile ().Invoke (20, null));
1780 void ModuloTest_7 ()
1782 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => a
% null;
1783 AssertNodeType (e7
, ExpressionType
.Modulo
);
1784 Assert (null, e7
.Compile ().Invoke (60));
1787 void MultiplyTest ()
1789 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
* b
;
1790 AssertNodeType (e
, ExpressionType
.Multiply
);
1791 Assert (1860, e
.Compile ().Invoke (60, 31));
1792 Assert (2147483617, e
.Compile ().Invoke (int.MaxValue
, 31));
1795 void MultiplyTest_2 ()
1797 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
* b
;
1798 AssertNodeType (e2
, ExpressionType
.Multiply
);
1799 Assert (null, e2
.Compile ().Invoke (null, 3));
1800 Assert (6.2, e2
.Compile ().Invoke (3.1, 2));
1803 void MultiplyTest_3 ()
1805 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
* b
;
1806 AssertNodeType (e3
, ExpressionType
.Multiply
);
1807 Assert (400, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1810 void MultiplyTest_4 ()
1812 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
* b
;
1813 AssertNodeType (e4
, ExpressionType
.Multiply
);
1814 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1815 Assert (new MyType (-240), e4
.Compile ().Invoke (new MyType (12), new MyType (-20)));
1818 void MultiplyTest_5 ()
1820 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
* b
;
1821 AssertNodeType (e5
, ExpressionType
.Multiply
);
1822 Assert (198, e5
.Compile ().Invoke (99, new MyType (2)));
1825 void MultiplyTest_6 ()
1827 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
* b
;
1828 AssertNodeType (e6
, ExpressionType
.Multiply
);
1829 Assert (0, e6
.Compile ().Invoke (int.MinValue
, new MyType (200)));
1830 Assert (null, e6
.Compile ().Invoke (20, null));
1833 void MultiplyTest_7 ()
1835 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => a
* null;
1836 AssertNodeType (e7
, ExpressionType
.Multiply
);
1837 Assert (null, e7
.Compile ().Invoke (60));
1840 void MultiplyCheckedTest ()
1843 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
* b
;
1844 AssertNodeType (e
, ExpressionType
.MultiplyChecked
);
1846 e
.Compile ().Invoke (int.MaxValue
, 309);
1847 throw new ApplicationException ("MultiplyCheckedTest #1");
1848 } catch (OverflowException
) { }
1852 void MultiplyCheckedTest_2 ()
1855 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a
* b
;
1856 AssertNodeType (e2
, ExpressionType
.MultiplyChecked
);
1857 Assert (null, e2
.Compile ().Invoke (null, 3));
1858 Assert (14025, e2
.Compile ().Invoke (byte.MaxValue
, 55));
1862 void MultiplyCheckedTest_3 ()
1865 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
* b
;
1866 AssertNodeType (e3
, ExpressionType
.Multiply
);
1867 Assert (-600, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
1871 void MultiplyCheckedTest_4 ()
1874 Expression
<Func
<double, double, double>> e4
= (a
, b
) => a
* b
;
1875 AssertNodeType (e4
, ExpressionType
.Multiply
);
1876 Assert (double.PositiveInfinity
, e4
.Compile ().Invoke (double.MaxValue
, int.MaxValue
));
1880 void MultiplyCheckedTest_5 ()
1883 Expression
<Func
<float?, float?, float?>> e5
= (a
, b
) => b
* a
;
1884 AssertNodeType (e5
, ExpressionType
.MultiplyChecked
);
1885 Assert (float.PositiveInfinity
, e5
.Compile ().Invoke (float.Epsilon
, float.PositiveInfinity
));
1891 Expression
<Func
<int, int>> e
= (a
) => -a
;
1892 AssertNodeType (e
, ExpressionType
.Negate
);
1893 Assert (30, e
.Compile ().Invoke (-30));
1896 void NegateTest_2 ()
1898 Expression
<Func
<sbyte, int>> e2
= (a
) => -(-a
);
1899 AssertNodeType (e2
, ExpressionType
.Negate
);
1900 Assert (-10, e2
.Compile ().Invoke (-10));
1903 void NegateTest_3 ()
1905 Expression
<Func
<long?, long?>> e3
= (a
) => -a
;
1906 AssertNodeType (e3
, ExpressionType
.Negate
);
1907 Assert (long.MinValue
+ 1, e3
.Compile ().Invoke (long.MaxValue
));
1908 Assert (null, e3
.Compile ().Invoke (null));
1911 void NegateTest_4 ()
1913 Expression
<Func
<MyType
, MyType
>> e4
= (a
) => -a
;
1914 AssertNodeType (e4
, ExpressionType
.Negate
);
1915 Assert (new MyType (14), e4
.Compile ().Invoke (new MyType (-14)));
1918 void NegateTest_5 ()
1920 Expression
<Func
<MyType
?, MyType
?>> e5
= (a
) => -a
;
1921 AssertNodeType (e5
, ExpressionType
.Negate
);
1922 Assert (new MyType (-33), e5
.Compile ().Invoke (new MyType (33)));
1923 Assert (null, e5
.Compile ().Invoke (null));
1926 void NegateTest_6 ()
1928 Expression
<Func
<MyTypeImplicitOnly
, int>> e6
= (MyTypeImplicitOnly a
) => -a
;
1929 AssertNodeType (e6
, ExpressionType
.Negate
);
1930 Assert (-4, e6
.Compile ().Invoke (new MyTypeImplicitOnly (4)));
1933 void NegateTest_7 ()
1935 Expression
<Func
<MyTypeImplicitOnly
?, int?>> e7
= (MyTypeImplicitOnly
? a
) => -a
;
1936 AssertNodeType (e7
, ExpressionType
.Negate
);
1937 Assert (-46, e7
.Compile ().Invoke (new MyTypeImplicitOnly (46)));
1939 // Another version of MS bug when predefined conversion is required on nullable user operator
1940 // Assert (null, e7.Compile ().Invoke (null));
1943 void NegateTest_8 ()
1945 Expression
<Func
<sbyte?, int?>> e8
= (a
) => -a
;
1946 AssertNodeType (e8
, ExpressionType
.Negate
);
1947 Assert (11, e8
.Compile ().Invoke (-11));
1950 void NegateTest_9 ()
1952 Expression
<Func
<uint, long>> e9
= (a
) => -a
;
1953 AssertNodeType (e9
, ExpressionType
.Negate
);
1954 Assert (-2, e9
.Compile ().Invoke (2));
1957 void NegateTestChecked ()
1960 Expression
<Func
<int, int>> e
= (int a
) => -a
;
1961 AssertNodeType (e
, ExpressionType
.NegateChecked
);
1963 e
.Compile ().Invoke (int.MinValue
);
1964 throw new ApplicationException ("NegateTestChecked #1");
1965 } catch (OverflowException
) { }
1969 void NegateTestChecked_2 ()
1972 Expression
<Func
<byte?, int?>> e2
= (a
) => -a
;
1973 AssertNodeType (e2
, ExpressionType
.NegateChecked
);
1974 Assert (null, e2
.Compile ().Invoke (null));
1975 Assert (-255, e2
.Compile ().Invoke (byte.MaxValue
));
1979 void NegateTestChecked_3 ()
1982 Expression
<Func
<MyType
, MyType
>> e3
= (MyType a
) => -a
;
1983 AssertNodeType (e3
, ExpressionType
.Negate
);
1984 Assert (20, e3
.Compile ().Invoke (new MyType (-20)));
1988 void NegateTestChecked_4 ()
1991 Expression
<Func
<double, double>> e4
= (a
) => -a
;
1992 AssertNodeType (e4
, ExpressionType
.Negate
);
1993 Assert (double.NegativeInfinity
, e4
.Compile ().Invoke (double.PositiveInfinity
));
1997 void NewArrayInitTest ()
1999 Expression
<Func
<int []>> e
= () => new int [1] { 5 }
;
2000 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
2001 Assert (new int [1] { 5 }
, e
.Compile ().Invoke ());
2004 void NewArrayInitTest_2 ()
2006 Expression
<Func
<int []>> e1
= () => new int [] { }
;
2007 AssertNodeType (e1
, ExpressionType
.NewArrayInit
);
2008 Assert (new int [0], e1
.Compile ().Invoke ());
2011 void NewArrayInitTest_3 ()
2013 Expression
<Func
<ushort, ulong? []>> e2
= (ushort a
) => new ulong? [] { a }
;
2014 AssertNodeType (e2
, ExpressionType
.NewArrayInit
);
2015 Assert (new ulong? [1] { ushort.MaxValue }
, e2
.Compile ().Invoke (ushort.MaxValue
));
2018 void NewArrayInitTest_4 ()
2020 Expression
<Func
<char [] []>> e3
= () => new char [] [] { new char [] { 'a' }
};
2021 AssertNodeType (e3
, ExpressionType
.NewArrayInit
);
2022 Assert (new char [] { 'a' }
, e3
.Compile ().Invoke () [0]);
2025 void NewArrayInitTest_5 ()
2027 Expression
<Func
<int?[]>> e
= () => new int?[] { null, 3, 4 }
;
2028 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
2029 Assert (3, e
.Compile ().Invoke ().Length
);
2032 void NewArrayInitTest_6 ()
2034 Expression
<Func
<string []>> e
= () => new [] { null, "a" }
;
2035 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
2036 Assert (2, e
.Compile ().Invoke ().Length
);
2039 void NewArrayBoundsTest ()
2041 Expression
<Func
<int [,]>> e
= () => new int [2,3];
2042 AssertNodeType (e
, ExpressionType
.NewArrayBounds
);
2043 Assert (new int [2,3].Length
, e
.Compile ().Invoke ().Length
);
2046 void NewArrayBoundsTest_2 ()
2048 Expression
<Func
<int[,]>> e2
= () => new int [0,0];
2049 AssertNodeType (e2
, ExpressionType
.NewArrayBounds
);
2050 Assert (new int [0, 0].Length
, e2
.Compile ().Invoke ().Length
);
2053 void NewArrayBoundsTest_3 ()
2055 Expression
<Func
<int []>> e
= () => new int [0];
2056 AssertNodeType (e
, ExpressionType
.NewArrayBounds
);
2057 Assert (0, e
.Compile ().Invoke ().Length
);
2060 void NewArrayBoundsTest_4 ()
2062 const ulong max
= ulong.MaxValue
;
2064 Expression
<Func
<bool[]>> e
= () => new bool [max
];
2065 AssertNodeType (e
, ExpressionType
.NewArrayBounds
);
2070 Expression
<Func
<MyType
>> e
= () => new MyType (2);
2071 AssertNodeType (e
, ExpressionType
.New
);
2072 Assert (new MyType (2), e
.Compile ().Invoke ());
2077 Expression
<Func
<MyType
>> e2
= () => new MyType ();
2078 AssertNodeType (e2
, ExpressionType
.New
);
2079 Assert (new MyType (), e2
.Compile ().Invoke ());
2084 Expression
<Func
<NewTest
<bool>>> e3
= () => new NewTest
<bool> (true);
2085 AssertNodeType (e3
, ExpressionType
.New
);
2086 Assert (new NewTest
<bool> (true), e3
.Compile ().Invoke ());
2091 Expression
<Func
<decimal, NewTest
<decimal>>> e4
= (decimal d
) => new NewTest
<decimal> (1, 5, d
);
2092 AssertNodeType (e4
, ExpressionType
.New
);
2093 Assert (new NewTest
<decimal> (1, 5, -9), e4
.Compile ().Invoke (-9));
2098 Expression
<Func
<object>> e5
= () => new { A = 9, Value = "a" }
;
2099 AssertNodeType (e5
, ExpressionType
.New
);
2100 var ne
= ((NewExpression
) e5
.Body
);
2102 Assert (2, ne
.Members
.Count
, "members count");
2104 // Behaviour is different between .NET 3.5 and .NET 4.0
2105 if (ne
.Members
[0].MemberType
== MemberTypes
.Property
) {
2106 Assert ("A", ne
.Members
[0].Name
, "Name #1");
2107 Assert ("Value", ne
.Members
[1].Name
, "Name #2");
2109 Assert ("get_A", ne
.Members
[0].Name
, "Name #1");
2110 Assert ("get_Value", ne
.Members
[1].Name
, "Name #2");
2113 Assert (new { A = 9, Value = "a" }
, e5
.Compile ().Invoke ());
2118 Expression
<Func
<object>> e5
= () => new { A = 9, Value = new MyType (5) }
;
2119 AssertNodeType (e5
, ExpressionType
.New
);
2122 // CSC bug: emits new MyEnum as a constant
2125 Expression
<Func
<MyEnum
>> e
= () => new MyEnum ();
2126 AssertNodeType (e
, ExpressionType
.New
);
2127 Assert
<MyEnum
> (0, e
.Compile ().Invoke ());
2132 Expression
<Func
<bool, bool>> e
= (bool a
) => !a
;
2133 AssertNodeType (e
, ExpressionType
.Not
);
2134 Assert (false, e
.Compile ().Invoke (true));
2139 Expression
<Func
<MyType
, bool>> e2
= (MyType a
) => !a
;
2140 AssertNodeType (e2
, ExpressionType
.Not
);
2141 Assert (true, e2
.Compile ().Invoke (new MyType (1)));
2142 Assert (false, e2
.Compile ().Invoke (new MyType (-1)));
2147 Expression
<Func
<int, int>> e3
= (int a
) => ~a
;
2148 AssertNodeType (e3
, ExpressionType
.Not
);
2149 Assert (-8, e3
.Compile ().Invoke (7));
2154 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => ~a
;
2155 AssertNodeType (e4
, ExpressionType
.Not
);
2156 Assert (0, e4
.Compile ().Invoke (new MyType (-1)));
2161 Expression
<Func
<ulong, ulong>> e5
= (ulong a
) => ~a
;
2162 AssertNodeType (e5
, ExpressionType
.Not
);
2163 Assert
<ulong> (18446744073709551608, e5
.Compile ().Invoke (7));
2168 Expression
<Func
<MyEnum
, MyEnum
>> e6
= (MyEnum a
) => ~a
;
2169 AssertNodeType (e6
, ExpressionType
.Convert
);
2170 Assert ((MyEnum
)254, e6
.Compile ().Invoke (MyEnum
.Value_1
));
2173 void NotNullableTest ()
2175 Expression
<Func
<bool?, bool?>> e
= (bool? a
) => !a
;
2176 AssertNodeType (e
, ExpressionType
.Not
);
2177 Assert (false, e
.Compile ().Invoke (true));
2178 Assert (null, e
.Compile ().Invoke (null));
2181 void NotNullableTest_2 ()
2183 Expression
<Func
<MyType
?, bool?>> e2
= (MyType
? a
) => !a
;
2184 AssertNodeType (e2
, ExpressionType
.Not
);
2185 Assert (true, e2
.Compile ().Invoke (new MyType (1)));
2186 Assert (null, e2
.Compile ().Invoke (null));
2189 void NotNullableTest_3 ()
2191 Expression
<Func
<sbyte?, int?>> e3
= (sbyte? a
) => ~a
;
2192 AssertNodeType (e3
, ExpressionType
.Not
);
2193 Assert (-5, e3
.Compile ().Invoke (4));
2194 Assert (null, e3
.Compile ().Invoke (null));
2197 void NotNullableTest_4 ()
2199 Expression
<Func
<MyType
?, int?>> e4
= (MyType
? a
) => ~a
;
2200 AssertNodeType (e4
, ExpressionType
.Not
);
2201 Assert (0, e4
.Compile ().Invoke (new MyType (-1)));
2202 Assert (null, e4
.Compile ().Invoke (null));
2205 void NotNullableTest_5 ()
2207 Expression
<Func
<MyEnum
?, MyEnum
?>> e5
= (MyEnum
? a
) => ~a
;
2208 AssertNodeType (e5
, ExpressionType
.Convert
);
2209 Assert ((MyEnum
) 254, e5
.Compile ().Invoke (MyEnum
.Value_1
));
2210 Assert (null, e5
.Compile ().Invoke (null));
2213 void NotEqualTest ()
2215 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
!= b
;
2216 AssertNodeType (e
, ExpressionType
.NotEqual
);
2217 Assert (true, e
.Compile ().Invoke (60, 30));
2218 Assert (false, e
.Compile ().Invoke (-1, -1));
2221 void NotEqualTest_2 ()
2223 Expression
<Func
<sbyte?, sbyte?, bool>> e2
= (a
, b
) => a
!= b
;
2224 AssertNodeType (e2
, ExpressionType
.NotEqual
);
2225 Assert (false, e2
.Compile ().Invoke (3, 3));
2226 Assert (true, e2
.Compile ().Invoke (3, 2));
2229 void NotEqualTest_3 ()
2231 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
!= b
;
2232 AssertNodeType (e3
, ExpressionType
.NotEqual
);
2233 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
2236 void NotEqualTest_4 ()
2238 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
!= b
;
2239 AssertNodeType (e4
, ExpressionType
.NotEqual
);
2240 Assert (true, e4
.Compile ().Invoke (null, new MyType (-20)));
2241 Assert (false, e4
.Compile ().Invoke (null, null));
2242 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (120)));
2245 void NotEqualTest_5 ()
2247 Expression
<Func
<bool?, bool?, bool>> e5
= (bool? a
, bool? b
) => a
!= b
;
2248 AssertNodeType (e5
, ExpressionType
.NotEqual
);
2249 Assert (true, e5
.Compile ().Invoke (true, null));
2250 Assert (false, e5
.Compile ().Invoke (null, null));
2251 Assert (false, e5
.Compile ().Invoke (false, false));
2254 void NotEqualTest_6 ()
2256 Expression
<Func
<bool, bool>> e6
= (bool a
) => a
!= null;
2257 AssertNodeType (e6
, ExpressionType
.NotEqual
);
2258 Assert (true, e6
.Compile ().Invoke (true));
2259 Assert (true, e6
.Compile ().Invoke (false));
2262 void NotEqualTest_7 ()
2264 Expression
<Func
<string, string, bool>> e7
= (string a
, string b
) => a
!= b
;
2265 AssertNodeType (e7
, ExpressionType
.NotEqual
);
2266 Assert (false, e7
.Compile ().Invoke (null, null));
2267 Assert (true, e7
.Compile ().Invoke ("a", "A"));
2268 Assert (false, e7
.Compile ().Invoke ("a", "a"));
2271 void NotEqualTest_8 ()
2273 Expression
<Func
<object, bool>> e8
= (object a
) => null != a
;
2274 AssertNodeType (e8
, ExpressionType
.NotEqual
);
2275 Assert (false, e8
.Compile ().Invoke (null));
2276 Assert (true, e8
.Compile ().Invoke ("a"));
2277 Assert (true, e8
.Compile ().Invoke (this));
2280 void NotEqualTest_9 ()
2282 Expression
<Func
<MyEnum
, MyEnum
, bool>> e9
= (a
, b
) => a
!= b
;
2283 AssertNodeType (e9
, ExpressionType
.NotEqual
);
2284 Assert (true, e9
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2285 Assert (false, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2288 void NotEqualTest_10 ()
2290 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e10
= (a
, b
) => a
!= b
;
2291 AssertNodeType (e10
, ExpressionType
.NotEqual
);
2292 Assert (true, e10
.Compile ().Invoke (MyEnum
.Value_1
, null));
2293 Assert (false, e10
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2296 void NotEqualTest_11 ()
2298 Expression
<Func
<MyEnum
?, bool>> e11
= (a
) => a
!= null;
2299 AssertNodeType (e11
, ExpressionType
.NotEqual
);
2300 Assert (true, e11
.Compile ().Invoke (MyEnum
.Value_1
));
2301 Assert (false, e11
.Compile ().Invoke (null));
2306 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
| b
;
2308 AssertNodeType (e
, ExpressionType
.Or
);
2309 Func
<bool, bool, bool> c
= e
.Compile ();
2311 Assert (true, c (true, true));
2312 Assert (true, c (true, false));
2313 Assert (true, c (false, true));
2314 Assert (false, c (false, false));
2319 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
| b
;
2320 AssertNodeType (e2
, ExpressionType
.Or
);
2321 var c2
= e2
.Compile ();
2322 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2327 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e3
= (a
, b
) => a
| b
;
2328 AssertNodeType (e3
, ExpressionType
.Convert
);
2329 Assert ((MyEnum
)3, e3
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2330 Assert (MyEnum
.Value_2
, e3
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2333 void OrNullableTest ()
2335 Expression
<Func
<bool?, bool?, bool?>> e
= (bool? a
, bool? b
) => a
| b
;
2337 AssertNodeType (e
, ExpressionType
.Or
);
2338 Func
<bool?, bool?, bool?> c
= e
.Compile ();
2340 Assert (true, c (true, true));
2341 Assert (true, c (true, false));
2342 Assert (true, c (false, true));
2343 Assert (false, c (false, false));
2345 Assert (true, c (true, null));
2346 Assert (null, c (false, null));
2347 Assert (null, c (null, false));
2348 Assert (true, c (true, null));
2349 Assert (null, c (null, null));
2352 void OrNullableTest_2 ()
2354 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e2
= (MyType
? a
, MyType
? b
) => a
| b
;
2355 AssertNodeType (e2
, ExpressionType
.Or
);
2356 var c2
= e2
.Compile ();
2357 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2358 Assert (null, c2 (new MyType (1), null));
2361 void OrNullableTest_3 ()
2363 Expression
<Func
<MyType
?, uint, long?>> e3
= (MyType
? a
, uint b
) => a
| b
;
2364 AssertNodeType (e3
, ExpressionType
.Or
);
2365 var c3
= e3
.Compile ();
2366 Assert (9, c3 (new MyType (1), 8));
2369 void OrNullableTest_4 ()
2371 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e4
= (a
, b
) => a
| b
;
2372 AssertNodeType (e4
, ExpressionType
.Convert
);
2373 Assert (null, e4
.Compile ().Invoke (null, MyEnum
.Value_2
));
2374 Assert ((MyEnum
)3, e4
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2379 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
|| b
;
2380 AssertNodeType (e
, ExpressionType
.OrElse
);
2381 Assert (true, e
.Compile ().Invoke (true, false));
2384 void OrElseTest_2 ()
2386 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
|| b
;
2387 AssertNodeType (e2
, ExpressionType
.OrElse
);
2388 Assert (new MyType (64), e2
.Compile ().Invoke (new MyType (64), new MyType (64)));
2389 Assert (new MyType (32), e2
.Compile ().Invoke (new MyType (32), new MyType (64)));
2392 void ParameterTest ()
2394 Expression
<Func
<string, string>> e
= (string a
) => a
;
2395 AssertNodeType (e
, ExpressionType
.Parameter
);
2396 Assert ("t", e
.Compile ().Invoke ("t"));
2399 void ParameterTest_2 ()
2401 Expression
<Func
<object[], object[]>> e2
= (object[] a
) => a
;
2402 AssertNodeType (e2
, ExpressionType
.Parameter
);
2403 Assert (new object [0], e2
.Compile ().Invoke (new object [0]));
2406 void ParameterTest_3 ()
2408 Expression
<Func
<IntPtr
, IntPtr
>> e3
= a
=> a
;
2409 AssertNodeType (e3
, ExpressionType
.Parameter
);
2410 Assert (IntPtr
.Zero
, e3
.Compile ().Invoke (IntPtr
.Zero
));
2413 unsafe void ParameterTest_4 ()
2415 Expression
<Func
<int*[], int* []>> e4
= (a
) => a
;
2416 AssertNodeType (e4
, ExpressionType
.Parameter
);
2417 Assert
<int*[]> (null, e4
.Compile ().Invoke (null));
2418 int* e4_el
= stackalloc int [5];
2419 int*[] ptr
= new int*[] { e4_el }
;
2420 Assert
<int*[]> (ptr
, e4
.Compile ().Invoke (ptr
));
2425 Expression
<Func
<Expression
<Func
<int>>>> e
= () => () => 2;
2426 AssertNodeType (e
, ExpressionType
.Quote
);
2427 Assert (2, e
.Compile ().Invoke ().Compile ().Invoke ());
2432 Expression
<Func
<string, Expression
<Func
<string>>>> e
= (string s
) => () => s
;
2433 AssertNodeType (e
, ExpressionType
.Quote
);
2435 Assert ("data", e
.Compile ().Invoke ("data").Compile ().Invoke ());
2438 void RightShiftTest ()
2440 Expression
<Func
<ulong, short, ulong>> e
= (ulong a
, short b
) => a
>> b
;
2441 AssertNodeType (e
, ExpressionType
.RightShift
);
2442 Assert ((ulong) 0x1FD940L
, e
.Compile ().Invoke (0xFECA0000, 11));
2443 Assert ((ulong) 0x7FFFFFFF, e
.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2445 // .net produces a strange result
2446 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
2447 // Assert ((ulong)0, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2450 void RightShiftTest_2 ()
2452 Expression
<Func
<MyType
, MyType
, int>> e2
= (MyType a
, MyType b
) => a
>> b
;
2453 AssertNodeType (e2
, ExpressionType
.RightShift
);
2454 var c2
= e2
.Compile ();
2455 Assert (64, c2 (new MyType (256), new MyType (2)));
2458 void RightShiftTest_3 ()
2460 Expression
<Func
<long?, sbyte, long?>> e3
= (long? a
, sbyte b
) => a
>> b
;
2461 AssertNodeType (e3
, ExpressionType
.RightShift
);
2462 Assert (null, e3
.Compile ().Invoke (null, 11));
2463 Assert (512, e3
.Compile ().Invoke (1024, 1));
2466 void RightShiftTest_4 ()
2468 Expression
<Func
<MyType
?, MyType
?, int?>> e4
= (MyType
? a
, MyType
? b
) => a
>> b
;
2469 AssertNodeType (e4
, ExpressionType
.RightShift
);
2470 var c4
= e4
.Compile ();
2471 Assert (null, c4 (new MyType (8), null));
2472 Assert (null, c4 (null, new MyType (8)));
2473 Assert (64, c4 (new MyType (256), new MyType (2)));
2476 void RightShiftTest_5 ()
2478 Expression
<Func
<int, MyTypeImplicitOnly
, int>> e
= (a
, b
) => a
>> b
;
2479 AssertNodeType (e
, ExpressionType
.RightShift
);
2480 Assert (31, e
.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
2483 void SubtractTest ()
2485 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
- b
;
2486 AssertNodeType (e
, ExpressionType
.Subtract
);
2487 Assert (-10, e
.Compile ().Invoke (20, 30));
2490 void SubtractTest_2 ()
2492 Expression
<Func
<int?, int?, int?>> e2
= (a
, b
) => a
- b
;
2493 AssertNodeType (e2
, ExpressionType
.Subtract
);
2494 Assert (null, e2
.Compile ().Invoke (null, 3));
2497 void SubtractTest_3 ()
2499 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
- b
;
2500 AssertNodeType (e3
, ExpressionType
.Subtract
);
2501 Assert (-50, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2504 void SubtractTest_4 ()
2506 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
- b
;
2507 AssertNodeType (e4
, ExpressionType
.Subtract
);
2508 Assert (new MyType (-50), e4
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2509 Assert (null, e4
.Compile ().Invoke (null, new MyType (30)));
2512 void SubtractTest_5 ()
2514 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
- b
;
2515 AssertNodeType (e5
, ExpressionType
.Subtract
);
2516 Assert (-29, e5
.Compile ().Invoke (1, new MyType (30)));
2519 void SubtractTest_6 ()
2521 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
- b
;
2522 AssertNodeType (e6
, ExpressionType
.Subtract
);
2523 Assert (-61, e6
.Compile ().Invoke (-31, new MyType (30)));
2526 void SubtractTest_7 ()
2528 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => null - a
;
2529 AssertNodeType (e7
, ExpressionType
.Subtract
);
2530 Assert (null, e7
.Compile ().Invoke (690));
2533 void SubtractTest_8 ()
2535 Expression
<Func
<MyEnum
, byte, MyEnum
>> e8
= (a
, b
) => a
- b
;
2536 AssertNodeType (e8
, ExpressionType
.Convert
);
2537 Assert ((MyEnum
)255, e8
.Compile ().Invoke (MyEnum
.Value_1
, 2));
2540 void SubtractTest_9 ()
2542 Expression
<Func
<MyEnum
, MyEnum
, byte>> e9
= (a
, b
) => a
- b
;
2543 AssertNodeType (e9
, ExpressionType
.Convert
);
2544 Assert (1, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
2548 void SubtractTest_10 ()
2550 Expression
<Func
<MyEnum
?, byte?, MyEnum
?>> e10
= (a
, b
) => a
- b
;
2551 AssertNodeType (e10
, ExpressionType
.Convert
);
2552 Assert ((MyEnum
) 255, e10
.Compile ().Invoke (MyEnum
.Value_1
, 2));
2556 void SubtractTest_11 ()
2558 Expression
<Func
<MyEnum
?, MyEnum
?, byte?>> e11
= (a
, b
) => a
- b
;
2559 AssertNodeType (e11
, ExpressionType
.Convert
);
2560 Assert
<byte?> (1, e11
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
2563 void SubtractCheckedTest ()
2566 Expression
<Func
<long, long, long>> e
= (long a
, long b
) => a
- b
;
2567 AssertNodeType (e
, ExpressionType
.SubtractChecked
);
2569 e
.Compile ().Invoke (long.MinValue
, 309);
2570 throw new ApplicationException ("SubtractCheckedTest #1");
2571 } catch (OverflowException
) { }
2575 void SubtractCheckedTest_2 ()
2578 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a
- b
;
2579 AssertNodeType (e2
, ExpressionType
.SubtractChecked
);
2580 Assert (null, e2
.Compile ().Invoke (null, 3));
2581 Assert (-55, e2
.Compile ().Invoke (byte.MinValue
, 55));
2585 void SubtractCheckedTest_3 ()
2588 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
- b
;
2589 AssertNodeType (e3
, ExpressionType
.Subtract
);
2590 Assert (-50, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2594 void SubtractCheckedTest_4 ()
2597 Expression
<Func
<double, double, double>> e4
= (a
, b
) => a
- b
;
2598 AssertNodeType (e4
, ExpressionType
.Subtract
);
2599 Assert (double.PositiveInfinity
, e4
.Compile ().Invoke (double.MinValue
, double.NegativeInfinity
));
2605 Expression
<Func
<object, Tester
>> e
= (object a
) => a
as Tester
;
2606 AssertNodeType (e
, ExpressionType
.TypeAs
);
2607 Assert (this, e
.Compile ().Invoke (this));
2610 void TypeAsTest_2 ()
2612 Expression
<Func
<object, int?>> e2
= (object a
) => a
as int?;
2613 AssertNodeType (e2
, ExpressionType
.TypeAs
);
2614 Assert (null, e2
.Compile ().Invoke (null));
2615 Assert (null, e2
.Compile ().Invoke (this));
2616 Assert (44, e2
.Compile ().Invoke (44));
2619 void TypeAsTest_3 ()
2621 Expression
<Func
<object, object>> e3
= (object a
) => null as object;
2622 AssertNodeType (e3
, ExpressionType
.TypeAs
);
2623 Assert (null, e3
.Compile ().Invoke (null));
2628 Expression
<Func
<object, bool>> e
= (object a
) => a
is Tester
;
2629 AssertNodeType (e
, ExpressionType
.TypeIs
);
2630 Assert (true, e
.Compile ().Invoke (this));
2631 Assert (false, e
.Compile ().Invoke (1));
2634 void TypeIsTest_2 ()
2636 Expression
<Func
<object, bool>> e2
= (object a
) => a
is int?;
2637 AssertNodeType (e2
, ExpressionType
.TypeIs
);
2638 Assert (false, e2
.Compile ().Invoke (null));
2639 Assert (true, e2
.Compile ().Invoke (1));
2642 void TypeIsTest_3 ()
2644 Expression
<Func
<object, bool>> e3
= (object a
) => null is object;
2645 AssertNodeType (e3
, ExpressionType
.TypeIs
);
2646 Assert (false, e3
.Compile ().Invoke (null));
2649 void TypeIsTest_5 ()
2651 Expression
<Func
<bool>> e5
= () => 1 is int;
2652 AssertNodeType (e5
, ExpressionType
.TypeIs
);
2653 Assert (true, e5
.Compile ().Invoke ());
2656 void TypeIsTest_6 ()
2658 Expression
<Func
<int?, bool>> e6
= (a
) => a
is int;
2659 AssertNodeType (e6
, ExpressionType
.TypeIs
);
2660 Assert (true, e6
.Compile ().Invoke (1));
2661 Assert (false, e6
.Compile ().Invoke (null));
2664 void UnaryPlusTest ()
2666 Expression
<Func
<int, int>> e
= (a
) => +a
;
2667 AssertNodeType (e
, ExpressionType
.Parameter
);
2668 Assert (-30, e
.Compile ().Invoke (-30));
2671 void UnaryPlusTest_2 ()
2673 Expression
<Func
<long?, long?>> e2
= (a
) => +a
;
2674 AssertNodeType (e2
, ExpressionType
.Parameter
);
2677 void UnaryPlusTest_3 ()
2679 Expression
<Func
<MyType
, MyType
>> e4
= (a
) => +a
;
2680 AssertNodeType (e4
, ExpressionType
.UnaryPlus
);
2681 Assert (new MyType (-14), e4
.Compile ().Invoke (new MyType (-14)));
2684 void UnaryPlusTest_4 ()
2686 Expression
<Func
<MyType
?, MyType
?>> e5
= (a
) => +a
;
2687 AssertNodeType (e5
, ExpressionType
.UnaryPlus
);
2688 Assert (new MyType (33), e5
.Compile ().Invoke (new MyType (33)));
2689 Assert (null, e5
.Compile ().Invoke (null));
2692 void UnaryPlusTest_5 ()
2694 Expression
<Func
<sbyte?, long?>> e6
= (a
) => +a
;
2695 AssertNodeType (e6
, ExpressionType
.Convert
);
2696 Assert (3, e6
.Compile ().Invoke (3));
2697 Assert (null, e6
.Compile ().Invoke (null));
2700 #pragma warning restore 169
2705 string InstanceMethod (string arg
)
2710 object InstanceParamsMethod (int index
, params object [] args
)
2714 if (args
.Length
== 0)
2716 return args
[index
];
2719 static int TestInt ()
2724 T GenericMethod
<T
> (T t
)
2729 static void RefMethod (ref int i
)
2734 static bool RunTest (MethodInfo test
)
2736 Console
.Write ("Running test {0, -25}", test
.Name
);
2738 test
.Invoke (new Tester (), null);
2739 Console
.WriteLine ("OK");
2741 } catch (Exception e
) {
2742 Console
.WriteLine ("FAILED");
2743 Console
.WriteLine (e
.ToString ());
2748 public static int Main ()
2750 var tests
= from test
in typeof (Tester
).GetMethods (BindingFlags
.Instance
| BindingFlags
.NonPublic
| BindingFlags
.DeclaredOnly
)
2751 where test
.GetParameters ().Length
== 0
2753 select RunTest (test
);
2755 int failures
= tests
.Count (a
=> !a
);
2756 Console
.WriteLine (failures
+ " tests failed");