/mcs/tests/gtest-etree-01.cs
C# | 2711 lines | 2283 code | 389 blank | 39 comment | 62 complexity | 450c281616aaa928b1015080e9858293 MD5 | raw file
Possible License(s): LGPL-2.0, MPL-2.0-no-copyleft-exception, CC-BY-SA-3.0, GPL-2.0, LGPL-2.1
Large files files are truncated, but you can click here to view the full file
- // Compiler options: -unsafe
- using System;
- using System.Collections.Generic;
- using System.Linq;
- using System.Linq.Expressions;
- using System.Reflection;
- public struct InverseLogicalOperator
- {
- bool value;
- public InverseLogicalOperator (bool value)
- {
- this.value = value;
- }
- public static bool operator true (InverseLogicalOperator u)
- {
- return u.value;
- }
- public static bool operator false (InverseLogicalOperator u)
- {
- return u.value;
- }
- }
- /* TODO: Add tests for every numeric expression where a type has only 1 implicit
- numeric conversion
- public struct MyType<T>
- {
- T value;
- public MyType (T value)
- {
- this.value = value;
- }
- public static implicit operator T (MyType<T> o)
- {
- return o.value;
- }
- }
- */
- // TODO: Create a clone which uses +(MyType, int) pattern and an implicit conversion
- // is required to do the user-conversion
- public struct MyType
- {
- int value;
-
- public MyType (int value) : this ()
- {
- this.value = value;
- }
-
- public short ShortProp { get; set; }
-
- public override int GetHashCode ()
- {
- throw new NotImplementedException ();
- }
- public static implicit operator int (MyType o)
- {
- return o.value;
- }
- public static bool operator true (MyType a)
- {
- return a.value == a;
- }
- public static bool operator false (MyType a)
- {
- return a.value != a;
- }
- public static MyType operator + (MyType a, MyType b)
- {
- return new MyType (a.value + b.value);
- }
- public static MyType operator - (MyType a, MyType b)
- {
- return new MyType (a.value - b.value);
- }
- public static MyType operator / (MyType a, MyType b)
- {
- return new MyType (a.value / b.value);
- }
- public static MyType operator * (MyType a, MyType b)
- {
- return new MyType (a.value * b.value);
- }
- public static MyType operator % (MyType a, MyType b)
- {
- return new MyType (a.value % b.value);
- }
- public static MyType operator &(MyType a, MyType b)
- {
- return new MyType (a.value & b.value);
- }
- public static MyType operator | (MyType a, MyType b)
- {
- return new MyType (a.value | b.value);
- }
- public static MyType operator ^ (MyType a, MyType b)
- {
- return new MyType (a.value ^ b.value);
- }
- public static bool operator == (MyType a, MyType b)
- {
- return a.value == b.value;
- }
- public static bool operator != (MyType a, MyType b)
- {
- return a.value != b.value;
- }
-
- public static bool operator > (MyType a, MyType b)
- {
- return a.value > b.value;
- }
- public static bool operator < (MyType a, MyType b)
- {
- return a.value < b.value;
- }
- public static bool operator >= (MyType a, MyType b)
- {
- return a.value >= b.value;
- }
-
- public static bool operator <= (MyType a, MyType b)
- {
- return a.value <= b.value;
- }
- public static bool operator ! (MyType a)
- {
- return a.value > 0;
- }
- public static int operator >> (MyType a, int b)
- {
- return a.value >> b;
- }
-
- public static int operator << (MyType a, int b)
- {
- return a.value << b;
- }
-
- public static MyType operator - (MyType a)
- {
- return new MyType (-a.value);
- }
-
- public static MyType operator + (MyType a)
- {
- return new MyType (+a.value);
- }
- public override string ToString ()
- {
- return value.ToString ();
- }
- }
- class MyTypeExplicit
- {
- int value;
-
- public MyTypeExplicit (int value)
- {
- this.value = value;
- }
-
- public static explicit operator int (MyTypeExplicit m)
- {
- return m.value;
- }
- }
- struct MyTypeImplicitOnly
- {
- short b;
- public MyTypeImplicitOnly (short b)
- {
- this.b = b;
- }
- public static implicit operator short (MyTypeImplicitOnly m)
- {
- return m.b;
- }
- }
- class MemberAccessData
- {
- public bool BoolValue;
- public static decimal DecimalValue = decimal.MinValue;
- public volatile uint VolatileValue;
- public string [] StringValues;
- public List<string> ListValues;
- event Func<bool> EventField;
- public Expression<Func<Func<bool>>> GetEvent ()
- {
- return () => EventField;
- }
-
- MyType mt;
- public MyType MyTypeProperty {
- set {
- mt = value;
- }
- get {
- return mt;
- }
- }
-
- public static string StaticProperty {
- get {
- return "alo";
- }
- }
- }
- enum MyEnum : byte
- {
- Value_1 = 1,
- Value_2 = 2
- }
- enum MyEnumUlong : ulong
- {
- Value_1 = 1
- }
- class NewTest<T>
- {
- T [] t;
- public NewTest (T i)
- {
- t = new T [] { i };
- }
- public NewTest (params T [] t)
- {
- this.t = t;
- }
- public override int GetHashCode ()
- {
- return base.GetHashCode ();
- }
- public override bool Equals (object obj)
- {
- NewTest<T> obj_t = obj as NewTest<T>;
- if (obj_t == null)
- return false;
- for (int i = 0; i < t.Length; ++i) {
- if (!t [i].Equals (obj_t.t [i]))
- return false;
- }
- return true;
- }
- }
- class Indexer
- {
- public int this [int i] { get { return i; } set { } }
- public string this [params string[] i] { get { return string.Concat (i); } }
- }
- // TODO: Add more nullable tests, follow AddTest pattern.
- class Tester
- {
- delegate void EmptyDelegate ();
- delegate int IntDelegate ();
- static void AssertNodeType (LambdaExpression e, ExpressionType et)
- {
- if (e.Body.NodeType != et)
- throw new ApplicationException (e.Body.NodeType + " != " + et);
- }
- static void Assert<T> (T expected, T value)
- {
- Assert (expected, value, null);
- }
- static void Assert<T> (T expected, T value, string name)
- {
- if (!EqualityComparer<T>.Default.Equals (expected, value)) {
- if (!string.IsNullOrEmpty (name))
- name += ": ";
- throw new ApplicationException (name + expected + " != " + value);
- }
- }
- static void Assert<T> (T [] expected, T [] value)
- {
- if (expected == null) {
- if (value != null)
- throw new ApplicationException ("Both arrays expected to be null");
- return;
- }
-
- if (expected.Length != value.Length)
- throw new ApplicationException ("Array length does not match " + expected.Length + " != " + value.Length);
- for (int i = 0; i < expected.Length; ++i) {
- if (!EqualityComparer<T>.Default.Equals (expected [i], value [i]))
- throw new ApplicationException ("Index " + i + ": " + expected [i] + " != " + value [i]);
- }
- }
- #pragma warning disable 169
- void AddTest ()
- {
- Expression<Func<int, int, int>> e = (int a, int b) => a + b;
- AssertNodeType (e, ExpressionType.Add);
- Assert (50, e.Compile ().Invoke (20, 30));
- }
-
- void AddTest_2 ()
- {
- Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
- AssertNodeType (e2, ExpressionType.Add);
- Assert (null, e2.Compile ().Invoke (null, 3));
- }
-
- void AddTest_3 ()
- {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
- AssertNodeType (e3, ExpressionType.Add);
- Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
- }
-
- void AddTest_4 ()
- {
- Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a + b;
- AssertNodeType (e4, ExpressionType.Add);
- Assert (new MyType (10), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
- Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
- }
-
- void AddTest_5 ()
- {
- Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a + b;
- AssertNodeType (e5, ExpressionType.Add);
- Assert (31, e5.Compile ().Invoke (1, new MyType (30)));
- }
-
- void AddTest_6 ()
- {
- Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a + b;
- AssertNodeType (e6, ExpressionType.Add);
- Assert (-1, e6.Compile ().Invoke (-31, new MyType (30)));
- }
-
- void AddTest_7 ()
- {
- Expression<Func<MyEnum, byte, MyEnum>> e7 = (a, b) => a + b;
- AssertNodeType (e7, ExpressionType.Convert);
- Assert (MyEnum.Value_2, e7.Compile ().Invoke (MyEnum.Value_1, 1));
- }
-
- void AddTest_8 ()
- {
- // CSC BUG: probably due to missing numeric promotion
- Expression<Func<MyEnum?, byte?, MyEnum?>> e8 = (a, b) => a + b;
- AssertNodeType (e8, ExpressionType.Convert);
- Assert<MyEnum?> (0, e8.Compile ().Invoke (MyEnum.Value_1, 255));
- Assert (null, e8.Compile ().Invoke (MyEnum.Value_1, null));
- Assert (null, e8.Compile ().Invoke (null, null));
- }
-
- void AddTest_9 ()
- {
- Expression<Func<byte, MyEnum, MyEnum>> e9 = (a, b) => a + b;
- AssertNodeType (e9, ExpressionType.Convert);
- Assert (MyEnum.Value_2, e9.Compile ().Invoke (1, MyEnum.Value_1));
- }
- void AddCheckedTest ()
- {
- checked {
- Expression<Func<int, int, int>> e = (int a, int b) => a + b;
- AssertNodeType (e, ExpressionType.AddChecked);
- Assert (50, e.Compile ().Invoke (20, 30));
- }
- }
-
- void AddCheckedTest_2 ()
- {
- checked {
- Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
- AssertNodeType (e2, ExpressionType.AddChecked);
- Assert (null, e2.Compile ().Invoke (null, 3));
- }
- }
-
- void AddCheckedTest_3 ()
- {
- checked {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
- AssertNodeType (e3, ExpressionType.Add);
- Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
- }
- }
-
- void AddStringTest ()
- {
- Expression<Func<string, string>> e6 = (a) => 1 + a;
- AssertNodeType (e6, ExpressionType.Add);
- Assert ("1to", e6.Compile ().Invoke ("to"));
- }
-
- void AddStringTest_2 ()
- {
- Expression<Func<object, string, string>> e7 = (object a, string b) => a + b;
- AssertNodeType (e7, ExpressionType.Add);
- Assert ("testme", e7.Compile ().Invoke ("test", "me"));
- Assert ("test", e7.Compile ().Invoke ("test", null));
- Assert ("", e7.Compile ().Invoke (null, null));
- }
-
- void AddStringTest_3 ()
- {
- Expression<Func<string, int, string>> e8 = (a, b) => a + " " + "-" + "> " + b;
- AssertNodeType (e8, ExpressionType.Add);
- Assert ("test -> 2", e8.Compile ().Invoke ("test", 2));
- }
-
- void AddStringTest_4 ()
- {
- Expression<Func<string, ushort?, string>> e9 = (a, b) => a + b;
- AssertNodeType (e9, ExpressionType.Add);
- Assert ("test2", e9.Compile ().Invoke ("test", 2));
- Assert ("test", e9.Compile ().Invoke ("test", null));
- }
- void AndTest ()
- {
- Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a & b;
- AssertNodeType (e, ExpressionType.And);
- Func<bool, bool, bool> c = e.Compile ();
- Assert (true, c (true, true));
- Assert (false, c (true, false));
- Assert (false, c (false, true));
- Assert (false, c (false, false));
- }
-
- void AndTest_2 ()
- {
- Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a & b;
- AssertNodeType (e2, ExpressionType.And);
- var c2 = e2.Compile ();
- Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
- Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
- }
-
- void AndTest_3 ()
- {
- Expression<Func<MyEnum, MyEnum, MyEnum>> e3 = (a, b) => a & b;
- AssertNodeType (e3, ExpressionType.Convert);
- Assert<MyEnum> (0, e3.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
- Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
-
- void AndTest_4 ()
- {
- Expression<Func<int, int>> e = (a) => a & 0;
- AssertNodeType (e, ExpressionType.And);
- var c = e.Compile ();
-
- Assert (0, c (1));
- }
- void AndNullableTest ()
- {
- Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a & b;
- AssertNodeType (e, ExpressionType.And);
- Func<bool?, bool?, bool?> c = e.Compile ();
- Assert (true, c (true, true));
- Assert (false, c (true, false));
- Assert (false, c (false, true));
- Assert (false, c (false, false));
- Assert (null, c (true, null));
- Assert (false, c (false, null));
- Assert (false, c (null, false));
- Assert (null, c (true, null));
- Assert (null, c (null, null));
- }
-
- void AndNullableTest_2 ()
- {
- Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a & b;
- AssertNodeType (e2, ExpressionType.And);
- var c2 = e2.Compile ();
- Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
- Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
- Assert (null, c2 (new MyType (0xFF), null));
- }
-
- void AndNullableTest_3 ()
- {
- Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e3 = (a, b) => a & b;
- AssertNodeType (e3, ExpressionType.Convert);
- Assert (null, e3.Compile ().Invoke (null, MyEnum.Value_2));
- Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void AndAlsoTest ()
- {
- Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a && b;
- AssertNodeType (e, ExpressionType.AndAlso);
- Assert (false, e.Compile ().Invoke (true, false));
- }
- void AndAlsoTest_2 ()
- {
- Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a && b;
- AssertNodeType (e2, ExpressionType.AndAlso);
- Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
- Assert (new MyType (0), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
- }
- void AndAlsoTest_3 ()
- {
- Expression<Func<bool, bool>> e3 = (bool a) => a && true;
- AssertNodeType (e3, ExpressionType.AndAlso);
- Assert (false, e3.Compile ().Invoke (false));
- Assert (true, e3.Compile ().Invoke (true));
- }
- void ArrayIndexTest ()
- {
- Expression<Func<string [], long, string>> e = (string [] a, long i) => a [i];
- AssertNodeType (e, ExpressionType.ArrayIndex);
- Assert ("b", e.Compile ().Invoke (new string [] { "a", "b", "c" }, 1));
- }
- void ArrayIndexTest_2 ()
- {
- Expression<Func<string [], string>> e2 = (string [] a) => a [0];
- AssertNodeType (e2, ExpressionType.ArrayIndex);
- Assert ("a", e2.Compile ().Invoke (new string [] { "a", "b" }));
- }
- void ArrayIndexTest_3 ()
- {
- Expression<Func<object [,], int, int, object>> e3 = (object [,] a, int i, int j) => a [i, j];
- AssertNodeType (e3, ExpressionType.Call);
- Assert ("z", e3.Compile ().Invoke (
- new object [,] { { 1, 2 }, { "x", "z" } }, 1, 1));
- }
- void ArrayIndexTest_4 ()
- {
- Expression<Func<decimal [] [], byte, decimal>> e4 = (decimal [] [] a, byte b) => a [b] [1];
- AssertNodeType (e4, ExpressionType.ArrayIndex);
- decimal [] [] array = { new decimal [] { 1, 9 }, new decimal [] { 10, 90 } };
- Assert (90, e4.Compile ().Invoke (array, 1));
- }
- void ArrayIndexTest_5 ()
- {
- Expression<Func<int>> e5 = () => (new int [1]) [0];
- AssertNodeType (e5, ExpressionType.ArrayIndex);
- Assert (0, e5.Compile ().Invoke ());
- }
-
- void ArrayIndexTest_6 ()
- {
- const ulong max = 3;
-
- Expression<Func<int[], int>> e = a => a [max];
- AssertNodeType (e, ExpressionType.ArrayIndex);
- Assert (4, e.Compile ().Invoke (new int [] { 1, 2, 3, 4, 5 }));
- }
-
- void ArrayIndexTest_7 ()
- {
- const ulong max = uint.MaxValue;
-
- Expression<Func<int[], int>> e = a => a [max];
- AssertNodeType (e, ExpressionType.ArrayIndex);
-
- try {
- e.Compile ().Invoke (new int [0]);
- throw new ApplicationException ("ArrayIndexTest_7");
- } catch (System.OverflowException) {
- // Check whether CheckedConversion was generated
- }
- }
- void ArrayLengthTest ()
- {
- Expression<Func<double [], int>> e = (double [] a) => a.Length;
- AssertNodeType (e, ExpressionType.ArrayLength);
- Assert (0, e.Compile ().Invoke (new double [0]));
- Assert (9, e.Compile ().Invoke (new double [9]));
- }
- void ArrayLengthTest_2 ()
- {
- Expression<Func<string [,], int>> e2 = (string [,] a) => a.Length;
- AssertNodeType (e2, ExpressionType.MemberAccess);
- Assert (0, e2.Compile ().Invoke (new string [0, 0]));
- }
- void CallTest ()
- {
- Expression<Func<int, int>> e = (int a) => Math.Max (a, 5);
- AssertNodeType (e, ExpressionType.Call);
- Assert (5, e.Compile ().Invoke (2));
- Assert (9, e.Compile ().Invoke (9));
- }
- void CallTest_2 ()
- {
- Expression<Func<string, string>> e2 = (string a) => InstanceMethod (a);
- AssertNodeType (e2, ExpressionType.Call);
- Assert ("abc", e2.Compile ().Invoke ("abc"));
- }
- void CallTest_3 ()
- {
- Expression<Func<int, string, int, object>> e3 = (int index, string a, int b) => InstanceParamsMethod (index, a, b);
- AssertNodeType (e3, ExpressionType.Call);
- Assert<object> (4, e3.Compile ().Invoke (1, "a", 4));
- }
- void CallTest_4 ()
- {
- Expression<Func<object>> e4 = () => InstanceParamsMethod (0);
- AssertNodeType (e4, ExpressionType.Call);
- Assert<object> ("<empty>", e4.Compile ().Invoke ());
- }
- void CallTest_5 ()
- {
- Expression<Func<int, int>> e5 = (int a) => GenericMethod (a);
- AssertNodeType (e5, ExpressionType.Call);
- Assert (5, e5.Compile ().Invoke (5));
- }
- void CallTest_6 ()
- {
- Expression<Action> e6 = () => Console.WriteLine ("call test");
- AssertNodeType (e6, ExpressionType.Call);
- }
- void CallTest_7 ()
- {
- Expression<Func<Indexer, int, int>> e7 = (a, b) => a [b];
- AssertNodeType (e7, ExpressionType.Call);
- Assert (3, e7.Compile ().Invoke (new Indexer (), 3));
- }
- void CallTest_8 ()
- {
- Expression<Func<Indexer, string, string, string, string>> e8 = (a, b, c , d) => a [b, c, d];
- AssertNodeType (e8, ExpressionType.Call);
- Assert ("zyb", e8.Compile ().Invoke (new Indexer (), "z", "y", "b"));
- }
- void CallTest_9 ()
- {
- Expression<Action<int>> e9 = (a) => RefMethod (ref a);
- AssertNodeType (e9, ExpressionType.Call);
- e9.Compile ().Invoke (1);
- }
- void CoalesceTest ()
- {
- Expression<Func<uint?, uint>> e = (uint? a) => a ?? 99;
- AssertNodeType (e, ExpressionType.Coalesce);
- var r = e.Compile ();
- Assert ((uint) 5, r.Invoke (5));
- Assert ((uint) 99, r.Invoke (null));
- }
- void CoalesceTest_2 ()
- {
- Expression<Func<MyType?, int>> e2 = (MyType? a) => a ?? -3;
- AssertNodeType (e2, ExpressionType.Coalesce);
- var r2 = e2.Compile ();
- Assert (2, r2.Invoke (new MyType (2)));
- Assert (-3, r2.Invoke (null));
- }
- void ConditionTest ()
- {
- Expression<Func<bool, byte, int, int>> e = (bool a, byte b, int c) => (a ? b : c);
- AssertNodeType (e, ExpressionType.Conditional);
- var r = e.Compile ();
- Assert (3, r.Invoke (true, 3, 999999));
- Assert (999999, r.Invoke (false, 3, 999999));
- }
- void ConditionTest_2 ()
- {
- Expression<Func<int, decimal, decimal?>> e2 = (int a, decimal d) => (a > 0 ? d : a < 0 ? -d : (decimal?) null);
- AssertNodeType (e2, ExpressionType.Conditional);
- var r2 = e2.Compile ();
- Assert (null, r2.Invoke (0, 10));
- Assert (50, r2.Invoke (1, 50));
- Assert (30, r2.Invoke (-7, -30));
- }
- void ConditionTest_3 ()
- {
- Expression<Func<bool?, int?>> e3 = (bool? a) => ((bool) a ? 3 : -2);
- AssertNodeType (e3, ExpressionType.Convert);
- var r3 = e3.Compile ();
- Assert (3, r3.Invoke (true));
- Assert (-2, r3.Invoke (false));
- }
- void ConditionTest_4 ()
- {
- Expression<Func<InverseLogicalOperator, byte, byte, byte>> e4 = (InverseLogicalOperator a, byte b, byte c) => (a ? b : c);
- AssertNodeType (e4, ExpressionType.Conditional);
- var r4 = e4.Compile ();
- Assert (3, r4.Invoke (new InverseLogicalOperator (true), 3, 4));
- Assert (4, r4.Invoke (new InverseLogicalOperator (false), 3, 4));
- }
-
- void ConditionTest_5 ()
- {
- // CSC bug ?
- Expression<Func<int>> e = () => false ? 1 : 4;
- AssertNodeType (e, ExpressionType.Conditional);
- var r = e.Compile ();
- Assert (4, r.Invoke ());
- }
-
- void ConstantTest ()
- {
- Expression<Func<int>> e1 = () => default (int);
- AssertNodeType (e1, ExpressionType.Constant);
- Assert (0, e1.Compile ().Invoke ());
- }
-
- void ConstantTest_2 ()
- {
- Expression<Func<int?>> e2 = () => default (int?);
- AssertNodeType (e2, ExpressionType.Constant);
- Assert (null, e2.Compile ().Invoke ());
- }
- void ConstantTest_3 ()
- {
- Expression<Func<Tester>> e3 = () => default (Tester);
- AssertNodeType (e3, ExpressionType.Constant);
- Assert (null, e3.Compile ().Invoke ());
- }
-
- void ConstantTest_4 ()
- {
- Expression<Func<object>> e4 = () => null;
- AssertNodeType (e4, ExpressionType.Constant);
- Assert (null, e4.Compile ().Invoke ());
- }
-
- void ConstantTest_5 ()
- {
- Expression<Func<int>> e5 = () => 8 / 4;
- AssertNodeType (e5, ExpressionType.Constant);
- Assert (2, e5.Compile ().Invoke ());
- }
-
- void ConstantTest_6 ()
- {
- Expression<Func<int>> e6 = () => 0xFFFFFF >> 0x40;
- AssertNodeType (e6, ExpressionType.Constant);
- Assert (0xFFFFFF, e6.Compile ().Invoke ());
- }
-
- void ConstantTest_7 ()
- {
- Expression<Func<object>> e7 = () => "Alleluia";
- AssertNodeType (e7, ExpressionType.Constant);
- Assert ("Alleluia", e7.Compile ().Invoke ());
- }
-
- void ConstantTest_8 ()
- {
- Expression<Func<Type>> e8 = () => typeof (int);
- AssertNodeType (e8, ExpressionType.Constant);
- Assert (typeof (int), e8.Compile ().Invoke ());
- }
-
- void ConstantTest_9 ()
- {
- Expression<Func<Type>> e9 = () => typeof (void);
- AssertNodeType (e9, ExpressionType.Constant);
- Assert (typeof (void), e9.Compile ().Invoke ());
- }
-
- void ConstantTest_10 ()
- {
- Expression<Func<Type>> e10 = () => typeof (Func<,>);
- AssertNodeType (e10, ExpressionType.Constant);
- Assert (typeof (Func<,>), e10.Compile ().Invoke ());
- }
-
- void ConstantTest_11 ()
- {
- Expression<Func<MyEnum>> e11 = () => MyEnum.Value_2;
- AssertNodeType (e11, ExpressionType.Constant);
- Assert (MyEnum.Value_2, e11.Compile ().Invoke ());
- }
-
- void ConstantTest_13 ()
- {
- Expression<Func<int>> e13 = () => sizeof (byte);
- AssertNodeType (e13, ExpressionType.Constant);
- Assert (1, e13.Compile ().Invoke ());
-
- }
-
- unsafe void ConstantTest_14 ()
- {
- Expression<Func<Type>> e14 = () => typeof (bool*);
- AssertNodeType (e14, ExpressionType.Constant);
- Assert (typeof (bool*), e14.Compile ().Invoke ());
- }
-
- void ConstantTest_15 ()
- {
- Expression<Func<int?>> e15 = () => null;
- AssertNodeType (e15, ExpressionType.Constant);
- Assert (null, e15.Compile ().Invoke ());
- }
- void ConvertTest ()
- {
- Expression<Func<int, byte>> e = (int a) => ((byte) a);
- AssertNodeType (e, ExpressionType.Convert);
- Assert (100, e.Compile ().Invoke (100));
- }
- void ConvertTest_2 ()
- {
- Expression<Func<long, ushort>> e2 = (long a) => ((ushort) a);
- AssertNodeType (e2, ExpressionType.Convert);
- Assert (100, e2.Compile ().Invoke (100));
- }
- void ConvertTest_3 ()
- {
- Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
- AssertNodeType (e3, ExpressionType.Convert);
- Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
- }
- void ConvertTest_4 ()
- {
- Expression<Func<MyType, int>> e4 = (MyType a) => (a);
- AssertNodeType (e4, ExpressionType.Convert);
- Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
- }
- void ConvertTest_5 ()
- {
- Expression<Func<MyType, MyType, bool?>> e5 = (MyType a, MyType b) => a == b;
- AssertNodeType (e5, ExpressionType.Convert);
- }
- void ConvertTest_6 ()
- {
- Expression<Func<MyType?, MyType?, bool?>> e6 = (MyType? a, MyType? b) => a == b;
- AssertNodeType (e6, ExpressionType.Convert);
- Assert (false, e6.Compile ().Invoke (null, new MyType (-20)));
- Assert (true, e6.Compile ().Invoke (null, null));
- Assert (true, e6.Compile ().Invoke (new MyType (120), new MyType (120)));
- }
- void ConvertTest_7 ()
- {
- Expression<Func<MyTypeExplicit, int?>> e7 = x => (int?)x;
- AssertNodeType (e7, ExpressionType.Convert);
- Assert (33, e7.Compile ().Invoke (new MyTypeExplicit (33)));
- }
- void ConvertTest_8 ()
- {
- Expression<Func<int?, object>> e8 = x => (object)x;
- AssertNodeType (e8, ExpressionType.Convert);
- Assert (null, e8.Compile ().Invoke (null));
- Assert (-100, e8.Compile ().Invoke (-100));
- }
- unsafe void ConvertTest_9 ()
- {
- int*[] p = new int* [1];
- Expression<Func<object>> e9 = () => (object)p;
- AssertNodeType (e9, ExpressionType.Convert);
- Assert (p, e9.Compile ().Invoke ());
- }
- void ConvertTest_10 ()
- {
- Expression<Func<Func<int>, Delegate>> e10 = (a) => a + a;
- AssertNodeType (e10, ExpressionType.Convert);
- Assert (null, e10.Compile ().Invoke (null));
- Assert (new Func<int> (TestInt) + new Func<int> (TestInt), e10.Compile ().Invoke (TestInt));
- }
- void ConvertTest_11 ()
- {
- Expression<Func<Func<int>, Delegate>> e11 = (a) => a - a;
- AssertNodeType (e11, ExpressionType.Convert);
- Assert (null, e11.Compile ().Invoke (null));
- }
- void ConvertTest_12 ()
- {
- Expression<Func<Func<int>>> e12 = () => TestInt;
- AssertNodeType (e12, ExpressionType.Convert);
- Assert (29, e12.Compile ().Invoke () ());
- }
- void ConvertTest_13 ()
- {
- Expression<Func<decimal, sbyte>> e13 = a => (sbyte)a;
- AssertNodeType (e13, ExpressionType.Convert);
- Assert (6, e13.Compile ().Invoke (6));
- }
- void ConvertTest_14 ()
- {
- Expression<Func<long, decimal>> e14 = a => a;
- AssertNodeType (e14, ExpressionType.Convert);
- Assert (-66, e14.Compile ().Invoke (-66));
- }
- void ConvertTest_15 ()
- {
- Expression<Func<ulong?, decimal?>> e15 = a => a;
- AssertNodeType (e15, ExpressionType.Convert);
- Assert (null, e15.Compile ().Invoke (null));
- Assert (9, e15.Compile ().Invoke (9));
- }
- void ConvertCheckedTest ()
- {
- Expression<Func<int, byte>> e = (int a) => checked((byte) a);
- AssertNodeType (e, ExpressionType.ConvertChecked);
- Assert (100, e.Compile ().Invoke (100));
- }
- void ConvertCheckedTest_2 ()
- {
- checked {
- Expression<Func<long, ushort>> e2 = (long a) => unchecked((ushort) a);
- AssertNodeType (e2, ExpressionType.Convert);
- Assert (100, e2.Compile ().Invoke (100));
- }
- }
- void ConvertCheckedTest_3 ()
- {
- checked {
- Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
- AssertNodeType (e3, ExpressionType.ConvertChecked);
- Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
- }
- }
- void ConvertCheckedTest_4 ()
- {
- checked {
- Expression<Func<MyType, int>> e4 = (MyType a) => (a);
- AssertNodeType (e4, ExpressionType.Convert);
- Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
- }
- }
- void DivideTest ()
- {
- Expression<Func<int, int, int>> e = (int a, int b) => a / b;
- AssertNodeType (e, ExpressionType.Divide);
- Assert (2, e.Compile ().Invoke (60, 30));
- }
- void DivideTest_2 ()
- {
- Expression<Func<double?, double?, double?>> e2 = (a, b) => a / b;
- AssertNodeType (e2, ExpressionType.Divide);
- Assert (null, e2.Compile ().Invoke (null, 3));
- Assert (1.5, e2.Compile ().Invoke (3, 2));
- }
- void DivideTest_3 ()
- {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a / b;
- AssertNodeType (e3, ExpressionType.Divide);
- Assert (1, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
- void DivideTest_4 ()
- {
- Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a / b;
- AssertNodeType (e4, ExpressionType.Divide);
- Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (new MyType (-6), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
- }
- void DivideTest_5 ()
- {
- Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a / b;
- AssertNodeType (e5, ExpressionType.Divide);
- Assert (50, e5.Compile ().Invoke (100, new MyType (2)));
- }
- void DivideTest_6 ()
- {
- Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a / b;
- AssertNodeType (e6, ExpressionType.Divide);
- Assert (50, e6.Compile ().Invoke (100, new MyType (2)));
- Assert (null, e6.Compile ().Invoke (20, null));
- }
- void EqualTest ()
- {
- Expression<Func<int, int, bool>> e = (int a, int b) => a == b;
- AssertNodeType (e, ExpressionType.Equal);
- Assert (false, e.Compile ().Invoke (60, 30));
- Assert (true, e.Compile ().Invoke (-1, -1));
- }
-
- void EqualTest_2 ()
- {
- Expression<Func<double?, double?, bool>> e2 = (a, b) => a == b;
- AssertNodeType (e2, ExpressionType.Equal);
- Assert (true, e2.Compile ().Invoke (3, 3));
- Assert (false, e2.Compile ().Invoke (3, 2));
- }
- void EqualTest_3 ()
- {
- Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a == b;
- AssertNodeType (e3, ExpressionType.Equal);
- Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
- void EqualTest_4 ()
- {
- Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a == b;
- AssertNodeType (e4, ExpressionType.Equal);
- Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (true, e4.Compile ().Invoke (null, null));
- Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
- }
- void EqualTest_5 ()
- {
- Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a == b;
- AssertNodeType (e5, ExpressionType.Equal);
- Assert (false, e5.Compile ().Invoke (true, null));
- Assert (true, e5.Compile ().Invoke (null, null));
- Assert (true, e5.Compile ().Invoke (false, false));
- }
- void EqualTest_6 ()
- {
- Expression<Func<bool, bool>> e6 = (bool a) => a == null;
- AssertNodeType (e6, ExpressionType.Equal);
- Assert (false, e6.Compile ().Invoke (true));
- Assert (false, e6.Compile ().Invoke (false));
- }
- void EqualTest_7 ()
- {
- Expression<Func<string, string, bool>> e7 = (string a, string b) => a == b;
- AssertNodeType (e7, ExpressionType.Equal);
- Assert (true, e7.Compile ().Invoke (null, null));
- Assert (false, e7.Compile ().Invoke ("a", "A"));
- Assert (true, e7.Compile ().Invoke ("a", "a"));
- }
- void EqualTest_8 ()
- {
- Expression<Func<object, bool>> e8 = (object a) => null == a;
- AssertNodeType (e8, ExpressionType.Equal);
- Assert (true, e8.Compile ().Invoke (null));
- Assert (false, e8.Compile ().Invoke ("a"));
- Assert (false, e8.Compile ().Invoke (this));
- }
- void EqualTest_9 ()
- {
- Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a == b;
- AssertNodeType (e9, ExpressionType.Equal);
- Assert (false, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
- Assert (true, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void EqualTest_10 ()
- {
- Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a == b;
- AssertNodeType (e10, ExpressionType.Equal);
- Assert (false, e10.Compile ().Invoke (MyEnum.Value_1, null));
- Assert (true, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void EqualTest_11 ()
- {
- Expression<Func<MyEnum?, bool>> e11 = (a) => a == null;
- AssertNodeType (e11, ExpressionType.Equal);
- Assert (false, e11.Compile ().Invoke (MyEnum.Value_1));
- Assert (true, e11.Compile ().Invoke (null));
- }
- void EqualTest_12 ()
- {
- Expression<Func<MyEnumUlong, bool>> e12 = (a) => a == 0;
- AssertNodeType (e12, ExpressionType.Equal);
- Assert (false, e12.Compile ().Invoke (MyEnumUlong.Value_1));
- Assert (true, e12.Compile ().Invoke (0));
- }
- void EqualTest_13 ()
- {
- Expression<Func<MyEnum, bool>> e13 = (a) => a == MyEnum.Value_2;
- AssertNodeType (e13, ExpressionType.Equal);
- Assert (true, e13.Compile ().Invoke (MyEnum.Value_2));
- Assert (false, e13.Compile ().Invoke (0));
- }
-
- void EqualTest_14 ()
- {
- Expression<Func<MyEnum, bool>> e = (a) => a == null;
- AssertNodeType (e, ExpressionType.Equal);
- Assert (false, e.Compile ().Invoke (MyEnum.Value_1));
- }
- void EqualTest_15 ()
- {
- Expression<Func<int?, uint, bool>> e = (a, b) => a == b;
- AssertNodeType (e, ExpressionType.Equal);
- Assert (false, e.Compile ().Invoke (null, 0));
- Assert (true, e.Compile ().Invoke (4, 4));
- }
- void EqualTestDelegate ()
- {
- Expression<Func<Delegate, Delegate, bool>> e1 = (a, b) => a == b;
- AssertNodeType (e1, ExpressionType.Equal);
- Assert (true, e1.Compile ().Invoke (null, null));
- }
- void EqualTestDelegate_2 ()
- {
- EmptyDelegate ed = delegate () {};
- Expression<Func<EmptyDelegate, EmptyDelegate, bool>> e2 = (a, b) => a == b;
- AssertNodeType (e2, ExpressionType.Equal);
- Assert (false, e2.Compile ().Invoke (delegate () {}, null));
- Assert (false, e2.Compile ().Invoke (delegate () {}, delegate {}));
- Assert (false, e2.Compile ().Invoke (ed, delegate {}));
- Assert (true, e2.Compile ().Invoke (ed, ed));
- }
- void ExclusiveOrTest ()
- {
- Expression<Func<int, short, int>> e = (int a, short b) => a ^ b;
- AssertNodeType (e, ExpressionType.ExclusiveOr);
- Assert (34, e.Compile ().Invoke (60, 30));
- }
- void ExclusiveOrTest_2 ()
- {
- Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a ^ b;
- AssertNodeType (e2, ExpressionType.ExclusiveOr);
- Assert (null, e2.Compile ().Invoke (null, 3));
- Assert (1, e2.Compile ().Invoke (3, 2));
- }
- void ExclusiveOrTest_3 ()
- {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a ^ b;
- AssertNodeType (e3, ExpressionType.ExclusiveOr);
- Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
- void ExclusiveOrTest_4 ()
- {
- Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a ^ b;
- AssertNodeType (e4, ExpressionType.ExclusiveOr);
- Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (new MyType (-108), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
- }
- void ExclusiveOrTest_5 ()
- {
- Expression<Func<MyType?, byte, int?>> e5 = (MyType? a, byte b) => a ^ b;
- AssertNodeType (e5, ExpressionType.ExclusiveOr);
- Assert (null, e5.Compile ().Invoke (null, 64));
- Assert (96, e5.Compile ().Invoke (new MyType (64), 32));
- }
- void ExclusiveOrTest_6 ()
- {
- Expression<Func<MyEnum, MyEnum, MyEnum>> e6 = (a, b) => a ^ b;
- AssertNodeType (e6, ExpressionType.Convert);
- Assert ((MyEnum)3, e6.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
- Assert<MyEnum> (0, e6.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void ExclusiveOrTest_7 ()
- {
- Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e7 = (a, b) => a ^ b;
- AssertNodeType (e7, ExpressionType.Convert);
- Assert (null, e7.Compile ().Invoke (MyEnum.Value_1, null));
- Assert<MyEnum?> (0, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void ExclusiveOrTest_8 ()
- {
- Expression<Func<MyEnum?, MyEnum?>> e8 = (a) => a ^ null;
- AssertNodeType (e8, ExpressionType.Convert);
- Assert (null, e8.Compile ().Invoke (MyEnum.Value_1));
- Assert (null, e8.Compile ().Invoke (null));
- }
- void GreaterThanTest ()
- {
- Expression<Func<int, int, bool>> e = (int a, int b) => a > b;
- AssertNodeType (e, ExpressionType.GreaterThan);
- Assert (true, e.Compile ().Invoke (60, 30));
- }
- void GreaterThanTest_2 ()
- {
- Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a > b;
- AssertNodeType (e2, ExpressionType.GreaterThan);
- Assert (false, e2.Compile ().Invoke (null, 3));
- Assert (false, e2.Compile ().Invoke (2, 2));
- }
- void GreaterThanTest_3 ()
- {
- Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a > b;
- AssertNodeType (e3, ExpressionType.GreaterThan);
- Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
- void GreaterThanTest_4 ()
- {
- Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a > b;
- AssertNodeType (e4, ExpressionType.GreaterThan);
- Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (false, e4.Compile ().Invoke (null, null));
- Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
- }
- void GreaterThanTest_5 ()
- {
- Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a > b;
- AssertNodeType (e5, ExpressionType.GreaterThan);
- Assert (false, e5.Compile ().Invoke (null, 33));
- Assert (false, e5.Compile ().Invoke (null, 0));
- Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
- }
- void GreaterThanTest_6 ()
- {
- Expression<Func<ushort, bool>> e6 = (ushort a) => a > null;
- AssertNodeType (e6, ExpressionType.GreaterThan);
- Assert (false, e6.Compile ().Invoke (60));
- }
- void GreaterThanTest_7 ()
- {
- Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a > b;
- AssertNodeType (e7, ExpressionType.GreaterThan);
- Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
- Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void GreaterThanTest_8 ()
- {
- Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a > b;
- AssertNodeType (e8, ExpressionType.GreaterThan);
- Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
- Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void GreaterThanOrEqualTest ()
- {
- Expression<Func<int, int, bool>> e = (int a, int b) => a >= b;
- AssertNodeType (e, ExpressionType.GreaterThanOrEqual);
- Assert (true, e.Compile ().Invoke (60, 30));
- }
- void GreaterThanOrEqualTest_2 ()
- {
- Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a >= b;
- AssertNodeType (e2, ExpressionType.GreaterThanOrEqual);
- Assert (false, e2.Compile ().Invoke (null, 3));
- Assert (true, e2.Compile ().Invoke (2, 2));
- }
- void GreaterThanOrEqualTest_3 ()
- {
- Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a >= b;
- AssertNodeType (e3, ExpressionType.GreaterThanOrEqual);
- Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
- }
- void GreaterThanOrEqualTest_4 ()
- {
- Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a >= b;
- AssertNodeType (e4, ExpressionType.GreaterThanOrEqual);
- Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (false, e4.Compile ().Invoke (null, null));
- Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
- }
- void GreaterThanOrEqualTest_5 ()
- {
- Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a >= b;
- AssertNodeType (e5, ExpressionType.GreaterThanOrEqual);
- Assert (false, e5.Compile ().Invoke (null, 33));
- Assert (false, e5.Compile ().Invoke (null, 0));
- Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
- }
- void GreaterThanOrEqualTest_6 ()
- {
- Expression<Func<ushort, bool>> e6 = (ushort a) => a >= null;
- AssertNodeType (e6, ExpressionType.GreaterThanOrEqual);
- Assert (false, e6.Compile ().Invoke (60));
- }
- void GreaterThanOrEqualTest_7 ()
- {
- Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a >= b;
- AssertNodeType (e7, ExpressionType.GreaterThanOrEqual);
- Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
- Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void GreaterThanOrEqualTest_8 ()
- {
- Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a >= b;
- AssertNodeType (e8, ExpressionType.GreaterThanOrEqual);
- Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
- Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
-
- void InvokeTest ()
- {
- var del = new IntDelegate (TestInt);
- Expression<Func<IntDelegate, int>> e = (a) => a ();
- AssertNodeType (e, ExpressionType.Invoke);
- Assert (29, e.Compile ().Invoke (del));
- }
-
- void InvokeTest_2 ()
- {
- Expression<Func<Func<int, string>, int, string>> e2 = (a, b) => a (b);
- AssertNodeType (e2, ExpressionType.Invoke);
- Assert ("4", e2.Compile ().Invoke ((a) => (a+1).ToString (), 3));
- }
-
- void LambdaTest ()
- {
- Expression<Func<string, Func<string>>> e = (string s) => () => s;
- AssertNodeType (e, ExpressionType.Lambda);
- Assert ("xx", e.Compile ().Invoke ("xx") ());
- }
-
- void LeftShiftTest ()
- {
- Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a << b;
- AssertNodeType (e, ExpressionType.LeftShift);
- Assert ((ulong) 0x7F000, e.Compile ().Invoke (0xFE, 11));
- Assert ((ulong) 0x1FFFFFFFE, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
- // .net produces a strange result
- // see https://bugzilla.novell.com/show_bug.cgi?id=398358
- // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
- }
-
- void LeftShiftTest_2 ()
- {
- Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a << b;
- AssertNodeType (e2, ExpressionType.LeftShift);
- var c2 = e2.Compile ();
- Assert (1024, c2 (new MyType (256), new MyType (2)));
- }
-
- void LeftShiftTest_3 ()
- {
- Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a << b;
- AssertNodeType (e3, ExpressionType.LeftShift);
- Assert (null, e3.Compile ().Invoke (null, 11));
- Assert (2048, e3.Compile ().Invoke (1024, 1));
- }
-
- void LeftShiftTest_4 ()
- {
- Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a << b;
- AssertNodeType (e4, ExpressionType.LeftShift);
- var c4 = e4.Compile ();
- Assert (null, c4 (new MyType (8), null));
- Assert (null, c4 (null, new MyType (8)));
- Assert (1024, c4 (new MyType (256), new MyType (2)));
- }
-
- void LeftShiftTest_5 ()
- {
- Expression<Func<ushort, int?>> e5 = (ushort a) => a << null;
- AssertNodeType (e5, ExpressionType.LeftShift);
- Assert (null, e5.Compile ().Invoke (30));
- }
-
- void LessThanTest ()
- {
- Expression<Func<int, int, bool>> e = (int a, int b) => a < b;
- AssertNodeType (e, ExpressionType.LessThan);
- Assert (false, e.Compile ().Invoke (60, 30));
- }
-
- void LessThanTest_2 ()
- {
- Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a < b;
- AssertNodeType (e2, ExpressionType.LessThan);
- Assert (false, e2.Compile ().Invoke (null, 3));
- Assert (false, e2.Compile ().Invoke (2, 2));
- }
-
- void LessThanTest_3 ()
- {
- Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a < b;
- AssertNodeType (e3, ExpressionType.LessThan);
- Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
-
- void LessThanTest_4 ()
- {
- Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a < b;
- AssertNodeType (e4, ExpressionType.LessThan);
- Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (false, e4.Compile ().Invoke (null, null));
- Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
- }
-
- void LessThanTest_5 ()
- {
- Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a < b;
- AssertNodeType (e5, ExpressionType.LessThan);
- Assert (false, e5.Compile ().Invoke (null, 33));
- Assert (false, e5.Compile ().Invoke (null, 0));
- Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
- }
-
- void LessThanTest_6 ()
- {
- Expression<Func<ushort, bool>> e6 = (ushort a) => a < null;
- AssertNodeType (e6, ExpressionType.LessThan);
- Assert (false, e6.Compile ().Invoke (60));
- }
-
- void LessThanTest_7 ()
- {
- Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a < b;
- AssertNodeType (e7, ExpressionType.LessThan);
- Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
- Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
-
- void LessThanTest_8 ()
- {
- Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a < b;
- AssertNodeType (e8, ExpressionType.LessThan);
- Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
- Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void LessThanOrEqualTest ()
- {
- Expression<Func<int, int, bool>> e = (int a, int b) => a <= b;
- AssertNodeType (e, ExpressionType.LessThanOrEqual);
- Assert (false, e.Compile ().Invoke (60, 30));
- }
- void LessThanOrEqualTest_2 ()
- {
- Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a <= b;
- AssertNodeType (e2, ExpressionType.LessThanOrEqual);
- Assert (false, e2.Compile ().Invoke (null, 3));
- Assert (true, e2.Compile ().Invoke (2, 2));
- }
- void LessThanOrEqualTest_3 ()
- {
- Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a <= b;
- AssertNodeType (e3, ExpressionType.LessThanOrEqual);
- Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
- void LessThanOrEqualTest_4 ()
- {
- Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a <= b;
- AssertNodeType (e4, ExpressionType.LessThanOrEqual);
- Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (false, e4.Compile ().Invoke (null, null));
- Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
- }
- void LessThanOrEqualTest_5 ()
- {
- Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a <= b;
- AssertNodeType (e5, ExpressionType.LessThanOrEqual);
- Assert (false, e5.Compile ().Invoke (null, 33));
- Assert (false, e5.Compile ().Invoke (null, 0));
- Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
- }
- void LessThanOrEqualTest_6 ()
- {
- Expression<Func<ushort, bool>> e6 = (ushort a) => a <= null;
- AssertNodeType (e6, ExpressionType.LessThanOrEqual);
- Assert (false, e6.Compile ().Invoke (60));
- }
- void LessThanOrEqualTest_7 ()
- {
- Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a <= b;
- AssertNodeType (e7, ExpressionType.LessThanOrEqual);
- Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
- Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
- void LessThanOrEqualTest_8 ()
- {
- Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a <= b;
- AssertNodeType (e8, ExpressionType.LessThanOrEqual);
- Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
- Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
- }
-
- void ListInitTest ()
- {
- Expression<Func<List<object>>> e1 = () => new List<object> { "Hello", "", null, "World", 5 };
- AssertNodeType (e1, ExpressionType.ListInit);
- var re1 = e1.Compile ().Invoke ();
- Assert (null, re1 [2]);
- Assert ("World", re1 [3]);
- Assert (5, re1 [4]);
- }
-
- void ListInitTest_2 ()
- {
- Expression<Func<int, Dictionary<string, int>>> e2 = (int value) => new Dictionary<string, int> (3) { { "A", value }, { "B", 2 } };
- AssertNodeType (e2, ExpressionType.ListInit);
- var re2 = e2.Compile ().Invoke (3456);
- Assert (3456, re2 ["A"]);
- }
-
- void MemberAccessTest ()
- {
- MemberAccessData d = new MemberAccessData ();
- d.BoolValue = true;
- Expression<Func<bool>> e = () => d.BoolValue;
- AssertNodeType (e, ExpressionType.MemberAccess);
- Assert (true, e.Compile ().Invoke ());
- d.BoolValue = false;
- Assert (false, e.Compile ().Invoke ());
- }
-
- void MemberAccessTest_2 ()
- {
- Expression<Func<decimal>> e2 = () => MemberAccessData.DecimalValue;
- AssertNodeType (e2, ExpressionType.MemberAccess);
- Assert (decimal.MinValue, e2.Compile ().Invoke ());
- }
-
- void MemberAccessTest_3 ()
- {
- MemberAccessData d = new MemberAccessData ();
- d.VolatileValue = 492;
- Expression<Func<uint>> e3 = () => d.VolatileValue;
- AssertNodeType (e3, ExpressionType.MemberAccess);
- Assert<uint> (492, e3.Compile ().Invoke ());
- }
-
- void MemberAccessTest_4 ()
- {
- MemberAccessData d = new MemberAccessData ();
- Expression<Func<string[]>> e4 = () => d.StringValues;
- AssertNodeType (e4, ExpressionType.MemberAccess);
- Assert (null, e4.Compile ().Invoke ());
- }
-
- void MemberAccessTest_5 ()
- {
- MemberAccessData d = new MemberAccessData ();
- var e5 = d.GetEvent ();
- AssertNodeType (e5, ExpressionType.MemberAccess);
- Assert (null, e5.Compile ().Invoke ());
- }
-
- void MemberAccessTest_6 ()
- {
- MemberAccessData d = new MemberAccessData ();
- Expression<Func<MyType>> e6 = () => d.MyTypeProperty;
- AssertNodeType (e6, ExpressionType.MemberAccess);
- Assert (new MyType (), e6.Compile ().Invoke ());
- }
-
- void MemberAccessTest_7 ()
- {
- MemberAccessData d = new MemberAccessData ();
- Expression<Func<MyType, short>> e7 = a => a.ShortProp;
- AssertNodeType (e7, ExpressionType.MemberAccess);
- MyType mt = new MyType ();
- mt.ShortProp = 124;
- Assert (124, e7.Compile ().Invoke (mt));
- }
-
- void MemberAccessTest_8 ()
- {
- Expression<Func<string>> e8 = () => MemberAccessData.StaticProperty;
- AssertNodeType (e8, ExpressionType.MemberAccess);
- Assert ("alo", e8.Compile ().Invoke ());
- }
-
- void MemberAccessTest_9 ()
- {
- string s = "localvar";
- Expression<Func<string>> e9 = () => s;
- AssertNodeType (e9, ExpressionType.MemberAccess);
- Assert ("localvar", e9.Compile ().Invoke ());
- }
-
- void MemberInitTest ()
- {
- Expression<Func<MemberAccessData>> e = () => new MemberAccessData {
- VolatileValue = 2, StringValues = new string [] { "sv" }, MyTypeProperty = new MyType (692)
- };
- AssertNodeType (e, ExpressionType.MemberInit);
- var r1 = e.Compile ().Invoke ();
- Assert<uint> (2, r1.VolatileValue);
- Assert (new string[] { "sv" }, r1.StringValues);
- Assert (new MyType (692), r1.MyTypeProperty);
- }
-
- void MemberInitTest_2 ()
- {
- Expression<Func<MemberAccessData>> e2 = () => new MemberAccessData {
- ListValues = new List<string> { "a", null }
- };
- AssertNodeType (e2, ExpressionType.MemberInit);
- var r2 = e2.Compile ().Invoke ();
- Assert ("a", r2.ListValues [0]);
- }
-
- void MemberInitTest_3 ()
- {
- Expression<Func<short, MyType>> e3 = a => new MyType { ShortProp = a };
- AssertNodeType (e3, ExpressionType.MemberInit);
- var r3 = e3.Compile ().Invoke (33);
- Assert (33, r3.ShortProp);
- }
-
- void MemberInitTest_4 ()
- {
- Expression<Func<int>> e = () => new int { };
-
- AssertNodeType (e, ExpressionType.MemberInit);
- var r = e.Compile ().Invoke ();
- Assert (0, r);
- }
- void ModuloTest ()
- {
- Expression<Func<int, int, int>> e = (int a, int b) => a % b;
- AssertNodeType (e, ExpressionType.Modulo);
- Assert (29, e.Compile ().Invoke (60, 31));
- }
- void ModuloTest_2 ()
- {
- Expression<Func<double?, double?, double?>> e2 = (a, b) => a % b;
- AssertNodeType (e2, ExpressionType.Modulo);
- Assert (null, e2.Compile ().Invoke (null, 3));
- Assert (1.1, e2.Compile ().Invoke (3.1, 2));
- }
- void ModuloTest_3 ()
- {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a % b;
- AssertNodeType (e3, ExpressionType.Modulo);
- Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
- void ModuloTest_4 ()
- {
- Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a % b;
- AssertNodeType (e4, ExpressionType.Modulo);
- Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (new MyType (12), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
- }
- void ModuloTest_5 ()
- {
- Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a % b;
- AssertNodeType (e5, ExpressionType.Modulo);
- Assert (1, e5.Compile ().Invoke (99, new MyType (2)));
- }
- void ModuloTest_6 ()
- {
- Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a % b;
- AssertNodeType (e6, ExpressionType.Modulo);
- Assert (100, e6.Compile ().Invoke (100, new MyType (200)));
- Assert (null, e6.Compile ().Invoke (20, null));
- }
- void ModuloTest_7 ()
- {
- Expression<Func<ushort, int?>> e7 = (ushort a) => a % null;
- AssertNodeType (e7, ExpressionType.Modulo);
- Assert (null, e7.Compile ().Invoke (60));
- }
-
- void MultiplyTest ()
- {
- Expression<Func<int, int, int>> e = (int a, int b) => a * b;
- AssertNodeType (e, ExpressionType.Multiply);
- Assert (1860, e.Compile ().Invoke (60, 31));
- Assert (2147483617, e.Compile ().Invoke (int.MaxValue, 31));
- }
-
- void MultiplyTest_2 ()
- {
- Expression<Func<double?, double?, double?>> e2 = (a, b) => a * b;
- AssertNodeType (e2, ExpressionType.Multiply);
- Assert (null, e2.Compile ().Invoke (null, 3));
- Assert (6.2, e2.Compile ().Invoke (3.1, 2));
- }
-
- void MultiplyTest_3 ()
- {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
- AssertNodeType (e3, ExpressionType.Multiply);
- Assert (400, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
-
- void MultiplyTest_4 ()
- {
- Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a * b;
- AssertNodeType (e4, Expr…
Large files files are truncated, but you can click here to view the full file