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 // FIXME: Redundant convert, need new expression
766 void ConstantTest_3 ()
768 Expression
<Func
<Tester
>> e3
= () => default (Tester
);
769 //AssertNodeType (e3, ExpressionType.Constant);
770 Assert (null, e3
.Compile ().Invoke ());
773 void ConstantTest_4 ()
775 Expression
<Func
<object>> e4
= () => null;
776 AssertNodeType (e4
, ExpressionType
.Constant
);
777 Assert (null, e4
.Compile ().Invoke ());
780 void ConstantTest_5 ()
782 Expression
<Func
<int>> e5
= () => 8 / 4;
783 AssertNodeType (e5
, ExpressionType
.Constant
);
784 Assert (2, e5
.Compile ().Invoke ());
787 void ConstantTest_6 ()
789 Expression
<Func
<int>> e6
= () => 0xFFFFFF >> 0x40;
790 AssertNodeType (e6
, ExpressionType
.Constant
);
791 Assert (0xFFFFFF, e6
.Compile ().Invoke ());
794 void ConstantTest_7 ()
796 Expression
<Func
<object>> e7
= () => "Alleluia";
797 AssertNodeType (e7
, ExpressionType
.Constant
);
798 Assert ("Alleluia", e7
.Compile ().Invoke ());
801 void ConstantTest_8 ()
803 Expression
<Func
<Type
>> e8
= () => typeof (int);
804 AssertNodeType (e8
, ExpressionType
.Constant
);
805 Assert (typeof (int), e8
.Compile ().Invoke ());
808 void ConstantTest_9 ()
810 Expression
<Func
<Type
>> e9
= () => typeof (void);
811 AssertNodeType (e9
, ExpressionType
.Constant
);
812 Assert (typeof (void), e9
.Compile ().Invoke ());
815 void ConstantTest_10 ()
817 Expression
<Func
<Type
>> e10
= () => typeof (Func
<,>);
818 AssertNodeType (e10
, ExpressionType
.Constant
);
819 Assert (typeof (Func
<,>), e10
.Compile ().Invoke ());
822 void ConstantTest_11 ()
824 Expression
<Func
<MyEnum
>> e11
= () => MyEnum
.Value_2
;
825 AssertNodeType (e11
, ExpressionType
.Constant
);
826 Assert (MyEnum
.Value_2
, e11
.Compile ().Invoke ());
829 void ConstantTest_13 ()
831 Expression
<Func
<int>> e13
= () => sizeof (byte);
832 AssertNodeType (e13
, ExpressionType
.Constant
);
833 Assert (1, e13
.Compile ().Invoke ());
837 unsafe void ConstantTest_14 ()
839 Expression
<Func
<Type
>> e14
= () => typeof (bool*);
840 AssertNodeType (e14
, ExpressionType
.Constant
);
841 Assert (typeof (bool*), e14
.Compile ().Invoke ());
844 void ConstantTest_15 ()
846 Expression
<Func
<int?>> e15
= () => null;
847 AssertNodeType (e15
, ExpressionType
.Constant
);
848 Assert (null, e15
.Compile ().Invoke ());
853 Expression
<Func
<int, byte>> e
= (int a
) => ((byte) a
);
854 AssertNodeType (e
, ExpressionType
.Convert
);
855 Assert (100, e
.Compile ().Invoke (100));
858 void ConvertTest_2 ()
860 Expression
<Func
<long, ushort>> e2
= (long a
) => ((ushort) a
);
861 AssertNodeType (e2
, ExpressionType
.Convert
);
862 Assert (100, e2
.Compile ().Invoke (100));
865 void ConvertTest_3 ()
867 Expression
<Func
<float?, float>> e3
= (float? a
) => ((float) a
);
868 AssertNodeType (e3
, ExpressionType
.Convert
);
869 Assert (-0.456f
, e3
.Compile ().Invoke (-0.456f
));
872 void ConvertTest_4 ()
874 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => (a
);
875 AssertNodeType (e4
, ExpressionType
.Convert
);
876 Assert (-9, e4
.Compile ().Invoke (new MyType (-9)));
879 void ConvertTest_5 ()
881 Expression
<Func
<MyType
, MyType
, bool?>> e5
= (MyType a
, MyType b
) => a
== b
;
882 AssertNodeType (e5
, ExpressionType
.Convert
);
885 void ConvertTest_6 ()
887 Expression
<Func
<MyType
?, MyType
?, bool?>> e6
= (MyType
? a
, MyType
? b
) => a
== b
;
888 AssertNodeType (e6
, ExpressionType
.Convert
);
889 Assert (false, e6
.Compile ().Invoke (null, new MyType (-20)));
890 Assert (true, e6
.Compile ().Invoke (null, null));
891 Assert (true, e6
.Compile ().Invoke (new MyType (120), new MyType (120)));
894 void ConvertTest_7 ()
896 Expression
<Func
<MyTypeExplicit
, int?>> e7
= x
=> (int?)x
;
897 AssertNodeType (e7
, ExpressionType
.Convert
);
898 Assert (33, e7
.Compile ().Invoke (new MyTypeExplicit (33)));
901 void ConvertTest_8 ()
903 Expression
<Func
<int?, object>> e8
= x
=> (object)x
;
904 AssertNodeType (e8
, ExpressionType
.Convert
);
905 Assert (null, e8
.Compile ().Invoke (null));
906 Assert (-100, e8
.Compile ().Invoke (-100));
909 unsafe void ConvertTest_9 ()
911 int*[] p
= new int* [1];
912 Expression
<Func
<object>> e9
= () => (object)p
;
913 AssertNodeType (e9
, ExpressionType
.Convert
);
914 Assert (p
, e9
.Compile ().Invoke ());
917 void ConvertTest_10 ()
919 Expression
<Func
<Func
<int>, Delegate
>> e10
= (a
) => a
+ a
;
920 AssertNodeType (e10
, ExpressionType
.Convert
);
921 Assert (null, e10
.Compile ().Invoke (null));
922 Assert (new Func
<int> (TestInt
) + new Func
<int> (TestInt
), e10
.Compile ().Invoke (TestInt
));
925 void ConvertTest_11 ()
927 Expression
<Func
<Func
<int>, Delegate
>> e11
= (a
) => a
- a
;
928 AssertNodeType (e11
, ExpressionType
.Convert
);
929 Assert (null, e11
.Compile ().Invoke (null));
932 void ConvertTest_12 ()
934 Expression
<Func
<Func
<int>>> e12
= () => TestInt
;
935 AssertNodeType (e12
, ExpressionType
.Convert
);
936 Assert (29, e12
.Compile ().Invoke () ());
939 void ConvertTest_13 ()
941 Expression
<Func
<decimal, sbyte>> e13
= a
=> (sbyte)a
;
942 AssertNodeType (e13
, ExpressionType
.Convert
);
943 Assert (6, e13
.Compile ().Invoke (6));
946 void ConvertTest_14 ()
948 Expression
<Func
<long, decimal>> e14
= a
=> a
;
949 AssertNodeType (e14
, ExpressionType
.Convert
);
950 Assert (-66, e14
.Compile ().Invoke (-66));
953 void ConvertTest_15 ()
955 Expression
<Func
<ulong?, decimal?>> e15
= a
=> a
;
956 AssertNodeType (e15
, ExpressionType
.Convert
);
957 Assert (null, e15
.Compile ().Invoke (null));
958 Assert (9, e15
.Compile ().Invoke (9));
961 void ConvertCheckedTest ()
963 Expression
<Func
<int, byte>> e
= (int a
) => checked((byte) a
);
964 AssertNodeType (e
, ExpressionType
.ConvertChecked
);
965 Assert (100, e
.Compile ().Invoke (100));
968 void ConvertCheckedTest_2 ()
971 Expression
<Func
<long, ushort>> e2
= (long a
) => unchecked((ushort) a
);
972 AssertNodeType (e2
, ExpressionType
.Convert
);
973 Assert (100, e2
.Compile ().Invoke (100));
977 void ConvertCheckedTest_3 ()
980 Expression
<Func
<float?, float>> e3
= (float? a
) => ((float) a
);
981 AssertNodeType (e3
, ExpressionType
.ConvertChecked
);
982 Assert (-0.456f
, e3
.Compile ().Invoke (-0.456f
));
986 void ConvertCheckedTest_4 ()
989 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => (a
);
990 AssertNodeType (e4
, ExpressionType
.Convert
);
991 Assert (-9, e4
.Compile ().Invoke (new MyType (-9)));
997 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
/ b
;
998 AssertNodeType (e
, ExpressionType
.Divide
);
999 Assert (2, e
.Compile ().Invoke (60, 30));
1002 void DivideTest_2 ()
1004 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
/ b
;
1005 AssertNodeType (e2
, ExpressionType
.Divide
);
1006 Assert (null, e2
.Compile ().Invoke (null, 3));
1007 Assert (1.5, e2
.Compile ().Invoke (3, 2));
1010 void DivideTest_3 ()
1012 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
/ b
;
1013 AssertNodeType (e3
, ExpressionType
.Divide
);
1014 Assert (1, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1017 void DivideTest_4 ()
1019 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
/ b
;
1020 AssertNodeType (e4
, ExpressionType
.Divide
);
1021 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1022 Assert (new MyType (-6), e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1025 void DivideTest_5 ()
1027 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
/ b
;
1028 AssertNodeType (e5
, ExpressionType
.Divide
);
1029 Assert (50, e5
.Compile ().Invoke (100, new MyType (2)));
1032 void DivideTest_6 ()
1034 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
/ b
;
1035 AssertNodeType (e6
, ExpressionType
.Divide
);
1036 Assert (50, e6
.Compile ().Invoke (100, new MyType (2)));
1037 Assert (null, e6
.Compile ().Invoke (20, null));
1042 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
== b
;
1043 AssertNodeType (e
, ExpressionType
.Equal
);
1044 Assert (false, e
.Compile ().Invoke (60, 30));
1045 Assert (true, e
.Compile ().Invoke (-1, -1));
1050 Expression
<Func
<double?, double?, bool>> e2
= (a
, b
) => a
== b
;
1051 AssertNodeType (e2
, ExpressionType
.Equal
);
1052 Assert (true, e2
.Compile ().Invoke (3, 3));
1053 Assert (false, e2
.Compile ().Invoke (3, 2));
1058 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
== b
;
1059 AssertNodeType (e3
, ExpressionType
.Equal
);
1060 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1065 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
== b
;
1066 AssertNodeType (e4
, ExpressionType
.Equal
);
1067 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1068 Assert (true, e4
.Compile ().Invoke (null, null));
1069 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (120)));
1074 Expression
<Func
<bool?, bool?, bool>> e5
= (bool? a
, bool? b
) => a
== b
;
1075 AssertNodeType (e5
, ExpressionType
.Equal
);
1076 Assert (false, e5
.Compile ().Invoke (true, null));
1077 Assert (true, e5
.Compile ().Invoke (null, null));
1078 Assert (true, e5
.Compile ().Invoke (false, false));
1083 Expression
<Func
<bool, bool>> e6
= (bool a
) => a
== null;
1084 AssertNodeType (e6
, ExpressionType
.Equal
);
1085 Assert (false, e6
.Compile ().Invoke (true));
1086 Assert (false, e6
.Compile ().Invoke (false));
1091 Expression
<Func
<string, string, bool>> e7
= (string a
, string b
) => a
== b
;
1092 AssertNodeType (e7
, ExpressionType
.Equal
);
1093 Assert (true, e7
.Compile ().Invoke (null, null));
1094 Assert (false, e7
.Compile ().Invoke ("a", "A"));
1095 Assert (true, e7
.Compile ().Invoke ("a", "a"));
1100 Expression
<Func
<object, bool>> e8
= (object a
) => null == a
;
1101 AssertNodeType (e8
, ExpressionType
.Equal
);
1102 Assert (true, e8
.Compile ().Invoke (null));
1103 Assert (false, e8
.Compile ().Invoke ("a"));
1104 Assert (false, e8
.Compile ().Invoke (this));
1109 Expression
<Func
<MyEnum
, MyEnum
, bool>> e9
= (a
, b
) => a
== b
;
1110 AssertNodeType (e9
, ExpressionType
.Equal
);
1111 Assert (false, e9
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
1112 Assert (true, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1115 void EqualTest_10 ()
1117 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e10
= (a
, b
) => a
== b
;
1118 AssertNodeType (e10
, ExpressionType
.Equal
);
1119 Assert (false, e10
.Compile ().Invoke (MyEnum
.Value_1
, null));
1120 Assert (true, e10
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1123 void EqualTest_11 ()
1125 Expression
<Func
<MyEnum
?, bool>> e11
= (a
) => a
== null;
1126 AssertNodeType (e11
, ExpressionType
.Equal
);
1127 Assert (false, e11
.Compile ().Invoke (MyEnum
.Value_1
));
1128 Assert (true, e11
.Compile ().Invoke (null));
1131 void EqualTest_12 ()
1133 Expression
<Func
<MyEnumUlong
, bool>> e12
= (a
) => a
== 0;
1134 AssertNodeType (e12
, ExpressionType
.Equal
);
1135 Assert (false, e12
.Compile ().Invoke (MyEnumUlong
.Value_1
));
1136 Assert (true, e12
.Compile ().Invoke (0));
1139 void EqualTest_13 ()
1141 Expression
<Func
<MyEnum
, bool>> e13
= (a
) => a
== MyEnum
.Value_2
;
1142 AssertNodeType (e13
, ExpressionType
.Equal
);
1143 Assert (true, e13
.Compile ().Invoke (MyEnum
.Value_2
));
1144 Assert (false, e13
.Compile ().Invoke (0));
1147 void EqualTest_14 ()
1149 Expression
<Func
<MyEnum
, bool>> e
= (a
) => a
== null;
1150 AssertNodeType (e
, ExpressionType
.Equal
);
1151 Assert (false, e
.Compile ().Invoke (MyEnum
.Value_1
));
1154 void EqualTestDelegate ()
1156 Expression
<Func
<Delegate
, Delegate
, bool>> e1
= (a
, b
) => a
== b
;
1157 AssertNodeType (e1
, ExpressionType
.Equal
);
1158 Assert (true, e1
.Compile ().Invoke (null, null));
1161 void EqualTestDelegate_2 ()
1163 EmptyDelegate ed
= delegate () {};
1165 Expression
<Func
<EmptyDelegate
, EmptyDelegate
, bool>> e2
= (a
, b
) => a
== b
;
1166 AssertNodeType (e2
, ExpressionType
.Equal
);
1167 Assert (false, e2
.Compile ().Invoke (delegate () {}, null));
1168 Assert (false, e2
.Compile ().Invoke (delegate () {}, delegate {}
));
1169 Assert (false, e2
.Compile ().Invoke (ed
, delegate {}));
1170 Assert (true, e2
.Compile ().Invoke (ed
, ed
));
1173 void ExclusiveOrTest ()
1175 Expression
<Func
<int, short, int>> e
= (int a
, short b
) => a ^ b
;
1176 AssertNodeType (e
, ExpressionType
.ExclusiveOr
);
1177 Assert (34, e
.Compile ().Invoke (60, 30));
1180 void ExclusiveOrTest_2 ()
1182 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a ^ b
;
1183 AssertNodeType (e2
, ExpressionType
.ExclusiveOr
);
1184 Assert (null, e2
.Compile ().Invoke (null, 3));
1185 Assert (1, e2
.Compile ().Invoke (3, 2));
1188 void ExclusiveOrTest_3 ()
1190 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a ^ b
;
1191 AssertNodeType (e3
, ExpressionType
.ExclusiveOr
);
1192 Assert (0, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1195 void ExclusiveOrTest_4 ()
1197 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a ^ b
;
1198 AssertNodeType (e4
, ExpressionType
.ExclusiveOr
);
1199 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1200 Assert (new MyType (-108), e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1203 void ExclusiveOrTest_5 ()
1205 Expression
<Func
<MyType
?, byte, int?>> e5
= (MyType
? a
, byte b
) => a ^ b
;
1206 AssertNodeType (e5
, ExpressionType
.ExclusiveOr
);
1207 Assert (null, e5
.Compile ().Invoke (null, 64));
1208 Assert (96, e5
.Compile ().Invoke (new MyType (64), 32));
1211 void ExclusiveOrTest_6 ()
1213 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e6
= (a
, b
) => a ^ b
;
1214 AssertNodeType (e6
, ExpressionType
.Convert
);
1215 Assert ((MyEnum
)3, e6
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
1216 Assert
<MyEnum
> (0, e6
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1219 void ExclusiveOrTest_7 ()
1221 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e7
= (a
, b
) => a ^ b
;
1222 AssertNodeType (e7
, ExpressionType
.Convert
);
1223 Assert (null, e7
.Compile ().Invoke (MyEnum
.Value_1
, null));
1224 Assert
<MyEnum
?> (0, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1227 void ExclusiveOrTest_8 ()
1229 Expression
<Func
<MyEnum
?, MyEnum
?>> e8
= (a
) => a ^
null;
1230 AssertNodeType (e8
, ExpressionType
.Convert
);
1231 Assert (null, e8
.Compile ().Invoke (MyEnum
.Value_1
));
1232 Assert (null, e8
.Compile ().Invoke (null));
1235 void GreaterThanTest ()
1237 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
> b
;
1238 AssertNodeType (e
, ExpressionType
.GreaterThan
);
1239 Assert (true, e
.Compile ().Invoke (60, 30));
1242 void GreaterThanTest_2 ()
1244 Expression
<Func
<uint?, byte?, bool>> e2
= (a
, b
) => a
> b
;
1245 AssertNodeType (e2
, ExpressionType
.GreaterThan
);
1246 Assert (false, e2
.Compile ().Invoke (null, 3));
1247 Assert (false, e2
.Compile ().Invoke (2, 2));
1250 void GreaterThanTest_3 ()
1252 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
> b
;
1253 AssertNodeType (e3
, ExpressionType
.GreaterThan
);
1254 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1257 void GreaterThanTest_4 ()
1259 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
> b
;
1260 AssertNodeType (e4
, ExpressionType
.GreaterThan
);
1261 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1262 Assert (false, e4
.Compile ().Invoke (null, null));
1263 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1266 void GreaterThanTest_5 ()
1268 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
> b
;
1269 AssertNodeType (e5
, ExpressionType
.GreaterThan
);
1270 Assert (false, e5
.Compile ().Invoke (null, 33));
1271 Assert (false, e5
.Compile ().Invoke (null, 0));
1272 Assert (true, e5
.Compile ().Invoke (new MyType (120), 3));
1275 void GreaterThanTest_6 ()
1277 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
> null;
1278 AssertNodeType (e6
, ExpressionType
.GreaterThan
);
1279 Assert (false, e6
.Compile ().Invoke (60));
1282 void GreaterThanTest_7 ()
1284 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
> b
;
1285 AssertNodeType (e7
, ExpressionType
.GreaterThan
);
1286 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1287 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1290 void GreaterThanTest_8 ()
1292 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
> b
;
1293 AssertNodeType (e8
, ExpressionType
.GreaterThan
);
1294 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1295 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1298 void GreaterThanOrEqualTest ()
1300 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
>= b
;
1301 AssertNodeType (e
, ExpressionType
.GreaterThanOrEqual
);
1302 Assert (true, e
.Compile ().Invoke (60, 30));
1305 void GreaterThanOrEqualTest_2 ()
1307 Expression
<Func
<byte?, byte?, bool>> e2
= (a
, b
) => a
>= b
;
1308 AssertNodeType (e2
, ExpressionType
.GreaterThanOrEqual
);
1309 Assert (false, e2
.Compile ().Invoke (null, 3));
1310 Assert (true, e2
.Compile ().Invoke (2, 2));
1313 void GreaterThanOrEqualTest_3 ()
1315 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
>= b
;
1316 AssertNodeType (e3
, ExpressionType
.GreaterThanOrEqual
);
1317 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
1320 void GreaterThanOrEqualTest_4 ()
1322 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
>= b
;
1323 AssertNodeType (e4
, ExpressionType
.GreaterThanOrEqual
);
1324 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1325 Assert (false, e4
.Compile ().Invoke (null, null));
1326 Assert (true, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1329 void GreaterThanOrEqualTest_5 ()
1331 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
>= b
;
1332 AssertNodeType (e5
, ExpressionType
.GreaterThanOrEqual
);
1333 Assert (false, e5
.Compile ().Invoke (null, 33));
1334 Assert (false, e5
.Compile ().Invoke (null, 0));
1335 Assert (true, e5
.Compile ().Invoke (new MyType (120), 3));
1338 void GreaterThanOrEqualTest_6 ()
1340 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
>= null;
1341 AssertNodeType (e6
, ExpressionType
.GreaterThanOrEqual
);
1342 Assert (false, e6
.Compile ().Invoke (60));
1345 void GreaterThanOrEqualTest_7 ()
1347 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
>= b
;
1348 AssertNodeType (e7
, ExpressionType
.GreaterThanOrEqual
);
1349 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1350 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1353 void GreaterThanOrEqualTest_8 ()
1355 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
>= b
;
1356 AssertNodeType (e8
, ExpressionType
.GreaterThanOrEqual
);
1357 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1358 Assert (true, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1363 var del
= new IntDelegate (TestInt
);
1364 Expression
<Func
<IntDelegate
, int>> e
= (a
) => a ();
1365 AssertNodeType (e
, ExpressionType
.Invoke
);
1366 Assert (29, e
.Compile ().Invoke (del
));
1369 void InvokeTest_2 ()
1371 Expression
<Func
<Func
<int, string>, int, string>> e2
= (a
, b
) => a (b
);
1372 AssertNodeType (e2
, ExpressionType
.Invoke
);
1373 Assert ("4", e2
.Compile ().Invoke ((a
) => (a
+1).ToString (), 3));
1376 void LeftShiftTest ()
1378 Expression
<Func
<ulong, short, ulong>> e
= (ulong a
, short b
) => a
<< b
;
1379 AssertNodeType (e
, ExpressionType
.LeftShift
);
1380 Assert ((ulong) 0x7F000, e
.Compile ().Invoke (0xFE, 11));
1381 Assert ((ulong) 0x1FFFFFFFE, e
.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1383 // .net produces a strange result
1384 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
1385 // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1388 void LeftShiftTest_2 ()
1390 Expression
<Func
<MyType
, MyType
, int>> e2
= (MyType a
, MyType b
) => a
<< b
;
1391 AssertNodeType (e2
, ExpressionType
.LeftShift
);
1392 var c2
= e2
.Compile ();
1393 Assert (1024, c2 (new MyType (256), new MyType (2)));
1396 void LeftShiftTest_3 ()
1398 Expression
<Func
<long?, sbyte, long?>> e3
= (long? a
, sbyte b
) => a
<< b
;
1399 AssertNodeType (e3
, ExpressionType
.LeftShift
);
1400 Assert (null, e3
.Compile ().Invoke (null, 11));
1401 Assert (2048, e3
.Compile ().Invoke (1024, 1));
1404 void LeftShiftTest_4 ()
1406 Expression
<Func
<MyType
?, MyType
?, int?>> e4
= (MyType
? a
, MyType
? b
) => a
<< b
;
1407 AssertNodeType (e4
, ExpressionType
.LeftShift
);
1408 var c4
= e4
.Compile ();
1409 Assert (null, c4 (new MyType (8), null));
1410 Assert (null, c4 (null, new MyType (8)));
1411 Assert (1024, c4 (new MyType (256), new MyType (2)));
1414 void LeftShiftTest_5 ()
1416 Expression
<Func
<ushort, int?>> e5
= (ushort a
) => a
<< null;
1417 AssertNodeType (e5
, ExpressionType
.LeftShift
);
1418 Assert (null, e5
.Compile ().Invoke (30));
1421 void LessThanTest ()
1423 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
< b
;
1424 AssertNodeType (e
, ExpressionType
.LessThan
);
1425 Assert (false, e
.Compile ().Invoke (60, 30));
1428 void LessThanTest_2 ()
1430 Expression
<Func
<uint?, byte?, bool>> e2
= (a
, b
) => a
< b
;
1431 AssertNodeType (e2
, ExpressionType
.LessThan
);
1432 Assert (false, e2
.Compile ().Invoke (null, 3));
1433 Assert (false, e2
.Compile ().Invoke (2, 2));
1436 void LessThanTest_3 ()
1438 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
< b
;
1439 AssertNodeType (e3
, ExpressionType
.LessThan
);
1440 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1443 void LessThanTest_4 ()
1445 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
< b
;
1446 AssertNodeType (e4
, ExpressionType
.LessThan
);
1447 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1448 Assert (false, e4
.Compile ().Invoke (null, null));
1449 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1452 void LessThanTest_5 ()
1454 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
< b
;
1455 AssertNodeType (e5
, ExpressionType
.LessThan
);
1456 Assert (false, e5
.Compile ().Invoke (null, 33));
1457 Assert (false, e5
.Compile ().Invoke (null, 0));
1458 Assert (false, e5
.Compile ().Invoke (new MyType (120), 3));
1461 void LessThanTest_6 ()
1463 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
< null;
1464 AssertNodeType (e6
, ExpressionType
.LessThan
);
1465 Assert (false, e6
.Compile ().Invoke (60));
1468 void LessThanTest_7 ()
1470 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
< b
;
1471 AssertNodeType (e7
, ExpressionType
.LessThan
);
1472 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1473 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1476 void LessThanTest_8 ()
1478 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
< b
;
1479 AssertNodeType (e8
, ExpressionType
.LessThan
);
1480 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1481 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1484 void LessThanOrEqualTest ()
1486 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
<= b
;
1487 AssertNodeType (e
, ExpressionType
.LessThanOrEqual
);
1488 Assert (false, e
.Compile ().Invoke (60, 30));
1491 void LessThanOrEqualTest_2 ()
1493 Expression
<Func
<byte?, byte?, bool>> e2
= (a
, b
) => a
<= b
;
1494 AssertNodeType (e2
, ExpressionType
.LessThanOrEqual
);
1495 Assert (false, e2
.Compile ().Invoke (null, 3));
1496 Assert (true, e2
.Compile ().Invoke (2, 2));
1499 void LessThanOrEqualTest_3 ()
1501 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
<= b
;
1502 AssertNodeType (e3
, ExpressionType
.LessThanOrEqual
);
1503 Assert (true, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1506 void LessThanOrEqualTest_4 ()
1508 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
<= b
;
1509 AssertNodeType (e4
, ExpressionType
.LessThanOrEqual
);
1510 Assert (false, e4
.Compile ().Invoke (null, new MyType (-20)));
1511 Assert (false, e4
.Compile ().Invoke (null, null));
1512 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (-20)));
1515 void LessThanOrEqualTest_5 ()
1517 Expression
<Func
<MyType
?, sbyte, bool>> e5
= (MyType
? a
, sbyte b
) => a
<= b
;
1518 AssertNodeType (e5
, ExpressionType
.LessThanOrEqual
);
1519 Assert (false, e5
.Compile ().Invoke (null, 33));
1520 Assert (false, e5
.Compile ().Invoke (null, 0));
1521 Assert (false, e5
.Compile ().Invoke (new MyType (120), 3));
1524 void LessThanOrEqualTest_6 ()
1526 Expression
<Func
<ushort, bool>> e6
= (ushort a
) => a
<= null;
1527 AssertNodeType (e6
, ExpressionType
.LessThanOrEqual
);
1528 Assert (false, e6
.Compile ().Invoke (60));
1531 void LessThanOrEqualTest_7 ()
1533 Expression
<Func
<MyEnum
, MyEnum
, bool>> e7
= (a
, b
) => a
<= b
;
1534 AssertNodeType (e7
, ExpressionType
.LessThanOrEqual
);
1535 Assert (false, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
1536 Assert (true, e7
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1539 void LessThanOrEqualTest_8 ()
1541 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e8
= (a
, b
) => a
<= b
;
1542 AssertNodeType (e8
, ExpressionType
.LessThanOrEqual
);
1543 Assert (false, e8
.Compile ().Invoke (MyEnum
.Value_1
, null));
1544 Assert (true, e8
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
1547 void ListInitTest ()
1549 Expression
<Func
<List
<object>>> e1
= () => new List
<object> { "Hello", "", null, "World", 5 }
;
1550 AssertNodeType (e1
, ExpressionType
.ListInit
);
1551 var re1
= e1
.Compile ().Invoke ();
1552 Assert (null, re1
[2]);
1553 Assert ("World", re1
[3]);
1554 Assert (5, re1
[4]);
1557 void ListInitTest_2 ()
1559 Expression
<Func
<int, Dictionary
<string, int>>> e2
= (int value) => new Dictionary
<string, int> (3) { { "A", value }
, { "B", 2 }
};
1560 AssertNodeType (e2
, ExpressionType
.ListInit
);
1561 var re2
= e2
.Compile ().Invoke (3456);
1562 Assert (3456, re2
["A"]);
1565 void MemberAccessTest ()
1567 MemberAccessData d
= new MemberAccessData ();
1569 Expression
<Func
<bool>> e
= () => d
.BoolValue
;
1570 AssertNodeType (e
, ExpressionType
.MemberAccess
);
1571 Assert (true, e
.Compile ().Invoke ());
1572 d
.BoolValue
= false;
1573 Assert (false, e
.Compile ().Invoke ());
1576 void MemberAccessTest_2 ()
1578 Expression
<Func
<decimal>> e2
= () => MemberAccessData
.DecimalValue
;
1579 AssertNodeType (e2
, ExpressionType
.MemberAccess
);
1580 Assert (decimal.MinValue
, e2
.Compile ().Invoke ());
1583 void MemberAccessTest_3 ()
1585 MemberAccessData d
= new MemberAccessData ();
1586 d
.VolatileValue
= 492;
1587 Expression
<Func
<uint>> e3
= () => d
.VolatileValue
;
1588 AssertNodeType (e3
, ExpressionType
.MemberAccess
);
1589 Assert
<uint> (492, e3
.Compile ().Invoke ());
1592 void MemberAccessTest_4 ()
1594 MemberAccessData d
= new MemberAccessData ();
1595 Expression
<Func
<string[]>> e4
= () => d
.StringValues
;
1596 AssertNodeType (e4
, ExpressionType
.MemberAccess
);
1597 Assert (null, e4
.Compile ().Invoke ());
1600 void MemberAccessTest_5 ()
1602 MemberAccessData d
= new MemberAccessData ();
1603 var e5
= d
.GetEvent ();
1604 AssertNodeType (e5
, ExpressionType
.MemberAccess
);
1605 Assert (null, e5
.Compile ().Invoke ());
1608 void MemberAccessTest_6 ()
1610 MemberAccessData d
= new MemberAccessData ();
1611 Expression
<Func
<MyType
>> e6
= () => d
.MyTypeProperty
;
1612 AssertNodeType (e6
, ExpressionType
.MemberAccess
);
1613 Assert (new MyType (), e6
.Compile ().Invoke ());
1616 void MemberAccessTest_7 ()
1618 MemberAccessData d
= new MemberAccessData ();
1619 Expression
<Func
<MyType
, short>> e7
= a
=> a
.ShortProp
;
1620 AssertNodeType (e7
, ExpressionType
.MemberAccess
);
1621 MyType mt
= new MyType ();
1623 Assert (124, e7
.Compile ().Invoke (mt
));
1626 void MemberAccessTest_8 ()
1628 Expression
<Func
<string>> e8
= () => MemberAccessData
.StaticProperty
;
1629 AssertNodeType (e8
, ExpressionType
.MemberAccess
);
1630 Assert ("alo", e8
.Compile ().Invoke ());
1633 void MemberAccessTest_9 ()
1635 string s
= "localvar";
1636 Expression
<Func
<string>> e9
= () => s
;
1637 AssertNodeType (e9
, ExpressionType
.MemberAccess
);
1638 Assert ("localvar", e9
.Compile ().Invoke ());
1641 void MemberInitTest ()
1643 Expression
<Func
<MemberAccessData
>> e
= () => new MemberAccessData
{
1644 VolatileValue
= 2, StringValues
= new string [] { "sv" }
, MyTypeProperty
= new MyType (692)
1646 AssertNodeType (e
, ExpressionType
.MemberInit
);
1647 var r1
= e
.Compile ().Invoke ();
1648 Assert
<uint> (2, r1
.VolatileValue
);
1649 Assert (new string[] { "sv" }
, r1
.StringValues
);
1650 Assert (new MyType (692), r1
.MyTypeProperty
);
1653 void MemberInitTest_2 ()
1655 Expression
<Func
<MemberAccessData
>> e2
= () => new MemberAccessData
{
1656 ListValues
= new List
<string> { "a", null }
1659 AssertNodeType (e2
, ExpressionType
.MemberInit
);
1660 var r2
= e2
.Compile ().Invoke ();
1661 Assert ("a", r2
.ListValues
[0]);
1664 void MemberInitTest_3 ()
1666 Expression
<Func
<short, MyType
>> e3
= a
=> new MyType { ShortProp = a }
;
1667 AssertNodeType (e3
, ExpressionType
.MemberInit
);
1668 var r3
= e3
.Compile ().Invoke (33);
1669 Assert (33, r3
.ShortProp
);
1672 void MemberInitTest_4 ()
1674 Expression
<Func
<int>> e
= () => new int { }
;
1676 AssertNodeType (e
, ExpressionType
.MemberInit
);
1677 var r
= e
.Compile ().Invoke ();
1683 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
% b
;
1684 AssertNodeType (e
, ExpressionType
.Modulo
);
1685 Assert (29, e
.Compile ().Invoke (60, 31));
1688 void ModuloTest_2 ()
1690 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
% b
;
1691 AssertNodeType (e2
, ExpressionType
.Modulo
);
1692 Assert (null, e2
.Compile ().Invoke (null, 3));
1693 Assert (1.1, e2
.Compile ().Invoke (3.1, 2));
1696 void ModuloTest_3 ()
1698 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
% b
;
1699 AssertNodeType (e3
, ExpressionType
.Modulo
);
1700 Assert (0, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1703 void ModuloTest_4 ()
1705 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
% b
;
1706 AssertNodeType (e4
, ExpressionType
.Modulo
);
1707 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1708 Assert (new MyType (12), e4
.Compile ().Invoke (new MyType (12), new MyType (-20)));
1711 void ModuloTest_5 ()
1713 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
% b
;
1714 AssertNodeType (e5
, ExpressionType
.Modulo
);
1715 Assert (1, e5
.Compile ().Invoke (99, new MyType (2)));
1718 void ModuloTest_6 ()
1720 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
% b
;
1721 AssertNodeType (e6
, ExpressionType
.Modulo
);
1722 Assert (100, e6
.Compile ().Invoke (100, new MyType (200)));
1723 Assert (null, e6
.Compile ().Invoke (20, null));
1726 void ModuloTest_7 ()
1728 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => a
% null;
1729 AssertNodeType (e7
, ExpressionType
.Modulo
);
1730 Assert (null, e7
.Compile ().Invoke (60));
1733 void MultiplyTest ()
1735 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
* b
;
1736 AssertNodeType (e
, ExpressionType
.Multiply
);
1737 Assert (1860, e
.Compile ().Invoke (60, 31));
1738 Assert (2147483617, e
.Compile ().Invoke (int.MaxValue
, 31));
1741 void MultiplyTest_2 ()
1743 Expression
<Func
<double?, double?, double?>> e2
= (a
, b
) => a
* b
;
1744 AssertNodeType (e2
, ExpressionType
.Multiply
);
1745 Assert (null, e2
.Compile ().Invoke (null, 3));
1746 Assert (6.2, e2
.Compile ().Invoke (3.1, 2));
1749 void MultiplyTest_3 ()
1751 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
* b
;
1752 AssertNodeType (e3
, ExpressionType
.Multiply
);
1753 Assert (400, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1756 void MultiplyTest_4 ()
1758 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
* b
;
1759 AssertNodeType (e4
, ExpressionType
.Multiply
);
1760 Assert (null, e4
.Compile ().Invoke (null, new MyType (-20)));
1761 Assert (new MyType (-240), e4
.Compile ().Invoke (new MyType (12), new MyType (-20)));
1764 void MultiplyTest_5 ()
1766 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
* b
;
1767 AssertNodeType (e5
, ExpressionType
.Multiply
);
1768 Assert (198, e5
.Compile ().Invoke (99, new MyType (2)));
1771 void MultiplyTest_6 ()
1773 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
* b
;
1774 AssertNodeType (e6
, ExpressionType
.Multiply
);
1775 Assert (0, e6
.Compile ().Invoke (int.MinValue
, new MyType (200)));
1776 Assert (null, e6
.Compile ().Invoke (20, null));
1779 void MultiplyTest_7 ()
1781 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => a
* null;
1782 AssertNodeType (e7
, ExpressionType
.Multiply
);
1783 Assert (null, e7
.Compile ().Invoke (60));
1786 void MultiplyCheckedTest ()
1789 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
* b
;
1790 AssertNodeType (e
, ExpressionType
.MultiplyChecked
);
1792 e
.Compile ().Invoke (int.MaxValue
, 309);
1793 throw new ApplicationException ("MultiplyCheckedTest #1");
1794 } catch (OverflowException
) { }
1798 void MultiplyCheckedTest_2 ()
1801 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a
* b
;
1802 AssertNodeType (e2
, ExpressionType
.MultiplyChecked
);
1803 Assert (null, e2
.Compile ().Invoke (null, 3));
1804 Assert (14025, e2
.Compile ().Invoke (byte.MaxValue
, 55));
1808 void MultiplyCheckedTest_3 ()
1811 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
* b
;
1812 AssertNodeType (e3
, ExpressionType
.Multiply
);
1813 Assert (-600, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
1817 void MultiplyCheckedTest_4 ()
1820 Expression
<Func
<double, double, double>> e4
= (a
, b
) => a
* b
;
1821 AssertNodeType (e4
, ExpressionType
.Multiply
);
1822 Assert (double.PositiveInfinity
, e4
.Compile ().Invoke (double.MaxValue
, int.MaxValue
));
1826 void MultiplyCheckedTest_5 ()
1829 Expression
<Func
<float?, float?, float?>> e5
= (a
, b
) => b
* a
;
1830 AssertNodeType (e5
, ExpressionType
.MultiplyChecked
);
1831 Assert (float.PositiveInfinity
, e5
.Compile ().Invoke (float.Epsilon
, float.PositiveInfinity
));
1837 Expression
<Func
<int, int>> e
= (a
) => -a
;
1838 AssertNodeType (e
, ExpressionType
.Negate
);
1839 Assert (30, e
.Compile ().Invoke (-30));
1842 void NegateTest_2 ()
1844 Expression
<Func
<sbyte, int>> e2
= (a
) => -(-a
);
1845 AssertNodeType (e2
, ExpressionType
.Negate
);
1846 Assert (-10, e2
.Compile ().Invoke (-10));
1849 void NegateTest_3 ()
1851 Expression
<Func
<long?, long?>> e3
= (a
) => -a
;
1852 AssertNodeType (e3
, ExpressionType
.Negate
);
1853 Assert (long.MinValue
+ 1, e3
.Compile ().Invoke (long.MaxValue
));
1854 Assert (null, e3
.Compile ().Invoke (null));
1857 void NegateTest_4 ()
1859 Expression
<Func
<MyType
, MyType
>> e4
= (a
) => -a
;
1860 AssertNodeType (e4
, ExpressionType
.Negate
);
1861 Assert (new MyType (14), e4
.Compile ().Invoke (new MyType (-14)));
1864 void NegateTest_5 ()
1866 Expression
<Func
<MyType
?, MyType
?>> e5
= (a
) => -a
;
1867 AssertNodeType (e5
, ExpressionType
.Negate
);
1868 Assert (new MyType (-33), e5
.Compile ().Invoke (new MyType (33)));
1869 Assert (null, e5
.Compile ().Invoke (null));
1872 void NegateTest_6 ()
1874 Expression
<Func
<MyTypeImplicitOnly
, int>> e6
= (MyTypeImplicitOnly a
) => -a
;
1875 AssertNodeType (e6
, ExpressionType
.Negate
);
1876 Assert (-4, e6
.Compile ().Invoke (new MyTypeImplicitOnly (4)));
1879 void NegateTest_7 ()
1881 Expression
<Func
<MyTypeImplicitOnly
?, int?>> e7
= (MyTypeImplicitOnly
? a
) => -a
;
1882 AssertNodeType (e7
, ExpressionType
.Negate
);
1883 Assert (-46, e7
.Compile ().Invoke (new MyTypeImplicitOnly (46)));
1885 // Another version of MS bug when predefined conversion is required on nullable user operator
1886 // Assert (null, e7.Compile ().Invoke (null));
1889 void NegateTest_8 ()
1891 Expression
<Func
<sbyte?, int?>> e8
= (a
) => -a
;
1892 AssertNodeType (e8
, ExpressionType
.Negate
);
1893 Assert (11, e8
.Compile ().Invoke (-11));
1896 void NegateTest_9 ()
1898 Expression
<Func
<uint, long>> e9
= (a
) => -a
;
1899 AssertNodeType (e9
, ExpressionType
.Negate
);
1900 Assert (-2, e9
.Compile ().Invoke (2));
1903 void NegateTestChecked ()
1906 Expression
<Func
<int, int>> e
= (int a
) => -a
;
1907 AssertNodeType (e
, ExpressionType
.NegateChecked
);
1909 e
.Compile ().Invoke (int.MinValue
);
1910 throw new ApplicationException ("NegateTestChecked #1");
1911 } catch (OverflowException
) { }
1915 void NegateTestChecked_2 ()
1918 Expression
<Func
<byte?, int?>> e2
= (a
) => -a
;
1919 AssertNodeType (e2
, ExpressionType
.NegateChecked
);
1920 Assert (null, e2
.Compile ().Invoke (null));
1921 Assert (-255, e2
.Compile ().Invoke (byte.MaxValue
));
1925 void NegateTestChecked_3 ()
1928 Expression
<Func
<MyType
, MyType
>> e3
= (MyType a
) => -a
;
1929 AssertNodeType (e3
, ExpressionType
.Negate
);
1930 Assert (20, e3
.Compile ().Invoke (new MyType (-20)));
1934 void NegateTestChecked_4 ()
1937 Expression
<Func
<double, double>> e4
= (a
) => -a
;
1938 AssertNodeType (e4
, ExpressionType
.Negate
);
1939 Assert (double.NegativeInfinity
, e4
.Compile ().Invoke (double.PositiveInfinity
));
1943 void NewArrayInitTest ()
1945 Expression
<Func
<int []>> e
= () => new int [0];
1946 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
1947 Assert (new int [0], e
.Compile ().Invoke ());
1950 void NewArrayInitTest_2 ()
1952 Expression
<Func
<int []>> e1
= () => new int [] { }
;
1953 AssertNodeType (e1
, ExpressionType
.NewArrayInit
);
1954 Assert (new int [0], e1
.Compile ().Invoke ());
1957 void NewArrayInitTest_3 ()
1959 Expression
<Func
<ushort, ulong? []>> e2
= (ushort a
) => new ulong? [] { a }
;
1960 AssertNodeType (e2
, ExpressionType
.NewArrayInit
);
1961 Assert (new ulong? [1] { ushort.MaxValue }
, e2
.Compile ().Invoke (ushort.MaxValue
));
1964 void NewArrayInitTest_4 ()
1966 Expression
<Func
<char [] []>> e3
= () => new char [] [] { new char [] { 'a' }
};
1967 AssertNodeType (e3
, ExpressionType
.NewArrayInit
);
1968 Assert (new char [] { 'a' }
, e3
.Compile ().Invoke () [0]);
1971 void NewArrayInitTest_5 ()
1973 Expression
<Func
<int?[]>> e
= () => new int?[] { null, 3, 4 }
;
1974 AssertNodeType (e
, ExpressionType
.NewArrayInit
);
1975 Assert (3, e
.Compile ().Invoke ().Length
);
1978 void NewArrayBoundsTest ()
1980 Expression
<Func
<int [,]>> e
= () => new int [2,3];
1981 AssertNodeType (e
, ExpressionType
.NewArrayBounds
);
1982 Assert (new int [2,3].Length
, e
.Compile ().Invoke ().Length
);
1985 void NewArrayBoundsTest_2 ()
1987 Expression
<Func
<int[,]>> e2
= () => new int [0,0];
1988 AssertNodeType (e2
, ExpressionType
.NewArrayBounds
);
1989 Assert (new int [0, 0].Length
, e2
.Compile ().Invoke ().Length
);
1994 Expression
<Func
<MyType
>> e
= () => new MyType (2);
1995 AssertNodeType (e
, ExpressionType
.New
);
1996 Assert (new MyType (2), e
.Compile ().Invoke ());
2001 Expression
<Func
<MyType
>> e2
= () => new MyType ();
2002 AssertNodeType (e2
, ExpressionType
.New
);
2003 Assert (new MyType (), e2
.Compile ().Invoke ());
2008 Expression
<Func
<NewTest
<bool>>> e3
= () => new NewTest
<bool> (true);
2009 AssertNodeType (e3
, ExpressionType
.New
);
2010 Assert (new NewTest
<bool> (true), e3
.Compile ().Invoke ());
2015 Expression
<Func
<decimal, NewTest
<decimal>>> e4
= (decimal d
) => new NewTest
<decimal> (1, 5, d
);
2016 AssertNodeType (e4
, ExpressionType
.New
);
2017 Assert (new NewTest
<decimal> (1, 5, -9), e4
.Compile ().Invoke (-9));
2022 Expression
<Func
<object>> e5
= () => new { A = 9, Value = "a" }
;
2023 AssertNodeType (e5
, ExpressionType
.New
);
2024 Assert (new { A = 9, Value = "a" }
, e5
.Compile ().Invoke ());
2027 // CSC bug: emits new MyEnum as a constant
2030 Expression
<Func
<MyEnum
>> e
= () => new MyEnum ();
2031 AssertNodeType (e
, ExpressionType
.New
);
2032 Assert
<MyEnum
> (0, e
.Compile ().Invoke ());
2037 Expression
<Func
<bool, bool>> e
= (bool a
) => !a
;
2038 AssertNodeType (e
, ExpressionType
.Not
);
2039 Assert (false, e
.Compile ().Invoke (true));
2044 Expression
<Func
<MyType
, bool>> e2
= (MyType a
) => !a
;
2045 AssertNodeType (e2
, ExpressionType
.Not
);
2046 Assert (true, e2
.Compile ().Invoke (new MyType (1)));
2047 Assert (false, e2
.Compile ().Invoke (new MyType (-1)));
2052 Expression
<Func
<int, int>> e3
= (int a
) => ~a
;
2053 AssertNodeType (e3
, ExpressionType
.Not
);
2054 Assert (-8, e3
.Compile ().Invoke (7));
2059 Expression
<Func
<MyType
, int>> e4
= (MyType a
) => ~a
;
2060 AssertNodeType (e4
, ExpressionType
.Not
);
2061 Assert (0, e4
.Compile ().Invoke (new MyType (-1)));
2066 Expression
<Func
<ulong, ulong>> e5
= (ulong a
) => ~a
;
2067 AssertNodeType (e5
, ExpressionType
.Not
);
2068 Assert
<ulong> (18446744073709551608, e5
.Compile ().Invoke (7));
2073 Expression
<Func
<MyEnum
, MyEnum
>> e6
= (MyEnum a
) => ~a
;
2074 AssertNodeType (e6
, ExpressionType
.Convert
);
2075 Assert ((MyEnum
)254, e6
.Compile ().Invoke (MyEnum
.Value_1
));
2078 void NotNullableTest ()
2080 Expression
<Func
<bool?, bool?>> e
= (bool? a
) => !a
;
2081 AssertNodeType (e
, ExpressionType
.Not
);
2082 Assert (false, e
.Compile ().Invoke (true));
2083 Assert (null, e
.Compile ().Invoke (null));
2086 void NotNullableTest_2 ()
2088 Expression
<Func
<MyType
?, bool?>> e2
= (MyType
? a
) => !a
;
2089 AssertNodeType (e2
, ExpressionType
.Not
);
2090 Assert (true, e2
.Compile ().Invoke (new MyType (1)));
2091 Assert (null, e2
.Compile ().Invoke (null));
2094 void NotNullableTest_3 ()
2096 Expression
<Func
<sbyte?, int?>> e3
= (sbyte? a
) => ~a
;
2097 AssertNodeType (e3
, ExpressionType
.Not
);
2098 Assert (-5, e3
.Compile ().Invoke (4));
2099 Assert (null, e3
.Compile ().Invoke (null));
2102 void NotNullableTest_4 ()
2104 Expression
<Func
<MyType
?, int?>> e4
= (MyType
? a
) => ~a
;
2105 AssertNodeType (e4
, ExpressionType
.Not
);
2106 Assert (0, e4
.Compile ().Invoke (new MyType (-1)));
2107 Assert (null, e4
.Compile ().Invoke (null));
2110 void NotNullableTest_5 ()
2112 Expression
<Func
<MyEnum
?, MyEnum
?>> e5
= (MyEnum
? a
) => ~a
;
2113 AssertNodeType (e5
, ExpressionType
.Convert
);
2114 Assert ((MyEnum
) 254, e5
.Compile ().Invoke (MyEnum
.Value_1
));
2115 Assert (null, e5
.Compile ().Invoke (null));
2118 void NotEqualTest ()
2120 Expression
<Func
<int, int, bool>> e
= (int a
, int b
) => a
!= b
;
2121 AssertNodeType (e
, ExpressionType
.NotEqual
);
2122 Assert (true, e
.Compile ().Invoke (60, 30));
2123 Assert (false, e
.Compile ().Invoke (-1, -1));
2126 void NotEqualTest_2 ()
2128 Expression
<Func
<sbyte?, sbyte?, bool>> e2
= (a
, b
) => a
!= b
;
2129 AssertNodeType (e2
, ExpressionType
.NotEqual
);
2130 Assert (false, e2
.Compile ().Invoke (3, 3));
2131 Assert (true, e2
.Compile ().Invoke (3, 2));
2134 void NotEqualTest_3 ()
2136 Expression
<Func
<MyType
, MyType
, bool>> e3
= (MyType a
, MyType b
) => a
!= b
;
2137 AssertNodeType (e3
, ExpressionType
.NotEqual
);
2138 Assert (false, e3
.Compile ().Invoke (new MyType (-20), new MyType (-20)));
2141 void NotEqualTest_4 ()
2143 Expression
<Func
<MyType
?, MyType
?, bool>> e4
= (MyType
? a
, MyType
? b
) => a
!= b
;
2144 AssertNodeType (e4
, ExpressionType
.NotEqual
);
2145 Assert (true, e4
.Compile ().Invoke (null, new MyType (-20)));
2146 Assert (false, e4
.Compile ().Invoke (null, null));
2147 Assert (false, e4
.Compile ().Invoke (new MyType (120), new MyType (120)));
2150 void NotEqualTest_5 ()
2152 Expression
<Func
<bool?, bool?, bool>> e5
= (bool? a
, bool? b
) => a
!= b
;
2153 AssertNodeType (e5
, ExpressionType
.NotEqual
);
2154 Assert (true, e5
.Compile ().Invoke (true, null));
2155 Assert (false, e5
.Compile ().Invoke (null, null));
2156 Assert (false, e5
.Compile ().Invoke (false, false));
2159 void NotEqualTest_6 ()
2161 Expression
<Func
<bool, bool>> e6
= (bool a
) => a
!= null;
2162 AssertNodeType (e6
, ExpressionType
.NotEqual
);
2163 Assert (true, e6
.Compile ().Invoke (true));
2164 Assert (true, e6
.Compile ().Invoke (false));
2167 void NotEqualTest_7 ()
2169 Expression
<Func
<string, string, bool>> e7
= (string a
, string b
) => a
!= b
;
2170 AssertNodeType (e7
, ExpressionType
.NotEqual
);
2171 Assert (false, e7
.Compile ().Invoke (null, null));
2172 Assert (true, e7
.Compile ().Invoke ("a", "A"));
2173 Assert (false, e7
.Compile ().Invoke ("a", "a"));
2176 void NotEqualTest_8 ()
2178 Expression
<Func
<object, bool>> e8
= (object a
) => null != a
;
2179 AssertNodeType (e8
, ExpressionType
.NotEqual
);
2180 Assert (false, e8
.Compile ().Invoke (null));
2181 Assert (true, e8
.Compile ().Invoke ("a"));
2182 Assert (true, e8
.Compile ().Invoke (this));
2185 void NotEqualTest_9 ()
2187 Expression
<Func
<MyEnum
, MyEnum
, bool>> e9
= (a
, b
) => a
!= b
;
2188 AssertNodeType (e9
, ExpressionType
.NotEqual
);
2189 Assert (true, e9
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2190 Assert (false, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2193 void NotEqualTest_10 ()
2195 Expression
<Func
<MyEnum
?, MyEnum
?, bool>> e10
= (a
, b
) => a
!= b
;
2196 AssertNodeType (e10
, ExpressionType
.NotEqual
);
2197 Assert (true, e10
.Compile ().Invoke (MyEnum
.Value_1
, null));
2198 Assert (false, e10
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2201 void NotEqualTest_11 ()
2203 Expression
<Func
<MyEnum
?, bool>> e11
= (a
) => a
!= null;
2204 AssertNodeType (e11
, ExpressionType
.NotEqual
);
2205 Assert (true, e11
.Compile ().Invoke (MyEnum
.Value_1
));
2206 Assert (false, e11
.Compile ().Invoke (null));
2211 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
| b
;
2213 AssertNodeType (e
, ExpressionType
.Or
);
2214 Func
<bool, bool, bool> c
= e
.Compile ();
2216 Assert (true, c (true, true));
2217 Assert (true, c (true, false));
2218 Assert (true, c (false, true));
2219 Assert (false, c (false, false));
2224 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
| b
;
2225 AssertNodeType (e2
, ExpressionType
.Or
);
2226 var c2
= e2
.Compile ();
2227 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2232 Expression
<Func
<MyEnum
, MyEnum
, MyEnum
>> e3
= (a
, b
) => a
| b
;
2233 AssertNodeType (e3
, ExpressionType
.Convert
);
2234 Assert ((MyEnum
)3, e3
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2235 Assert (MyEnum
.Value_2
, e3
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_2
));
2238 void OrNullableTest ()
2240 Expression
<Func
<bool?, bool?, bool?>> e
= (bool? a
, bool? b
) => a
| b
;
2242 AssertNodeType (e
, ExpressionType
.Or
);
2243 Func
<bool?, bool?, bool?> c
= e
.Compile ();
2245 Assert (true, c (true, true));
2246 Assert (true, c (true, false));
2247 Assert (true, c (false, true));
2248 Assert (false, c (false, false));
2250 Assert (true, c (true, null));
2251 Assert (null, c (false, null));
2252 Assert (null, c (null, false));
2253 Assert (true, c (true, null));
2254 Assert (null, c (null, null));
2257 void OrNullableTest_2 ()
2259 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e2
= (MyType
? a
, MyType
? b
) => a
| b
;
2260 AssertNodeType (e2
, ExpressionType
.Or
);
2261 var c2
= e2
.Compile ();
2262 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2263 Assert (null, c2 (new MyType (1), null));
2267 void OrNullableTest_3 ()
2269 Expression
<Func
<MyType
?, uint, long?>> e3
= (MyType
? a
, uint b
) => a
| b
;
2270 AssertNodeType (e3
, ExpressionType
.Or
);
2271 var c3
= e3
.Compile ();
2272 Assert (9, c3 (new MyType (1), 8));
2275 void OrNullableTest_4 ()
2277 Expression
<Func
<MyEnum
?, MyEnum
?, MyEnum
?>> e4
= (a
, b
) => a
| b
;
2278 AssertNodeType (e4
, ExpressionType
.Convert
);
2279 Assert (null, e4
.Compile ().Invoke (null, MyEnum
.Value_2
));
2280 Assert ((MyEnum
)3, e4
.Compile ().Invoke (MyEnum
.Value_1
, MyEnum
.Value_2
));
2285 Expression
<Func
<bool, bool, bool>> e
= (bool a
, bool b
) => a
|| b
;
2286 AssertNodeType (e
, ExpressionType
.OrElse
);
2287 Assert (true, e
.Compile ().Invoke (true, false));
2290 void OrElseTest_2 ()
2292 Expression
<Func
<MyType
, MyType
, MyType
>> e2
= (MyType a
, MyType b
) => a
|| b
;
2293 AssertNodeType (e2
, ExpressionType
.OrElse
);
2294 Assert (new MyType (64), e2
.Compile ().Invoke (new MyType (64), new MyType (64)));
2295 Assert (new MyType (32), e2
.Compile ().Invoke (new MyType (32), new MyType (64)));
2298 void ParameterTest ()
2300 Expression
<Func
<string, string>> e
= (string a
) => a
;
2301 AssertNodeType (e
, ExpressionType
.Parameter
);
2302 Assert ("t", e
.Compile ().Invoke ("t"));
2305 void ParameterTest_2 ()
2307 Expression
<Func
<object[], object[]>> e2
= (object[] a
) => a
;
2308 AssertNodeType (e2
, ExpressionType
.Parameter
);
2309 Assert (new object [0], e2
.Compile ().Invoke (new object [0]));
2312 void ParameterTest_3 ()
2314 Expression
<Func
<IntPtr
, IntPtr
>> e3
= a
=> a
;
2315 AssertNodeType (e3
, ExpressionType
.Parameter
);
2316 Assert (IntPtr
.Zero
, e3
.Compile ().Invoke (IntPtr
.Zero
));
2319 unsafe void ParameterTest_4 ()
2321 Expression
<Func
<int*[], int* []>> e4
= (a
) => a
;
2322 AssertNodeType (e4
, ExpressionType
.Parameter
);
2323 Assert
<int*[]> (null, e4
.Compile ().Invoke (null));
2324 int* e4_el
= stackalloc int [5];
2325 int*[] ptr
= new int*[] { e4_el }
;
2326 Assert
<int*[]> (ptr
, e4
.Compile ().Invoke (ptr
));
2331 Expression
<Func
<Expression
<Func
<int>>>> e
= () => () => 2;
2332 AssertNodeType (e
, ExpressionType
.Quote
);
2333 Assert (2, e
.Compile ().Invoke ().Compile ().Invoke ());
2336 void RightShiftTest ()
2338 Expression
<Func
<ulong, short, ulong>> e
= (ulong a
, short b
) => a
>> b
;
2339 AssertNodeType (e
, ExpressionType
.RightShift
);
2340 Assert ((ulong) 0x1FD940L
, e
.Compile ().Invoke (0xFECA0000, 11));
2341 Assert ((ulong) 0x7FFFFFFF, e
.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2343 // .net produces a strange result
2344 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
2345 // Assert ((ulong)0, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2348 void RightShiftTest_2 ()
2350 Expression
<Func
<MyType
, MyType
, int>> e2
= (MyType a
, MyType b
) => a
>> b
;
2351 AssertNodeType (e2
, ExpressionType
.RightShift
);
2352 var c2
= e2
.Compile ();
2353 Assert (64, c2 (new MyType (256), new MyType (2)));
2356 void RightShiftTest_3 ()
2358 Expression
<Func
<long?, sbyte, long?>> e3
= (long? a
, sbyte b
) => a
>> b
;
2359 AssertNodeType (e3
, ExpressionType
.RightShift
);
2360 Assert (null, e3
.Compile ().Invoke (null, 11));
2361 Assert (512, e3
.Compile ().Invoke (1024, 1));
2364 void RightShiftTest_4 ()
2366 Expression
<Func
<MyType
?, MyType
?, int?>> e4
= (MyType
? a
, MyType
? b
) => a
>> b
;
2367 AssertNodeType (e4
, ExpressionType
.RightShift
);
2368 var c4
= e4
.Compile ();
2369 Assert (null, c4 (new MyType (8), null));
2370 Assert (null, c4 (null, new MyType (8)));
2371 Assert (64, c4 (new MyType (256), new MyType (2)));
2374 void SubtractTest ()
2376 Expression
<Func
<int, int, int>> e
= (int a
, int b
) => a
- b
;
2377 AssertNodeType (e
, ExpressionType
.Subtract
);
2378 Assert (-10, e
.Compile ().Invoke (20, 30));
2381 void SubtractTest_2 ()
2383 Expression
<Func
<int?, int?, int?>> e2
= (a
, b
) => a
- b
;
2384 AssertNodeType (e2
, ExpressionType
.Subtract
);
2385 Assert (null, e2
.Compile ().Invoke (null, 3));
2388 void SubtractTest_3 ()
2390 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
- b
;
2391 AssertNodeType (e3
, ExpressionType
.Subtract
);
2392 Assert (-50, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2395 void SubtractTest_4 ()
2397 Expression
<Func
<MyType
?, MyType
?, MyType
?>> e4
= (MyType
? a
, MyType
? b
) => a
- b
;
2398 AssertNodeType (e4
, ExpressionType
.Subtract
);
2399 Assert (new MyType (-50), e4
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2400 Assert (null, e4
.Compile ().Invoke (null, new MyType (30)));
2403 void SubtractTest_5 ()
2405 Expression
<Func
<int, MyType
, int>> e5
= (int a
, MyType b
) => a
- b
;
2406 AssertNodeType (e5
, ExpressionType
.Subtract
);
2407 Assert (-29, e5
.Compile ().Invoke (1, new MyType (30)));
2410 void SubtractTest_6 ()
2412 Expression
<Func
<int, MyType
?, int?>> e6
= (int a
, MyType
? b
) => a
- b
;
2413 AssertNodeType (e6
, ExpressionType
.Subtract
);
2414 Assert (-61, e6
.Compile ().Invoke (-31, new MyType (30)));
2417 void SubtractTest_7 ()
2419 Expression
<Func
<ushort, int?>> e7
= (ushort a
) => null - a
;
2420 AssertNodeType (e7
, ExpressionType
.Subtract
);
2421 Assert (null, e7
.Compile ().Invoke (690));
2424 void SubtractTest_8 ()
2426 Expression
<Func
<MyEnum
, byte, MyEnum
>> e8
= (a
, b
) => a
- b
;
2427 AssertNodeType (e8
, ExpressionType
.Convert
);
2428 Assert ((MyEnum
)255, e8
.Compile ().Invoke (MyEnum
.Value_1
, 2));
2431 void SubtractTest_9 ()
2433 Expression
<Func
<MyEnum
, MyEnum
, byte>> e9
= (a
, b
) => a
- b
;
2434 AssertNodeType (e9
, ExpressionType
.Convert
);
2435 Assert (1, e9
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
2439 void SubtractTest_10 ()
2441 Expression
<Func
<MyEnum
?, byte?, MyEnum
?>> e10
= (a
, b
) => a
- b
;
2442 AssertNodeType (e10
, ExpressionType
.Convert
);
2443 Assert ((MyEnum
) 255, e10
.Compile ().Invoke (MyEnum
.Value_1
, 2));
2447 void SubtractTest_11 ()
2449 Expression
<Func
<MyEnum
?, MyEnum
?, byte?>> e11
= (a
, b
) => a
- b
;
2450 AssertNodeType (e11
, ExpressionType
.Convert
);
2451 Assert
<byte?> (1, e11
.Compile ().Invoke (MyEnum
.Value_2
, MyEnum
.Value_1
));
2454 void SubtractCheckedTest ()
2457 Expression
<Func
<long, long, long>> e
= (long a
, long b
) => a
- b
;
2458 AssertNodeType (e
, ExpressionType
.SubtractChecked
);
2460 e
.Compile ().Invoke (long.MinValue
, 309);
2461 throw new ApplicationException ("SubtractCheckedTest #1");
2462 } catch (OverflowException
) { }
2466 void SubtractCheckedTest_2 ()
2469 Expression
<Func
<byte?, byte?, int?>> e2
= (a
, b
) => a
- b
;
2470 AssertNodeType (e2
, ExpressionType
.SubtractChecked
);
2471 Assert (null, e2
.Compile ().Invoke (null, 3));
2472 Assert (-55, e2
.Compile ().Invoke (byte.MinValue
, 55));
2476 void SubtractCheckedTest_3 ()
2479 Expression
<Func
<MyType
, MyType
, MyType
>> e3
= (MyType a
, MyType b
) => a
- b
;
2480 AssertNodeType (e3
, ExpressionType
.Subtract
);
2481 Assert (-50, e3
.Compile ().Invoke (new MyType (-20), new MyType (30)));
2485 void SubtractCheckedTest_4 ()
2488 Expression
<Func
<double, double, double>> e4
= (a
, b
) => a
- b
;
2489 AssertNodeType (e4
, ExpressionType
.Subtract
);
2490 Assert (double.PositiveInfinity
, e4
.Compile ().Invoke (double.MinValue
, double.NegativeInfinity
));
2496 Expression
<Func
<object, Tester
>> e
= (object a
) => a
as Tester
;
2497 AssertNodeType (e
, ExpressionType
.TypeAs
);
2498 Assert (this, e
.Compile ().Invoke (this));
2501 void TypeAsTest_2 ()
2503 Expression
<Func
<object, int?>> e2
= (object a
) => a
as int?;
2504 AssertNodeType (e2
, ExpressionType
.TypeAs
);
2505 Assert (null, e2
.Compile ().Invoke (null));
2506 Assert (null, e2
.Compile ().Invoke (this));
2507 Assert (44, e2
.Compile ().Invoke (44));
2510 void TypeAsTest_3 ()
2512 Expression
<Func
<object, object>> e3
= (object a
) => null as object;
2513 AssertNodeType (e3
, ExpressionType
.TypeAs
);
2514 Assert (null, e3
.Compile ().Invoke (null));
2519 Expression
<Func
<object, bool>> e
= (object a
) => a
is Tester
;
2520 AssertNodeType (e
, ExpressionType
.TypeIs
);
2521 Assert (true, e
.Compile ().Invoke (this));
2522 Assert (false, e
.Compile ().Invoke (1));
2525 void TypeIsTest_2 ()
2527 Expression
<Func
<object, bool>> e2
= (object a
) => a
is int?;
2528 AssertNodeType (e2
, ExpressionType
.TypeIs
);
2529 Assert (false, e2
.Compile ().Invoke (null));
2530 Assert (true, e2
.Compile ().Invoke (1));
2533 void TypeIsTest_3 ()
2535 Expression
<Func
<object, bool>> e3
= (object a
) => null is object;
2536 AssertNodeType (e3
, ExpressionType
.TypeIs
);
2537 Assert (false, e3
.Compile ().Invoke (null));
2540 void TypeIsTest_5 ()
2542 Expression
<Func
<bool>> e5
= () => 1 is int;
2543 AssertNodeType (e5
, ExpressionType
.TypeIs
);
2544 Assert (true, e5
.Compile ().Invoke ());
2547 void TypeIsTest_6 ()
2549 Expression
<Func
<int?, bool>> e6
= (a
) => a
is int;
2550 AssertNodeType (e6
, ExpressionType
.TypeIs
);
2551 Assert (true, e6
.Compile ().Invoke (1));
2552 Assert (false, e6
.Compile ().Invoke (null));
2555 void UnaryPlusTest ()
2557 Expression
<Func
<int, int>> e
= (a
) => +a
;
2558 AssertNodeType (e
, ExpressionType
.Parameter
);
2559 Assert (-30, e
.Compile ().Invoke (-30));
2562 void UnaryPlusTest_2 ()
2564 Expression
<Func
<long?, long?>> e2
= (a
) => +a
;
2565 AssertNodeType (e2
, ExpressionType
.Parameter
);
2568 void UnaryPlusTest_3 ()
2570 Expression
<Func
<MyType
, MyType
>> e4
= (a
) => +a
;
2571 AssertNodeType (e4
, ExpressionType
.UnaryPlus
);
2572 Assert (new MyType (-14), e4
.Compile ().Invoke (new MyType (-14)));
2575 void UnaryPlusTest_4 ()
2577 Expression
<Func
<MyType
?, MyType
?>> e5
= (a
) => +a
;
2578 AssertNodeType (e5
, ExpressionType
.UnaryPlus
);
2579 Assert (new MyType (33), e5
.Compile ().Invoke (new MyType (33)));
2580 Assert (null, e5
.Compile ().Invoke (null));
2583 void UnaryPlusTest_5 ()
2585 Expression
<Func
<sbyte?, long?>> e6
= (a
) => +a
;
2586 AssertNodeType (e6
, ExpressionType
.Convert
);
2587 Assert (3, e6
.Compile ().Invoke (3));
2588 Assert (null, e6
.Compile ().Invoke (null));
2591 #pragma warning restore 169
2596 string InstanceMethod (string arg
)
2601 object InstanceParamsMethod (int index
, params object [] args
)
2605 if (args
.Length
== 0)
2607 return args
[index
];
2610 static int TestInt ()
2615 T GenericMethod
<T
> (T t
)
2620 static void RefMethod (ref int i
)
2625 static bool RunTest (MethodInfo test
)
2627 Console
.Write ("Running test {0, -25}", test
.Name
);
2629 test
.Invoke (new Tester (), null);
2630 Console
.WriteLine ("OK");
2632 } catch (Exception e
) {
2633 Console
.WriteLine ("FAILED");
2634 Console
.WriteLine (e
.ToString ());
2639 public static int Main ()
2641 var tests
= from test
in typeof (Tester
).GetMethods (BindingFlags
.Instance
| BindingFlags
.NonPublic
| BindingFlags
.DeclaredOnly
)
2642 where test
.GetParameters ().Length
== 0
2644 select RunTest (test
);
2646 int failures
= tests
.Count (a
=> !a
);
2647 Console
.WriteLine (failures
+ " tests failed");