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 ArrayLengthTest ()
611 Expression
<Func
<double [], int>> e
= (double [] a
) => a
.Length
;
612 AssertNodeType (e
, ExpressionType
.ArrayLength
);
613 Assert (0, e
.Compile ().Invoke (new double [0]));
614 Assert (9, e
.Compile ().Invoke (new double [9]));
617 void ArrayLengthTest_2 ()
619 Expression
<Func
<string [,], int>> e2
= (string [,] a
) => a
.Length
;
620 AssertNodeType (e2
, ExpressionType
.MemberAccess
);
621 Assert (0, e2
.Compile ().Invoke (new string [0, 0]));
626 Expression
<Func
<int, int>> e
= (int a
) => Math
.Max (a
, 5);
627 AssertNodeType (e
, ExpressionType
.Call
);
628 Assert (5, e
.Compile ().Invoke (2));
629 Assert (9, e
.Compile ().Invoke (9));
634 Expression
<Func
<string, string>> e2
= (string a
) => InstanceMethod (a
);
635 AssertNodeType (e2
, ExpressionType
.Call
);
636 Assert ("abc", e2
.Compile ().Invoke ("abc"));
641 Expression
<Func
<int, string, int, object>> e3
= (int index
, string a
, int b
) => InstanceParamsMethod (index
, a
, b
);
642 AssertNodeType (e3
, ExpressionType
.Call
);
643 Assert
<object> (4, e3
.Compile ().Invoke (1, "a", 4));
648 Expression
<Func
<object>> e4
= () => InstanceParamsMethod (0);
649 AssertNodeType (e4
, ExpressionType
.Call
);
650 Assert
<object> ("<empty>", e4
.Compile ().Invoke ());
655 Expression
<Func
<int, int>> e5
= (int a
) => GenericMethod (a
);
656 AssertNodeType (e5
, ExpressionType
.Call
);
657 Assert (5, e5
.Compile ().Invoke (5));
662 Expression
<Action
> e6
= () => Console
.WriteLine ("call test");
663 AssertNodeType (e6
, ExpressionType
.Call
);
668 Expression
<Func
<Indexer
, int, int>> e7
= (a
, b
) => a
[b
];
669 AssertNodeType (e7
, ExpressionType
.Call
);
670 Assert (3, e7
.Compile ().Invoke (new Indexer (), 3));
675 Expression
<Func
<Indexer
, string, string, string, string>> e8
= (a
, b
, c
, d
) => a
[b
, c
, d
];
676 AssertNodeType (e8
, ExpressionType
.Call
);
677 Assert ("zyb", e8
.Compile ().Invoke (new Indexer (), "z", "y", "b"));
682 Expression
<Action
<int>> e9
= (a
) => RefMethod (ref a
);
683 AssertNodeType (e9
, ExpressionType
.Call
);
684 e9
.Compile ().Invoke (1);
689 Expression
<Func
<uint?, uint>> e
= (uint? a
) => a
?? 99;
690 AssertNodeType (e
, ExpressionType
.Coalesce
);
691 var r
= e
.Compile ();
692 Assert ((uint) 5, r
.Invoke (5));
693 Assert ((uint) 99, r
.Invoke (null));
696 void CoalesceTest_2 ()
698 Expression
<Func
<MyType
?, int>> e2
= (MyType
? a
) => a
?? -3;
699 AssertNodeType (e2
, ExpressionType
.Coalesce
);
700 var r2
= e2
.Compile ();
701 Assert (2, r2
.Invoke (new MyType (2)));
702 Assert (-3, r2
.Invoke (null));
705 void ConditionTest ()
707 Expression
<Func
<bool, byte, int, int>> e
= (bool a
, byte b
, int c
) => (a
? b
: c
);
708 AssertNodeType (e
, ExpressionType
.Conditional
);
709 var r
= e
.Compile ();
710 Assert (3, r
.Invoke (true, 3, 999999));
711 Assert (999999, r
.Invoke (false, 3, 999999));
714 void ConditionTest_2 ()
716 Expression
<Func
<int, decimal, decimal?>> e2
= (int a
, decimal d
) => (a
> 0 ? d
: a
< 0 ? -d
: (decimal?) null);
717 AssertNodeType (e2
, ExpressionType
.Conditional
);
718 var r2
= e2
.Compile ();
719 Assert (null, r2
.Invoke (0, 10));
720 Assert (50, r2
.Invoke (1, 50));
721 Assert (30, r2
.Invoke (-7, -30));
724 void ConditionTest_3 ()
726 Expression
<Func
<bool?, int?>> e3
= (bool? a
) => ((bool) a
? 3 : -2);
727 AssertNodeType (e3
, ExpressionType
.Convert
);
728 var r3
= e3
.Compile ();
729 Assert (3, r3
.Invoke (true));
730 Assert (-2, r3
.Invoke (false));
733 void ConditionTest_4 ()
735 Expression
<Func
<InverseLogicalOperator
, byte, byte, byte>> e4
= (InverseLogicalOperator a
, byte b
, byte c
) => (a
? b
: c
);
736 AssertNodeType (e4
, ExpressionType
.Conditional
);
737 var r4
= e4
.Compile ();
738 Assert (3, r4
.Invoke (new InverseLogicalOperator (true), 3, 4));
739 Assert (4, r4
.Invoke (new InverseLogicalOperator (false), 3, 4));
742 void ConditionTest_5 ()
745 Expression
<Func
<int>> e
= () => false ? 1 : 4;
746 AssertNodeType (e
, ExpressionType
.Conditional
);
747 var r
= e
.Compile ();
748 Assert (4, r
.Invoke ());
753 Expression
<Func
<int>> e1
= () => default (int);
754 AssertNodeType (e1
, ExpressionType
.Constant
);
755 Assert (0, e1
.Compile ().Invoke ());
758 void ConstantTest_2 ()
760 Expression
<Func
<int?>> e2
= () => default (int?);
761 AssertNodeType (e2
, ExpressionType
.Constant
);
762 Assert (null, e2
.Compile ().Invoke ());
765 void ConstantTest_3 ()
767 Expression
<Func
<Tester
>> e3
= () => default (Tester
);
768 AssertNodeType (e3
, ExpressionType
.Constant
);
769 Assert (null, e3
.Compile ().Invoke ());
772 void ConstantTest_4 ()
774 Expression
<Func
<object>> e4
= () => null;
775 AssertNodeType (e4
, ExpressionType
.Constant
);
776 Assert (null, e4
.Compile ().Invoke ());
779 void ConstantTest_5 ()
781 Expression
<Func
<int>> e5
= () => 8 / 4;
782 AssertNodeType (e5
, ExpressionType
.Constant
);
783 Assert (2, e5
.Compile ().Invoke ());
786 void ConstantTest_6 ()
788 Expression
<Func
<int>> e6
= () => 0xFFFFFF >> 0x40;
789 AssertNodeType (e6
, ExpressionType
.Constant
);
790 Assert (0xFFFFFF, e6
.Compile ().Invoke ());
793 void ConstantTest_7 ()
795 Expression
<Func
<object>> e7
= () => "Alleluia";
796 AssertNodeType (e7
, ExpressionType
.Constant
);
797 Assert ("Alleluia", e7
.Compile ().Invoke ());
800 void ConstantTest_8 ()
802 Expression
<Func
<Type
>> e8
= () => typeof (int);
803 AssertNodeType (e8
, ExpressionType
.Constant
);
804 Assert (typeof (int), e8
.Compile ().Invoke ());
807 void ConstantTest_9 ()
809 Expression
<Func
<Type
>> e9
= () => typeof (void);
810 AssertNodeType (e9
, ExpressionType
.Constant
);
811 Assert (typeof (void), e9
.Compile ().Invoke ());
814 void ConstantTest_10 ()
816 Expression
<Func
<Type
>> e10
= () => typeof (Func
<,>);
817 AssertNodeType (e10
, ExpressionType
.Constant
);
818 Assert (typeof (Func
<,>), e10
.Compile ().Invoke ());
821 void ConstantTest_11 ()
823 Expression
<Func
<MyEnum
>> e11
= () => MyEnum
.Value_2
;
824 AssertNodeType (e11
, ExpressionType
.Constant
);
825 Assert (MyEnum
.Value_2
, e11
.Compile ().Invoke ());
828 void ConstantTest_13 ()
830 Expression
<Func
<int>> e13
= () => sizeof (byte);
831 AssertNodeType (e13
, ExpressionType
.Constant
);
832 Assert (1, e13
.Compile ().Invoke ());
836 unsafe void ConstantTest_14 ()
838 Expression
<Func
<Type
>> e14
= () => typeof (bool*);
839 AssertNodeType (e14
, ExpressionType
.Constant
);
840 Assert (typeof (bool*), e14
.Compile ().Invoke ());
843 void ConstantTest_15 ()
845 Expression
<Func
<int?>> e15
= () => null;
846 AssertNodeType (e15
, ExpressionType
.Constant
);
847 Assert (null, e15
.Compile ().Invoke ());
852 Expression
<Func
<int, byte>> e
= (int a
) => ((byte) a
);
853 AssertNodeType (e
, ExpressionType
.Convert
);
854 Assert (100, e
.Compile ().Invoke (100));
857 void ConvertTest_2 ()
859 Expression
<Func
<long, ushort>> e2
= (long a
) => ((ushort) a
);
860 AssertNodeType (e2
, ExpressionType
.Convert
);
861 Assert (100, e2
.Compile ().Invoke (100));
864 void ConvertTest_3 ()
866 Expression
<Func
<float?, float>> e3
= (float? a
) => ((float) a
);
867 AssertNodeType (e3
, ExpressionType
.Convert
);
868 Assert (-0.456f
, e3
.Compile ().Invoke (-0.456f
));
871 void ConvertTest_4 ()
873 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => (a
);
874 AssertNodeType (e4
, ExpressionType
.Convert
);
875 Assert (-9, e4
.Compile ().Invoke (new MyType (-9)));
878 void ConvertTest_5 ()
880 Expression
<Func
<MyType
, MyType
, bool?>> e5
= (MyType a
, MyType b
) => a
== b
;
881 AssertNodeType (e5
, ExpressionType
.Convert
);
884 void ConvertTest_6 ()
886 Expression
<Func
<MyType
?, MyType
?, bool?>> e6
= (MyType
? a
, MyType
? b
) => a
== b
;
887 AssertNodeType (e6
, ExpressionType
.Convert
);
888 Assert (false, e6
.Compile ().Invoke (null, new MyType (-20)));
889 Assert (true, e6
.Compile ().Invoke (null, null));
890 Assert (true, e6
.Compile ().Invoke (new MyType (120), new MyType (120)));
893 void ConvertTest_7 ()
895 Expression
<Func
<MyTypeExplicit
, int?>> e7
= x
=> (int?)x
;
896 AssertNodeType (e7
, ExpressionType
.Convert
);
897 Assert (33, e7
.Compile ().Invoke (new MyTypeExplicit (33)));
900 void ConvertTest_8 ()
902 Expression
<Func
<int?, object>> e8
= x
=> (object)x
;
903 AssertNodeType (e8
, ExpressionType
.Convert
);
904 Assert (null, e8
.Compile ().Invoke (null));
905 Assert (-100, e8
.Compile ().Invoke (-100));
908 unsafe void ConvertTest_9 ()
910 int*[] p
= new int* [1];
911 Expression
<Func
<object>> e9
= () => (object)p
;
912 AssertNodeType (e9
, ExpressionType
.Convert
);
913 Assert (p
, e9
.Compile ().Invoke ());
916 void ConvertTest_10 ()
918 Expression
<Func
<Func
<int>, Delegate
>> e10
= (a
) => a
+ a
;
919 AssertNodeType (e10
, ExpressionType
.Convert
);
920 Assert (null, e10
.Compile ().Invoke (null));
921 Assert (new Func
<int> (TestInt
) + new Func
<int> (TestInt
), e10
.Compile ().Invoke (TestInt
));
924 void ConvertTest_11 ()
926 Expression
<Func
<Func
<int>, Delegate
>> e11
= (a
) => a
- a
;
927 AssertNodeType (e11
, ExpressionType
.Convert
);
928 Assert (null, e11
.Compile ().Invoke (null));
931 void ConvertTest_12 ()
933 Expression
<Func
<Func
<int>>> e12
= () => TestInt
;
934 AssertNodeType (e12
, ExpressionType
.Convert
);
935 Assert (29, e12
.Compile ().Invoke () ());
938 void ConvertTest_13 ()
940 Expression
<Func
<decimal, sbyte>> e13
= a
=> (sbyte)a
;
941 AssertNodeType (e13
, ExpressionType
.Convert
);
942 Assert (6, e13
.Compile ().Invoke (6));
945 void ConvertTest_14 ()
947 Expression
<Func
<long, decimal>> e14
= a
=> a
;
948 AssertNodeType (e14
, ExpressionType
.Convert
);
949 Assert (-66, e14
.Compile ().Invoke (-66));
952 void ConvertTest_15 ()
954 Expression
<Func
<ulong?, decimal?>> e15
= a
=> a
;
955 AssertNodeType (e15
, ExpressionType
.Convert
);
956 Assert (null, e15
.Compile ().Invoke (null));
957 Assert (9, e15
.Compile ().Invoke (9));
960 void ConvertCheckedTest ()
962 Expression
<Func
<int, byte>> e
= (int a
) => checked((byte) a
);
963 AssertNodeType (e
, ExpressionType
.ConvertChecked
);
964 Assert (100, e
.Compile ().Invoke (100));
967 void ConvertCheckedTest_2 ()
970 Expression
<Func
<long, ushort>> e2
= (long a
) => unchecked((ushort) a
);
971 AssertNodeType (e2
, ExpressionType
.Convert
);
972 Assert (100, e2
.Compile ().Invoke (100));
976 void ConvertCheckedTest_3 ()
979 Expression
<Func
<float?, float>> e3
= (float? a
) => ((float) a
);
980 AssertNodeType (e3
, ExpressionType
.ConvertChecked
);
981 Assert (-0.456f
, e3
.Compile ().Invoke (-0.456f
));
985 void ConvertCheckedTest_4 ()
988 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => (a
);
989 AssertNodeType (e4
, ExpressionType
.Convert
);
990 Assert (-9, e4
.Compile ().Invoke (new MyType (-9)));
996 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
/ b
;
997 AssertNodeType (e
, ExpressionType
.Divide
);
998 Assert (2, e
.Compile ().Invoke (60, 30));
1001 void DivideTest_2 ()
1003 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
/ b
;
1004 AssertNodeType (e2
, ExpressionType
.Divide
);
1005 Assert (null, e2
.Compile ().Invoke (null, 3));
1006 Assert (1.5, e2
.Compile ().Invoke (3, 2));
1009 void DivideTest_3 ()
1011 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
/ b
;
1012 AssertNodeType (e3
, ExpressionType
.Divide
);
1013 Assert (1, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1016 void DivideTest_4 ()
1018 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
/ b
;
1019 AssertNodeType (e4
, ExpressionType
.Divide
);
1020 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1021 Assert (new MyType (-6), e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1024 void DivideTest_5 ()
1026 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
/ b
;
1027 AssertNodeType (e5
, ExpressionType
.Divide
);
1028 Assert (50, e5
.Compile ().Invoke (100, new MyType (2)));
1031 void DivideTest_6 ()
1033 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
/ b
;
1034 AssertNodeType (e6
, ExpressionType
.Divide
);
1035 Assert (50, e6
.Compile ().Invoke (100, new MyType (2)));
1036 Assert (null, e6
.Compile ().Invoke (20, null));
1041 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
== b
;
1042 AssertNodeType (e
, ExpressionType
.Equal
);
1043 Assert (false, e
.Compile ().Invoke (60, 30));
1044 Assert (true, e
.Compile ().Invoke (-1, -1));
1049 Expression
<Func
<double?, double?, bool>> e2
= (a
, b
) => a
== b
;
1050 AssertNodeType (e2
, ExpressionType
.Equal
);
1051 Assert (true, e2
.Compile ().Invoke (3, 3));
1052 Assert (false, e2
.Compile ().Invoke (3, 2));
1057 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
== b
;
1058 AssertNodeType (e3
, ExpressionType
.Equal
);
1059 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1064 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
== b
;
1065 AssertNodeType (e4
, ExpressionType
.Equal
);
1066 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1067 Assert (true, e4
.Compile ().Invoke (null, null));
1068 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (120)));
1073 Expression
<Func
<bool?, bool?, bool>> e5
= (bool? a
, bool? b
) => a
== b
;
1074 AssertNodeType (e5
, ExpressionType
.Equal
);
1075 Assert (false, e5
.Compile ().Invoke (true, null));
1076 Assert (true, e5
.Compile ().Invoke (null, null));
1077 Assert (true, e5
.Compile ().Invoke (false, false));
1082 Expression
<Func
<bool, bool>> e6
= (bool a
) => a
== null;
1083 AssertNodeType (e6
, ExpressionType
.Equal
);
1084 Assert (false, e6
.Compile ().Invoke (true));
1085 Assert (false, e6
.Compile ().Invoke (false));
1090 Expression
<Func
<string, string, bool>> e7
= (string a
, string b
) => a
== b
;
1091 AssertNodeType (e7
, ExpressionType
.Equal
);
1092 Assert (true, e7
.Compile ().Invoke (null, null));
1093 Assert (false, e7
.Compile ().Invoke ("a", "A"));
1094 Assert (true, e7
.Compile ().Invoke ("a", "a"));
1099 Expression
<Func
<object, bool>> e8
= (object a
) => null == a
;
1100 AssertNodeType (e8
, ExpressionType
.Equal
);
1101 Assert (true, e8
.Compile ().Invoke (null));
1102 Assert (false, e8
.Compile ().Invoke ("a"));
1103 Assert (false, e8
.Compile ().Invoke (this));
1108 Expression
<Func
<MyEnum
, MyEnum
, bool>> e9
= (a
, b
) => a
== b
;
1109 AssertNodeType (e9
, ExpressionType
.Equal
);
1110 Assert (false, e9
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
1111 Assert (true, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1114 void EqualTest_10 ()
1116 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e10
= (a
, b
) => a
== b
;
1117 AssertNodeType (e10
, ExpressionType
.Equal
);
1118 Assert (false, e10
.Compile ().Invoke (MyEnum
.Value_1
, null));
1119 Assert (true, e10
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1122 void EqualTest_11 ()
1124 Expression
<Func
<MyEnum
?, bool>> e11
= (a
) => a
== null;
1125 AssertNodeType (e11
, ExpressionType
.Equal
);
1126 Assert (false, e11
.Compile ().Invoke (MyEnum
.Value_1
));
1127 Assert (true, e11
.Compile ().Invoke (null));
1130 void EqualTest_12 ()
1132 Expression
<Func
<MyEnumUlong
, bool>> e12
= (a
) => a
== 0;
1133 AssertNodeType (e12
, ExpressionType
.Equal
);
1134 Assert (false, e12
.Compile ().Invoke (MyEnumUlong
.Value_1
));
1135 Assert (true, e12
.Compile ().Invoke (0));
1138 void EqualTest_13 ()
1140 Expression
<Func
<MyEnum
, bool>> e13
= (a
) => a
== MyEnum
.Value_2
;
1141 AssertNodeType (e13
, ExpressionType
.Equal
);
1142 Assert (true, e13
.Compile ().Invoke (MyEnum
.Value_2
));
1143 Assert (false, e13
.Compile ().Invoke (0));
1146 void EqualTest_14 ()
1148 Expression
<Func
<MyEnum
, bool>> e
= (a
) => a
== null;
1149 AssertNodeType (e
, ExpressionType
.Equal
);
1150 Assert (false, e
.Compile ().Invoke (MyEnum
.Value_1
));
1153 void EqualTest_15 ()
1155 Expression
<Func
<int?, uint, bool>> e
= (a
, b
) => a
== b
;
1156 AssertNodeType (e
, ExpressionType
.Equal
);
1157 Assert (false, e
.Compile ().Invoke (null, 0));
1158 Assert (true, e
.Compile ().Invoke (4, 4));
1161 void EqualTestDelegate ()
1163 Expression
<Func
<Delegate
, Delegate
, bool>> e1
= (a
, b
) => a
== b
;
1164 AssertNodeType (e1
, ExpressionType
.Equal
);
1165 Assert (true, e1
.Compile ().Invoke (null, null));
1168 void EqualTestDelegate_2 ()
1170 EmptyDelegate ed
= delegate () {};
1172 Expression
<Func
<EmptyDelegate
, EmptyDelegate
, bool>> e2
= (a
, b
) => a
== b
;
1173 AssertNodeType (e2
, ExpressionType
.Equal
);
1174 Assert (false, e2
.Compile ().Invoke (delegate () {}, null));
1175 Assert (false, e2
.Compile ().Invoke (delegate () {}, delegate {}
));
1176 Assert (false, e2
.Compile ().Invoke (ed
, delegate {}));
1177 Assert (true, e2
.Compile ().Invoke (ed
, ed
));
1180 void ExclusiveOrTest ()
1182 Expression
<Func
<int, short, int>> e
= (int a
, short b
) => a ^ b
;
1183 AssertNodeType (e
, ExpressionType
.ExclusiveOr
);
1184 Assert (34, e
.Compile ().Invoke (60, 30));
1187 void ExclusiveOrTest_2 ()
1189 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a ^ b
;
1190 AssertNodeType (e2
, ExpressionType
.ExclusiveOr
);
1191 Assert (null, e2
.Compile ().Invoke (null, 3));
1192 Assert (1, e2
.Compile ().Invoke (3, 2));
1195 void ExclusiveOrTest_3 ()
1197 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a ^ b
;
1198 AssertNodeType (e3
, ExpressionType
.ExclusiveOr
);
1199 Assert (0, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1202 void ExclusiveOrTest_4 ()
1204 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a ^ b
;
1205 AssertNodeType (e4
, ExpressionType
.ExclusiveOr
);
1206 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1207 Assert (new MyType (-108), e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1210 void ExclusiveOrTest_5 ()
1212 Expression
<Func
<MyType
?, byte, int?>> e5
= (MyType
? a
, byte b
) => a ^ b
;
1213 AssertNodeType (e5
, ExpressionType
.ExclusiveOr
);
1214 Assert (null, e5
.Compile ().Invoke (null, 64));
1215 Assert (96, e5
.Compile ().Invoke (new MyType (64), 32));
1218 void ExclusiveOrTest_6 ()
1220 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e6
= (a
, b
) => a ^ b
;
1221 AssertNodeType (e6
, ExpressionType
.Convert
);
1222 Assert ((MyEnum
)3, e6
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
1223 Assert
<MyEnum
> (0, e6
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1226 void ExclusiveOrTest_7 ()
1228 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e7
= (a
, b
) => a ^ b
;
1229 AssertNodeType (e7
, ExpressionType
.Convert
);
1230 Assert (null, e7
.Compile ().Invoke (MyEnum
.Value_1
, null));
1231 Assert
<MyEnum
?> (0, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1234 void ExclusiveOrTest_8 ()
1236 Expression
<Func
<MyEnum
?, MyEnum
?>> e8
= (a
) => a ^
null;
1237 AssertNodeType (e8
, ExpressionType
.Convert
);
1238 Assert (null, e8
.Compile ().Invoke (MyEnum
.Value_1
));
1239 Assert (null, e8
.Compile ().Invoke (null));
1242 void GreaterThanTest ()
1244 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
> b
;
1245 AssertNodeType (e
, ExpressionType
.GreaterThan
);
1246 Assert (true, e
.Compile ().Invoke (60, 30));
1249 void GreaterThanTest_2 ()
1251 Expression
<Func
<uint?, byte?, bool>> e2
= (a
, b
) => a
> b
;
1252 AssertNodeType (e2
, ExpressionType
.GreaterThan
);
1253 Assert (false, e2
.Compile ().Invoke (null, 3));
1254 Assert (false, e2
.Compile ().Invoke (2, 2));
1257 void GreaterThanTest_3 ()
1259 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
> b
;
1260 AssertNodeType (e3
, ExpressionType
.GreaterThan
);
1261 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1264 void GreaterThanTest_4 ()
1266 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
> b
;
1267 AssertNodeType (e4
, ExpressionType
.GreaterThan
);
1268 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1269 Assert (false, e4
.Compile ().Invoke (null, null));
1270 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1273 void GreaterThanTest_5 ()
1275 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
> b
;
1276 AssertNodeType (e5
, ExpressionType
.GreaterThan
);
1277 Assert (false, e5
.Compile ().Invoke (null, 33));
1278 Assert (false, e5
.Compile ().Invoke (null, 0));
1279 Assert (true, e5
.Compile ().Invoke (new MyType (120), 3));
1282 void GreaterThanTest_6 ()
1284 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
> null;
1285 AssertNodeType (e6
, ExpressionType
.GreaterThan
);
1286 Assert (false, e6
.Compile ().Invoke (60));
1289 void GreaterThanTest_7 ()
1291 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
> b
;
1292 AssertNodeType (e7
, ExpressionType
.GreaterThan
);
1293 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1294 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1297 void GreaterThanTest_8 ()
1299 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
> b
;
1300 AssertNodeType (e8
, ExpressionType
.GreaterThan
);
1301 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1302 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1305 void GreaterThanOrEqualTest ()
1307 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
>= b
;
1308 AssertNodeType (e
, ExpressionType
.GreaterThanOrEqual
);
1309 Assert (true, e
.Compile ().Invoke (60, 30));
1312 void GreaterThanOrEqualTest_2 ()
1314 Expression
<Func
<byte?, byte?, bool>> e2
= (a
, b
) => a
>= b
;
1315 AssertNodeType (e2
, ExpressionType
.GreaterThanOrEqual
);
1316 Assert (false, e2
.Compile ().Invoke (null, 3));
1317 Assert (true, e2
.Compile ().Invoke (2, 2));
1320 void GreaterThanOrEqualTest_3 ()
1322 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
>= b
;
1323 AssertNodeType (e3
, ExpressionType
.GreaterThanOrEqual
);
1324 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
1327 void GreaterThanOrEqualTest_4 ()
1329 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
>= b
;
1330 AssertNodeType (e4
, ExpressionType
.GreaterThanOrEqual
);
1331 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1332 Assert (false, e4
.Compile ().Invoke (null, null));
1333 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1336 void GreaterThanOrEqualTest_5 ()
1338 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
>= b
;
1339 AssertNodeType (e5
, ExpressionType
.GreaterThanOrEqual
);
1340 Assert (false, e5
.Compile ().Invoke (null, 33));
1341 Assert (false, e5
.Compile ().Invoke (null, 0));
1342 Assert (true, e5
.Compile ().Invoke (new MyType (120), 3));
1345 void GreaterThanOrEqualTest_6 ()
1347 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
>= null;
1348 AssertNodeType (e6
, ExpressionType
.GreaterThanOrEqual
);
1349 Assert (false, e6
.Compile ().Invoke (60));
1352 void GreaterThanOrEqualTest_7 ()
1354 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
>= b
;
1355 AssertNodeType (e7
, ExpressionType
.GreaterThanOrEqual
);
1356 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1357 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1360 void GreaterThanOrEqualTest_8 ()
1362 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
>= b
;
1363 AssertNodeType (e8
, ExpressionType
.GreaterThanOrEqual
);
1364 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1365 Assert (true, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1370 var del
= new IntDelegate (TestInt
);
1371 Expression
<Func
<IntDelegate
, int>> e
= (a
) => a ();
1372 AssertNodeType (e
, ExpressionType
.Invoke
);
1373 Assert (29, e
.Compile ().Invoke (del
));
1376 void InvokeTest_2 ()
1378 Expression
<Func
<Func
<int, string>, int, string>> e2
= (a
, b
) => a (b
);
1379 AssertNodeType (e2
, ExpressionType
.Invoke
);
1380 Assert ("4", e2
.Compile ().Invoke ((a
) => (a
+1).ToString (), 3));
1385 Expression
<Func
<string, Func
<string>>> e
= (string s
) => () => s
;
1386 AssertNodeType (e
, ExpressionType
.Lambda
);
1387 Assert ("xx", e
.Compile ().Invoke ("xx") ());
1390 void LeftShiftTest ()
1392 Expression
<Func
<ulong, short, ulong>> e
= (ulong a
, short b
) => a
<< b
;
1393 AssertNodeType (e
, ExpressionType
.LeftShift
);
1394 Assert ((ulong) 0x7F000, e
.Compile ().Invoke (0xFE, 11));
1395 Assert ((ulong) 0x1FFFFFFFE, e
.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1397 // .net produces a strange result
1398 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
1399 // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1402 void LeftShiftTest_2 ()
1404 Expression
<Func
<MyType
, MyType
, int>> e2
= (MyType a
, MyType b
) => a
<< b
;
1405 AssertNodeType (e2
, ExpressionType
.LeftShift
);
1406 var c2
= e2
.Compile ();
1407 Assert (1024, c2 (new MyType (256), new MyType (2)));
1410 void LeftShiftTest_3 ()
1412 Expression
<Func
<long?, sbyte, long?>> e3
= (long? a
, sbyte b
) => a
<< b
;
1413 AssertNodeType (e3
, ExpressionType
.LeftShift
);
1414 Assert (null, e3
.Compile ().Invoke (null, 11));
1415 Assert (2048, e3
.Compile ().Invoke (1024, 1));
1418 void LeftShiftTest_4 ()
1420 Expression
<Func
<MyType
?, MyType
?, int?>> e4
= (MyType
? a
, MyType
? b
) => a
<< b
;
1421 AssertNodeType (e4
, ExpressionType
.LeftShift
);
1422 var c4
= e4
.Compile ();
1423 Assert (null, c4 (new MyType (8), null));
1424 Assert (null, c4 (null, new MyType (8)));
1425 Assert (1024, c4 (new MyType (256), new MyType (2)));
1428 void LeftShiftTest_5 ()
1430 Expression
<Func
<ushort, int?>> e5
= (ushort a
) => a
<< null;
1431 AssertNodeType (e5
, ExpressionType
.LeftShift
);
1432 Assert (null, e5
.Compile ().Invoke (30));
1435 void LessThanTest ()
1437 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
< b
;
1438 AssertNodeType (e
, ExpressionType
.LessThan
);
1439 Assert (false, e
.Compile ().Invoke (60, 30));
1442 void LessThanTest_2 ()
1444 Expression
<Func
<uint?, byte?, bool>> e2
= (a
, b
) => a
< b
;
1445 AssertNodeType (e2
, ExpressionType
.LessThan
);
1446 Assert (false, e2
.Compile ().Invoke (null, 3));
1447 Assert (false, e2
.Compile ().Invoke (2, 2));
1450 void LessThanTest_3 ()
1452 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
< b
;
1453 AssertNodeType (e3
, ExpressionType
.LessThan
);
1454 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1457 void LessThanTest_4 ()
1459 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
< b
;
1460 AssertNodeType (e4
, ExpressionType
.LessThan
);
1461 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1462 Assert (false, e4
.Compile ().Invoke (null, null));
1463 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1466 void LessThanTest_5 ()
1468 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
< b
;
1469 AssertNodeType (e5
, ExpressionType
.LessThan
);
1470 Assert (false, e5
.Compile ().Invoke (null, 33));
1471 Assert (false, e5
.Compile ().Invoke (null, 0));
1472 Assert (false, e5
.Compile ().Invoke (new MyType (120), 3));
1475 void LessThanTest_6 ()
1477 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
< null;
1478 AssertNodeType (e6
, ExpressionType
.LessThan
);
1479 Assert (false, e6
.Compile ().Invoke (60));
1482 void LessThanTest_7 ()
1484 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
< b
;
1485 AssertNodeType (e7
, ExpressionType
.LessThan
);
1486 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1487 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1490 void LessThanTest_8 ()
1492 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
< b
;
1493 AssertNodeType (e8
, ExpressionType
.LessThan
);
1494 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1495 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1498 void LessThanOrEqualTest ()
1500 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
<= b
;
1501 AssertNodeType (e
, ExpressionType
.LessThanOrEqual
);
1502 Assert (false, e
.Compile ().Invoke (60, 30));
1505 void LessThanOrEqualTest_2 ()
1507 Expression
<Func
<byte?, byte?, bool>> e2
= (a
, b
) => a
<= b
;
1508 AssertNodeType (e2
, ExpressionType
.LessThanOrEqual
);
1509 Assert (false, e2
.Compile ().Invoke (null, 3));
1510 Assert (true, e2
.Compile ().Invoke (2, 2));
1513 void LessThanOrEqualTest_3 ()
1515 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
<= b
;
1516 AssertNodeType (e3
, ExpressionType
.LessThanOrEqual
);
1517 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1520 void LessThanOrEqualTest_4 ()
1522 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
<= b
;
1523 AssertNodeType (e4
, ExpressionType
.LessThanOrEqual
);
1524 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1525 Assert (false, e4
.Compile ().Invoke (null, null));
1526 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1529 void LessThanOrEqualTest_5 ()
1531 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
<= b
;
1532 AssertNodeType (e5
, ExpressionType
.LessThanOrEqual
);
1533 Assert (false, e5
.Compile ().Invoke (null, 33));
1534 Assert (false, e5
.Compile ().Invoke (null, 0));
1535 Assert (false, e5
.Compile ().Invoke (new MyType (120), 3));
1538 void LessThanOrEqualTest_6 ()
1540 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
<= null;
1541 AssertNodeType (e6
, ExpressionType
.LessThanOrEqual
);
1542 Assert (false, e6
.Compile ().Invoke (60));
1545 void LessThanOrEqualTest_7 ()
1547 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
<= b
;
1548 AssertNodeType (e7
, ExpressionType
.LessThanOrEqual
);
1549 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1550 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1553 void LessThanOrEqualTest_8 ()
1555 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
<= b
;
1556 AssertNodeType (e8
, ExpressionType
.LessThanOrEqual
);
1557 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1558 Assert (true, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1561 void ListInitTest ()
1563 Expression
<Func
<List
<object>>> e1
= () => new List
<object> { "Hello", "", null, "World", 5 }
;
1564 AssertNodeType (e1
, ExpressionType
.ListInit
);
1565 var re1
= e1
.Compile ().Invoke ();
1566 Assert (null, re1
[2]);
1567 Assert ("World", re1
[3]);
1568 Assert (5, re1
[4]);
1571 void ListInitTest_2 ()
1573 Expression
<Func
<int, Dictionary
<string, int>>> e2
= (int value) => new Dictionary
<string, int> (3) { { "A", value }
, { "B", 2 }
};
1574 AssertNodeType (e2
, ExpressionType
.ListInit
);
1575 var re2
= e2
.Compile ().Invoke (3456);
1576 Assert (3456, re2
["A"]);
1579 void MemberAccessTest ()
1581 MemberAccessData d
= new MemberAccessData ();
1583 Expression
<Func
<bool>> e
= () => d
.BoolValue
;
1584 AssertNodeType (e
, ExpressionType
.MemberAccess
);
1585 Assert (true, e
.Compile ().Invoke ());
1586 d
.BoolValue
= false;
1587 Assert (false, e
.Compile ().Invoke ());
1590 void MemberAccessTest_2 ()
1592 Expression
<Func
<decimal>> e2
= () => MemberAccessData
.DecimalValue
;
1593 AssertNodeType (e2
, ExpressionType
.MemberAccess
);
1594 Assert (decimal.MinValue
, e2
.Compile ().Invoke ());
1597 void MemberAccessTest_3 ()
1599 MemberAccessData d
= new MemberAccessData ();
1600 d
.VolatileValue
= 492;
1601 Expression
<Func
<uint>> e3
= () => d
.VolatileValue
;
1602 AssertNodeType (e3
, ExpressionType
.MemberAccess
);
1603 Assert
<uint> (492, e3
.Compile ().Invoke ());
1606 void MemberAccessTest_4 ()
1608 MemberAccessData d
= new MemberAccessData ();
1609 Expression
<Func
<string[]>> e4
= () => d
.StringValues
;
1610 AssertNodeType (e4
, ExpressionType
.MemberAccess
);
1611 Assert (null, e4
.Compile ().Invoke ());
1614 void MemberAccessTest_5 ()
1616 MemberAccessData d
= new MemberAccessData ();
1617 var e5
= d
.GetEvent ();
1618 AssertNodeType (e5
, ExpressionType
.MemberAccess
);
1619 Assert (null, e5
.Compile ().Invoke ());
1622 void MemberAccessTest_6 ()
1624 MemberAccessData d
= new MemberAccessData ();
1625 Expression
<Func
<MyType
>> e6
= () => d
.MyTypeProperty
;
1626 AssertNodeType (e6
, ExpressionType
.MemberAccess
);
1627 Assert (new MyType (), e6
.Compile ().Invoke ());
1630 void MemberAccessTest_7 ()
1632 MemberAccessData d
= new MemberAccessData ();
1633 Expression
<Func
<MyType
, short>> e7
= a
=> a
.ShortProp
;
1634 AssertNodeType (e7
, ExpressionType
.MemberAccess
);
1635 MyType mt
= new MyType ();
1637 Assert (124, e7
.Compile ().Invoke (mt
));
1640 void MemberAccessTest_8 ()
1642 Expression
<Func
<string>> e8
= () => MemberAccessData
.StaticProperty
;
1643 AssertNodeType (e8
, ExpressionType
.MemberAccess
);
1644 Assert ("alo", e8
.Compile ().Invoke ());
1647 void MemberAccessTest_9 ()
1649 string s
= "localvar";
1650 Expression
<Func
<string>> e9
= () => s
;
1651 AssertNodeType (e9
, ExpressionType
.MemberAccess
);
1652 Assert ("localvar", e9
.Compile ().Invoke ());
1655 void MemberInitTest ()
1657 Expression
<Func
<MemberAccessData
>> e
= () => new MemberAccessData
{
1658 VolatileValue
= 2, StringValues
= new string [] { "sv" }
, MyTypeProperty
= new MyType (692)
1660 AssertNodeType (e
, ExpressionType
.MemberInit
);
1661 var r1
= e
.Compile ().Invoke ();
1662 Assert
<uint> (2, r1
.VolatileValue
);
1663 Assert (new string[] { "sv" }
, r1
.StringValues
);
1664 Assert (new MyType (692), r1
.MyTypeProperty
);
1667 void MemberInitTest_2 ()
1669 Expression
<Func
<MemberAccessData
>> e2
= () => new MemberAccessData
{
1670 ListValues
= new List
<string> { "a", null }
1673 AssertNodeType (e2
, ExpressionType
.MemberInit
);
1674 var r2
= e2
.Compile ().Invoke ();
1675 Assert ("a", r2
.ListValues
[0]);
1678 void MemberInitTest_3 ()
1680 Expression
<Func
<short, MyType
>> e3
= a
=> new MyType { ShortProp = a }
;
1681 AssertNodeType (e3
, ExpressionType
.MemberInit
);
1682 var r3
= e3
.Compile ().Invoke (33);
1683 Assert (33, r3
.ShortProp
);
1686 void MemberInitTest_4 ()
1688 Expression
<Func
<int>> e
= () => new int { }
;
1690 AssertNodeType (e
, ExpressionType
.MemberInit
);
1691 var r
= e
.Compile ().Invoke ();
1697 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
% b
;
1698 AssertNodeType (e
, ExpressionType
.Modulo
);
1699 Assert (29, e
.Compile ().Invoke (60, 31));
1702 void ModuloTest_2 ()
1704 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
% b
;
1705 AssertNodeType (e2
, ExpressionType
.Modulo
);
1706 Assert (null, e2
.Compile ().Invoke (null, 3));
1707 Assert (1.1, e2
.Compile ().Invoke (3.1, 2));
1710 void ModuloTest_3 ()
1712 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
% b
;
1713 AssertNodeType (e3
, ExpressionType
.Modulo
);
1714 Assert (0, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1717 void ModuloTest_4 ()
1719 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
% b
;
1720 AssertNodeType (e4
, ExpressionType
.Modulo
);
1721 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1722 Assert (new MyType (12), e4
.Compile ().Invoke (new MyType (12), new MyType (-20)));
1725 void ModuloTest_5 ()
1727 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
% b
;
1728 AssertNodeType (e5
, ExpressionType
.Modulo
);
1729 Assert (1, e5
.Compile ().Invoke (99, new MyType (2)));
1732 void ModuloTest_6 ()
1734 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
% b
;
1735 AssertNodeType (e6
, ExpressionType
.Modulo
);
1736 Assert (100, e6
.Compile ().Invoke (100, new MyType (200)));
1737 Assert (null, e6
.Compile ().Invoke (20, null));
1740 void ModuloTest_7 ()
1742 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => a
% null;
1743 AssertNodeType (e7
, ExpressionType
.Modulo
);
1744 Assert (null, e7
.Compile ().Invoke (60));
1747 void MultiplyTest ()
1749 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
* b
;
1750 AssertNodeType (e
, ExpressionType
.Multiply
);
1751 Assert (1860, e
.Compile ().Invoke (60, 31));
1752 Assert (2147483617, e
.Compile ().Invoke (int.MaxValue
, 31));
1755 void MultiplyTest_2 ()
1757 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
* b
;
1758 AssertNodeType (e2
, ExpressionType
.Multiply
);
1759 Assert (null, e2
.Compile ().Invoke (null, 3));
1760 Assert (6.2, e2
.Compile ().Invoke (3.1, 2));
1763 void MultiplyTest_3 ()
1765 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
* b
;
1766 AssertNodeType (e3
, ExpressionType
.Multiply
);
1767 Assert (400, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1770 void MultiplyTest_4 ()
1772 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
* b
;
1773 AssertNodeType (e4
, ExpressionType
.Multiply
);
1774 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1775 Assert (new MyType (-240), e4
.Compile ().Invoke (new MyType (12), new MyType (-20)));
1778 void MultiplyTest_5 ()
1780 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
* b
;
1781 AssertNodeType (e5
, ExpressionType
.Multiply
);
1782 Assert (198, e5
.Compile ().Invoke (99, new MyType (2)));
1785 void MultiplyTest_6 ()
1787 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
* b
;
1788 AssertNodeType (e6
, ExpressionType
.Multiply
);
1789 Assert (0, e6
.Compile ().Invoke (int.MinValue
, new MyType (200)));
1790 Assert (null, e6
.Compile ().Invoke (20, null));
1793 void MultiplyTest_7 ()
1795 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => a
* null;
1796 AssertNodeType (e7
, ExpressionType
.Multiply
);
1797 Assert (null, e7
.Compile ().Invoke (60));
1800 void MultiplyCheckedTest ()
1803 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
* b
;
1804 AssertNodeType (e
, ExpressionType
.MultiplyChecked
);
1806 e
.Compile ().Invoke (int.MaxValue
, 309);
1807 throw new ApplicationException ("MultiplyCheckedTest #1");
1808 } catch (OverflowException
) { }
1812 void MultiplyCheckedTest_2 ()
1815 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a
* b
;
1816 AssertNodeType (e2
, ExpressionType
.MultiplyChecked
);
1817 Assert (null, e2
.Compile ().Invoke (null, 3));
1818 Assert (14025, e2
.Compile ().Invoke (byte.MaxValue
, 55));
1822 void MultiplyCheckedTest_3 ()
1825 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
* b
;
1826 AssertNodeType (e3
, ExpressionType
.Multiply
);
1827 Assert (-600, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
1831 void MultiplyCheckedTest_4 ()
1834 Expression
<Func
<double, double, double>> e4
= (a
, b
) => a
* b
;
1835 AssertNodeType (e4
, ExpressionType
.Multiply
);
1836 Assert (double.PositiveInfinity
, e4
.Compile ().Invoke (double.MaxValue
, int.MaxValue
));
1840 void MultiplyCheckedTest_5 ()
1843 Expression
<Func
<float?, float?, float?>> e5
= (a
, b
) => b
* a
;
1844 AssertNodeType (e5
, ExpressionType
.MultiplyChecked
);
1845 Assert (float.PositiveInfinity
, e5
.Compile ().Invoke (float.Epsilon
, float.PositiveInfinity
));
1851 Expression
<Func
<int, int>> e
= (a
) => -a
;
1852 AssertNodeType (e
, ExpressionType
.Negate
);
1853 Assert (30, e
.Compile ().Invoke (-30));
1856 void NegateTest_2 ()
1858 Expression
<Func
<sbyte, int>> e2
= (a
) => -(-a
);
1859 AssertNodeType (e2
, ExpressionType
.Negate
);
1860 Assert (-10, e2
.Compile ().Invoke (-10));
1863 void NegateTest_3 ()
1865 Expression
<Func
<long?, long?>> e3
= (a
) => -a
;
1866 AssertNodeType (e3
, ExpressionType
.Negate
);
1867 Assert (long.MinValue
+ 1, e3
.Compile ().Invoke (long.MaxValue
));
1868 Assert (null, e3
.Compile ().Invoke (null));
1871 void NegateTest_4 ()
1873 Expression
<Func
<MyType
, MyType
>> e4
= (a
) => -a
;
1874 AssertNodeType (e4
, ExpressionType
.Negate
);
1875 Assert (new MyType (14), e4
.Compile ().Invoke (new MyType (-14)));
1878 void NegateTest_5 ()
1880 Expression
<Func
<MyType
?, MyType
?>> e5
= (a
) => -a
;
1881 AssertNodeType (e5
, ExpressionType
.Negate
);
1882 Assert (new MyType (-33), e5
.Compile ().Invoke (new MyType (33)));
1883 Assert (null, e5
.Compile ().Invoke (null));
1886 void NegateTest_6 ()
1888 Expression
<Func
<MyTypeImplicitOnly
, int>> e6
= (MyTypeImplicitOnly a
) => -a
;
1889 AssertNodeType (e6
, ExpressionType
.Negate
);
1890 Assert (-4, e6
.Compile ().Invoke (new MyTypeImplicitOnly (4)));
1893 void NegateTest_7 ()
1895 Expression
<Func
<MyTypeImplicitOnly
?, int?>> e7
= (MyTypeImplicitOnly
? a
) => -a
;
1896 AssertNodeType (e7
, ExpressionType
.Negate
);
1897 Assert (-46, e7
.Compile ().Invoke (new MyTypeImplicitOnly (46)));
1899 // Another version of MS bug when predefined conversion is required on nullable user operator
1900 // Assert (null, e7.Compile ().Invoke (null));
1903 void NegateTest_8 ()
1905 Expression
<Func
<sbyte?, int?>> e8
= (a
) => -a
;
1906 AssertNodeType (e8
, ExpressionType
.Negate
);
1907 Assert (11, e8
.Compile ().Invoke (-11));
1910 void NegateTest_9 ()
1912 Expression
<Func
<uint, long>> e9
= (a
) => -a
;
1913 AssertNodeType (e9
, ExpressionType
.Negate
);
1914 Assert (-2, e9
.Compile ().Invoke (2));
1917 void NegateTestChecked ()
1920 Expression
<Func
<int, int>> e
= (int a
) => -a
;
1921 AssertNodeType (e
, ExpressionType
.NegateChecked
);
1923 e
.Compile ().Invoke (int.MinValue
);
1924 throw new ApplicationException ("NegateTestChecked #1");
1925 } catch (OverflowException
) { }
1929 void NegateTestChecked_2 ()
1932 Expression
<Func
<byte?, int?>> e2
= (a
) => -a
;
1933 AssertNodeType (e2
, ExpressionType
.NegateChecked
);
1934 Assert (null, e2
.Compile ().Invoke (null));
1935 Assert (-255, e2
.Compile ().Invoke (byte.MaxValue
));
1939 void NegateTestChecked_3 ()
1942 Expression
<Func
<MyType
, MyType
>> e3
= (MyType a
) => -a
;
1943 AssertNodeType (e3
, ExpressionType
.Negate
);
1944 Assert (20, e3
.Compile ().Invoke (new MyType (-20)));
1948 void NegateTestChecked_4 ()
1951 Expression
<Func
<double, double>> e4
= (a
) => -a
;
1952 AssertNodeType (e4
, ExpressionType
.Negate
);
1953 Assert (double.NegativeInfinity
, e4
.Compile ().Invoke (double.PositiveInfinity
));
1957 void NewArrayInitTest ()
1959 Expression
<Func
<int []>> e
= () => new int [0];
1960 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
1961 Assert (new int [0], e
.Compile ().Invoke ());
1964 void NewArrayInitTest_2 ()
1966 Expression
<Func
<int []>> e1
= () => new int [] { }
;
1967 AssertNodeType (e1
, ExpressionType
.NewArrayInit
);
1968 Assert (new int [0], e1
.Compile ().Invoke ());
1971 void NewArrayInitTest_3 ()
1973 Expression
<Func
<ushort, ulong? []>> e2
= (ushort a
) => new ulong? [] { a }
;
1974 AssertNodeType (e2
, ExpressionType
.NewArrayInit
);
1975 Assert (new ulong? [1] { ushort.MaxValue }
, e2
.Compile ().Invoke (ushort.MaxValue
));
1978 void NewArrayInitTest_4 ()
1980 Expression
<Func
<char [] []>> e3
= () => new char [] [] { new char [] { 'a' }
};
1981 AssertNodeType (e3
, ExpressionType
.NewArrayInit
);
1982 Assert (new char [] { 'a' }
, e3
.Compile ().Invoke () [0]);
1985 void NewArrayInitTest_5 ()
1987 Expression
<Func
<int?[]>> e
= () => new int?[] { null, 3, 4 }
;
1988 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
1989 Assert (3, e
.Compile ().Invoke ().Length
);
1992 void NewArrayInitTest_6 ()
1994 Expression
<Func
<string []>> e
= () => new [] { null, "a" }
;
1995 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
1996 Assert (2, e
.Compile ().Invoke ().Length
);
1999 void NewArrayBoundsTest ()
2001 Expression
<Func
<int [,]>> e
= () => new int [2,3];
2002 AssertNodeType (e
, ExpressionType
.NewArrayBounds
);
2003 Assert (new int [2,3].Length
, e
.Compile ().Invoke ().Length
);
2006 void NewArrayBoundsTest_2 ()
2008 Expression
<Func
<int[,]>> e2
= () => new int [0,0];
2009 AssertNodeType (e2
, ExpressionType
.NewArrayBounds
);
2010 Assert (new int [0, 0].Length
, e2
.Compile ().Invoke ().Length
);
2015 Expression
<Func
<MyType
>> e
= () => new MyType (2);
2016 AssertNodeType (e
, ExpressionType
.New
);
2017 Assert (new MyType (2), e
.Compile ().Invoke ());
2022 Expression
<Func
<MyType
>> e2
= () => new MyType ();
2023 AssertNodeType (e2
, ExpressionType
.New
);
2024 Assert (new MyType (), e2
.Compile ().Invoke ());
2029 Expression
<Func
<NewTest
<bool>>> e3
= () => new NewTest
<bool> (true);
2030 AssertNodeType (e3
, ExpressionType
.New
);
2031 Assert (new NewTest
<bool> (true), e3
.Compile ().Invoke ());
2036 Expression
<Func
<decimal, NewTest
<decimal>>> e4
= (decimal d
) => new NewTest
<decimal> (1, 5, d
);
2037 AssertNodeType (e4
, ExpressionType
.New
);
2038 Assert (new NewTest
<decimal> (1, 5, -9), e4
.Compile ().Invoke (-9));
2043 Expression
<Func
<object>> e5
= () => new { A = 9, Value = "a" }
;
2044 AssertNodeType (e5
, ExpressionType
.New
);
2045 Assert (new { A = 9, Value = "a" }
, e5
.Compile ().Invoke ());
2048 // CSC bug: emits new MyEnum as a constant
2051 Expression
<Func
<MyEnum
>> e
= () => new MyEnum ();
2052 AssertNodeType (e
, ExpressionType
.New
);
2053 Assert
<MyEnum
> (0, e
.Compile ().Invoke ());
2058 Expression
<Func
<bool, bool>> e
= (bool a
) => !a
;
2059 AssertNodeType (e
, ExpressionType
.Not
);
2060 Assert (false, e
.Compile ().Invoke (true));
2065 Expression
<Func
<MyType
, bool>> e2
= (MyType a
) => !a
;
2066 AssertNodeType (e2
, ExpressionType
.Not
);
2067 Assert (true, e2
.Compile ().Invoke (new MyType (1)));
2068 Assert (false, e2
.Compile ().Invoke (new MyType (-1)));
2073 Expression
<Func
<int, int>> e3
= (int a
) => ~a
;
2074 AssertNodeType (e3
, ExpressionType
.Not
);
2075 Assert (-8, e3
.Compile ().Invoke (7));
2080 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => ~a
;
2081 AssertNodeType (e4
, ExpressionType
.Not
);
2082 Assert (0, e4
.Compile ().Invoke (new MyType (-1)));
2087 Expression
<Func
<ulong, ulong>> e5
= (ulong a
) => ~a
;
2088 AssertNodeType (e5
, ExpressionType
.Not
);
2089 Assert
<ulong> (18446744073709551608, e5
.Compile ().Invoke (7));
2094 Expression
<Func
<MyEnum
, MyEnum
>> e6
= (MyEnum a
) => ~a
;
2095 AssertNodeType (e6
, ExpressionType
.Convert
);
2096 Assert ((MyEnum
)254, e6
.Compile ().Invoke (MyEnum
.Value_1
));
2099 void NotNullableTest ()
2101 Expression
<Func
<bool?, bool?>> e
= (bool? a
) => !a
;
2102 AssertNodeType (e
, ExpressionType
.Not
);
2103 Assert (false, e
.Compile ().Invoke (true));
2104 Assert (null, e
.Compile ().Invoke (null));
2107 void NotNullableTest_2 ()
2109 Expression
<Func
<MyType
?, bool?>> e2
= (MyType
? a
) => !a
;
2110 AssertNodeType (e2
, ExpressionType
.Not
);
2111 Assert (true, e2
.Compile ().Invoke (new MyType (1)));
2112 Assert (null, e2
.Compile ().Invoke (null));
2115 void NotNullableTest_3 ()
2117 Expression
<Func
<sbyte?, int?>> e3
= (sbyte? a
) => ~a
;
2118 AssertNodeType (e3
, ExpressionType
.Not
);
2119 Assert (-5, e3
.Compile ().Invoke (4));
2120 Assert (null, e3
.Compile ().Invoke (null));
2123 void NotNullableTest_4 ()
2125 Expression
<Func
<MyType
?, int?>> e4
= (MyType
? a
) => ~a
;
2126 AssertNodeType (e4
, ExpressionType
.Not
);
2127 Assert (0, e4
.Compile ().Invoke (new MyType (-1)));
2128 Assert (null, e4
.Compile ().Invoke (null));
2131 void NotNullableTest_5 ()
2133 Expression
<Func
<MyEnum
?, MyEnum
?>> e5
= (MyEnum
? a
) => ~a
;
2134 AssertNodeType (e5
, ExpressionType
.Convert
);
2135 Assert ((MyEnum
) 254, e5
.Compile ().Invoke (MyEnum
.Value_1
));
2136 Assert (null, e5
.Compile ().Invoke (null));
2139 void NotEqualTest ()
2141 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
!= b
;
2142 AssertNodeType (e
, ExpressionType
.NotEqual
);
2143 Assert (true, e
.Compile ().Invoke (60, 30));
2144 Assert (false, e
.Compile ().Invoke (-1, -1));
2147 void NotEqualTest_2 ()
2149 Expression
<Func
<sbyte?, sbyte?, bool>> e2
= (a
, b
) => a
!= b
;
2150 AssertNodeType (e2
, ExpressionType
.NotEqual
);
2151 Assert (false, e2
.Compile ().Invoke (3, 3));
2152 Assert (true, e2
.Compile ().Invoke (3, 2));
2155 void NotEqualTest_3 ()
2157 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
!= b
;
2158 AssertNodeType (e3
, ExpressionType
.NotEqual
);
2159 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
2162 void NotEqualTest_4 ()
2164 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
!= b
;
2165 AssertNodeType (e4
, ExpressionType
.NotEqual
);
2166 Assert (true, e4
.Compile ().Invoke (null, new MyType (-20)));
2167 Assert (false, e4
.Compile ().Invoke (null, null));
2168 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (120)));
2171 void NotEqualTest_5 ()
2173 Expression
<Func
<bool?, bool?, bool>> e5
= (bool? a
, bool? b
) => a
!= b
;
2174 AssertNodeType (e5
, ExpressionType
.NotEqual
);
2175 Assert (true, e5
.Compile ().Invoke (true, null));
2176 Assert (false, e5
.Compile ().Invoke (null, null));
2177 Assert (false, e5
.Compile ().Invoke (false, false));
2180 void NotEqualTest_6 ()
2182 Expression
<Func
<bool, bool>> e6
= (bool a
) => a
!= null;
2183 AssertNodeType (e6
, ExpressionType
.NotEqual
);
2184 Assert (true, e6
.Compile ().Invoke (true));
2185 Assert (true, e6
.Compile ().Invoke (false));
2188 void NotEqualTest_7 ()
2190 Expression
<Func
<string, string, bool>> e7
= (string a
, string b
) => a
!= b
;
2191 AssertNodeType (e7
, ExpressionType
.NotEqual
);
2192 Assert (false, e7
.Compile ().Invoke (null, null));
2193 Assert (true, e7
.Compile ().Invoke ("a", "A"));
2194 Assert (false, e7
.Compile ().Invoke ("a", "a"));
2197 void NotEqualTest_8 ()
2199 Expression
<Func
<object, bool>> e8
= (object a
) => null != a
;
2200 AssertNodeType (e8
, ExpressionType
.NotEqual
);
2201 Assert (false, e8
.Compile ().Invoke (null));
2202 Assert (true, e8
.Compile ().Invoke ("a"));
2203 Assert (true, e8
.Compile ().Invoke (this));
2206 void NotEqualTest_9 ()
2208 Expression
<Func
<MyEnum
, MyEnum
, bool>> e9
= (a
, b
) => a
!= b
;
2209 AssertNodeType (e9
, ExpressionType
.NotEqual
);
2210 Assert (true, e9
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2211 Assert (false, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2214 void NotEqualTest_10 ()
2216 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e10
= (a
, b
) => a
!= b
;
2217 AssertNodeType (e10
, ExpressionType
.NotEqual
);
2218 Assert (true, e10
.Compile ().Invoke (MyEnum
.Value_1
, null));
2219 Assert (false, e10
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2222 void NotEqualTest_11 ()
2224 Expression
<Func
<MyEnum
?, bool>> e11
= (a
) => a
!= null;
2225 AssertNodeType (e11
, ExpressionType
.NotEqual
);
2226 Assert (true, e11
.Compile ().Invoke (MyEnum
.Value_1
));
2227 Assert (false, e11
.Compile ().Invoke (null));
2232 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
| b
;
2234 AssertNodeType (e
, ExpressionType
.Or
);
2235 Func
<bool, bool, bool> c
= e
.Compile ();
2237 Assert (true, c (true, true));
2238 Assert (true, c (true, false));
2239 Assert (true, c (false, true));
2240 Assert (false, c (false, false));
2245 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
| b
;
2246 AssertNodeType (e2
, ExpressionType
.Or
);
2247 var c2
= e2
.Compile ();
2248 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2253 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e3
= (a
, b
) => a
| b
;
2254 AssertNodeType (e3
, ExpressionType
.Convert
);
2255 Assert ((MyEnum
)3, e3
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2256 Assert (MyEnum
.Value_2
, e3
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2259 void OrNullableTest ()
2261 Expression
<Func
<bool?, bool?, bool?>> e
= (bool? a
, bool? b
) => a
| b
;
2263 AssertNodeType (e
, ExpressionType
.Or
);
2264 Func
<bool?, bool?, bool?> c
= e
.Compile ();
2266 Assert (true, c (true, true));
2267 Assert (true, c (true, false));
2268 Assert (true, c (false, true));
2269 Assert (false, c (false, false));
2271 Assert (true, c (true, null));
2272 Assert (null, c (false, null));
2273 Assert (null, c (null, false));
2274 Assert (true, c (true, null));
2275 Assert (null, c (null, null));
2278 void OrNullableTest_2 ()
2280 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e2
= (MyType
? a
, MyType
? b
) => a
| b
;
2281 AssertNodeType (e2
, ExpressionType
.Or
);
2282 var c2
= e2
.Compile ();
2283 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2284 Assert (null, c2 (new MyType (1), null));
2288 void OrNullableTest_3 ()
2290 Expression
<Func
<MyType
?, uint, long?>> e3
= (MyType
? a
, uint b
) => a
| b
;
2291 AssertNodeType (e3
, ExpressionType
.Or
);
2292 var c3
= e3
.Compile ();
2293 Assert (9, c3 (new MyType (1), 8));
2296 void OrNullableTest_4 ()
2298 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e4
= (a
, b
) => a
| b
;
2299 AssertNodeType (e4
, ExpressionType
.Convert
);
2300 Assert (null, e4
.Compile ().Invoke (null, MyEnum
.Value_2
));
2301 Assert ((MyEnum
)3, e4
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2306 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
|| b
;
2307 AssertNodeType (e
, ExpressionType
.OrElse
);
2308 Assert (true, e
.Compile ().Invoke (true, false));
2311 void OrElseTest_2 ()
2313 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
|| b
;
2314 AssertNodeType (e2
, ExpressionType
.OrElse
);
2315 Assert (new MyType (64), e2
.Compile ().Invoke (new MyType (64), new MyType (64)));
2316 Assert (new MyType (32), e2
.Compile ().Invoke (new MyType (32), new MyType (64)));
2319 void ParameterTest ()
2321 Expression
<Func
<string, string>> e
= (string a
) => a
;
2322 AssertNodeType (e
, ExpressionType
.Parameter
);
2323 Assert ("t", e
.Compile ().Invoke ("t"));
2326 void ParameterTest_2 ()
2328 Expression
<Func
<object[], object[]>> e2
= (object[] a
) => a
;
2329 AssertNodeType (e2
, ExpressionType
.Parameter
);
2330 Assert (new object [0], e2
.Compile ().Invoke (new object [0]));
2333 void ParameterTest_3 ()
2335 Expression
<Func
<IntPtr
, IntPtr
>> e3
= a
=> a
;
2336 AssertNodeType (e3
, ExpressionType
.Parameter
);
2337 Assert (IntPtr
.Zero
, e3
.Compile ().Invoke (IntPtr
.Zero
));
2340 unsafe void ParameterTest_4 ()
2342 Expression
<Func
<int*[], int* []>> e4
= (a
) => a
;
2343 AssertNodeType (e4
, ExpressionType
.Parameter
);
2344 Assert
<int*[]> (null, e4
.Compile ().Invoke (null));
2345 int* e4_el
= stackalloc int [5];
2346 int*[] ptr
= new int*[] { e4_el }
;
2347 Assert
<int*[]> (ptr
, e4
.Compile ().Invoke (ptr
));
2352 Expression
<Func
<Expression
<Func
<int>>>> e
= () => () => 2;
2353 AssertNodeType (e
, ExpressionType
.Quote
);
2354 Assert (2, e
.Compile ().Invoke ().Compile ().Invoke ());
2357 void RightShiftTest ()
2359 Expression
<Func
<ulong, short, ulong>> e
= (ulong a
, short b
) => a
>> b
;
2360 AssertNodeType (e
, ExpressionType
.RightShift
);
2361 Assert ((ulong) 0x1FD940L
, e
.Compile ().Invoke (0xFECA0000, 11));
2362 Assert ((ulong) 0x7FFFFFFF, e
.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2364 // .net produces a strange result
2365 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
2366 // Assert ((ulong)0, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2369 void RightShiftTest_2 ()
2371 Expression
<Func
<MyType
, MyType
, int>> e2
= (MyType a
, MyType b
) => a
>> b
;
2372 AssertNodeType (e2
, ExpressionType
.RightShift
);
2373 var c2
= e2
.Compile ();
2374 Assert (64, c2 (new MyType (256), new MyType (2)));
2377 void RightShiftTest_3 ()
2379 Expression
<Func
<long?, sbyte, long?>> e3
= (long? a
, sbyte b
) => a
>> b
;
2380 AssertNodeType (e3
, ExpressionType
.RightShift
);
2381 Assert (null, e3
.Compile ().Invoke (null, 11));
2382 Assert (512, e3
.Compile ().Invoke (1024, 1));
2385 void RightShiftTest_4 ()
2387 Expression
<Func
<MyType
?, MyType
?, int?>> e4
= (MyType
? a
, MyType
? b
) => a
>> b
;
2388 AssertNodeType (e4
, ExpressionType
.RightShift
);
2389 var c4
= e4
.Compile ();
2390 Assert (null, c4 (new MyType (8), null));
2391 Assert (null, c4 (null, new MyType (8)));
2392 Assert (64, c4 (new MyType (256), new MyType (2)));
2395 void SubtractTest ()
2397 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
- b
;
2398 AssertNodeType (e
, ExpressionType
.Subtract
);
2399 Assert (-10, e
.Compile ().Invoke (20, 30));
2402 void SubtractTest_2 ()
2404 Expression
<Func
<int?, int?, int?>> e2
= (a
, b
) => a
- b
;
2405 AssertNodeType (e2
, ExpressionType
.Subtract
);
2406 Assert (null, e2
.Compile ().Invoke (null, 3));
2409 void SubtractTest_3 ()
2411 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
- b
;
2412 AssertNodeType (e3
, ExpressionType
.Subtract
);
2413 Assert (-50, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2416 void SubtractTest_4 ()
2418 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
- b
;
2419 AssertNodeType (e4
, ExpressionType
.Subtract
);
2420 Assert (new MyType (-50), e4
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2421 Assert (null, e4
.Compile ().Invoke (null, new MyType (30)));
2424 void SubtractTest_5 ()
2426 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
- b
;
2427 AssertNodeType (e5
, ExpressionType
.Subtract
);
2428 Assert (-29, e5
.Compile ().Invoke (1, new MyType (30)));
2431 void SubtractTest_6 ()
2433 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
- b
;
2434 AssertNodeType (e6
, ExpressionType
.Subtract
);
2435 Assert (-61, e6
.Compile ().Invoke (-31, new MyType (30)));
2438 void SubtractTest_7 ()
2440 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => null - a
;
2441 AssertNodeType (e7
, ExpressionType
.Subtract
);
2442 Assert (null, e7
.Compile ().Invoke (690));
2445 void SubtractTest_8 ()
2447 Expression
<Func
<MyEnum
, byte, MyEnum
>> e8
= (a
, b
) => a
- b
;
2448 AssertNodeType (e8
, ExpressionType
.Convert
);
2449 Assert ((MyEnum
)255, e8
.Compile ().Invoke (MyEnum
.Value_1
, 2));
2452 void SubtractTest_9 ()
2454 Expression
<Func
<MyEnum
, MyEnum
, byte>> e9
= (a
, b
) => a
- b
;
2455 AssertNodeType (e9
, ExpressionType
.Convert
);
2456 Assert (1, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
2460 void SubtractTest_10 ()
2462 Expression
<Func
<MyEnum
?, byte?, MyEnum
?>> e10
= (a
, b
) => a
- b
;
2463 AssertNodeType (e10
, ExpressionType
.Convert
);
2464 Assert ((MyEnum
) 255, e10
.Compile ().Invoke (MyEnum
.Value_1
, 2));
2468 void SubtractTest_11 ()
2470 Expression
<Func
<MyEnum
?, MyEnum
?, byte?>> e11
= (a
, b
) => a
- b
;
2471 AssertNodeType (e11
, ExpressionType
.Convert
);
2472 Assert
<byte?> (1, e11
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
2475 void SubtractCheckedTest ()
2478 Expression
<Func
<long, long, long>> e
= (long a
, long b
) => a
- b
;
2479 AssertNodeType (e
, ExpressionType
.SubtractChecked
);
2481 e
.Compile ().Invoke (long.MinValue
, 309);
2482 throw new ApplicationException ("SubtractCheckedTest #1");
2483 } catch (OverflowException
) { }
2487 void SubtractCheckedTest_2 ()
2490 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a
- b
;
2491 AssertNodeType (e2
, ExpressionType
.SubtractChecked
);
2492 Assert (null, e2
.Compile ().Invoke (null, 3));
2493 Assert (-55, e2
.Compile ().Invoke (byte.MinValue
, 55));
2497 void SubtractCheckedTest_3 ()
2500 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
- b
;
2501 AssertNodeType (e3
, ExpressionType
.Subtract
);
2502 Assert (-50, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2506 void SubtractCheckedTest_4 ()
2509 Expression
<Func
<double, double, double>> e4
= (a
, b
) => a
- b
;
2510 AssertNodeType (e4
, ExpressionType
.Subtract
);
2511 Assert (double.PositiveInfinity
, e4
.Compile ().Invoke (double.MinValue
, double.NegativeInfinity
));
2517 Expression
<Func
<object, Tester
>> e
= (object a
) => a
as Tester
;
2518 AssertNodeType (e
, ExpressionType
.TypeAs
);
2519 Assert (this, e
.Compile ().Invoke (this));
2522 void TypeAsTest_2 ()
2524 Expression
<Func
<object, int?>> e2
= (object a
) => a
as int?;
2525 AssertNodeType (e2
, ExpressionType
.TypeAs
);
2526 Assert (null, e2
.Compile ().Invoke (null));
2527 Assert (null, e2
.Compile ().Invoke (this));
2528 Assert (44, e2
.Compile ().Invoke (44));
2531 void TypeAsTest_3 ()
2533 Expression
<Func
<object, object>> e3
= (object a
) => null as object;
2534 AssertNodeType (e3
, ExpressionType
.TypeAs
);
2535 Assert (null, e3
.Compile ().Invoke (null));
2540 Expression
<Func
<object, bool>> e
= (object a
) => a
is Tester
;
2541 AssertNodeType (e
, ExpressionType
.TypeIs
);
2542 Assert (true, e
.Compile ().Invoke (this));
2543 Assert (false, e
.Compile ().Invoke (1));
2546 void TypeIsTest_2 ()
2548 Expression
<Func
<object, bool>> e2
= (object a
) => a
is int?;
2549 AssertNodeType (e2
, ExpressionType
.TypeIs
);
2550 Assert (false, e2
.Compile ().Invoke (null));
2551 Assert (true, e2
.Compile ().Invoke (1));
2554 void TypeIsTest_3 ()
2556 Expression
<Func
<object, bool>> e3
= (object a
) => null is object;
2557 AssertNodeType (e3
, ExpressionType
.TypeIs
);
2558 Assert (false, e3
.Compile ().Invoke (null));
2561 void TypeIsTest_5 ()
2563 Expression
<Func
<bool>> e5
= () => 1 is int;
2564 AssertNodeType (e5
, ExpressionType
.TypeIs
);
2565 Assert (true, e5
.Compile ().Invoke ());
2568 void TypeIsTest_6 ()
2570 Expression
<Func
<int?, bool>> e6
= (a
) => a
is int;
2571 AssertNodeType (e6
, ExpressionType
.TypeIs
);
2572 Assert (true, e6
.Compile ().Invoke (1));
2573 Assert (false, e6
.Compile ().Invoke (null));
2576 void UnaryPlusTest ()
2578 Expression
<Func
<int, int>> e
= (a
) => +a
;
2579 AssertNodeType (e
, ExpressionType
.Parameter
);
2580 Assert (-30, e
.Compile ().Invoke (-30));
2583 void UnaryPlusTest_2 ()
2585 Expression
<Func
<long?, long?>> e2
= (a
) => +a
;
2586 AssertNodeType (e2
, ExpressionType
.Parameter
);
2589 void UnaryPlusTest_3 ()
2591 Expression
<Func
<MyType
, MyType
>> e4
= (a
) => +a
;
2592 AssertNodeType (e4
, ExpressionType
.UnaryPlus
);
2593 Assert (new MyType (-14), e4
.Compile ().Invoke (new MyType (-14)));
2596 void UnaryPlusTest_4 ()
2598 Expression
<Func
<MyType
?, MyType
?>> e5
= (a
) => +a
;
2599 AssertNodeType (e5
, ExpressionType
.UnaryPlus
);
2600 Assert (new MyType (33), e5
.Compile ().Invoke (new MyType (33)));
2601 Assert (null, e5
.Compile ().Invoke (null));
2604 void UnaryPlusTest_5 ()
2606 Expression
<Func
<sbyte?, long?>> e6
= (a
) => +a
;
2607 AssertNodeType (e6
, ExpressionType
.Convert
);
2608 Assert (3, e6
.Compile ().Invoke (3));
2609 Assert (null, e6
.Compile ().Invoke (null));
2612 #pragma warning restore 169
2617 string InstanceMethod (string arg
)
2622 object InstanceParamsMethod (int index
, params object [] args
)
2626 if (args
.Length
== 0)
2628 return args
[index
];
2631 static int TestInt ()
2636 T GenericMethod
<T
> (T t
)
2641 static void RefMethod (ref int i
)
2646 static bool RunTest (MethodInfo test
)
2648 Console
.Write ("Running test {0, -25}", test
.Name
);
2650 test
.Invoke (new Tester (), null);
2651 Console
.WriteLine ("OK");
2653 } catch (Exception e
) {
2654 Console
.WriteLine ("FAILED");
2655 Console
.WriteLine (e
.ToString ());
2660 public static int Main ()
2662 var tests
= from test
in typeof (Tester
).GetMethods (BindingFlags
.Instance
| BindingFlags
.NonPublic
| BindingFlags
.DeclaredOnly
)
2663 where test
.GetParameters ().Length
== 0
2665 select RunTest (test
);
2667 int failures
= tests
.Count (a
=> !a
);
2668 Console
.WriteLine (failures
+ " tests failed");