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
266 public NewTest (params T [] t)
271 public override int GetHashCode ()
273 return base.GetHashCode ();
276 public override bool Equals (object obj)
278 NewTest<T> obj_t = obj as NewTest<T>;
282 for (int i = 0; i < t.Length; ++i) {
283 if (!t [i].Equals (obj_t.t [i]))
293 public int this [int i] { get { return i; } set { } }
294 public string this [params string[] i] { get { return string.Concat (i); } }
300 // TODO: Add more nullable tests, follow AddTest pattern.
304 delegate void EmptyDelegate ();
305 delegate int IntDelegate ();
306 static int ReturnNumber ()
311 static void AssertNodeType (LambdaExpression e, ExpressionType et)
313 if (e.Body.NodeType != et)
314 throw new ApplicationException (e.Body.NodeType + " != " + et);
317 static void Assert<T> (T expected, T value)
319 Assert (expected, value, null);
322 static void Assert<T> (T expected, T value, string name)
324 if (!EqualityComparer<T>.Default.Equals (expected, value)) {
325 if (!string.IsNullOrEmpty (name))
327 throw new ApplicationException (name + expected + " != " + value);
331 static void Assert<T> (T [] expected, T [] value)
333 if (expected == null) {
335 throw new ApplicationException ("Both arrays expected to be null");
339 if (expected.Length != value.Length)
340 throw new ApplicationException ("Array length does not match " + expected.Length + " != " + value.Length);
342 for (int i = 0; i < expected.Length; ++i) {
343 if (!EqualityComparer<T>.Default.Equals (expected [i], value [i]))
344 throw new ApplicationException ("Index " + i + ": " + expected [i] + " != " + value [i]);
348 #pragma warning disable 169
352 Expression<Func<int, int, int>> e = (int a, int b) => a + b;
353 AssertNodeType (e, ExpressionType.Add);
354 Assert (50, e.Compile ().Invoke (20, 30));
359 Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
360 AssertNodeType (e2, ExpressionType.Add);
361 Assert (null, e2.Compile ().Invoke (null, 3));
366 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
367 AssertNodeType (e3, ExpressionType.Add);
368 Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
373 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a + b;
374 AssertNodeType (e4, ExpressionType.Add);
375 Assert (new MyType (10), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
376 Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
381 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a + b;
382 AssertNodeType (e5, ExpressionType.Add);
383 Assert (31, e5.Compile ().Invoke (1, new MyType (30)));
388 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a + b;
389 AssertNodeType (e6, ExpressionType.Add);
390 Assert (-1, e6.Compile ().Invoke (-31, new MyType (30)));
395 Expression<Func<MyEnum, byte, MyEnum>> e7 = (a, b) => a + b;
396 AssertNodeType (e7, ExpressionType.Convert);
397 Assert (MyEnum.Value_2, e7.Compile ().Invoke (MyEnum.Value_1, 1));
402 // CSC BUG: probably due to missing numeric promotion
403 Expression<Func<MyEnum?, byte?, MyEnum?>> e8 = (a, b) => a + b;
404 AssertNodeType (e8, ExpressionType.Convert);
405 Assert<MyEnum?> (0, e8.Compile ().Invoke (MyEnum.Value_1, 255));
406 Assert (null, e8.Compile ().Invoke (MyEnum.Value_1, null));
407 Assert (null, e8.Compile ().Invoke (null, null));
412 Expression<Func<byte, MyEnum, MyEnum>> e9 = (a, b) => a + b;
413 AssertNodeType (e9, ExpressionType.Convert);
414 Assert (MyEnum.Value_2, e9.Compile ().Invoke (1, MyEnum.Value_1));
417 void AddCheckedTest ()
420 Expression<Func<int, int, int>> e = (int a, int b) => a + b;
421 AssertNodeType (e, ExpressionType.AddChecked);
422 Assert (50, e.Compile ().Invoke (20, 30));
426 void AddCheckedTest_2 ()
429 Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
430 AssertNodeType (e2, ExpressionType.AddChecked);
431 Assert (null, e2.Compile ().Invoke (null, 3));
435 void AddCheckedTest_3 ()
438 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
439 AssertNodeType (e3, ExpressionType.Add);
440 Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
444 void AddStringTest ()
446 Expression<Func<string, string>> e6 = (a) => 1 + a;
447 AssertNodeType (e6, ExpressionType.Add);
448 Assert ("1to", e6.Compile ().Invoke ("to"));
451 void AddStringTest_2 ()
453 Expression<Func<object, string, string>> e7 = (object a, string b) => a + b;
454 AssertNodeType (e7, ExpressionType.Add);
455 Assert ("testme", e7.Compile ().Invoke ("test", "me"));
456 Assert ("test", e7.Compile ().Invoke ("test", null));
457 Assert ("", e7.Compile ().Invoke (null, null));
460 void AddStringTest_3 ()
462 Expression<Func<string, int, string>> e8 = (a, b) => a + " " + "-" + "> " + b;
463 AssertNodeType (e8, ExpressionType.Add);
464 Assert ("test -> 2", e8.Compile ().Invoke ("test", 2));
467 void AddStringTest_4 ()
469 Expression<Func<string, ushort?, string>> e9 = (a, b) => a + b;
470 AssertNodeType (e9, ExpressionType.Add);
471 Assert ("test2", e9.Compile ().Invoke ("test", 2));
472 Assert ("test", e9.Compile ().Invoke ("test", null));
477 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a & b;
479 AssertNodeType (e, ExpressionType.And);
480 Func<bool, bool, bool> c = e.Compile ();
482 Assert (true, c (true, true));
483 Assert (false, c (true, false));
484 Assert (false, c (false, true));
485 Assert (false, c (false, false));
490 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a & b;
492 AssertNodeType (e2, ExpressionType.And);
493 var c2 = e2.Compile ();
495 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
496 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
501 Expression<Func<MyEnum, MyEnum, MyEnum>> e3 = (a, b) => a & b;
502 AssertNodeType (e3, ExpressionType.Convert);
503 Assert<MyEnum> (0, e3.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
504 Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
509 Expression<Func<int, int>> e = (a) => a & 0;
510 AssertNodeType (e, ExpressionType.And);
511 var c = e.Compile ();
516 void AndNullableTest ()
518 Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a & b;
520 AssertNodeType (e, ExpressionType.And);
521 Func<bool?, bool?, bool?> c = e.Compile ();
523 Assert (true, c (true, true));
524 Assert (false, c (true, false));
525 Assert (false, c (false, true));
526 Assert (false, c (false, false));
528 Assert (null, c (true, null));
529 Assert (false, c (false, null));
530 Assert (false, c (null, false));
531 Assert (null, c (true, null));
532 Assert (null, c (null, null));
535 void AndNullableTest_2 ()
537 Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a & b;
539 AssertNodeType (e2, ExpressionType.And);
540 var c2 = e2.Compile ();
542 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
543 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
544 Assert (null, c2 (new MyType (0xFF), null));
547 void AndNullableTest_3 ()
549 Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e3 = (a, b) => a & b;
550 AssertNodeType (e3, ExpressionType.Convert);
551 Assert (null, e3.Compile ().Invoke (null, MyEnum.Value_2));
552 Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
557 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a && b;
558 AssertNodeType (e, ExpressionType.AndAlso);
559 Assert (false, e.Compile ().Invoke (true, false));
562 void AndAlsoTest_2 ()
564 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a && b;
565 AssertNodeType (e2, ExpressionType.AndAlso);
566 Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
567 Assert (new MyType (0), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
570 void AndAlsoTest_3 ()
572 Expression<Func<bool, bool>> e3 = (bool a) => a && true;
573 AssertNodeType (e3, ExpressionType.AndAlso);
574 Assert (false, e3.Compile ().Invoke (false));
575 Assert (true, e3.Compile ().Invoke (true));
578 void ArrayIndexTest ()
580 Expression<Func<string [], long, string>> e = (string [] a, long i) => a [i];
581 AssertNodeType (e, ExpressionType.ArrayIndex);
582 Assert ("b", e.Compile ().Invoke (new string [] { "a", "b", "c" }, 1));
585 void ArrayIndexTest_2 ()
587 Expression<Func<string [], string>> e2 = (string [] a) => a [0];
588 AssertNodeType (e2, ExpressionType.ArrayIndex);
589 Assert ("a", e2.Compile ().Invoke (new string [] { "a", "b" }));
592 void ArrayIndexTest_3 ()
594 Expression<Func<object [,], int, int, object>> e3 = (object [,] a, int i, int j) => a [i, j];
595 AssertNodeType (e3, ExpressionType.Call);
597 Assert ("z", e3.Compile ().Invoke (
598 new object [,] { { 1, 2 }, { "x", "z" } }, 1, 1));
601 void ArrayIndexTest_4 ()
603 Expression<Func<decimal [] [], byte, decimal>> e4 = (decimal [] [] a, byte b) => a [b] [1];
604 AssertNodeType (e4, ExpressionType.ArrayIndex);
606 decimal [] [] array = { new decimal [] { 1, 9 }, new decimal [] { 10, 90 } };
607 Assert (90, e4.Compile ().Invoke (array, 1));
610 void ArrayIndexTest_5 ()
612 Expression<Func<int>> e5 = () => (new int [1]) [0];
613 AssertNodeType (e5, ExpressionType.ArrayIndex);
614 Assert (0, e5.Compile ().Invoke ());
617 void ArrayIndexTest_6 ()
621 Expression<Func<int[], int>> e = a => a [max];
622 AssertNodeType (e, ExpressionType.ArrayIndex);
623 Assert (4, e.Compile ().Invoke (new int [] { 1, 2, 3, 4, 5 }));
626 void ArrayIndexTest_7 ()
628 const ulong max = uint.MaxValue;
630 Expression<Func<int[], int>> e = a => a [max];
631 AssertNodeType (e, ExpressionType.ArrayIndex);
634 e.Compile ().Invoke (new int [0]);
635 throw new ApplicationException ("ArrayIndexTest_7");
636 } catch (System.OverflowException) {
637 // Check whether CheckedConversion was generated
641 void ArrayLengthTest ()
643 Expression<Func<double [], int>> e = (double [] a) => a.Length;
644 AssertNodeType (e, ExpressionType.ArrayLength);
645 Assert (0, e.Compile ().Invoke (new double [0]));
646 Assert (9, e.Compile ().Invoke (new double [9]));
649 void ArrayLengthTest_2 ()
651 Expression<Func<string [,], int>> e2 = (string [,] a) => a.Length;
652 AssertNodeType (e2, ExpressionType.MemberAccess);
653 Assert (0, e2.Compile ().Invoke (new string [0, 0]));
658 Expression<Func<int, int>> e = (int a) => Math.Max (a, 5);
659 AssertNodeType (e, ExpressionType.Call);
660 Assert (5, e.Compile ().Invoke (2));
661 Assert (9, e.Compile ().Invoke (9));
666 Expression<Func<string, string>> e2 = (string a) => InstanceMethod (a);
667 AssertNodeType (e2, ExpressionType.Call);
668 Assert ("abc", e2.Compile ().Invoke ("abc"));
673 Expression<Func<int, string, int, object>> e3 = (int index, string a, int b) => InstanceParamsMethod (index, a, b);
674 AssertNodeType (e3, ExpressionType.Call);
675 Assert<object> (4, e3.Compile ().Invoke (1, "a", 4));
680 Expression<Func<object>> e4 = () => InstanceParamsMethod (0);
681 AssertNodeType (e4, ExpressionType.Call);
682 Assert<object> ("<empty>", e4.Compile ().Invoke ());
687 Expression<Func<int, int>> e5 = (int a) => GenericMethod (a);
688 AssertNodeType (e5, ExpressionType.Call);
689 Assert (5, e5.Compile ().Invoke (5));
694 Expression<Action> e6 = () => Console.WriteLine ("call test");
695 AssertNodeType (e6, ExpressionType.Call);
700 Expression<Func<Indexer, int, int>> e7 = (a, b) => a [b];
701 AssertNodeType (e7, ExpressionType.Call);
702 Assert (3, e7.Compile ().Invoke (new Indexer (), 3));
707 Expression<Func<Indexer, string, string, string, string>> e8 = (a, b, c , d) => a [b, c, d];
708 AssertNodeType (e8, ExpressionType.Call);
709 Assert ("zyb", e8.Compile ().Invoke (new Indexer (), "z", "y", "b"));
714 Expression<Action<int>> e9 = (a) => RefMethod (ref a);
715 AssertNodeType (e9, ExpressionType.Call);
716 e9.Compile ().Invoke (1);
721 Expression<Func<uint?, uint>> e = (uint? a) => a ?? 99;
722 AssertNodeType (e, ExpressionType.Coalesce);
723 var r = e.Compile ();
724 Assert ((uint) 5, r.Invoke (5));
725 Assert ((uint) 99, r.Invoke (null));
728 void CoalesceTest_2 ()
730 Expression<Func<MyType?, int>> e2 = (MyType? a) => a ?? -3;
731 AssertNodeType (e2, ExpressionType.Coalesce);
732 var r2 = e2.Compile ();
733 Assert (2, r2.Invoke (new MyType (2)));
734 Assert (-3, r2.Invoke (null));
737 void ConditionTest ()
739 Expression<Func<bool, byte, int, int>> e = (bool a, byte b, int c) => (a ? b : c);
740 AssertNodeType (e, ExpressionType.Conditional);
741 var r = e.Compile ();
742 Assert (3, r.Invoke (true, 3, 999999));
743 Assert (999999, r.Invoke (false, 3, 999999));
746 void ConditionTest_2 ()
748 Expression<Func<int, decimal, decimal?>> e2 = (int a, decimal d) => (a > 0 ? d : a < 0 ? -d : (decimal?) null);
749 AssertNodeType (e2, ExpressionType.Conditional);
750 var r2 = e2.Compile ();
751 Assert (null, r2.Invoke (0, 10));
752 Assert (50, r2.Invoke (1, 50));
753 Assert (30, r2.Invoke (-7, -30));
756 void ConditionTest_3 ()
758 Expression<Func<bool?, int?>> e3 = (bool? a) => ((bool) a ? 3 : -2);
759 AssertNodeType (e3, ExpressionType.Convert);
760 var r3 = e3.Compile ();
761 Assert (3, r3.Invoke (true));
762 Assert (-2, r3.Invoke (false));
765 void ConditionTest_4 ()
767 Expression<Func<InverseLogicalOperator, byte, byte, byte>> e4 = (InverseLogicalOperator a, byte b, byte c) => (a ? b : c);
768 AssertNodeType (e4, ExpressionType.Conditional);
769 var r4 = e4.Compile ();
770 Assert (3, r4.Invoke (new InverseLogicalOperator (true), 3, 4));
771 Assert (4, r4.Invoke (new InverseLogicalOperator (false), 3, 4));
774 void ConditionTest_5 ()
777 Expression<Func<int>> e = () => false ? 1 : 4;
778 AssertNodeType (e, ExpressionType.Conditional);
779 var r = e.Compile ();
780 Assert (4, r.Invoke ());
785 Expression<Func<int>> e1 = () => default (int);
786 AssertNodeType (e1, ExpressionType.Constant);
787 Assert (0, e1.Compile ().Invoke ());
790 void ConstantTest_2 ()
792 Expression<Func<int?>> e2 = () => default (int?);
793 AssertNodeType (e2, ExpressionType.Constant);
794 Assert (null, e2.Compile ().Invoke ());
797 void ConstantTest_3 ()
799 Expression<Func<Tester>> e3 = () => default (Tester);
800 AssertNodeType (e3, ExpressionType.Constant);
801 Assert (null, e3.Compile ().Invoke ());
804 void ConstantTest_4 ()
806 Expression<Func<object>> e4 = () => null;
807 AssertNodeType (e4, ExpressionType.Constant);
808 Assert (null, e4.Compile ().Invoke ());
811 void ConstantTest_5 ()
813 Expression<Func<int>> e5 = () => 8 / 4;
814 AssertNodeType (e5, ExpressionType.Constant);
815 Assert (2, e5.Compile ().Invoke ());
818 void ConstantTest_6 ()
820 Expression<Func<int>> e6 = () => 0xFFFFFF >> 0x40;
821 AssertNodeType (e6, ExpressionType.Constant);
822 Assert (0xFFFFFF, e6.Compile ().Invoke ());
825 void ConstantTest_7 ()
827 Expression<Func<object>> e7 = () => "Alleluia";
828 AssertNodeType (e7, ExpressionType.Constant);
829 Assert ("Alleluia", e7.Compile ().Invoke ());
832 void ConstantTest_8 ()
834 Expression<Func<Type>> e8 = () => typeof (int);
835 AssertNodeType (e8, ExpressionType.Constant);
836 Assert (typeof (int), e8.Compile ().Invoke ());
839 void ConstantTest_9 ()
841 Expression<Func<Type>> e9 = () => typeof (void);
842 AssertNodeType (e9, ExpressionType.Constant);
843 Assert (typeof (void), e9.Compile ().Invoke ());
846 void ConstantTest_10 ()
848 Expression<Func<Type>> e10 = () => typeof (Func<,>);
849 AssertNodeType (e10, ExpressionType.Constant);
850 Assert (typeof (Func<,>), e10.Compile ().Invoke ());
853 void ConstantTest_11 ()
855 Expression<Func<MyEnum>> e11 = () => MyEnum.Value_2;
856 AssertNodeType (e11, ExpressionType.Constant);
857 Assert (MyEnum.Value_2, e11.Compile ().Invoke ());
860 void ConstantTest_13 ()
862 Expression<Func<int>> e13 = () => sizeof (byte);
863 AssertNodeType (e13, ExpressionType.Constant);
864 Assert (1, e13.Compile ().Invoke ());
868 void ConstantTest_14 ()
870 Expression<Func<Type>> e14 = () => typeof (bool*);
871 AssertNodeType (e14, ExpressionType.Constant);
872 Assert (typeof (bool*), e14.Compile ().Invoke ());
875 void ConstantTest_15 ()
877 Expression<Func<int?>> e15 = () => null;
878 AssertNodeType (e15, ExpressionType.Constant);
879 Assert (null, e15.Compile ().Invoke ());
884 Expression<Func<int, byte>> e = (int a) => ((byte) a);
885 AssertNodeType (e, ExpressionType.Convert);
886 Assert (100, e.Compile ().Invoke (100));
889 void ConvertTest_2 ()
891 Expression<Func<long, ushort>> e2 = (long a) => ((ushort) a);
892 AssertNodeType (e2, ExpressionType.Convert);
893 Assert (100, e2.Compile ().Invoke (100));
896 void ConvertTest_3 ()
898 Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
899 AssertNodeType (e3, ExpressionType.Convert);
900 Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
903 void ConvertTest_4 ()
905 Expression<Func<MyType, int>> e4 = (MyType a) => (a);
906 AssertNodeType (e4, ExpressionType.Convert);
907 Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
910 void ConvertTest_5 ()
912 Expression<Func<MyType, MyType, bool?>> e5 = (MyType a, MyType b) => a == b;
913 AssertNodeType (e5, ExpressionType.Convert);
916 void ConvertTest_6 ()
918 Expression<Func<MyType?, MyType?, bool?>> e6 = (MyType? a, MyType? b) => a == b;
919 AssertNodeType (e6, ExpressionType.Convert);
920 Assert (false, e6.Compile ().Invoke (null, new MyType (-20)));
921 Assert (true, e6.Compile ().Invoke (null, null));
922 Assert (true, e6.Compile ().Invoke (new MyType (120), new MyType (120)));
925 void ConvertTest_7 ()
927 Expression<Func<MyTypeExplicit, int?>> e7 = x => (int?)x;
928 AssertNodeType (e7, ExpressionType.Convert);
929 Assert (33, e7.Compile ().Invoke (new MyTypeExplicit (33)));
932 void ConvertTest_8 ()
934 Expression<Func<int?, object>> e8 = x => (object)x;
935 AssertNodeType (e8, ExpressionType.Convert);
936 Assert (null, e8.Compile ().Invoke (null));
937 Assert (-100, e8.Compile ().Invoke (-100));
940 unsafe void ConvertTest_9 ()
942 int*[] p = new int* [1];
943 Expression<Func<object>> e9 = () => (object)p;
944 AssertNodeType (e9, ExpressionType.Convert);
945 Assert (p, e9.Compile ().Invoke ());
948 void ConvertTest_10 ()
950 Expression<Func<Func<int>, Delegate>> e10 = (a) => a + a;
951 AssertNodeType (e10, ExpressionType.Convert);
952 Assert (null, e10.Compile ().Invoke (null));
953 Assert (new Func<int> (TestInt) + new Func<int> (TestInt), e10.Compile ().Invoke (TestInt));
956 void ConvertTest_11 ()
958 Expression<Func<Func<int>, Delegate>> e11 = (a) => a - a;
959 AssertNodeType (e11, ExpressionType.Convert);
960 Assert (null, e11.Compile ().Invoke (null));
963 void ConvertTest_12 ()
965 Expression<Func<Func<int>>> e12 = () => TestInt;
966 AssertNodeType (e12, ExpressionType.Convert);
967 Assert (29, e12.Compile ().Invoke () ());
970 void ConvertTest_13 ()
972 Expression<Func<decimal, sbyte>> e13 = a => (sbyte)a;
973 AssertNodeType (e13, ExpressionType.Convert);
974 Assert (6, e13.Compile ().Invoke (6));
977 void ConvertTest_14 ()
979 Expression<Func<long, decimal>> e14 = a => a;
980 AssertNodeType (e14, ExpressionType.Convert);
981 Assert (-66, e14.Compile ().Invoke (-66));
984 void ConvertTest_15 ()
986 Expression<Func<ulong?, decimal?>> e15 = a => a;
987 AssertNodeType (e15, ExpressionType.Convert);
988 Assert (null, e15.Compile ().Invoke (null));
989 Assert (9, e15.Compile ().Invoke (9));
992 void ConvertTest_16 ()
994 Expression<Func<sbyte, sbyte>> e16 = a => (sbyte)a;
995 AssertNodeType (e16, ExpressionType.Convert);
996 Assert (6, e16.Compile ().Invoke (6));
999 void ConvertCheckedTest ()
1001 Expression<Func<int, byte>> e = (int a) => checked((byte) a);
1002 AssertNodeType (e, ExpressionType.ConvertChecked);
1003 Assert (100, e.Compile ().Invoke (100));
1006 void ConvertCheckedTest_2 ()
1009 Expression<Func<long, ushort>> e2 = (long a) => unchecked((ushort) a);
1010 AssertNodeType (e2, ExpressionType.Convert);
1011 Assert (100, e2.Compile ().Invoke (100));
1015 void ConvertCheckedTest_3 ()
1018 Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
1019 AssertNodeType (e3, ExpressionType.ConvertChecked);
1020 Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
1024 void ConvertCheckedTest_4 ()
1027 Expression<Func<MyType, int>> e4 = (MyType a) => (a);
1028 AssertNodeType (e4, ExpressionType.Convert);
1029 Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
1035 Expression<Func<int, int, int>> e = (int a, int b) => a / b;
1036 AssertNodeType (e, ExpressionType.Divide);
1037 Assert (2, e.Compile ().Invoke (60, 30));
1040 void DivideTest_2 ()
1042 Expression<Func<double?, double?, double?>> e2 = (a, b) => a / b;
1043 AssertNodeType (e2, ExpressionType.Divide);
1044 Assert (null, e2.Compile ().Invoke (null, 3));
1045 Assert (1.5, e2.Compile ().Invoke (3, 2));
1048 void DivideTest_3 ()
1050 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a / b;
1051 AssertNodeType (e3, ExpressionType.Divide);
1052 Assert (1, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1055 void DivideTest_4 ()
1057 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a / b;
1058 AssertNodeType (e4, ExpressionType.Divide);
1059 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1060 Assert (new MyType (-6), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1063 void DivideTest_5 ()
1065 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a / b;
1066 AssertNodeType (e5, ExpressionType.Divide);
1067 Assert (50, e5.Compile ().Invoke (100, new MyType (2)));
1070 void DivideTest_6 ()
1072 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a / b;
1073 AssertNodeType (e6, ExpressionType.Divide);
1074 Assert (50, e6.Compile ().Invoke (100, new MyType (2)));
1075 Assert (null, e6.Compile ().Invoke (20, null));
1078 void DivideTest_7 ()
1080 Expression<Func<float, uint?, float?>> e = (a, b) => a / b;
1081 AssertNodeType (e, ExpressionType.Divide);
1082 Assert (50, e.Compile () (100, 2));
1083 Assert (null, e.Compile () (20, null));
1088 Expression<Func<int, int, bool>> e = (int a, int b) => a == b;
1089 AssertNodeType (e, ExpressionType.Equal);
1090 Assert (false, e.Compile ().Invoke (60, 30));
1091 Assert (true, e.Compile ().Invoke (-1, -1));
1096 Expression<Func<double?, double?, bool>> e2 = (a, b) => a == b;
1097 AssertNodeType (e2, ExpressionType.Equal);
1098 Assert (true, e2.Compile ().Invoke (3, 3));
1099 Assert (false, e2.Compile ().Invoke (3, 2));
1104 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a == b;
1105 AssertNodeType (e3, ExpressionType.Equal);
1106 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1111 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a == b;
1112 AssertNodeType (e4, ExpressionType.Equal);
1113 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1114 Assert (true, e4.Compile ().Invoke (null, null));
1115 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
1120 Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a == b;
1121 AssertNodeType (e5, ExpressionType.Equal);
1122 Assert (false, e5.Compile ().Invoke (true, null));
1123 Assert (true, e5.Compile ().Invoke (null, null));
1124 Assert (true, e5.Compile ().Invoke (false, false));
1129 Expression<Func<bool, bool>> e6 = (bool a) => a == null;
1130 AssertNodeType (e6, ExpressionType.Equal);
1131 Assert (false, e6.Compile ().Invoke (true));
1132 Assert (false, e6.Compile ().Invoke (false));
1137 Expression<Func<string, string, bool>> e7 = (string a, string b) => a == b;
1138 AssertNodeType (e7, ExpressionType.Equal);
1139 Assert (true, e7.Compile ().Invoke (null, null));
1140 Assert (false, e7.Compile ().Invoke ("a", "A"));
1141 Assert (true, e7.Compile ().Invoke ("a", "a"));
1146 Expression<Func<object, bool>> e8 = (object a) => null == a;
1147 AssertNodeType (e8, ExpressionType.Equal);
1148 Assert (true, e8.Compile ().Invoke (null));
1149 Assert (false, e8.Compile ().Invoke ("a"));
1150 Assert (false, e8.Compile ().Invoke (this));
1155 Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a == b;
1156 AssertNodeType (e9, ExpressionType.Equal);
1157 Assert (false, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
1158 Assert (true, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1161 void EqualTest_10 ()
1163 Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a == b;
1164 AssertNodeType (e10, ExpressionType.Equal);
1165 Assert (false, e10.Compile ().Invoke (MyEnum.Value_1, null));
1166 Assert (true, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1169 void EqualTest_11 ()
1171 Expression<Func<MyEnum?, bool>> e11 = (a) => a == null;
1172 AssertNodeType (e11, ExpressionType.Equal);
1173 Assert (false, e11.Compile ().Invoke (MyEnum.Value_1));
1174 Assert (true, e11.Compile ().Invoke (null));
1177 void EqualTest_12 ()
1179 Expression<Func<MyEnumUlong, bool>> e12 = (a) => a == 0;
1180 AssertNodeType (e12, ExpressionType.Equal);
1181 Assert (false, e12.Compile ().Invoke (MyEnumUlong.Value_1));
1182 Assert (true, e12.Compile ().Invoke (0));
1185 void EqualTest_13 ()
1187 Expression<Func<MyEnum, bool>> e13 = (a) => a == MyEnum.Value_2;
1188 AssertNodeType (e13, ExpressionType.Equal);
1189 Assert (true, e13.Compile ().Invoke (MyEnum.Value_2));
1190 Assert (false, e13.Compile ().Invoke (0));
1193 void EqualTest_14 ()
1195 Expression<Func<MyEnum, bool>> e = (a) => a == null;
1196 AssertNodeType (e, ExpressionType.Equal);
1197 Assert (false, e.Compile ().Invoke (MyEnum.Value_1));
1200 void EqualTest_15 ()
1202 Expression<Func<int?, uint, bool>> e = (a, b) => a == b;
1203 AssertNodeType (e, ExpressionType.Equal);
1204 Assert (false, e.Compile ().Invoke (null, 0));
1205 Assert (true, e.Compile ().Invoke (4, 4));
1208 void EqualTestDelegate ()
1210 Expression<Func<Delegate, Delegate, bool>> e1 = (a, b) => a == b;
1211 AssertNodeType (e1, ExpressionType.Equal);
1212 Assert (true, e1.Compile ().Invoke (null, null));
1215 void EqualTestDelegate_2 ()
1217 EmptyDelegate ed = delegate () {};
1219 Expression<Func<EmptyDelegate, EmptyDelegate, bool>> e2 = (a, b) => a == b;
1220 AssertNodeType (e2, ExpressionType.Equal);
1221 Assert (false, e2.Compile ().Invoke (delegate () {}, null));
1222 Assert (false, e2.Compile ().Invoke (delegate () {}, delegate {}));
1223 Assert (false, e2.Compile ().Invoke (ed, delegate {}));
1224 Assert (true, e2.Compile ().Invoke (ed, ed));
1227 void EqualTestDelegate_3 ()
1229 Expression<Func<Func<int>, bool>> e1 = (a) => a == ReturnNumber;
1230 AssertNodeType (e1, ExpressionType.Equal);
1231 Assert (false, e1.Compile ().Invoke (null));
1232 Assert (true, e1.Compile ().Invoke (ReturnNumber));
1235 void ExclusiveOrTest ()
1237 Expression<Func<int, short, int>> e = (int a, short b) => a ^ b;
1238 AssertNodeType (e, ExpressionType.ExclusiveOr);
1239 Assert (34, e.Compile ().Invoke (60, 30));
1242 void ExclusiveOrTest_2 ()
1244 Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a ^ b;
1245 AssertNodeType (e2, ExpressionType.ExclusiveOr);
1246 Assert (null, e2.Compile ().Invoke (null, 3));
1247 Assert (1, e2.Compile ().Invoke (3, 2));
1250 void ExclusiveOrTest_3 ()
1252 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a ^ b;
1253 AssertNodeType (e3, ExpressionType.ExclusiveOr);
1254 Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1257 void ExclusiveOrTest_4 ()
1259 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a ^ b;
1260 AssertNodeType (e4, ExpressionType.ExclusiveOr);
1261 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1262 Assert (new MyType (-108), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1265 void ExclusiveOrTest_5 ()
1267 Expression<Func<MyType?, byte, int?>> e5 = (MyType? a, byte b) => a ^ b;
1268 AssertNodeType (e5, ExpressionType.ExclusiveOr);
1269 Assert (null, e5.Compile ().Invoke (null, 64));
1270 Assert (96, e5.Compile ().Invoke (new MyType (64), 32));
1273 void ExclusiveOrTest_6 ()
1275 Expression<Func<MyEnum, MyEnum, MyEnum>> e6 = (a, b) => a ^ b;
1276 AssertNodeType (e6, ExpressionType.Convert);
1277 Assert ((MyEnum)3, e6.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
1278 Assert<MyEnum> (0, e6.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1281 void ExclusiveOrTest_7 ()
1283 Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e7 = (a, b) => a ^ b;
1284 AssertNodeType (e7, ExpressionType.Convert);
1285 Assert (null, e7.Compile ().Invoke (MyEnum.Value_1, null));
1286 Assert<MyEnum?> (0, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1289 void ExclusiveOrTest_8 ()
1291 Expression<Func<MyEnum?, MyEnum?>> e8 = (a) => a ^ null;
1292 AssertNodeType (e8, ExpressionType.Convert);
1293 Assert (null, e8.Compile ().Invoke (MyEnum.Value_1));
1294 Assert (null, e8.Compile ().Invoke (null));
1297 void GreaterThanTest ()
1299 Expression<Func<int, int, bool>> e = (int a, int b) => a > b;
1300 AssertNodeType (e, ExpressionType.GreaterThan);
1301 Assert (true, e.Compile ().Invoke (60, 30));
1304 void GreaterThanTest_2 ()
1306 Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a > b;
1307 AssertNodeType (e2, ExpressionType.GreaterThan);
1308 Assert (false, e2.Compile ().Invoke (null, 3));
1309 Assert (false, e2.Compile ().Invoke (2, 2));
1312 void GreaterThanTest_3 ()
1314 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a > b;
1315 AssertNodeType (e3, ExpressionType.GreaterThan);
1316 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1319 void GreaterThanTest_4 ()
1321 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a > b;
1322 AssertNodeType (e4, ExpressionType.GreaterThan);
1323 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1324 Assert (false, e4.Compile ().Invoke (null, null));
1325 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1328 void GreaterThanTest_5 ()
1330 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a > b;
1331 AssertNodeType (e5, ExpressionType.GreaterThan);
1332 Assert (false, e5.Compile ().Invoke (null, 33));
1333 Assert (false, e5.Compile ().Invoke (null, 0));
1334 Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
1337 void GreaterThanTest_6 ()
1339 Expression<Func<ushort, bool>> e6 = (ushort a) => a > null;
1340 AssertNodeType (e6, ExpressionType.GreaterThan);
1341 Assert (false, e6.Compile ().Invoke (60));
1344 void GreaterThanTest_7 ()
1346 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a > b;
1347 AssertNodeType (e7, ExpressionType.GreaterThan);
1348 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1349 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1352 void GreaterThanTest_8 ()
1354 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a > b;
1355 AssertNodeType (e8, ExpressionType.GreaterThan);
1356 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1357 Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1360 void GreaterThanOrEqualTest ()
1362 Expression<Func<int, int, bool>> e = (int a, int b) => a >= b;
1363 AssertNodeType (e, ExpressionType.GreaterThanOrEqual);
1364 Assert (true, e.Compile ().Invoke (60, 30));
1367 void GreaterThanOrEqualTest_2 ()
1369 Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a >= b;
1370 AssertNodeType (e2, ExpressionType.GreaterThanOrEqual);
1371 Assert (false, e2.Compile ().Invoke (null, 3));
1372 Assert (true, e2.Compile ().Invoke (2, 2));
1375 void GreaterThanOrEqualTest_3 ()
1377 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a >= b;
1378 AssertNodeType (e3, ExpressionType.GreaterThanOrEqual);
1379 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
1382 void GreaterThanOrEqualTest_4 ()
1384 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a >= b;
1385 AssertNodeType (e4, ExpressionType.GreaterThanOrEqual);
1386 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1387 Assert (false, e4.Compile ().Invoke (null, null));
1388 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1391 void GreaterThanOrEqualTest_5 ()
1393 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a >= b;
1394 AssertNodeType (e5, ExpressionType.GreaterThanOrEqual);
1395 Assert (false, e5.Compile ().Invoke (null, 33));
1396 Assert (false, e5.Compile ().Invoke (null, 0));
1397 Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
1400 void GreaterThanOrEqualTest_6 ()
1402 Expression<Func<ushort, bool>> e6 = (ushort a) => a >= null;
1403 AssertNodeType (e6, ExpressionType.GreaterThanOrEqual);
1404 Assert (false, e6.Compile ().Invoke (60));
1407 void GreaterThanOrEqualTest_7 ()
1409 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a >= b;
1410 AssertNodeType (e7, ExpressionType.GreaterThanOrEqual);
1411 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1412 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1415 void GreaterThanOrEqualTest_8 ()
1417 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a >= b;
1418 AssertNodeType (e8, ExpressionType.GreaterThanOrEqual);
1419 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1420 Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1425 var del = new IntDelegate (TestInt);
1426 Expression<Func<IntDelegate, int>> e = (a) => a ();
1427 AssertNodeType (e, ExpressionType.Invoke);
1428 Assert (29, e.Compile ().Invoke (del));
1431 void InvokeTest_2 ()
1433 Expression<Func<Func<int, string>, int, string>> e2 = (a, b) => a (b);
1434 AssertNodeType (e2, ExpressionType.Invoke);
1435 Assert ("4", e2.Compile ().Invoke ((a) => (a+1).ToString (), 3));
1440 Expression<Func<string, Func<string>>> e = (string s) => () => s;
1441 AssertNodeType (e, ExpressionType.Lambda);
1442 Assert ("xx", e.Compile ().Invoke ("xx") ());
1445 void LeftShiftTest ()
1447 Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a << b;
1448 AssertNodeType (e, ExpressionType.LeftShift);
1449 Assert ((ulong) 0x7F000, e.Compile ().Invoke (0xFE, 11));
1450 Assert ((ulong) 0x1FFFFFFFE, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1452 // .net produces a strange result
1453 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
1454 // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1457 void LeftShiftTest_2 ()
1459 Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a << b;
1460 AssertNodeType (e2, ExpressionType.LeftShift);
1461 var c2 = e2.Compile ();
1462 Assert (1024, c2 (new MyType (256), new MyType (2)));
1465 void LeftShiftTest_3 ()
1467 Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a << b;
1468 AssertNodeType (e3, ExpressionType.LeftShift);
1469 Assert (null, e3.Compile ().Invoke (null, 11));
1470 Assert (2048, e3.Compile ().Invoke (1024, 1));
1473 void LeftShiftTest_4 ()
1475 Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a << b;
1476 AssertNodeType (e4, ExpressionType.LeftShift);
1477 var c4 = e4.Compile ();
1478 Assert (null, c4 (new MyType (8), null));
1479 Assert (null, c4 (null, new MyType (8)));
1480 Assert (1024, c4 (new MyType (256), new MyType (2)));
1483 void LeftShiftTest_5 ()
1485 Expression<Func<ushort, int?>> e5 = (ushort a) => a << null;
1486 AssertNodeType (e5, ExpressionType.LeftShift);
1487 Assert (null, e5.Compile ().Invoke (30));
1490 void LeftShiftTest_6 ()
1492 Expression<Func<int, MyTypeImplicitOnly, int>> e = (a, b) => a << b;
1493 AssertNodeType (e, ExpressionType.LeftShift);
1494 Assert (0x7F0, e.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
1497 void LessThanTest ()
1499 Expression<Func<int, int, bool>> e = (int a, int b) => a < b;
1500 AssertNodeType (e, ExpressionType.LessThan);
1501 Assert (false, e.Compile ().Invoke (60, 30));
1504 void LessThanTest_2 ()
1506 Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a < b;
1507 AssertNodeType (e2, ExpressionType.LessThan);
1508 Assert (false, e2.Compile ().Invoke (null, 3));
1509 Assert (false, e2.Compile ().Invoke (2, 2));
1512 void LessThanTest_3 ()
1514 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a < b;
1515 AssertNodeType (e3, ExpressionType.LessThan);
1516 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1519 void LessThanTest_4 ()
1521 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a < b;
1522 AssertNodeType (e4, ExpressionType.LessThan);
1523 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1524 Assert (false, e4.Compile ().Invoke (null, null));
1525 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1528 void LessThanTest_5 ()
1530 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a < b;
1531 AssertNodeType (e5, ExpressionType.LessThan);
1532 Assert (false, e5.Compile ().Invoke (null, 33));
1533 Assert (false, e5.Compile ().Invoke (null, 0));
1534 Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
1537 void LessThanTest_6 ()
1539 Expression<Func<ushort, bool>> e6 = (ushort a) => a < null;
1540 AssertNodeType (e6, ExpressionType.LessThan);
1541 Assert (false, e6.Compile ().Invoke (60));
1544 void LessThanTest_7 ()
1546 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a < b;
1547 AssertNodeType (e7, ExpressionType.LessThan);
1548 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1549 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1552 void LessThanTest_8 ()
1554 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a < b;
1555 AssertNodeType (e8, ExpressionType.LessThan);
1556 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1557 Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1560 void LessThanTest_9 ()
1562 Expression<Func<object, int?, bool>> e = (a, b) => (int) a < b;
1563 AssertNodeType (e, ExpressionType.LessThan);
1564 Assert (false, e.Compile ().Invoke (1, null));
1565 Assert (false, e.Compile ().Invoke (3, 3));
1566 Assert (true, e.Compile ().Invoke (1, 3));
1569 void LessThanOrEqualTest ()
1571 Expression<Func<int, int, bool>> e = (int a, int b) => a <= b;
1572 AssertNodeType (e, ExpressionType.LessThanOrEqual);
1573 Assert (false, e.Compile ().Invoke (60, 30));
1576 void LessThanOrEqualTest_2 ()
1578 Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a <= b;
1579 AssertNodeType (e2, ExpressionType.LessThanOrEqual);
1580 Assert (false, e2.Compile ().Invoke (null, 3));
1581 Assert (true, e2.Compile ().Invoke (2, 2));
1584 void LessThanOrEqualTest_3 ()
1586 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a <= b;
1587 AssertNodeType (e3, ExpressionType.LessThanOrEqual);
1588 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1591 void LessThanOrEqualTest_4 ()
1593 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a <= b;
1594 AssertNodeType (e4, ExpressionType.LessThanOrEqual);
1595 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1596 Assert (false, e4.Compile ().Invoke (null, null));
1597 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1600 void LessThanOrEqualTest_5 ()
1602 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a <= b;
1603 AssertNodeType (e5, ExpressionType.LessThanOrEqual);
1604 Assert (false, e5.Compile ().Invoke (null, 33));
1605 Assert (false, e5.Compile ().Invoke (null, 0));
1606 Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
1609 void LessThanOrEqualTest_6 ()
1611 Expression<Func<ushort, bool>> e6 = (ushort a) => a <= null;
1612 AssertNodeType (e6, ExpressionType.LessThanOrEqual);
1613 Assert (false, e6.Compile ().Invoke (60));
1616 void LessThanOrEqualTest_7 ()
1618 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a <= b;
1619 AssertNodeType (e7, ExpressionType.LessThanOrEqual);
1620 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1621 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1624 void LessThanOrEqualTest_8 ()
1626 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a <= b;
1627 AssertNodeType (e8, ExpressionType.LessThanOrEqual);
1628 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1629 Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1632 void ListInitTest ()
1634 Expression<Func<List<object>>> e1 = () => new List<object> { "Hello", "", null, "World", 5 };
1635 AssertNodeType (e1, ExpressionType.ListInit);
1636 var re1 = e1.Compile ().Invoke ();
1637 Assert (null, re1 [2]);
1638 Assert ("World", re1 [3]);
1639 Assert (5, re1 [4]);
1642 void ListInitTest_2 ()
1644 Expression<Func<int, Dictionary<string, int>>> e2 = (int value) => new Dictionary<string, int> (3) { { "A", value }, { "B", 2 } };
1645 AssertNodeType (e2, ExpressionType.ListInit);
1646 var re2 = e2.Compile ().Invoke (3456);
1647 Assert (3456, re2 ["A"]);
1650 void MemberAccessTest ()
1652 MemberAccessData d = new MemberAccessData ();
1654 Expression<Func<bool>> e = () => d.BoolValue;
1655 AssertNodeType (e, ExpressionType.MemberAccess);
1656 Assert (true, e.Compile ().Invoke ());
1657 d.BoolValue = false;
1658 Assert (false, e.Compile ().Invoke ());
1661 void MemberAccessTest_2 ()
1663 Expression<Func<decimal>> e2 = () => MemberAccessData.DecimalValue;
1664 AssertNodeType (e2, ExpressionType.MemberAccess);
1665 Assert (decimal.MinValue, e2.Compile ().Invoke ());
1668 void MemberAccessTest_3 ()
1670 MemberAccessData d = new MemberAccessData ();
1671 d.VolatileValue = 492;
1672 Expression<Func<uint>> e3 = () => d.VolatileValue;
1673 AssertNodeType (e3, ExpressionType.MemberAccess);
1674 Assert<uint> (492, e3.Compile ().Invoke ());
1677 void MemberAccessTest_4 ()
1679 MemberAccessData d = new MemberAccessData ();
1680 Expression<Func<string[]>> e4 = () => d.StringValues;
1681 AssertNodeType (e4, ExpressionType.MemberAccess);
1682 Assert (null, e4.Compile ().Invoke ());
1685 void MemberAccessTest_5 ()
1687 MemberAccessData d = new MemberAccessData ();
1688 var e5 = d.GetEvent ();
1689 AssertNodeType (e5, ExpressionType.MemberAccess);
1690 Assert (null, e5.Compile ().Invoke ());
1693 void MemberAccessTest_6 ()
1695 MemberAccessData d = new MemberAccessData ();
1696 Expression<Func<MyType>> e6 = () => d.MyTypeProperty;
1697 AssertNodeType (e6, ExpressionType.MemberAccess);
1698 Assert (new MyType (), e6.Compile ().Invoke ());
1701 void MemberAccessTest_7 ()
1703 MemberAccessData d = new MemberAccessData ();
1704 Expression<Func<MyType, short>> e7 = a => a.ShortProp;
1705 AssertNodeType (e7, ExpressionType.MemberAccess);
1706 MyType mt = new MyType ();
1708 Assert (124, e7.Compile ().Invoke (mt));
1711 void MemberAccessTest_8 ()
1713 Expression<Func<string>> e8 = () => MemberAccessData.StaticProperty;
1714 AssertNodeType (e8, ExpressionType.MemberAccess);
1715 Assert ("alo", e8.Compile ().Invoke ());
1718 void MemberAccessTest_9 ()
1720 string s = "localvar";
1721 Expression<Func<string>> e9 = () => s;
1724 AssertNodeType (e9, ExpressionType.MemberAccess);
1725 Assert ("changed", e9.Compile ().Invoke ());
1728 void MemberInitTest ()
1730 Expression<Func<MemberAccessData>> e = () => new MemberAccessData {
1731 VolatileValue = 2, StringValues = new string [] { "sv" }, MyTypeProperty = new MyType (692)
1733 AssertNodeType (e, ExpressionType.MemberInit);
1734 var r1 = e.Compile ().Invoke ();
1735 Assert<uint> (2, r1.VolatileValue);
1736 Assert (new string[] { "sv" }, r1.StringValues);
1737 Assert (new MyType (692), r1.MyTypeProperty);
1740 void MemberInitTest_2 ()
1742 Expression<Func<MemberAccessData>> e2 = () => new MemberAccessData {
1743 ListValues = new List<string> { "a", null }
1746 AssertNodeType (e2, ExpressionType.MemberInit);
1747 var r2 = e2.Compile ().Invoke ();
1748 Assert ("a", r2.ListValues [0]);
1751 void MemberInitTest_3 ()
1753 Expression<Func<short, MyType>> e3 = a => new MyType { ShortProp = a };
1754 AssertNodeType (e3, ExpressionType.MemberInit);
1755 var r3 = e3.Compile ().Invoke (33);
1756 Assert (33, r3.ShortProp);
1759 void MemberInitTest_4 ()
1761 Expression<Func<int>> e = () => new int { };
1763 AssertNodeType (e, ExpressionType.MemberInit);
1764 var r = e.Compile ().Invoke ();
1768 void MemberInitTest_5 ()
1770 Expression<Func<MemberAccessData>> e = () => new MemberAccessData { SetOnly = new object { } };
1772 AssertNodeType (e, ExpressionType.MemberInit);
1778 Expression<Func<int, int, int>> e = (int a, int b) => a % b;
1779 AssertNodeType (e, ExpressionType.Modulo);
1780 Assert (29, e.Compile ().Invoke (60, 31));
1783 void ModuloTest_2 ()
1785 Expression<Func<double?, double?, double?>> e2 = (a, b) => a % b;
1786 AssertNodeType (e2, ExpressionType.Modulo);
1787 Assert (null, e2.Compile ().Invoke (null, 3));
1788 Assert (1.1, e2.Compile ().Invoke (3.1, 2));
1791 void ModuloTest_3 ()
1793 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a % b;
1794 AssertNodeType (e3, ExpressionType.Modulo);
1795 Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1798 void ModuloTest_4 ()
1800 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a % b;
1801 AssertNodeType (e4, ExpressionType.Modulo);
1802 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1803 Assert (new MyType (12), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
1806 void ModuloTest_5 ()
1808 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a % b;
1809 AssertNodeType (e5, ExpressionType.Modulo);
1810 Assert (1, e5.Compile ().Invoke (99, new MyType (2)));
1813 void ModuloTest_6 ()
1815 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a % b;
1816 AssertNodeType (e6, ExpressionType.Modulo);
1817 Assert (100, e6.Compile ().Invoke (100, new MyType (200)));
1818 Assert (null, e6.Compile ().Invoke (20, null));
1821 void ModuloTest_7 ()
1823 Expression<Func<ushort, int?>> e7 = (ushort a) => a % null;
1824 AssertNodeType (e7, ExpressionType.Modulo);
1825 Assert (null, e7.Compile ().Invoke (60));
1828 void MultiplyTest ()
1830 Expression<Func<int, int, int>> e = (int a, int b) => a * b;
1831 AssertNodeType (e, ExpressionType.Multiply);
1832 Assert (1860, e.Compile ().Invoke (60, 31));
1833 Assert (2147483617, e.Compile ().Invoke (int.MaxValue, 31));
1836 void MultiplyTest_2 ()
1838 Expression<Func<double?, double?, double?>> e2 = (a, b) => a * b;
1839 AssertNodeType (e2, ExpressionType.Multiply);
1840 Assert (null, e2.Compile ().Invoke (null, 3));
1841 Assert (6.2, e2.Compile ().Invoke (3.1, 2));
1844 void MultiplyTest_3 ()
1846 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
1847 AssertNodeType (e3, ExpressionType.Multiply);
1848 Assert (400, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1851 void MultiplyTest_4 ()
1853 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a * b;
1854 AssertNodeType (e4, ExpressionType.Multiply);
1855 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1856 Assert (new MyType (-240), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
1859 void MultiplyTest_5 ()
1861 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a * b;
1862 AssertNodeType (e5, ExpressionType.Multiply);
1863 Assert (198, e5.Compile ().Invoke (99, new MyType (2)));
1866 void MultiplyTest_6 ()
1868 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a * b;
1869 AssertNodeType (e6, ExpressionType.Multiply);
1870 Assert (0, e6.Compile ().Invoke (int.MinValue, new MyType (200)));
1871 Assert (null, e6.Compile ().Invoke (20, null));
1874 void MultiplyTest_7 ()
1876 Expression<Func<ushort, int?>> e7 = (ushort a) => a * null;
1877 AssertNodeType (e7, ExpressionType.Multiply);
1878 Assert (null, e7.Compile ().Invoke (60));
1881 void MultiplyTest_8 ()
1883 Expression<Func<double, ulong?, double?>> e = (a, b) => a * b;
1884 AssertNodeType (e, ExpressionType.Multiply);
1885 Assert (180, e.Compile () (60, 3));
1886 Assert (null, e.Compile () (60, null));
1889 void MultiplyCheckedTest ()
1892 Expression<Func<int, int, int>> e = (int a, int b) => a * b;
1893 AssertNodeType (e, ExpressionType.MultiplyChecked);
1895 e.Compile ().Invoke (int.MaxValue, 309);
1896 throw new ApplicationException ("MultiplyCheckedTest #1");
1897 } catch (OverflowException) { }
1901 void MultiplyCheckedTest_2 ()
1904 Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a * b;
1905 AssertNodeType (e2, ExpressionType.MultiplyChecked);
1906 Assert (null, e2.Compile ().Invoke (null, 3));
1907 Assert (14025, e2.Compile ().Invoke (byte.MaxValue, 55));
1911 void MultiplyCheckedTest_3 ()
1914 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
1915 AssertNodeType (e3, ExpressionType.Multiply);
1916 Assert (-600, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
1920 void MultiplyCheckedTest_4 ()
1923 Expression<Func<double, double, double>> e4 = (a, b) => a * b;
1924 AssertNodeType (e4, ExpressionType.Multiply);
1925 Assert (double.PositiveInfinity, e4.Compile ().Invoke (double.MaxValue, int.MaxValue));
1929 void MultiplyCheckedTest_5 ()
1932 Expression<Func<float?, float?, float?>> e5 = (a, b) => b * a;
1933 AssertNodeType (e5, ExpressionType.MultiplyChecked);
1934 Assert (float.PositiveInfinity, e5.Compile ().Invoke (float.Epsilon, float.PositiveInfinity));
1940 Expression<Func<int, int>> e = (a) => -a;
1941 AssertNodeType (e, ExpressionType.Negate);
1942 Assert (30, e.Compile ().Invoke (-30));
1945 void NegateTest_2 ()
1947 Expression<Func<sbyte, int>> e2 = (a) => -(-a);
1948 AssertNodeType (e2, ExpressionType.Negate);
1949 Assert (-10, e2.Compile ().Invoke (-10));
1952 void NegateTest_3 ()
1954 Expression<Func<long?, long?>> e3 = (a) => -a;
1955 AssertNodeType (e3, ExpressionType.Negate);
1956 Assert (long.MinValue + 1, e3.Compile ().Invoke (long.MaxValue));
1957 Assert (null, e3.Compile ().Invoke (null));
1960 void NegateTest_4 ()
1962 Expression<Func<MyType, MyType>> e4 = (a) => -a;
1963 AssertNodeType (e4, ExpressionType.Negate);
1964 Assert (new MyType (14), e4.Compile ().Invoke (new MyType (-14)));
1967 void NegateTest_5 ()
1969 Expression<Func<MyType?, MyType?>> e5 = (a) => -a;
1970 AssertNodeType (e5, ExpressionType.Negate);
1971 Assert (new MyType (-33), e5.Compile ().Invoke (new MyType (33)));
1972 Assert (null, e5.Compile ().Invoke (null));
1975 void NegateTest_6 ()
1977 Expression<Func<MyTypeImplicitOnly, int>> e6 = (MyTypeImplicitOnly a) => -a;
1978 AssertNodeType (e6, ExpressionType.Negate);
1979 Assert (-4, e6.Compile ().Invoke (new MyTypeImplicitOnly (4)));
1982 void NegateTest_7 ()
1984 Expression<Func<MyTypeImplicitOnly?, int?>> e7 = (MyTypeImplicitOnly? a) => -a;
1985 AssertNodeType (e7, ExpressionType.Negate);
1986 Assert (-46, e7.Compile ().Invoke (new MyTypeImplicitOnly (46)));
1988 // Another version of MS bug when predefined conversion is required on nullable user operator
1989 // Assert (null, e7.Compile ().Invoke (null));
1992 void NegateTest_8 ()
1994 Expression<Func<sbyte?, int?>> e8 = (a) => -a;
1995 AssertNodeType (e8, ExpressionType.Negate);
1996 Assert (11, e8.Compile ().Invoke (-11));
1999 void NegateTest_9 ()
2001 Expression<Func<uint, long>> e9 = (a) => -a;
2002 AssertNodeType (e9, ExpressionType.Negate);
2003 Assert (-2, e9.Compile ().Invoke (2));
2006 void NegateTestChecked ()
2009 Expression<Func<int, int>> e = (int a) => -a;
2010 AssertNodeType (e, ExpressionType.NegateChecked);
2012 e.Compile ().Invoke (int.MinValue);
2013 throw new ApplicationException ("NegateTestChecked #1");
2014 } catch (OverflowException) { }
2018 void NegateTestChecked_2 ()
2021 Expression<Func<byte?, int?>> e2 = (a) => -a;
2022 AssertNodeType (e2, ExpressionType.NegateChecked);
2023 Assert (null, e2.Compile ().Invoke (null));
2024 Assert (-255, e2.Compile ().Invoke (byte.MaxValue));
2028 void NegateTestChecked_3 ()
2031 Expression<Func<MyType, MyType>> e3 = (MyType a) => -a;
2032 AssertNodeType (e3, ExpressionType.Negate);
2033 Assert (20, e3.Compile ().Invoke (new MyType (-20)));
2037 void NegateTestChecked_4 ()
2040 Expression<Func<double, double>> e4 = (a) => -a;
2041 AssertNodeType (e4, ExpressionType.Negate);
2042 Assert (double.NegativeInfinity, e4.Compile ().Invoke (double.PositiveInfinity));
2046 void NewArrayInitTest ()
2048 Expression<Func<int []>> e = () => new int [1] { 5 };
2049 AssertNodeType (e, ExpressionType.NewArrayInit);
2050 Assert (new int [1] { 5 }, e.Compile ().Invoke ());
2053 void NewArrayInitTest_2 ()
2055 Expression<Func<int []>> e1 = () => new int [] { };
2056 AssertNodeType (e1, ExpressionType.NewArrayInit);
2057 Assert (new int [0], e1.Compile ().Invoke ());
2060 void NewArrayInitTest_3 ()
2062 Expression<Func<ushort, ulong? []>> e2 = (ushort a) => new ulong? [] { a };
2063 AssertNodeType (e2, ExpressionType.NewArrayInit);
2064 Assert (new ulong? [1] { ushort.MaxValue }, e2.Compile ().Invoke (ushort.MaxValue));
2067 void NewArrayInitTest_4 ()
2069 Expression<Func<char [] []>> e3 = () => new char [] [] { new char [] { 'a' } };
2070 AssertNodeType (e3, ExpressionType.NewArrayInit);
2071 Assert (new char [] { 'a' }, e3.Compile ().Invoke () [0]);
2074 void NewArrayInitTest_5 ()
2076 Expression<Func<int?[]>> e = () => new int?[] { null, 3, 4 };
2077 AssertNodeType (e, ExpressionType.NewArrayInit);
2078 Assert (3, e.Compile ().Invoke ().Length);
2081 void NewArrayInitTest_6 ()
2083 Expression<Func<string []>> e = () => new [] { null, "a" };
2084 AssertNodeType (e, ExpressionType.NewArrayInit);
2085 Assert (2, e.Compile ().Invoke ().Length);
2088 void NewArrayBoundsTest ()
2090 Expression<Func<int [,]>> e = () => new int [2,3];
2091 AssertNodeType (e, ExpressionType.NewArrayBounds);
2092 Assert (new int [2,3].Length, e.Compile ().Invoke ().Length);
2095 void NewArrayBoundsTest_2 ()
2097 Expression<Func<int[,]>> e2 = () => new int [0,0];
2098 AssertNodeType (e2, ExpressionType.NewArrayBounds);
2099 Assert (new int [0, 0].Length, e2.Compile ().Invoke ().Length);
2102 void NewArrayBoundsTest_3 ()
2104 Expression<Func<int []>> e = () => new int [0];
2105 AssertNodeType (e, ExpressionType.NewArrayBounds);
2106 Assert (0, e.Compile ().Invoke ().Length);
2109 void NewArrayBoundsTest_4 ()
2111 const ulong max = ulong.MaxValue;
2113 Expression<Func<bool[]>> e = () => new bool [max];
2114 AssertNodeType (e, ExpressionType.NewArrayBounds);
2119 Expression<Func<MyType>> e = () => new MyType (2);
2120 AssertNodeType (e, ExpressionType.New);
2121 Assert (new MyType (2), e.Compile ().Invoke ());
2126 Expression<Func<MyType>> e2 = () => new MyType ();
2127 AssertNodeType (e2, ExpressionType.New);
2128 Assert (new MyType (), e2.Compile ().Invoke ());
2133 Expression<Func<NewTest<bool>>> e3 = () => new NewTest<bool> (true);
2134 AssertNodeType (e3, ExpressionType.New);
2135 Assert (new NewTest<bool> (true), e3.Compile ().Invoke ());
2140 Expression<Func<decimal, NewTest<decimal>>> e4 = (decimal d) => new NewTest<decimal> (1, 5, d);
2141 AssertNodeType (e4, ExpressionType.New);
2142 Assert (new NewTest<decimal> (1, 5, -9), e4.Compile ().Invoke (-9));
2147 Expression<Func<object>> e5 = () => new { A = 9, Value = "a" };
2148 AssertNodeType (e5, ExpressionType.New);
2149 var ne = ((NewExpression) e5.Body);
2151 Assert (2, ne.Members.Count, "members count");
2153 // Behaviour is different between .NET 3.5 and .NET 4.0
2154 if (ne.Members [0].MemberType == MemberTypes.Property) {
2155 Assert ("A", ne.Members [0].Name, "Name #1");
2156 Assert ("Value", ne.Members [1].Name, "Name #2");
2158 Assert ("get_A", ne.Members [0].Name, "Name #1");
2159 Assert ("get_Value", ne.Members [1].Name, "Name #2");
2162 Assert (new { A = 9, Value = "a" }, e5.Compile ().Invoke ());
2167 Expression<Func<object>> e5 = () => new { A = 9, Value = new MyType (5) };
2168 AssertNodeType (e5, ExpressionType.New);
2171 // CSC bug: emits new MyEnum as a constant
2174 Expression<Func<MyEnum>> e = () => new MyEnum ();
2175 AssertNodeType (e, ExpressionType.New);
2176 Assert<MyEnum> (0, e.Compile ().Invoke ());
2181 Expression<Func<bool, bool>> e = (bool a) => !a;
2182 AssertNodeType (e, ExpressionType.Not);
2183 Assert (false, e.Compile ().Invoke (true));
2188 Expression<Func<MyType, bool>> e2 = (MyType a) => !a;
2189 AssertNodeType (e2, ExpressionType.Not);
2190 Assert (true, e2.Compile ().Invoke (new MyType (1)));
2191 Assert (false, e2.Compile ().Invoke (new MyType (-1)));
2196 Expression<Func<int, int>> e3 = (int a) => ~a;
2197 AssertNodeType (e3, ExpressionType.Not);
2198 Assert (-8, e3.Compile ().Invoke (7));
2203 Expression<Func<MyType, int>> e4 = (MyType a) => ~a;
2204 AssertNodeType (e4, ExpressionType.Not);
2205 Assert (0, e4.Compile ().Invoke (new MyType (-1)));
2210 Expression<Func<ulong, ulong>> e5 = (ulong a) => ~a;
2211 AssertNodeType (e5, ExpressionType.Not);
2212 Assert<ulong> (18446744073709551608, e5.Compile ().Invoke (7));
2217 Expression<Func<MyEnum, MyEnum>> e6 = (MyEnum a) => ~a;
2218 AssertNodeType (e6, ExpressionType.Convert);
2219 Assert ((MyEnum)254, e6.Compile ().Invoke (MyEnum.Value_1));
2222 void NotNullableTest ()
2224 Expression<Func<bool?, bool?>> e = (bool? a) => !a;
2225 AssertNodeType (e, ExpressionType.Not);
2226 Assert (false, e.Compile ().Invoke (true));
2227 Assert (null, e.Compile ().Invoke (null));
2230 void NotNullableTest_2 ()
2232 Expression<Func<MyType?, bool?>> e2 = (MyType? a) => !a;
2233 AssertNodeType (e2, ExpressionType.Not);
2234 Assert (true, e2.Compile ().Invoke (new MyType (1)));
2235 Assert (null, e2.Compile ().Invoke (null));
2238 void NotNullableTest_3 ()
2240 Expression<Func<sbyte?, int?>> e3 = (sbyte? a) => ~a;
2241 AssertNodeType (e3, ExpressionType.Not);
2242 Assert (-5, e3.Compile ().Invoke (4));
2243 Assert (null, e3.Compile ().Invoke (null));
2246 void NotNullableTest_4 ()
2248 Expression<Func<MyType?, int?>> e4 = (MyType? a) => ~a;
2249 AssertNodeType (e4, ExpressionType.Not);
2250 Assert (0, e4.Compile ().Invoke (new MyType (-1)));
2251 Assert (null, e4.Compile ().Invoke (null));
2254 void NotNullableTest_5 ()
2256 Expression<Func<MyEnum?, MyEnum?>> e5 = (MyEnum? a) => ~a;
2257 AssertNodeType (e5, ExpressionType.Convert);
2258 Assert ((MyEnum) 254, e5.Compile ().Invoke (MyEnum.Value_1));
2259 Assert (null, e5.Compile ().Invoke (null));
2262 void NotEqualTest ()
2264 Expression<Func<int, int, bool>> e = (int a, int b) => a != b;
2265 AssertNodeType (e, ExpressionType.NotEqual);
2266 Assert (true, e.Compile ().Invoke (60, 30));
2267 Assert (false, e.Compile ().Invoke (-1, -1));
2270 void NotEqualTest_2 ()
2272 Expression<Func<sbyte?, sbyte?, bool>> e2 = (a, b) => a != b;
2273 AssertNodeType (e2, ExpressionType.NotEqual);
2274 Assert (false, e2.Compile ().Invoke (3, 3));
2275 Assert (true, e2.Compile ().Invoke (3, 2));
2278 void NotEqualTest_3 ()
2280 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a != b;
2281 AssertNodeType (e3, ExpressionType.NotEqual);
2282 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
2285 void NotEqualTest_4 ()
2287 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a != b;
2288 AssertNodeType (e4, ExpressionType.NotEqual);
2289 Assert (true, e4.Compile ().Invoke (null, new MyType (-20)));
2290 Assert (false, e4.Compile ().Invoke (null, null));
2291 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
2294 void NotEqualTest_5 ()
2296 Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a != b;
2297 AssertNodeType (e5, ExpressionType.NotEqual);
2298 Assert (true, e5.Compile ().Invoke (true, null));
2299 Assert (false, e5.Compile ().Invoke (null, null));
2300 Assert (false, e5.Compile ().Invoke (false, false));
2303 void NotEqualTest_6 ()
2305 Expression<Func<bool, bool>> e6 = (bool a) => a != null;
2306 AssertNodeType (e6, ExpressionType.NotEqual);
2307 Assert (true, e6.Compile ().Invoke (true));
2308 Assert (true, e6.Compile ().Invoke (false));
2311 void NotEqualTest_7 ()
2313 Expression<Func<string, string, bool>> e7 = (string a, string b) => a != b;
2314 AssertNodeType (e7, ExpressionType.NotEqual);
2315 Assert (false, e7.Compile ().Invoke (null, null));
2316 Assert (true, e7.Compile ().Invoke ("a", "A"));
2317 Assert (false, e7.Compile ().Invoke ("a", "a"));
2320 void NotEqualTest_8 ()
2322 Expression<Func<object, bool>> e8 = (object a) => null != a;
2323 AssertNodeType (e8, ExpressionType.NotEqual);
2324 Assert (false, e8.Compile ().Invoke (null));
2325 Assert (true, e8.Compile ().Invoke ("a"));
2326 Assert (true, e8.Compile ().Invoke (this));
2329 void NotEqualTest_9 ()
2331 Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a != b;
2332 AssertNodeType (e9, ExpressionType.NotEqual);
2333 Assert (true, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2334 Assert (false, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2337 void NotEqualTest_10 ()
2339 Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a != b;
2340 AssertNodeType (e10, ExpressionType.NotEqual);
2341 Assert (true, e10.Compile ().Invoke (MyEnum.Value_1, null));
2342 Assert (false, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2345 void NotEqualTest_11 ()
2347 Expression<Func<MyEnum?, bool>> e11 = (a) => a != null;
2348 AssertNodeType (e11, ExpressionType.NotEqual);
2349 Assert (true, e11.Compile ().Invoke (MyEnum.Value_1));
2350 Assert (false, e11.Compile ().Invoke (null));
2355 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a | b;
2357 AssertNodeType (e, ExpressionType.Or);
2358 Func<bool, bool, bool> c = e.Compile ();
2360 Assert (true, c (true, true));
2361 Assert (true, c (true, false));
2362 Assert (true, c (false, true));
2363 Assert (false, c (false, false));
2368 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a | b;
2369 AssertNodeType (e2, ExpressionType.Or);
2370 var c2 = e2.Compile ();
2371 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2376 Expression<Func<MyEnum, MyEnum, MyEnum>> e3 = (a, b) => a | b;
2377 AssertNodeType (e3, ExpressionType.Convert);
2378 Assert ((MyEnum)3, e3.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2379 Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2382 void OrNullableTest ()
2384 Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a | b;
2386 AssertNodeType (e, ExpressionType.Or);
2387 Func<bool?, bool?, bool?> c = e.Compile ();
2389 Assert (true, c (true, true));
2390 Assert (true, c (true, false));
2391 Assert (true, c (false, true));
2392 Assert (false, c (false, false));
2394 Assert (true, c (true, null));
2395 Assert (null, c (false, null));
2396 Assert (null, c (null, false));
2397 Assert (true, c (true, null));
2398 Assert (null, c (null, null));
2401 void OrNullableTest_2 ()
2403 Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a | b;
2404 AssertNodeType (e2, ExpressionType.Or);
2405 var c2 = e2.Compile ();
2406 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2407 Assert (null, c2 (new MyType (1), null));
2410 void OrNullableTest_3 ()
2412 Expression<Func<MyType?, uint, long?>> e3 = (MyType? a, uint b) => a | b;
2413 AssertNodeType (e3, ExpressionType.Or);
2414 var c3 = e3.Compile ();
2415 Assert (9, c3 (new MyType (1), 8));
2418 void OrNullableTest_4 ()
2420 Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e4 = (a, b) => a | b;
2421 AssertNodeType (e4, ExpressionType.Convert);
2422 Assert (null, e4.Compile ().Invoke (null, MyEnum.Value_2));
2423 Assert ((MyEnum)3, e4.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2428 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a || b;
2429 AssertNodeType (e, ExpressionType.OrElse);
2430 Assert (true, e.Compile ().Invoke (true, false));
2433 void OrElseTest_2 ()
2435 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a || b;
2436 AssertNodeType (e2, ExpressionType.OrElse);
2437 Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
2438 Assert (new MyType (32), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
2441 void ParameterTest ()
2443 Expression<Func<string, string>> e = (string a) => a;
2444 AssertNodeType (e, ExpressionType.Parameter);
2445 Assert ("t", e.Compile ().Invoke ("t"));
2448 void ParameterTest_2 ()
2450 Expression<Func<object[], object[]>> e2 = (object[] a) => a;
2451 AssertNodeType (e2, ExpressionType.Parameter);
2452 Assert (new object [0], e2.Compile ().Invoke (new object [0]));
2455 void ParameterTest_3 ()
2457 Expression<Func<IntPtr, IntPtr>> e3 = a => a;
2458 AssertNodeType (e3, ExpressionType.Parameter);
2459 Assert (IntPtr.Zero, e3.Compile ().Invoke (IntPtr.Zero));
2462 unsafe void ParameterTest_4 ()
2464 Expression<Func<int*[], int* []>> e4 = (a) => a;
2465 AssertNodeType (e4, ExpressionType.Parameter);
2466 Assert<int*[]> (null, e4.Compile ().Invoke (null));
2467 int* e4_el = stackalloc int [5];
2468 int*[] ptr = new int*[] { e4_el };
2469 Assert<int*[]> (ptr, e4.Compile ().Invoke (ptr));
2474 Expression<Func<Expression<Func<int>>>> e = () => () => 2;
2475 AssertNodeType (e, ExpressionType.Quote);
2476 Assert (2, e.Compile ().Invoke ().Compile ().Invoke ());
2481 Expression<Func<string, Expression<Func<string>>>> e = (string s) => () => s;
2482 AssertNodeType (e, ExpressionType.Quote);
2484 Assert ("data", e.Compile ().Invoke ("data").Compile ().Invoke ());
2487 void RightShiftTest ()
2489 Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a >> b;
2490 AssertNodeType (e, ExpressionType.RightShift);
2491 Assert ((ulong) 0x1FD940L, e.Compile ().Invoke (0xFECA0000, 11));
2492 Assert ((ulong) 0x7FFFFFFF, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2494 // .net produces a strange result
2495 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
2496 // Assert ((ulong)0, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2499 void RightShiftTest_2 ()
2501 Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a >> b;
2502 AssertNodeType (e2, ExpressionType.RightShift);
2503 var c2 = e2.Compile ();
2504 Assert (64, c2 (new MyType (256), new MyType (2)));
2507 void RightShiftTest_3 ()
2509 Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a >> b;
2510 AssertNodeType (e3, ExpressionType.RightShift);
2511 Assert (null, e3.Compile ().Invoke (null, 11));
2512 Assert (512, e3.Compile ().Invoke (1024, 1));
2515 void RightShiftTest_4 ()
2517 Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a >> b;
2518 AssertNodeType (e4, ExpressionType.RightShift);
2519 var c4 = e4.Compile ();
2520 Assert (null, c4 (new MyType (8), null));
2521 Assert (null, c4 (null, new MyType (8)));
2522 Assert (64, c4 (new MyType (256), new MyType (2)));
2525 void RightShiftTest_5 ()
2527 Expression<Func<int, MyTypeImplicitOnly, int>> e = (a, b) => a >> b;
2528 AssertNodeType (e, ExpressionType.RightShift);
2529 Assert (31, e.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
2532 void RightShiftTest_6 ()
2534 Expression<Func<ulong, byte?, ulong?>> e = (a, b) => a >> b;
2535 AssertNodeType (e, ExpressionType.RightShift);
2536 Assert (null, e.Compile () (2, null));
2539 void SubtractTest ()
2541 Expression<Func<int, int, int>> e = (int a, int b) => a - b;
2542 AssertNodeType (e, ExpressionType.Subtract);
2543 Assert (-10, e.Compile ().Invoke (20, 30));
2546 void SubtractTest_2 ()
2548 Expression<Func<int?, int?, int?>> e2 = (a, b) => a - b;
2549 AssertNodeType (e2, ExpressionType.Subtract);
2550 Assert (null, e2.Compile ().Invoke (null, 3));
2553 void SubtractTest_3 ()
2555 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a - b;
2556 AssertNodeType (e3, ExpressionType.Subtract);
2557 Assert (-50, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
2560 void SubtractTest_4 ()
2562 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a - b;
2563 AssertNodeType (e4, ExpressionType.Subtract);
2564 Assert (new MyType (-50), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
2565 Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
2568 void SubtractTest_5 ()
2570 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a - b;
2571 AssertNodeType (e5, ExpressionType.Subtract);
2572 Assert (-29, e5.Compile ().Invoke (1, new MyType (30)));
2575 void SubtractTest_6 ()
2577 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a - b;
2578 AssertNodeType (e6, ExpressionType.Subtract);
2579 Assert (-61, e6.Compile ().Invoke (-31, new MyType (30)));
2582 void SubtractTest_7 ()
2584 Expression<Func<ushort, int?>> e7 = (ushort a) => null - a;
2585 AssertNodeType (e7, ExpressionType.Subtract);
2586 Assert (null, e7.Compile ().Invoke (690));
2589 void SubtractTest_8 ()
2591 Expression<Func<MyEnum, byte, MyEnum>> e8 = (a, b) => a - b;
2592 AssertNodeType (e8, ExpressionType.Convert);
2593 Assert ((MyEnum)255, e8.Compile ().Invoke (MyEnum.Value_1, 2));
2596 void SubtractTest_9 ()
2598 Expression<Func<MyEnum, MyEnum, byte>> e9 = (a, b) => a - b;
2599 AssertNodeType (e9, ExpressionType.Convert);
2600 Assert (1, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
2603 void SubtractTest_10 ()
2605 Expression<Func<MyEnum?, byte?, MyEnum?>> e10 = (a, b) => a - b;
2606 AssertNodeType (e10, ExpressionType.Convert);
2607 Assert ((MyEnum) 255, e10.Compile ().Invoke (MyEnum.Value_1, 2));
2611 void SubtractTest_11 ()
2613 Expression<Func<MyEnum?, MyEnum?, byte?>> e11 = (a, b) => a - b;
2614 AssertNodeType (e11, ExpressionType.Convert);
2615 Assert<byte?> (1, e11.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
2618 void SubtractCheckedTest ()
2621 Expression<Func<long, long, long>> e = (long a, long b) => a - b;
2622 AssertNodeType (e, ExpressionType.SubtractChecked);
2624 e.Compile ().Invoke (long.MinValue, 309);
2625 throw new ApplicationException ("SubtractCheckedTest #1");
2626 } catch (OverflowException) { }
2630 void SubtractCheckedTest_2 ()
2633 Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a - b;
2634 AssertNodeType (e2, ExpressionType.SubtractChecked);
2635 Assert (null, e2.Compile ().Invoke (null, 3));
2636 Assert (-55, e2.Compile ().Invoke (byte.MinValue, 55));
2640 void SubtractCheckedTest_3 ()
2643 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a - b;
2644 AssertNodeType (e3, ExpressionType.Subtract);
2645 Assert (-50, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
2649 void SubtractCheckedTest_4 ()
2652 Expression<Func<double, double, double>> e4 = (a, b) => a - b;
2653 AssertNodeType (e4, ExpressionType.Subtract);
2654 Assert (double.PositiveInfinity, e4.Compile ().Invoke (double.MinValue, double.NegativeInfinity));
2660 Expression<Func<object, Tester>> e = (object a) => a as Tester;
2661 AssertNodeType (e, ExpressionType.TypeAs);
2662 Assert (this, e.Compile ().Invoke (this));
2665 void TypeAsTest_2 ()
2667 Expression<Func<object, int?>> e2 = (object a) => a as int?;
2668 AssertNodeType (e2, ExpressionType.TypeAs);
2669 Assert (null, e2.Compile ().Invoke (null));
2670 Assert (null, e2.Compile ().Invoke (this));
2671 Assert (44, e2.Compile ().Invoke (44));
2674 void TypeAsTest_3 ()
2676 Expression<Func<object, object>> e3 = (object a) => null as object;
2677 AssertNodeType (e3, ExpressionType.TypeAs);
2678 Assert (null, e3.Compile ().Invoke (null));
2681 void TypeAsTest_4 ()
2683 Expression<Func<int, IConvertible>> e = a => a as IConvertible;
2684 AssertNodeType (e, ExpressionType.TypeAs);
2685 Assert (ExpressionType.Parameter, ((UnaryExpression) e.Body).Operand.NodeType);
2686 Assert (5, e.Compile ().Invoke (5));
2691 Expression<Func<object, bool>> e = (object a) => a is Tester;
2692 AssertNodeType (e, ExpressionType.TypeIs);
2693 Assert (true, e.Compile ().Invoke (this));
2694 Assert (false, e.Compile ().Invoke (1));
2697 void TypeIsTest_2 ()
2699 Expression<Func<object, bool>> e2 = (object a) => a is int?;
2700 AssertNodeType (e2, ExpressionType.TypeIs);
2701 Assert (false, e2.Compile ().Invoke (null));
2702 Assert (true, e2.Compile ().Invoke (1));
2705 void TypeIsTest_3 ()
2707 Expression<Func<object, bool>> e3 = (object a) => null is object;
2708 AssertNodeType (e3, ExpressionType.TypeIs);
2709 Assert (false, e3.Compile ().Invoke (null));
2712 void TypeIsTest_4 ()
2714 Expression<Func<B, bool>> e = l => l is A;
2715 AssertNodeType (e, ExpressionType.TypeIs);
2716 Assert (false, e.Compile ().Invoke (null));
2719 void TypeIsTest_5 ()
2721 Expression<Func<bool>> e5 = () => 1 is int;
2722 AssertNodeType (e5, ExpressionType.TypeIs);
2723 Assert (true, e5.Compile ().Invoke ());
2726 void TypeIsTest_6 ()
2728 Expression<Func<int?, bool>> e6 = (a) => a is int;
2729 AssertNodeType (e6, ExpressionType.TypeIs);
2730 Assert (true, e6.Compile ().Invoke (1));
2731 Assert (false, e6.Compile ().Invoke (null));
2734 void UnaryPlusTest ()
2736 Expression<Func<int, int>> e = (a) => +a;
2737 AssertNodeType (e, ExpressionType.Parameter);
2738 Assert (-30, e.Compile ().Invoke (-30));
2741 void UnaryPlusTest_2 ()
2743 Expression<Func<long?, long?>> e2 = (a) => +a;
2744 AssertNodeType (e2, ExpressionType.Parameter);
2747 void UnaryPlusTest_3 ()
2749 Expression<Func<MyType, MyType>> e4 = (a) => +a;
2750 AssertNodeType (e4, ExpressionType.UnaryPlus);
2751 Assert (new MyType (-14), e4.Compile ().Invoke (new MyType (-14)));
2754 void UnaryPlusTest_4 ()
2756 Expression<Func<MyType?, MyType?>> e5 = (a) => +a;
2757 AssertNodeType (e5, ExpressionType.UnaryPlus);
2758 Assert (new MyType (33), e5.Compile ().Invoke (new MyType (33)));
2759 Assert (null, e5.Compile ().Invoke (null));
2762 void UnaryPlusTest_5 ()
2764 Expression<Func<sbyte?, long?>> e6 = (a) => +a;
2765 AssertNodeType (e6, ExpressionType.Convert);
2766 Assert (3, e6.Compile ().Invoke (3));
2767 Assert (null, e6.Compile ().Invoke (null));
2770 #pragma warning restore 169
2775 string InstanceMethod (string arg)
2780 object InstanceParamsMethod (int index, params object [] args)
2784 if (args.Length == 0)
2786 return args [index];
2789 static int TestInt ()
2794 T GenericMethod<T> (T t)
2799 static void RefMethod (ref int i)
2804 static bool RunTest (MethodInfo test)
2806 Console.Write ("Running test {0, -25}", test.Name);
2808 test.Invoke (new Tester (), null);
2809 Console.WriteLine ("OK");
2811 } catch (Exception e) {
2812 Console.WriteLine ("FAILED");
2813 Console.WriteLine (e.ToString ());
2818 public static int Main ()
2820 var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
2821 where test.GetParameters ().Length == 0
2823 select RunTest (test);
2825 int failures = tests.Count (a => !a);
2826 Console.WriteLine (failures + " tests failed");