using System;
using System.Collections.Generic;
using System.Linq;
-using System.Linq.Expressions;
using System.Reflection;
-// Dynamic binary and unary operators tests
+// Dynamic binary operator, unary operators and convert tests
public struct InverseLogicalOperator
{
}
}
-/* 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;
throw new NotImplementedException ();
}
- public static implicit operator int (MyType o)
- {
- return o.value;
- }
-
public static bool operator true (MyType a)
{
- return a.value == a;
+ return a.value != 1;
}
public static bool operator false (MyType a)
{
- return a.value != a;
+ return a.value == 0;
}
public static MyType operator + (MyType a, MyType b)
return a.value > 0;
}
+ public static int operator ~ (MyType a)
+ {
+ return ~a.value;
+ }
+
+ public static MyType operator ++ (MyType a)
+ {
+ return new MyType (a.value * 2);
+ }
+
+ public static MyType operator -- (MyType a)
+ {
+ return new MyType (a.value / 2);
+ }
+
public static int operator >> (MyType a, int b)
{
return a.value >> b;
public static MyType operator + (MyType a)
{
- return new MyType (+a.value);
+ return new MyType (334455); // magic number
}
public override string ToString ()
{
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 ()
+ public static implicit operator bool (MyTypeImplicitOnly m)
{
- return () => EventField;
- }
-
- MyType mt;
- public MyType MyTypeProperty {
- set {
- mt = value;
- }
- get {
- return mt;
- }
- }
-
- public static string StaticProperty {
- get {
- return "alo";
- }
+ return m.b != 0;
}
}
}
-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); } }
-}
-
-
class Tester
{
+ delegate void EmptyDelegate ();
+ event Action ev_assign;
+
static void Assert<T> (T expected, T value, string name)
{
if (!EqualityComparer<T>.Default.Equals (expected, value)) {
}
}
-/*
- static void Assert<T> (T [] expected, T [] value)
+ static void AssertChecked (Action expected, string name)
{
- 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]);
+ try {
+ expected ();
+ throw new ApplicationException (name + ": OverflowException expected");
+ } catch (OverflowException) {
+ // passed
}
}
-*/
#pragma warning disable 169
double v2 = 0.5;
Assert (d + v2, 5.5, "#1a");
+ d = new MyType (5);
MyType v3 = new MyType (30);
Assert (d + v3, new MyType (35), "#3");
dynamic d3 = new MyType (-7);
Assert<MyType> (d3 + new MyType (6), new MyType (-1), "#3a");
- Assert (d3 + 11, 4, "#3b");
+ d3 = new MyTypeImplicitOnly (6);
+ Assert (d3 + new MyTypeImplicitOnly (11), 17, "#3b");
+
+ d = new MyTypeImplicitOnly (5);
decimal v4 = 4m;
Assert (d + v4, 9m, "#4");
}
- void AddTestNullable ()
+ void AddNullableTest ()
{
dynamic d = 5;
dynamic d2 = (int?) -2;
Assert (d2 + 1, -1, "#2a");
+ d = new MyType (5);
MyType? v3 = new MyType (30);
Assert (d + v3, new MyType (35), "#3");
dynamic d3 = new MyType? (new MyType (-7));
Assert (d3 + new MyType (6), new MyType (-1), "#3a");
Assert<MyType?> (d3 + null, null, "#3b");
+ d = new MyTypeImplicitOnly (5);
decimal? v4 = 4m;
Assert (d + v4, 9m, "#4");
v4 = null;
Assert<decimal?> (d + v4, null, "#4a");
}
- void AddTestEnum ()
+ void AddEnumTest ()
{
dynamic d = MyEnum.Value_1;
- // CSC: Invalid System.InvalidOperationException
- Assert (d + null, null, "#1");
-
- Assert (d + 1, MyEnum.Value_2, "#2");
+ Assert (d + 1, MyEnum.Value_2, "#1");
dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
- Assert (d2 + (byte) 1, MyEnumUlong.Value_2, "#3");
- Assert<MyEnumUlong?> (d2 + (object) null, null, "#3a");
+ Assert (d2 + (byte) 1, MyEnumUlong.Value_2, "#2");
+ Assert<MyEnumUlong?> (d2 + null, null, "#2a");
+
+ // CSC: Invalid System.InvalidOperationException
+ Assert<MyEnum?> (d + null, null, "#1");
}
- void AddTestChecked ()
+ void AddCheckedTest ()
{
checked {
dynamic d = 5;
int v = int.MaxValue;
AssertChecked (() => d + v, 7, "#1");
- // int? v2 = v;
- // AssertChecked (() => d + v2, null, "#2");
+ int? v2 = v;
+ AssertChecked (() => d + v2, null, "#2");
-// MyType v3 = new MyType (int.MaxValue);
- // AssertChecked (() => d + v3, new MyType (35), "#3");
+ d = new MyType (3);
+ MyType v3 = new MyType (int.MaxValue);
+ Assert (new MyType (-2147483646), d + v3, "#3");
}
}
Assert (d + v2, "foo4", "#2");
}
-/*
- void AndTest ()
+ void AddAssignTest ()
{
- Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a & b;
+ dynamic d = 5;
- AssertNodeType (e, ExpressionType.And);
- Func<bool, bool, bool> c = e.Compile ();
+ int v = 2;
+ d += v;
+ Assert (d, 7, "#1");
- 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;
+ d = 5.0;
+ double v2 = 0.5;
+ d += v2;
+ Assert (d, 5.5, "#1a");
+ d += v;
+ Assert (d, 7.5, "#1b");
- AssertNodeType (e2, ExpressionType.And);
- var c2 = e2.Compile ();
+ dynamic d3 = new MyType (-7);
+ d3 += new MyType (6);
+ Assert<MyType> (d3, new MyType (-1), "#3");
- 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));
+ d = 5m;
+ decimal v4 = 4m;
+ d += v4;
+ Assert (d, 9m, "#4");
}
- void AndNullableTest ()
+ void AddAssignNullableTest ()
{
- Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a & b;
+ dynamic d = (int?) 5;
- AssertNodeType (e, ExpressionType.And);
- Func<bool?, bool?, bool?> c = e.Compile ();
+ // FEATURE
+ // For now it's impossible to use nullable compound assignment
+ // due to the way how DLR works. GetType () on nullable object returns
+ // underlying type and not nullable type, that means that
+ // C# binder is initialized with wrong operand type and any operation
+ // fails to resolve
+/*
+ long? v2 = null;
+ d += v2;
+ Assert<int?> (d, null, "#1");
+ d += null;
+ Assert<int?> (d, null, "#1a");
+
+ long? l = (long?) 3;
+ d = l;
+ v2 = -2;
+ d += v2;
+ Assert (d, 3, "#2");
+ d = (int?) -2;
+ d += 1;
+ Assert (d, -1, "#2a");
- Assert (true, c (true, true));
- Assert (false, c (true, false));
- Assert (false, c (false, true));
- Assert (false, c (false, false));
+ MyType? v3 = new MyType (30);
+ d += v3;
+ Assert (d, new MyType (35), "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 + new MyType (6), new MyType (-1), "#3a");
+ Assert<MyType?> (d3 + null, null, "#3b");
- 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));
+ decimal? v4 = 4m;
+ d = 2m;
+ d += v4;
+ Assert (d, 9m, "#4");
+ d += null;
+ Assert<decimal?> (d, null, "#4a");
+ */
}
-
- void AndNullableTest_2 ()
+
+ void AddAssignEnumTest ()
{
- Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a & b;
+ dynamic d = MyEnum.Value_1;
- AssertNodeType (e2, ExpressionType.And);
- var c2 = e2.Compile ();
+ d = MyEnum.Value_1;
+ d += 1;
+ Assert (d, MyEnum.Value_2, "#2");
- 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));
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
+ d2 += (byte) 1;
+ Assert (d2, MyEnumUlong.Value_2, "#3");
}
- void AndAlsoTest ()
+ void AddAssignCheckedTest ()
{
- Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a && b;
- AssertNodeType (e, ExpressionType.AndAlso);
- Assert (false, e.Compile ().Invoke (true, false));
- }
+ checked {
+ dynamic d = 5;
- 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)));
- }
+ int v = int.MaxValue;
+ AssertChecked (() => { d += v; Assert (d, 0, "#1-"); }, "#1");
- 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));
+ d = new MyType (5);
+ MyType v3 = new MyType (int.MaxValue);
+ d += v3;
+ Assert (d, new MyType (-2147483644), "#3-");
+ }
}
- void ArrayIndexTest ()
+ void AddAssignStringTest ()
{
- 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));
+ dynamic d = "foo";
+ string v = "->";
+ d += v;
+ Assert (d, "foo->", "#1");
+
+ d = "foo";
+ d += 1;
+ Assert (d, "foo1", "#1a");
+
+ d += null;
+ Assert (d, "foo1", "#1b");
+
+ uint? v2 = 4;
+ d = "foo";
+ d += v2;
+ Assert (d, "foo4", "#2");
}
- void ArrayIndexTest_2 ()
+ void AddAssignEvent ()
{
- Expression<Func<string [], string>> e2 = (string [] a) => a [0];
- AssertNodeType (e2, ExpressionType.ArrayIndex);
- Assert ("a", e2.Compile ().Invoke (new string [] { "a", "b" }));
+ dynamic d = null;
+
+ // FIXME: Will have to special case events
+ // ev_assign += d;
}
- void ArrayIndexTest_3 ()
+ void AndTest ()
{
- Expression<Func<object [,], int, int, object>> e3 = (object [,] a, int i, int j) => a [i, j];
- AssertNodeType (e3, ExpressionType.Call);
+ dynamic d = true;
- Assert ("z", e3.Compile ().Invoke (
- new object [,] { { 1, 2 }, { "x", "z" } }, 1, 1));
- }
+ var v = false;
+ Assert (d & v, false, "#1");
+ Assert (d & true, true, "#1a");
- void ArrayIndexTest_4 ()
- {
- Expression<Func<decimal [] [], byte, decimal>> e4 = (decimal [] [] a, byte b) => a [b] [1];
- AssertNodeType (e4, ExpressionType.ArrayIndex);
+ d = 42;
+ var v2 = 62;
+ Assert (d & v2, 42, "#2");
+ Assert (d & 0, 0, "#2a");
- decimal [] [] array = { new decimal [] { 1, 9 }, new decimal [] { 10, 90 } };
- Assert (90, e4.Compile ().Invoke (array, 1));
- }
+ d = new MyType (10);
+ MyType v3 = new MyType (30);
+ Assert (d & v3, new MyType (10), "#3");
+ dynamic d3 = new MyType (-7);
+ Assert<MyType> (d3 & new MyType (6), new MyType (0), "#3a");
- void ArrayIndexTest_5 ()
- {
- Expression<Func<int>> e5 = () => (new int [1]) [0];
- AssertNodeType (e5, ExpressionType.ArrayIndex);
- Assert (0, e5.Compile ().Invoke ());
+ d3 = new MyTypeImplicitOnly (6);
+ Assert (d3 & 11, 2, "#3b");
}
- void ArrayLengthTest ()
+ void AndTestEnum ()
{
- 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]));
- }
+ dynamic d = MyEnum.Value_1;
- 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]));
- }
+ Assert<MyEnum?> (d & null, null, "#1");
- 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));
+ Assert (d & d, MyEnum.Value_1, "#2");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
+ Assert<MyEnumUlong> (d2 & MyEnumUlong.Value_2, 0, "#3");
}
- void CallTest_2 ()
+ void AndTestNullable ()
{
- Expression<Func<string, string>> e2 = (string a) => InstanceMethod (a);
- AssertNodeType (e2, ExpressionType.Call);
- Assert ("abc", e2.Compile ().Invoke ("abc"));
+ dynamic d = 5;
+
+ int? v2 = null;
+ Assert<int?> (d & v2, null, "#1");
+ Assert<int?> (d & null, null, "#1a");
+ Assert<int?> (null & d, null, "#1b");
+
+ v2 = -2;
+ Assert (d & v2, 4, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 & 1, 0, "#2a");
+
+ d = new MyType (22);
+ MyType? v3 = new MyType (30);
+ Assert (d & v3, new MyType (22), "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 & new MyType (6), new MyType (0), "#3a");
+ Assert<MyType?> (d3 + null, null, "#3b");
+
+ dynamic a = (bool?) true;
+ dynamic b = (bool?) null;
+ Assert (a & b, (bool?)null, "#4a");
+ Assert (b & a, (bool?)null, "#4b");
}
- void CallTest_3 ()
+ void AndAssignedTest ()
{
- 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));
+ dynamic d = true;
+
+ var v = false;
+ d &= v;
+ Assert (d, false, "#1");
+ d = true;
+ d &= true;
+ Assert (d, true, "#1a");
+
+ d = 42;
+ var v2 = 62;
+ d &= v2;
+ Assert (d, 42, "#2");
+
+ MyType v3 = new MyType (30);
+ dynamic d3 = new MyType (-7);
+ d3 &= new MyType (6);
+ Assert<MyType> (d3, new MyType (0), "#3");
}
- void CallTest_4 ()
+ void AndAssignedTestEnum ()
{
- Expression<Func<object>> e4 = () => InstanceParamsMethod (0);
- AssertNodeType (e4, ExpressionType.Call);
- Assert<object> ("<empty>", e4.Compile ().Invoke ());
+ dynamic d = MyEnum.Value_1;
+ d &= MyEnum.Value_2;
+ Assert<MyEnum>(d, 0, "#1");
+
+ d = MyEnum.Value_2;
+ d &= d;
+ Assert (d, MyEnum.Value_2, "#2");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
+ Assert<MyEnumUlong> (d2 & MyEnumUlong.Value_2, 0, "#3");
}
- void CallTest_5 ()
+ void AndAlsoTest ()
{
- Expression<Func<int, int>> e5 = (int a) => GenericMethod (a);
- AssertNodeType (e5, ExpressionType.Call);
- Assert (5, e5.Compile ().Invoke (5));
+ dynamic d = true;
+
+ var v = false;
+ Assert<bool> (d && v, false, "#1");
+
+ Assert (d && true, true, "#1a");
+
+ d = true;
+ Assert (d && d, true, "#2");
+
+ dynamic d3 = new MyType (-7);
+ Assert<MyType> (d3 && new MyType (6), new MyType (0), "#3");
}
- void CallTest_6 ()
+ void DivideTest ()
{
- Expression<Action> e6 = () => Console.WriteLine ("call test");
- AssertNodeType (e6, ExpressionType.Call);
+ dynamic d = 5;
+
+ int v = 2;
+ Assert (d / v, 2, "#1");
+
+ d = new MyType (5);
+ MyType v3 = new MyType (30);
+ Assert (d / v3, new MyType (0), "#3");
+ dynamic d3 = new MyType (-7);
+ Assert<MyType> (d3 + new MyType (6), new MyType (-1), "#3a");
+
+ d = new MyTypeImplicitOnly (6);
+ decimal v4 = 4m;
+ Assert (d / v4, 1.5m, "#4");
}
- void CallTest_7 ()
+ void DivideNullableTest ()
{
- Expression<Func<Indexer, int, int>> e7 = (a, b) => a [b];
- AssertNodeType (e7, ExpressionType.Call);
- Assert (3, e7.Compile ().Invoke (new Indexer (), 3));
+ dynamic d = 5;
+
+ double? v2 = null;
+ Assert<double?> (d / v2, null, "#1");
+ Assert<double?> (d / null, null, "#1a");
+ Assert<double?> (null / d, null, "#1b");
+
+ v2 = -2;
+ Assert (d / v2, -2.5, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 / 1, -2, "#2a");
+
+ d = new MyType (5);
+ MyType? v3 = new MyType (30);
+ Assert (d / v3, new MyType (0), "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 / new MyType (6), new MyType (-1), "#3a");
+ Assert<MyType?> (d3 + null, null, "#3b");
+
+ d = new MyTypeImplicitOnly (5);
+ decimal? v4 = 4m;
+ Assert (d / v4, 1.25m, "#4");
+ v4 = null;
+ Assert<decimal?> (d / v4, null, "#4a");
}
- void CallTest_8 ()
+ void DivideCheckedTest ()
{
- 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"));
+ checked {
+ // TODO:
+ }
}
- void CallTest_9 ()
+ void DivideAssignTest ()
{
- Expression<Action<int>> e9 = (a) => RefMethod (ref a);
- AssertNodeType (e9, ExpressionType.Call);
- e9.Compile ().Invoke (1);
- }
+ dynamic d = 5;
- 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));
- }
+ int v = 2;
+ d /= v;
+ Assert (d, 2, "#1");
- 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));
+ d = 5.0;
+ double v2 = 0.5;
+ d /= v2;
+ Assert (d, 10, "#1a");
+ d /= v;
+ Assert (d, 5, "#1b");
+
+ dynamic d3 = new MyType (-7);
+ d3 /= new MyType (6);
+ Assert<MyType> (d3, new MyType (-1), "#3");
+
+ d = 5m;
+ decimal v4 = 4m;
+ d /= v4;
+ Assert (d, 1.25m, "#4");
}
- void ConditionTest ()
+ void DivideAssignCheckedTest ()
{
- 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));
+ checked {
+ // TODO:
+ }
}
- void ConditionTest_2 ()
+ void ConvertImplicitTest ()
{
- 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));
+ dynamic d = 3;
+ decimal v1 = d;
+ Assert (3m, v1, "#1");
+
+ d = new MyTypeImplicitOnly (5);
+ int v2 = d;
+ Assert (5, v2, "#2");
+
+ d = (byte) 4;
+ int v3 = d;
+ Assert (4, v3, "#3");
+
+ int[] v4 = new int[] { d };
+ Assert (4, v4[0], "#4");
+
+ d = true;
+ var v5 = new [] { d, 1 };
+ Assert (true, v5[0], "#5");
+ Assert (1, v5[1], "#5a");
+
+ d = "aa";
+ bool b = false;
+ var r = b ? d : "ss";
+ Assert ("ss", r, "#6");
+
+ var v = new [] { d, 1 };
+ Assert ("aa", v [0], "#7");
+
+ dynamic [,] a = new dynamic [,] { { 1, 2 }, { 'b', 'x' } };
+ Assert (2, a [0, 1], "#8");
+ Assert ('x', a [1, 1], "#8a");
}
- void ConditionTest_3 ()
+ int ConvertImplicitReturnTest ()
{
- 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));
+ dynamic d = (byte) 3;
+ return d;
}
- void ConditionTest_4 ()
+ IEnumerable<string> ConvertImplicitReturnTest_2 ()
{
- 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));
+ dynamic d = "aaa";
+ yield return d;
}
-
- void ConditionTest_5 ()
+
+ void ConvertExplicitTest ()
{
- // CSC bug ?
- Expression<Func<int>> e = () => false ? 1 : 4;
- AssertNodeType (e, ExpressionType.Conditional);
- var r = e.Compile ();
- Assert (4, r.Invoke ());
+ dynamic d = 300;
+ Assert (44, (byte) d, "#1");
+ Assert<byte?> (44, (byte?) d, "#1a");
+
+ d = 3m;
+ Assert (3, d, "#2");
+
+ d = new MyTypeImplicitOnly (5);
+ Assert (5, (int) d, "#3");
+
+ d = new MyTypeExplicit (-2);
+ Assert (-2, (int) d, "#4");
+
+ d = null;
+ Assert (null, (object) d, "#5");
}
-
- void ConstantTest ()
+
+ void ConvertExplicitCheckedTest ()
{
- Expression<Func<int>> e1 = () => default (int);
- AssertNodeType (e1, ExpressionType.Constant);
- Assert (0, e1.Compile ().Invoke ());
+ checked {
+ dynamic d = 300;
+ AssertChecked (() => (byte) d, 7, "#1");
+
+ d = ulong.MaxValue;
+ AssertChecked<uint?> (() => (uint?) d, 2, "#2");
+ }
}
- void ConstantTest_2 ()
+ void ConvertArray ()
{
- Expression<Func<int?>> e2 = () => default (int?);
- AssertNodeType (e2, ExpressionType.Constant);
- Assert (null, e2.Compile ().Invoke ());
+ dynamic idx = (uint) 1;
+ var arr = new int [5];
+ arr [idx] = 2;
+ Assert (2, arr [idx], "#1");
}
- void ConstantTest_3 ()
+ void EqualTest ()
{
- Expression<Func<Tester>> e3 = () => default (Tester);
- AssertNodeType (e3, ExpressionType.Constant);
- Assert (null, e3.Compile ().Invoke ());
+ dynamic d = 5;
+
+ int v = 2;
+ Assert (d == v, false, "#1");
+ double v2 = 5;
+ Assert (d == v2, true, "#1a");
+
+ d = true;
+ Assert (d == false, false, "#2");
+ bool b2 = true;
+ Assert (d == b2, true, "#2a");
+
+ d = new MyType (30);
+ MyType v3 = new MyType (30);
+ Assert (d == v3, true, "#3");
+ dynamic d3 = new MyTypeImplicitOnly (-7);
+ Assert (d3 == 11, false, "#3b");
+
+ d = 2m;
+ decimal v4 = 4m;
+ Assert (d == v4, false, "#4");
+ Assert (d == 2m, true, "#4a");
+
+ d = null;
+ Assert (d == null, true, "#5");
}
-
- void ConstantTest_4 ()
+
+ void EqualNullableTest ()
{
- Expression<Func<object>> e4 = () => null;
- AssertNodeType (e4, ExpressionType.Constant);
- Assert (null, e4.Compile ().Invoke ());
+ dynamic d = 5;
+
+ int? v2 = null;
+ Assert (d == v2, false, "#1");
+ Assert (d == null, false, "#1a");
+ Assert (null == d, false, "#1b");
+
+ v2 = -2;
+ Assert (d == v2, false, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 == 1, false, "#2a");
+ d2 = (uint?) 44;
+ Assert (d2 == 44, true, "#2b");
+
+ d = new MyType (30);
+ MyType? v3 = new MyType (30);
+ Assert (d == v3, true, "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 == new MyType (6), false, "#3a");
+ Assert (d3 == null, false, "#3b");
+
+ d = 4.1m;
+ decimal? v4 = 4m;
+ Assert (d == v4, false, "#4");
+ v4 = null;
+ Assert (d == v4, false, "#4a");
+
+ d = (bool?) true;
+ Assert (d == true, true, "#5");
+ Assert (d == null, false, "#5a");
+ Assert (d == false, false, "#5b");
}
-
- void ConstantTest_5 ()
+
+ void EqualEnumTest ()
{
- Expression<Func<int>> e5 = () => 8 / 4;
- AssertNodeType (e5, ExpressionType.Constant);
- Assert (2, e5.Compile ().Invoke ());
+ dynamic d = MyEnum.Value_1;
+
+ Assert (d == null, false, "#1");
+
+ Assert (d == MyEnum.Value_1, true, "#2");
+ Assert (d == 0, false, "#2a");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
+ Assert (d2 == MyEnumUlong.Value_2, true, "#3");
+ Assert (d2 == null, false, "#3a");
}
-
- void ConstantTest_6 ()
+
+ void EqualStringTest ()
{
- Expression<Func<int>> e6 = () => 0xFFFFFF >> 0x40;
- AssertNodeType (e6, ExpressionType.Constant);
- Assert (0xFFFFFF, e6.Compile ().Invoke ());
+ dynamic d = "text";
+
+ Assert (d == "te", false, "#1");
+ Assert (d == "text", true, "#1a");
+ Assert (d == null, false, "#1b");
}
-
- void ConstantTest_7 ()
+
+ void EqualDelegateTest ()
{
- Expression<Func<object>> e7 = () => "Alleluia";
- AssertNodeType (e7, ExpressionType.Constant);
- Assert ("Alleluia", e7.Compile ().Invoke ());
- }
+ dynamic d = this;
+
+// Assert (d == delegate { }, true, "#1");
+
+ EmptyDelegate b = EqualDelegateTest;
+ d = b;
+
+ //Assert (d == EqualDelegateTest, true, "#2");
- void ConstantTest_8 ()
+/*
+
+ void EqualTestDelegate_2 ()
{
- 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 ());
- }
+ EmptyDelegate ed = delegate () {};
- void ConvertTest ()
- {
- Expression<Func<int, byte>> e = (int a) => ((byte) a);
- AssertNodeType (e, ExpressionType.Convert);
- Assert (100, e.Compile ().Invoke (100));
+ 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 ConvertTest_2 ()
+ void ExclusiveOrTest ()
{
- Expression<Func<long, ushort>> e2 = (long a) => ((ushort) a);
- AssertNodeType (e2, ExpressionType.Convert);
- Assert (100, e2.Compile ().Invoke (100));
- }
+ dynamic d = true;
- void ConvertTest_3 ()
- {
- Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
- AssertNodeType (e3, ExpressionType.Convert);
- Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
- }
+ var v = false;
+ Assert (d ^ v, true, "#1");
+ Assert (d ^ true, false, "#1a");
- void ConvertTest_4 ()
- {
- Expression<Func<MyType, int>> e4 = (MyType a) => (a);
- AssertNodeType (e4, ExpressionType.Convert);
- Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
- }
+ d = 42;
+ var v2 = 62;
+ Assert (d ^ v2, 20, "#2");
+ Assert (d ^ 0, 42, "#2a");
- void ConvertTest_5 ()
- {
- Expression<Func<MyType, MyType, bool?>> e5 = (MyType a, MyType b) => a == b;
- AssertNodeType (e5, ExpressionType.Convert);
- }
+ d = new MyType (42);
+ MyType v3 = new MyType (30);
+ Assert (d ^ v3, new MyType (52), "#3");
+ dynamic d3 = new MyType (-7);
+ Assert<MyType> (d3 ^ new MyType (6), new MyType (-1), "#3a");
- 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)));
+ d3 = new MyTypeImplicitOnly (-7);
+ Assert (d3 ^ 11, -14, "#3b");
}
- void ConvertTest_7 ()
+ void ExclusiveOrNullableTest ()
{
- Expression<Func<MyTypeExplicit, int?>> e7 = x => (int?)x;
- AssertNodeType (e7, ExpressionType.Convert);
- Assert (33, e7.Compile ().Invoke (new MyTypeExplicit (33)));
- }
+ dynamic d = 5;
- 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));
- }
+ int? v2 = null;
+ Assert<int?> (d ^ v2, null, "#1");
+ Assert<int?> (d ^ null, null, "#1a");
+ Assert<int?> (null ^ d, null, "#1b");
- //unsafe void ConvertTest_9 ()
- //{
- // int*[] p = new int* [1];
- // Expression<Func<object>> e9 = () => (object)p;
- // AssertNodeType (e9, ExpressionType.Convert);
- // Assert (p, e9.Compile ().Invoke ());
- //}
+ v2 = -2;
+ Assert (d ^ v2, -5, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 ^ 1, -1, "#2a");
- 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));
+ d = new MyType (5);
+ MyType? v3 = new MyType (30);
+ Assert (d ^ v3, new MyType (27), "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 ^ new MyType (6), new MyType (-1), "#3a");
+ Assert<MyType?> (d3 ^ null, null, "#3b");
}
- void ConvertTest_11 ()
+ void ExclusiveOrTestEnum ()
{
- Expression<Func<Func<int>, Delegate>> e11 = (a) => a - a;
- AssertNodeType (e11, ExpressionType.Convert);
- Assert (null, e11.Compile ().Invoke (null));
- }
+ dynamic d = MyEnum.Value_1;
- void ConvertTest_12 ()
- {
- Expression<Func<Func<int>>> e12 = () => TestInt;
- AssertNodeType (e12, ExpressionType.Convert);
- Assert (29, e12.Compile ().Invoke () ());
- }
+ Assert<MyEnum?> (d ^ null, null, "#1");
- void ConvertTest_13 ()
- {
- Expression<Func<decimal, sbyte>> e13 = a => (sbyte)a;
- AssertNodeType (e13, ExpressionType.Convert);
- Assert (6, e13.Compile ().Invoke (6));
- }
+ Assert<MyEnum> (d ^ d, 0, "#2");
- void ConvertTest_14 ()
- {
- Expression<Func<long, decimal>> e14 = a => a;
- AssertNodeType (e14, ExpressionType.Convert);
- Assert (-66, e14.Compile ().Invoke (-66));
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
+ Assert<MyEnumUlong> (d2 ^ MyEnumUlong.Value_2, (MyEnumUlong) 3, "#3");
}
- void ConvertTest_15 ()
+ void ExclusiveOrAssignedTest ()
{
- Expression<Func<ulong?, decimal?>> e15 = a => a;
- AssertNodeType (e15, ExpressionType.Convert);
- Assert (null, e15.Compile ().Invoke (null));
- Assert (9, e15.Compile ().Invoke (9));
- }
+ dynamic d = true;
- void ConvertCheckedTest ()
- {
- Expression<Func<int, byte>> e = (int a) => checked((byte) a);
- AssertNodeType (e, ExpressionType.ConvertChecked);
- Assert (100, e.Compile ().Invoke (100));
- }
+ var v = false;
+ d ^= v;
+ Assert (d, true, "#1");
+ d = true;
+ d ^= true;
+ Assert (d, false, "#1a");
- void ConvertCheckedTest_2 ()
- {
- checked {
- Expression<Func<long, ushort>> e2 = (long a) => unchecked((ushort) a);
- AssertNodeType (e2, ExpressionType.Convert);
- Assert (100, e2.Compile ().Invoke (100));
- }
- }
+ d = 42;
+ var v2 = 62;
+ d ^= v2;
+ Assert (d, 20, "#2");
- 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));
- }
+ MyType v3 = new MyType (30);
+ dynamic d3 = new MyType (-7);
+ d3 ^= new MyType (6);
+ Assert (d3, new MyType (-1), "#3");
}
- void ConvertCheckedTest_4 ()
+ void ExclusiveOrAssignedTestEnum ()
{
- checked {
- Expression<Func<MyType, int>> e4 = (MyType a) => (a);
- AssertNodeType (e4, ExpressionType.Convert);
- Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
- }
- }
+ dynamic d = MyEnum.Value_1;
+ d ^= MyEnum.Value_2;
+ Assert<MyEnum>(d, (MyEnum) 3, "#1");
- 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));
- }
+ d = MyEnum.Value_2;
+ d ^= d;
+ Assert<MyEnum> (d, 0, "#2");
- 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));
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
+ Assert (d2 ^ MyEnumUlong.Value_2, (MyEnumUlong)3, "#3");
}
- void DivideTest_3 ()
+ void GreaterThanTest ()
{
- 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)));
- }
+ dynamic d = 5;
- 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)));
- }
+ int v = 2;
+ Assert (d > v, true, "#1");
+ double v2 = 5;
+ Assert (d > v2, false, "#1a");
- 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)));
- }
+ d = 4.6;
+ Assert (d > 4.59, true, "#2");
+ var b2 = 4.6;
+ Assert (d > b2, false, "#2a");
- 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));
- }
+ d = new MyType (30);
+ MyType v3 = new MyType (30);
+ Assert (d > v3, false, "#3");
+ dynamic d3 = new MyType (-7);
+ Assert (d3 > new MyType (6), false, "#3a");
- 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));
- }
+ d3 = new MyTypeImplicitOnly (-7);
+ Assert (d3 > 11, false, "#3b");
- 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)));
+ d = 2m;
+ decimal v4 = 4m;
+ Assert (d > v4, false, "#4");
+ Assert (d > 2m, false, "#4a");
}
- void EqualTest_4 ()
+ void GreaterThanNullableTest ()
{
- 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)));
- }
+ dynamic d = 5;
- 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));
- }
+ int? v2 = null;
+ Assert (d > v2, false, "#1");
+ Assert (d > null, false, "#1a");
+ Assert (null > d, false, "#1b");
- 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));
- }
+ v2 = -2;
+ Assert (d > v2, true, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 > 1, false, "#2a");
+ d2 = (uint?) 44;
+ Assert (d2 > 44, false, "#2b");
- 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"));
- }
+ d = new MyType (30);
+ MyType? v3 = new MyType (30);
+ Assert (d > v3, false, "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 > new MyType (6), false, "#3a");
+ Assert (d3 > null, false, "#3b");
- 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));
+ d = 4.1m;
+ decimal? v4 = 4m;
+ Assert (d > v4, true, "#4");
+ v4 = null;
+ Assert (d > v4, false, "#4a");
}
- void EqualTest_9 ()
+ void GreaterThanEnumTest ()
{
- 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));
- }
+ dynamic d = MyEnum.Value_1;
- 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));
- }
+ Assert (d > null, false, "#1");
- 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));
- }
+ Assert (d > MyEnum.Value_1, false, "#2");
+ Assert (d > 0, true, "#2a");
- 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));
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
+ Assert (d2 > MyEnumUlong.Value_2, false, "#3");
+ Assert (d2 > null, false, "#3a");
}
- 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 ()
+ void GreaterThanEqualTest ()
{
- Expression<Func<MyEnum, bool>> e = (a) => a == null;
- AssertNodeType (e, ExpressionType.Equal);
- Assert (false, e.Compile ().Invoke (MyEnum.Value_1));
- }
+ dynamic d = 5;
- 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));
- }
+ int v = 2;
+ Assert (d >= v, true, "#1");
+ double v2 = 5;
+ Assert (d >= v2, true, "#1a");
- void EqualTestDelegate ()
- {
- Expression<Func<Delegate, Delegate, bool>> e1 = (a, b) => a == b;
- AssertNodeType (e1, ExpressionType.Equal);
- Assert (true, e1.Compile ().Invoke (null, null));
- }
+ d = 4.6;
+ Assert (d >= 4.59, true, "#2");
+ var b2 = 4.6;
+ Assert (d >= b2, true, "#2a");
- void EqualTestDelegate_2 ()
- {
- EmptyDelegate ed = delegate () {};
+ d = new MyType (30);
+ MyType v3 = new MyType (30);
+ Assert (d >= v3, true, "#3");
+ dynamic d3 = new MyType (-7);
+ Assert (d3 >= new MyType (6), false, "#3a");
- 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));
- }
+ d3 = new MyTypeImplicitOnly (-7);
+ Assert (d3 >= 11, false, "#3b");
- 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));
+ d = 2m;
+ decimal v4 = 4m;
+ Assert (d >= v4, false, "#4");
+ Assert (d >= 2m, true, "#4a");
}
- void ExclusiveOrTest_2 ()
+ void GreaterThanEqualNullableTest ()
{
- 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));
- }
+ dynamic d = 5;
- 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)));
- }
+ int? v2 = null;
+ Assert (d >= v2, false, "#1");
+ Assert (d >= null, false, "#1a");
+ Assert (null >= d, false, "#1b");
- 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)));
- }
+ v2 = -2;
+ Assert (d >= v2, true, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 >= 1, false, "#2a");
+ d2 = (uint?) 44;
+ Assert (d2 >= 44, true, "#2b");
- 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));
- }
+ d = new MyType (30);
+ MyType? v3 = new MyType (30);
+ Assert (d >= v3, true, "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 >= new MyType (6), false, "#3a");
+ Assert (d3 >= null, false, "#3b");
- 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));
+ d = 4.1m;
+ decimal? v4 = 4m;
+ Assert (d >= v4, true, "#4");
+ v4 = null;
+ Assert (d >= v4, false, "#4a");
}
- void ExclusiveOrTest_7 ()
+ void GreaterThanEqualEnumTest ()
{
- 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));
- }
+ dynamic d = MyEnum.Value_1;
- 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));
- }
+ Assert (d >= null, false, "#1");
- 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));
- }
+ Assert (d >= MyEnum.Value_1, true, "#2");
+ Assert (d >= 0, true, "#2a");
- 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));
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
+ Assert (d2 >= MyEnumUlong.Value_2, true, "#3");
+ Assert (d2 >= null, false, "#3a");
}
- void GreaterThanTest_3 ()
+ void IsTest ()
{
- 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)));
+ dynamic d = 1;
+ Assert (d is long, false, "#1");
+ Assert (d is int, true, "#2");
+ Assert (d is string, false, "#3");
}
- void GreaterThanTest_4 ()
+ void LeftShiftTest ()
{
- 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)));
- }
+ dynamic d = (ulong) 0x7F000;
- 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));
+ int v = 2;
+ Assert<ulong> (d << v, 0x1FC000, "#1");
+ Assert<ulong> (d << 1, 0xFE000, "#1a");
+ short s = 2;
+ Assert<ulong> (d << s, 0x1FC000, "#1b");
+
+ d = 0x7F000;
+ MyTypeImplicitOnly v3 = new MyTypeImplicitOnly (3);
+ Assert (d << v3, 0x3F8000, "#3");
+ dynamic d3 = new MyType (-7);
+ Assert (d3 << new MyTypeImplicitOnly (6), -448, "#3a");
+ Assert (d3 << 11, -14336, "#3b");
}
- void GreaterThanTest_6 ()
+ void LeftShiftNullableTest ()
{
- Expression<Func<ushort, bool>> e6 = (ushort a) => a > null;
- AssertNodeType (e6, ExpressionType.GreaterThan);
- Assert (false, e6.Compile ().Invoke (60));
+ dynamic d = 5;
+
+ int? v2 = null;
+ Assert<int?> (d << v2, null, "#1");
+ d = 5;
+ Assert<int?> (d << null, null, "#1a");
+ d = 5;
+ Assert<int?> (null << d, null, "#1b");
+
+ v2 = -2;
+ Assert (d << v2, 0x40000000, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 << 1, -4, "#2a");
+
+ dynamic d3 = (int?) null;
+ Assert (d3 << (null << null), (int?)null, "#3");
}
- void GreaterThanTest_7 ()
+ void LeftShiftAssignTest ()
{
- 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));
+ dynamic d = 0x7F000;
+
+ int v = 2;
+ d <<= v;
+ Assert (d, 0x1FC000, "#1");
+ d <<= 1;
+ Assert (d, 0x3F8000, "#1a");
+ sbyte s = 2;
+ d <<= s;
+ Assert (d, 0xFE0000, "#1b");
}
- void GreaterThanTest_8 ()
+ void LeftShiftAssignNullableTest ()
{
- 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));
+ dynamic d = 5;
+
+ var v2 = -2;
+ d <<= v2;
+ Assert (d, 0x40000000, "#2");
+ dynamic d2 = (int?) -2;
+ d2 <<= 1;
+ Assert (d2, -4, "#2a");
}
- void GreaterThanOrEqualTest ()
+ void LessThanTest ()
{
- Expression<Func<int, int, bool>> e = (int a, int b) => a >= b;
- AssertNodeType (e, ExpressionType.GreaterThanOrEqual);
- Assert (true, e.Compile ().Invoke (60, 30));
+ dynamic d = 5;
+
+ int v = 2;
+ Assert (d < v, false, "#1");
+ double v2 = 5;
+ Assert (d < v2, false, "#1a");
+
+ d = 4.6;
+ Assert (d < 4.59, false, "#2");
+ var b2 = 4.6;
+ Assert (d < b2, false, "#2a");
+
+ d = new MyType (30);
+ MyType v3 = new MyType (30);
+ Assert (d < v3, false, "#3");
+ dynamic d3 = new MyType (-7);
+ Assert (d3 < new MyType (6), true, "#3a");
+
+ d3 = new MyTypeImplicitOnly (-7);
+ Assert (d3 < 11, true, "#3b");
+
+ d = 2m;
+ decimal v4 = 4m;
+ Assert (d < v4, true, "#4");
+ Assert (d < 2m, false, "#4a");
}
- void GreaterThanOrEqualTest_2 ()
+ void LessThanNullableTest ()
{
- 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));
+ dynamic d = 5;
+
+ int? v2 = null;
+ Assert (d < v2, false, "#1");
+ Assert (d < null, false, "#1a");
+ Assert (null < d, false, "#1b");
+
+ v2 = -2;
+ Assert (d < v2, false, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 < 1, true, "#2a");
+ d2 = (uint?) 44;
+ Assert (d2 < 44, false, "#2b");
+
+ d = new MyType (30);
+ MyType? v3 = new MyType (30);
+ Assert (d < v3, false, "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 < new MyType (6), true, "#3a");
+
+ d3 = new MyTypeImplicitOnly (-7);
+ Assert (d3 < null, false, "#3b");
+
+ d = 4.1m;
+ decimal? v4 = 4m;
+ Assert (d < v4, false, "#4");
+ v4 = null;
+ Assert (d < v4, false, "#4a");
}
- void GreaterThanOrEqualTest_3 ()
+ void LessThanEnumTest ()
{
- 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");
+ dynamic d = MyEnum.Value_1;
+
+ Assert (d < null, false, "#1");
+
+ Assert (d < MyEnum.Value_1, false, "#2");
+ Assert (d < 0, false, "#2a");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
+ Assert (d2 < MyEnumUlong.Value_2, false, "#3");
+ Assert (d2 < null, false, "#3a");
}
- void GreaterThanOrEqualTest_4 ()
+ void LessThanOrEqualTest ()
{
- 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)));
+ dynamic d = 5;
+
+ int v = 2;
+ Assert (d <= v, false, "#1");
+ double v2 = 5;
+ Assert (d <= v2, true, "#1a");
+
+ d = 4.6;
+ Assert (d <= 4.59, false, "#2");
+ var b2 = 4.6;
+ Assert (d <= b2, true, "#2a");
+
+ d = new MyType (30);
+ MyType v3 = new MyType (30);
+ Assert (d <= v3, true, "#3");
+ dynamic d3 = new MyType (-7);
+ Assert (d3 <= new MyType (6), true, "#3a");
+
+ d3 = new MyTypeImplicitOnly (-7);
+ Assert (d3 <= 11, true, "#3b");
+
+ d = 2m;
+ decimal v4 = 4m;
+ Assert (d <= v4, true, "#4");
+ Assert (d <= 2m, true, "#4a");
}
- void GreaterThanOrEqualTest_5 ()
+ void LessThanOrEqualNullableTest ()
{
- 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));
+ dynamic d = 5;
+
+ int? v2 = null;
+ Assert (d <= v2, false, "#1");
+ Assert (d <= null, false, "#1a");
+ Assert (null <= d, false, "#1b");
+
+ v2 = -2;
+ Assert (d <= v2, false, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 <= 1, true, "#2a");
+ d2 = (uint?) 44;
+ Assert (d2 <= 44, true, "#2b");
+
+ d = new MyType (30);
+ MyType? v3 = new MyType (30);
+ Assert (d <= v3, true, "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 <= new MyType (6), true, "#3a");
+ Assert (d3 <= null, false, "#3b");
+
+ d = 4.1m;
+ decimal? v4 = 4m;
+ Assert (d <= v4, false, "#4");
+ v4 = null;
+ Assert (d <= v4, false, "#4a");
}
- void GreaterThanOrEqualTest_6 ()
+ void LessThanOrEqualEnumTest ()
{
- Expression<Func<ushort, bool>> e6 = (ushort a) => a >= null;
- AssertNodeType (e6, ExpressionType.GreaterThanOrEqual);
- Assert (false, e6.Compile ().Invoke (60));
+ dynamic d = MyEnum.Value_1;
+
+ Assert (d <= null, false, "#1");
+
+ Assert (d <= MyEnum.Value_1, true, "#2");
+ Assert (d <= 0, false, "#2a");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
+ Assert (d2 <= MyEnumUlong.Value_2, true, "#3");
+ Assert (d2 <= null, false, "#3a");
}
- void GreaterThanOrEqualTest_7 ()
+ void ModuloTest ()
{
- 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));
+ dynamic d = 5;
+
+ int v = 2;
+ Assert (d % v, 1, "#1");
+
+ d = new MyType (5);
+ MyType v3 = new MyType (30);
+ Assert (d % v3, new MyType (5), "#3");
+ dynamic d3 = new MyType (-7);
+ Assert<MyType> (d3 % new MyType (6), new MyType (-1), "#3a");
+
+ d = new MyTypeImplicitOnly (5);
+ decimal v4 = 4m;
+ Assert (d % v4, 1m, "#4");
}
- void GreaterThanOrEqualTest_8 ()
+ void ModuloNullableTest ()
{
- 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));
+ dynamic d = 5;
- // .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));
- }
+ double? v2 = null;
+ Assert<double?> (d % v2, null, "#1");
+ Assert<double?> (d % null, null, "#1a");
+ Assert<double?> (null % d, null, "#1b");
- 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));
- }
+ v2 = -2;
+ Assert (d % v2, 1, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 % 1, 0, "#2a");
- 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));
- }
+ d = new MyType (-2);
+ MyType? v3 = new MyType (30);
+ Assert (d % v3, new MyType (-2), "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 % new MyType (6), new MyType (-1), "#3a");
+ Assert<MyType?> (d3 + null, null, "#3b");
- 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)));
+ d = new MyTypeImplicitOnly (5);
+ decimal? v4 = 4m;
+ Assert (d % v4, 1m, "#4");
+ v4 = null;
+ Assert<decimal?> (d % v4, null, "#4a");
}
- void LessThanOrEqualTest_4 ()
+ void ModuloAssignTest ()
{
- 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)));
- }
+ dynamic d = 5;
- 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));
- }
+ int v = 2;
+ d %= v;
+ Assert (d, 1, "#1");
- void LessThanOrEqualTest_6 ()
- {
- Expression<Func<ushort, bool>> e6 = (ushort a) => a <= null;
- AssertNodeType (e6, ExpressionType.LessThanOrEqual);
- Assert (false, e6.Compile ().Invoke (60));
- }
+ d = 5.0;
+ double v2 = 0.5;
+ d %= v2;
+ Assert (d, 0, "#1a");
+ d %= v;
+ Assert (d, 0, "#1b");
- 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));
- }
+ dynamic d3 = new MyType (-7);
+ d3 %= new MyType (6);
+ Assert<MyType> (d3, new MyType (-1), "#3");
- 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);
+ d = 5m;
+ decimal v4 = 4m;
+ d %= v4;
+ Assert (d, 1m, "#4");
}
-
- 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 ()
+ void MultiplyTest ()
{
- Expression<Func<int>> e = () => new int { };
-
- AssertNodeType (e, ExpressionType.MemberInit);
- var r = e.Compile ().Invoke ();
- Assert (0, r);
- }
+ dynamic d = 5;
- 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));
- }
+ int v = 2;
+ Assert (d * v, 10, "#1");
+ double v2 = 0.5;
+ Assert (d * v2, 2.5, "#1a");
- 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));
- }
+ d = new MyType (5);
+ MyType v3 = new MyType (30);
+ Assert (d * v3, new MyType (150), "#3");
+ dynamic d3 = new MyType (-7);
+ Assert<MyType> (d3 * new MyType (6), new MyType (-42), "#3a");
- 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)));
- }
+ decimal v4 = 4m;
+ d = 7.9m;
+ Assert (d * v4, 31.6m, "#4");
+ }
- void ModuloTest_4 ()
+ void MultiplyNullableTest ()
{
- 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)));
- }
+ dynamic d = 5;
- 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)));
- }
+ int? v2 = null;
+ Assert<int?> (d * v2, null, "#1");
+ Assert<int?> (d * null, null, "#1a");
+ Assert<int?> (null * d, null, "#1b");
- 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));
- }
+ v2 = -2;
+ Assert (d * v2, -10, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 * 1, -2, "#2a");
- 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, ExpressionType.Multiply);
- Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (new MyType (-240), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
- }
-
- void MultiplyTest_5 ()
- {
- Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a * b;
- AssertNodeType (e5, ExpressionType.Multiply);
- Assert (198, e5.Compile ().Invoke (99, new MyType (2)));
- }
-
- void MultiplyTest_6 ()
- {
- Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a * b;
- AssertNodeType (e6, ExpressionType.Multiply);
- Assert (0, e6.Compile ().Invoke (int.MinValue, new MyType (200)));
- Assert (null, e6.Compile ().Invoke (20, null));
- }
-
- void MultiplyTest_7 ()
- {
- Expression<Func<ushort, int?>> e7 = (ushort a) => a * null;
- AssertNodeType (e7, ExpressionType.Multiply);
- Assert (null, e7.Compile ().Invoke (60));
+ d = new MyType (5);
+ MyType? v3 = new MyType (30);
+ Assert (d * v3, new MyType (150), "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 * new MyType (6), new MyType (-42), "#3a");
+ Assert<MyType?> (d3 * null, null, "#3b");
+
+ d = new MyTypeImplicitOnly (5);
+ decimal? v4 = 4m;
+ Assert (d * v4, 20m, "#4");
+ v4 = null;
+ Assert<decimal?> (d * v4, null, "#4a");
}
-
+
void MultiplyCheckedTest ()
{
checked {
- Expression<Func<int, int, int>> e = (int a, int b) => a * b;
- AssertNodeType (e, ExpressionType.MultiplyChecked);
- try {
- e.Compile ().Invoke (int.MaxValue, 309);
- throw new ApplicationException ("MultiplyCheckedTest #1");
- } catch (OverflowException) { }
- }
- }
-
- void MultiplyCheckedTest_2 ()
- {
- checked {
- Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a * b;
- AssertNodeType (e2, ExpressionType.MultiplyChecked);
- Assert (null, e2.Compile ().Invoke (null, 3));
- Assert (14025, e2.Compile ().Invoke (byte.MaxValue, 55));
- }
- }
-
- void MultiplyCheckedTest_3 ()
- {
- checked {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
- AssertNodeType (e3, ExpressionType.Multiply);
- Assert (-600, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
- }
- }
-
- void MultiplyCheckedTest_4 ()
- {
- checked {
- Expression<Func<double, double, double>> e4 = (a, b) => a * b;
- AssertNodeType (e4, ExpressionType.Multiply);
- Assert (double.PositiveInfinity, e4.Compile ().Invoke (double.MaxValue, int.MaxValue));
- }
- }
-
- void MultiplyCheckedTest_5 ()
- {
- checked {
- Expression<Func<float?, float?, float?>> e5 = (a, b) => b * a;
- AssertNodeType (e5, ExpressionType.MultiplyChecked);
- Assert (float.PositiveInfinity, e5.Compile ().Invoke (float.Epsilon, float.PositiveInfinity));
- }
- }
-
- void NegateTest ()
- {
- Expression<Func<int, int>> e = (a) => -a;
- AssertNodeType (e, ExpressionType.Negate);
- Assert (30, e.Compile ().Invoke (-30));
- }
-
- void NegateTest_2 ()
- {
- Expression<Func<sbyte, int>> e2 = (a) => -(-a);
- AssertNodeType (e2, ExpressionType.Negate);
- Assert (-10, e2.Compile ().Invoke (-10));
- }
-
- void NegateTest_3 ()
- {
- Expression<Func<long?, long?>> e3 = (a) => -a;
- AssertNodeType (e3, ExpressionType.Negate);
- Assert (long.MinValue + 1, e3.Compile ().Invoke (long.MaxValue));
- Assert (null, e3.Compile ().Invoke (null));
- }
-
- void NegateTest_4 ()
- {
- Expression<Func<MyType, MyType>> e4 = (a) => -a;
- AssertNodeType (e4, ExpressionType.Negate);
- Assert (new MyType (14), e4.Compile ().Invoke (new MyType (-14)));
- }
-
- void NegateTest_5 ()
- {
- Expression<Func<MyType?, MyType?>> e5 = (a) => -a;
- AssertNodeType (e5, ExpressionType.Negate);
- Assert (new MyType (-33), e5.Compile ().Invoke (new MyType (33)));
- Assert (null, e5.Compile ().Invoke (null));
- }
-
- void NegateTest_6 ()
- {
- Expression<Func<MyTypeImplicitOnly, int>> e6 = (MyTypeImplicitOnly a) => -a;
- AssertNodeType (e6, ExpressionType.Negate);
- Assert (-4, e6.Compile ().Invoke (new MyTypeImplicitOnly (4)));
- }
-
- void NegateTest_7 ()
- {
- Expression<Func<MyTypeImplicitOnly?, int?>> e7 = (MyTypeImplicitOnly? a) => -a;
- AssertNodeType (e7, ExpressionType.Negate);
- Assert (-46, e7.Compile ().Invoke (new MyTypeImplicitOnly (46)));
-
- // Another version of MS bug when predefined conversion is required on nullable user operator
- // Assert (null, e7.Compile ().Invoke (null));
- }
-
- void NegateTest_8 ()
- {
- Expression<Func<sbyte?, int?>> e8 = (a) => -a;
- AssertNodeType (e8, ExpressionType.Negate);
- Assert (11, e8.Compile ().Invoke (-11));
- }
-
- void NegateTest_9 ()
- {
- Expression<Func<uint, long>> e9 = (a) => -a;
- AssertNodeType (e9, ExpressionType.Negate);
- Assert (-2, e9.Compile ().Invoke (2));
- }
-
- void NegateTestChecked ()
- {
- checked {
- Expression<Func<int, int>> e = (int a) => -a;
- AssertNodeType (e, ExpressionType.NegateChecked);
- try {
- e.Compile ().Invoke (int.MinValue);
- throw new ApplicationException ("NegateTestChecked #1");
- } catch (OverflowException) { }
- }
- }
-
- void NegateTestChecked_2 ()
- {
- checked {
- Expression<Func<byte?, int?>> e2 = (a) => -a;
- AssertNodeType (e2, ExpressionType.NegateChecked);
- Assert (null, e2.Compile ().Invoke (null));
- Assert (-255, e2.Compile ().Invoke (byte.MaxValue));
- }
- }
-
- void NegateTestChecked_3 ()
- {
- checked {
- Expression<Func<MyType, MyType>> e3 = (MyType a) => -a;
- AssertNodeType (e3, ExpressionType.Negate);
- Assert (20, e3.Compile ().Invoke (new MyType (-20)));
- }
- }
-
- void NegateTestChecked_4 ()
- {
- checked {
- Expression<Func<double, double>> e4 = (a) => -a;
- AssertNodeType (e4, ExpressionType.Negate);
- Assert (double.NegativeInfinity, e4.Compile ().Invoke (double.PositiveInfinity));
- }
- }
-
- void NewArrayInitTest ()
- {
- Expression<Func<int []>> e = () => new int [0];
- AssertNodeType (e, ExpressionType.NewArrayInit);
- Assert (new int [0], e.Compile ().Invoke ());
- }
-
- void NewArrayInitTest_2 ()
- {
- Expression<Func<int []>> e1 = () => new int [] { };
- AssertNodeType (e1, ExpressionType.NewArrayInit);
- Assert (new int [0], e1.Compile ().Invoke ());
- }
-
- void NewArrayInitTest_3 ()
- {
- Expression<Func<ushort, ulong? []>> e2 = (ushort a) => new ulong? [] { a };
- AssertNodeType (e2, ExpressionType.NewArrayInit);
- Assert (new ulong? [1] { ushort.MaxValue }, e2.Compile ().Invoke (ushort.MaxValue));
- }
-
- void NewArrayInitTest_4 ()
- {
- Expression<Func<char [] []>> e3 = () => new char [] [] { new char [] { 'a' } };
- AssertNodeType (e3, ExpressionType.NewArrayInit);
- Assert (new char [] { 'a' }, e3.Compile ().Invoke () [0]);
- }
-
- void NewArrayInitTest_5 ()
- {
- Expression<Func<int?[]>> e = () => new int?[] { null, 3, 4 };
- AssertNodeType (e, ExpressionType.NewArrayInit);
- Assert (3, e.Compile ().Invoke ().Length);
- }
+ dynamic d = 5;
- void NewArrayInitTest_6 ()
- {
- Expression<Func<string []>> e = () => new [] { null, "a" };
- AssertNodeType (e, ExpressionType.NewArrayInit);
- Assert (2, e.Compile ().Invoke ().Length);
- }
-
- void NewArrayBoundsTest ()
- {
- Expression<Func<int [,]>> e = () => new int [2,3];
- AssertNodeType (e, ExpressionType.NewArrayBounds);
- Assert (new int [2,3].Length, e.Compile ().Invoke ().Length);
- }
-
- void NewArrayBoundsTest_2 ()
- {
- Expression<Func<int[,]>> e2 = () => new int [0,0];
- AssertNodeType (e2, ExpressionType.NewArrayBounds);
- Assert (new int [0, 0].Length, e2.Compile ().Invoke ().Length);
- }
-
- void NewTest ()
- {
- Expression<Func<MyType>> e = () => new MyType (2);
- AssertNodeType (e, ExpressionType.New);
- Assert (new MyType (2), e.Compile ().Invoke ());
- }
-
- void NewTest_2 ()
- {
- Expression<Func<MyType>> e2 = () => new MyType ();
- AssertNodeType (e2, ExpressionType.New);
- Assert (new MyType (), e2.Compile ().Invoke ());
- }
-
- void NewTest_3 ()
- {
- Expression<Func<NewTest<bool>>> e3 = () => new NewTest<bool> (true);
- AssertNodeType (e3, ExpressionType.New);
- Assert (new NewTest<bool> (true), e3.Compile ().Invoke ());
- }
-
- void NewTest_4 ()
- {
- Expression<Func<decimal, NewTest<decimal>>> e4 = (decimal d) => new NewTest<decimal> (1, 5, d);
- AssertNodeType (e4, ExpressionType.New);
- Assert (new NewTest<decimal> (1, 5, -9), e4.Compile ().Invoke (-9));
- }
-
- void NewTest_5 ()
- {
- Expression<Func<object>> e5 = () => new { A = 9, Value = "a" };
- AssertNodeType (e5, ExpressionType.New);
- Assert (new { A = 9, Value = "a" }, e5.Compile ().Invoke ());
- }
+ int v = int.MaxValue;
+ AssertChecked (() => d * v, 7, "#1");
- // CSC bug: emits new MyEnum as a constant
- void NewTest_6 ()
- {
- Expression<Func<MyEnum>> e = () => new MyEnum ();
- AssertNodeType (e, ExpressionType.New);
- Assert<MyEnum> (0, e.Compile ().Invoke ());
- }
+ int? v2 = v;
+ AssertChecked (() => d * v2, null, "#2");
- void NotTest ()
- {
- Expression<Func<bool, bool>> e = (bool a) => !a;
- AssertNodeType (e, ExpressionType.Not);
- Assert (false, e.Compile ().Invoke (true));
- }
+ d = new MyType (4);
+ MyType v3 = new MyType (int.MaxValue);
+ Assert (d * v3, new MyType (-4), "#3");
+ }
+ }
- void NotTest_2 ()
+ void MultiplyAssignTest ()
{
- Expression<Func<MyType, bool>> e2 = (MyType a) => !a;
- AssertNodeType (e2, ExpressionType.Not);
- Assert (true, e2.Compile ().Invoke (new MyType (1)));
- Assert (false, e2.Compile ().Invoke (new MyType (-1)));
- }
+ dynamic d = 5;
- void NotTest_3 ()
- {
- Expression<Func<int, int>> e3 = (int a) => ~a;
- AssertNodeType (e3, ExpressionType.Not);
- Assert (-8, e3.Compile ().Invoke (7));
- }
+ int v = 2;
+ d *= v;
+ Assert (d, 10, "#1");
- void NotTest_4 ()
- {
- Expression<Func<MyType, int>> e4 = (MyType a) => ~a;
- AssertNodeType (e4, ExpressionType.Not);
- Assert (0, e4.Compile ().Invoke (new MyType (-1)));
- }
+ d = 5.0;
+ double v2 = 0.5;
+ d *= v2;
+ Assert (d, 2.5, "#1a");
+ d *= v;
+ Assert (d, 5, "#1b");
- void NotTest_5 ()
- {
- Expression<Func<ulong, ulong>> e5 = (ulong a) => ~a;
- AssertNodeType (e5, ExpressionType.Not);
- Assert<ulong> (18446744073709551608, e5.Compile ().Invoke (7));
- }
+ dynamic d3 = new MyType (-7);
+ d3 *= new MyType (6);
+ Assert<MyType> (d3, new MyType (-42), "#3");
- void NotTest_6 ()
- {
- Expression<Func<MyEnum, MyEnum>> e6 = (MyEnum a) => ~a;
- AssertNodeType (e6, ExpressionType.Convert);
- Assert ((MyEnum)254, e6.Compile ().Invoke (MyEnum.Value_1));
+ d = 5m;
+ decimal v4 = 4m;
+ d *= v4;
+ Assert (d, 20m, "#4");
+
+ int i = 3;
+ d = 5;
+ i *= d;
+ Assert (i, 15, "#5");
}
- void NotNullableTest ()
+ void MultiplyAssignCheckedTest ()
{
- Expression<Func<bool?, bool?>> e = (bool? a) => !a;
- AssertNodeType (e, ExpressionType.Not);
- Assert (false, e.Compile ().Invoke (true));
- Assert (null, e.Compile ().Invoke (null));
+ checked {
+ dynamic d = 5;
+
+ int v = int.MaxValue;
+ AssertChecked (() => { d *= v; Assert (d, 0, "#1-"); }, "#1");
+
+ d = new MyType (44);
+ MyType v3 = new MyType (int.MaxValue);
+ d *= v3;
+ Assert (d, new MyType (-44), "#3-");
+ }
}
- void NotNullableTest_2 ()
+ void Negate ()
{
- Expression<Func<MyType?, bool?>> e2 = (MyType? a) => !a;
- AssertNodeType (e2, ExpressionType.Not);
- Assert (true, e2.Compile ().Invoke (new MyType (1)));
- Assert (null, e2.Compile ().Invoke (null));
+ dynamic d = -8;
+ Assert (8, -d, "#1");
+ Assert (-8, -(-d), "#1a");
+
+ d = new MyType (-14);
+ Assert (new MyType (14), -d, "#2");
+
+ d = new MyTypeImplicitOnly (4);
+ Assert (-4, -d, "#3");
+
+ d = (uint) 7;
+ Assert (-7, -d, "#4");
+
+ d = double.NegativeInfinity;
+ Assert (double.PositiveInfinity, -d, "#5");
}
- void NotNullableTest_3 ()
+ void NegateNullable ()
{
- Expression<Func<sbyte?, int?>> e3 = (sbyte? a) => ~a;
- AssertNodeType (e3, ExpressionType.Not);
- Assert (-5, e3.Compile ().Invoke (4));
- Assert (null, e3.Compile ().Invoke (null));
+ dynamic d = (int?) -8;
+ Assert (8, -d, "#1");
+ Assert (-8, -(-d), "#1a");
+
+ MyType? n1 = new MyType (4);
+ d = n1;
+ Assert (new MyType (-4), -d, "#2");
+
+ MyTypeImplicitOnly? n2 = new MyTypeImplicitOnly (4);
+ d = n2;
+ Assert (-4, -d, "#3");
+
+ d = (sbyte?) 7;
+ Assert (-7, -d, "#4");
}
- void NotNullableTest_4 ()
+ void NegateChecked ()
{
- Expression<Func<MyType?, int?>> e4 = (MyType? a) => ~a;
- AssertNodeType (e4, ExpressionType.Not);
- Assert (0, e4.Compile ().Invoke (new MyType (-1)));
- Assert (null, e4.Compile ().Invoke (null));
+ checked {
+ dynamic d = int.MinValue;
+ AssertChecked (() => -d, 0, "#1");
+ }
}
- void NotNullableTest_5 ()
+ void Not ()
{
- Expression<Func<MyEnum?, MyEnum?>> e5 = (MyEnum? a) => ~a;
- AssertNodeType (e5, ExpressionType.Convert);
- Assert ((MyEnum) 254, e5.Compile ().Invoke (MyEnum.Value_1));
- Assert (null, e5.Compile ().Invoke (null));
+ dynamic d = true;
+ Assert (false, !d, "#1");
+
+ var de = new MyType (-1);
+ Assert (false, !d, "#2");
}
void NotEqualTest ()
{
- Expression<Func<int, int, bool>> e = (int a, int b) => a != b;
- AssertNodeType (e, ExpressionType.NotEqual);
- Assert (true, e.Compile ().Invoke (60, 30));
- Assert (false, e.Compile ().Invoke (-1, -1));
- }
+ dynamic d = 5;
- void NotEqualTest_2 ()
- {
- Expression<Func<sbyte?, sbyte?, bool>> e2 = (a, b) => a != b;
- AssertNodeType (e2, ExpressionType.NotEqual);
- Assert (false, e2.Compile ().Invoke (3, 3));
- Assert (true, e2.Compile ().Invoke (3, 2));
- }
+ int v = 2;
+ Assert (d != v, true, "#1");
+ double v2 = 5;
+ Assert (d != v2, false, "#1a");
- void NotEqualTest_3 ()
- {
- Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a != b;
- AssertNodeType (e3, ExpressionType.NotEqual);
- Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
- }
+ d = true;
+ Assert (d != false, true, "#2");
+ bool b2 = true;
+ Assert (d != b2, false, "#2a");
- void NotEqualTest_4 ()
- {
- Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a != b;
- AssertNodeType (e4, ExpressionType.NotEqual);
- Assert (true, e4.Compile ().Invoke (null, new MyType (-20)));
- Assert (false, e4.Compile ().Invoke (null, null));
- Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
- }
+ d = new MyType (30);
+ MyType v3 = new MyType (30);
+ Assert (d != v3, false, "#3");
+ dynamic d3 = new MyType (-7);
+ Assert (d3 != new MyType (6), true, "#3a");
- void NotEqualTest_5 ()
- {
- Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a != b;
- AssertNodeType (e5, ExpressionType.NotEqual);
- Assert (true, e5.Compile ().Invoke (true, null));
- Assert (false, e5.Compile ().Invoke (null, null));
- Assert (false, e5.Compile ().Invoke (false, false));
- }
+ d = 2m;
+ decimal v4 = 4m;
+ Assert (d != v4, true, "#4");
+ Assert (d != 2m, false, "#4a");
- void NotEqualTest_6 ()
- {
- Expression<Func<bool, bool>> e6 = (bool a) => a != null;
- AssertNodeType (e6, ExpressionType.NotEqual);
- Assert (true, e6.Compile ().Invoke (true));
- Assert (true, e6.Compile ().Invoke (false));
+ d = null;
+ Assert (d != null, false, "#5");
}
- void NotEqualTest_7 ()
+ void NotEqualNullableTest ()
{
- Expression<Func<string, string, bool>> e7 = (string a, string b) => a != b;
- AssertNodeType (e7, ExpressionType.NotEqual);
- Assert (false, e7.Compile ().Invoke (null, null));
- Assert (true, e7.Compile ().Invoke ("a", "A"));
- Assert (false, e7.Compile ().Invoke ("a", "a"));
+ dynamic d = 5;
+
+ int? v2 = null;
+ Assert (d != v2, true, "#1");
+ Assert (d != null, true, "#1a");
+ Assert (null != d, true, "#1b");
+
+ v2 = -2;
+ Assert (d != v2, true, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 != 1, true, "#2a");
+ d2 = (uint?) 44;
+ Assert (d2 != 44, false, "#2b");
+
+ d = new MyType (30);
+ MyType? v3 = new MyType (30);
+ Assert (d != v3, false, "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 != new MyType (6), true, "#3a");
+ Assert (d3 != null, true, "#3b");
+
+ d = 4.1m;
+ decimal? v4 = 4m;
+ Assert (d != v4, true, "#4");
+ v4 = null;
+ Assert (d != v4, true, "#4a");
+
+ d = (bool?) true;
+ Assert (d != true, false, "#5");
+ Assert (d != null, true, "#5a");
+ Assert (d != false, true, "#5b");
+
+ d = null;
+ long? l = null;
+ Assert (d != l, false, "#6a");
+ Assert (l != d, false, "#6b");
}
- void NotEqualTest_8 ()
+ void NotEqualEnumTest ()
{
- Expression<Func<object, bool>> e8 = (object a) => null != a;
- AssertNodeType (e8, ExpressionType.NotEqual);
- Assert (false, e8.Compile ().Invoke (null));
- Assert (true, e8.Compile ().Invoke ("a"));
- Assert (true, e8.Compile ().Invoke (this));
+ dynamic d = MyEnum.Value_1;
+
+ Assert (d != null, true, "#1");
+
+ Assert (d != MyEnum.Value_1, false, "#2");
+ Assert (d != 0, true, "#2a");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
+ Assert (d2 != MyEnumUlong.Value_2, false, "#3");
+ Assert (d2 != null, true, "#3a");
}
- void NotEqualTest_9 ()
+ void NotEqualStringTest ()
{
- Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a != b;
- AssertNodeType (e9, ExpressionType.NotEqual);
- Assert (true, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
- Assert (false, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
+ dynamic d = "text";
+
+ Assert (d != "te", true, "#1");
+ Assert (d != "text", false, "#1a");
+ Assert (d != null, true, "#1b");
}
- void NotEqualTest_10 ()
+ void OnesComplement ()
{
- Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a != b;
- AssertNodeType (e10, ExpressionType.NotEqual);
- Assert (true, e10.Compile ().Invoke (MyEnum.Value_1, null));
- Assert (false, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
+ dynamic d = 7;
+ Assert (-8, ~d, "#1");
+
+ d = new MyType (-1);
+ Assert (0, ~d, "#2");
+
+ d = (ulong) 7;
+ Assert (18446744073709551608, ~d, "#3");
+
+ d = MyEnum.Value_1;
+ Assert ((MyEnum) 254, ~d, "#4");
}
- void NotEqualTest_11 ()
+ void OnesComplementNullable ()
{
- Expression<Func<MyEnum?, bool>> e11 = (a) => a != null;
- AssertNodeType (e11, ExpressionType.NotEqual);
- Assert (true, e11.Compile ().Invoke (MyEnum.Value_1));
- Assert (false, e11.Compile ().Invoke (null));
+ dynamic d = (int?) 7;
+ Assert (-8, ~d, "#1");
+
+ d = (MyEnum?) MyEnum.Value_1;
+ Assert ((MyEnum) 254, ~d, "#4");
}
void OrTest ()
{
- Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a | b;
+ dynamic d = true;
- AssertNodeType (e, ExpressionType.Or);
- Func<bool, bool, bool> c = e.Compile ();
+ var v = false;
+ Assert (d | v, true, "#1");
+ Assert (d | false, true, "#1a");
- Assert (true, c (true, true));
- Assert (true, c (true, false));
- Assert (true, c (false, true));
- Assert (false, c (false, false));
- }
+ d = 42;
+ var v2 = 62;
+ Assert (d | v2, 62, "#2");
+ Assert (d | 0, 42, "#2a");
- void OrTest_2 ()
- {
- Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a | b;
- AssertNodeType (e2, ExpressionType.Or);
- var c2 = e2.Compile ();
- Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
- }
+ d = new MyType (42);
+ MyType v3 = new MyType (30);
+ Assert (d | v3, new MyType (62), "#3");
+ dynamic d3 = new MyType (-7);
+ Assert<MyType> (d3 | new MyType (6), new MyType (-1), "#3a");
- void OrTest_3 ()
- {
- Expression<Func<MyEnum, MyEnum, MyEnum>> e3 = (a, b) => a | b;
- AssertNodeType (e3, ExpressionType.Convert);
- Assert ((MyEnum)3, e3.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
- Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
+ d3 = new MyTypeImplicitOnly (-7);
+ Assert (d3 | 11, -5, "#3b");
}
- void OrNullableTest ()
+ void OrTestEnum ()
{
- Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a | b;
+ dynamic d = MyEnum.Value_1;
- AssertNodeType (e, ExpressionType.Or);
- Func<bool?, bool?, bool?> c = e.Compile ();
+ Assert<MyEnum?> (d | null, null, "#1");
- Assert (true, c (true, true));
- Assert (true, c (true, false));
- Assert (true, c (false, true));
- Assert (false, c (false, false));
+ Assert (d | d, MyEnum.Value_1, "#2");
- Assert (true, c (true, null));
- Assert (null, c (false, null));
- Assert (null, c (null, false));
- Assert (true, c (true, null));
- Assert (null, c (null, null));
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
+ Assert<MyEnumUlong> (d2 | MyEnumUlong.Value_2, (MyEnumUlong) 3, "#3");
}
- void OrNullableTest_2 ()
+ void OrTestNullable ()
{
- Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a | b;
- AssertNodeType (e2, ExpressionType.Or);
- var c2 = e2.Compile ();
- Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
- Assert (null, c2 (new MyType (1), null));
- }
+ dynamic d = 5;
- // CSC BUG: Fixed?
- void OrNullableTest_3 ()
- {
- Expression<Func<MyType?, uint, long?>> e3 = (MyType? a, uint b) => a | b;
- AssertNodeType (e3, ExpressionType.Or);
- var c3 = e3.Compile ();
- Assert (9, c3 (new MyType (1), 8));
- }
+ int? v2 = null;
+ Assert<int?> (d | v2, null, "#1");
+ Assert<int?> (d | null, null, "#1a");
+ Assert<int?> (null | d, null, "#1b");
- void OrNullableTest_4 ()
- {
- Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e4 = (a, b) => a | b;
- AssertNodeType (e4, ExpressionType.Convert);
- Assert (null, e4.Compile ().Invoke (null, MyEnum.Value_2));
- Assert ((MyEnum)3, e4.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
- }
+ v2 = -2;
+ Assert (d | v2, -1, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 | 1, -1, "#2a");
- void OrElseTest ()
- {
- Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a || b;
- AssertNodeType (e, ExpressionType.OrElse);
- Assert (true, e.Compile ().Invoke (true, false));
+ d = new MyType (-2);
+ MyType? v3 = new MyType (30);
+ Assert (d | v3, new MyType (-2), "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 | new MyType (6), new MyType (-1), "#3a");
}
- void OrElseTest_2 ()
+ void OrAssignedTest ()
{
- Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a || b;
- AssertNodeType (e2, ExpressionType.OrElse);
- Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
- Assert (new MyType (32), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
- }
+ dynamic d = true;
- void ParameterTest ()
- {
- Expression<Func<string, string>> e = (string a) => a;
- AssertNodeType (e, ExpressionType.Parameter);
- Assert ("t", e.Compile ().Invoke ("t"));
+ var v = false;
+ d |= v;
+ Assert (d, true, "#1");
+ d = true;
+ d |= true;
+ Assert (d, true, "#1a");
+
+ d = 42;
+ var v2 = 62;
+ d |= v2;
+ Assert (d, 62, "#2");
+
+ MyType v3 = new MyType (30);
+ dynamic d3 = new MyType (-7);
+ d3 |= new MyType (6);
+ Assert<MyType> (d3, new MyType (-1), "#3");
}
- void ParameterTest_2 ()
+ void OrAssignedTestEnum ()
{
- Expression<Func<object[], object[]>> e2 = (object[] a) => a;
- AssertNodeType (e2, ExpressionType.Parameter);
- Assert (new object [0], e2.Compile ().Invoke (new object [0]));
+ dynamic d = MyEnum.Value_1;
+ d |= MyEnum.Value_2;
+ Assert<MyEnum> (d, (MyEnum) 3, "#1");
+
+ d = MyEnum.Value_2;
+ d |= d;
+ Assert (d, MyEnum.Value_2, "#2");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
+ Assert<MyEnumUlong> (d2 | MyEnumUlong.Value_2, (MyEnumUlong)3, "#3");
}
- void ParameterTest_3 ()
+ void OrElseTest ()
{
- Expression<Func<IntPtr, IntPtr>> e3 = a => a;
- AssertNodeType (e3, ExpressionType.Parameter);
- Assert (IntPtr.Zero, e3.Compile ().Invoke (IntPtr.Zero));
- }
+ dynamic d = true;
- //unsafe void ParameterTest_4 ()
- //{
- // Expression<Func<int*[], int* []>> e4 = (a) => a;
- // AssertNodeType (e4, ExpressionType.Parameter);
- // Assert<int*[]> (null, e4.Compile ().Invoke (null));
- // int* e4_el = stackalloc int [5];
- // int*[] ptr = new int*[] { e4_el };
- // Assert<int*[]> (ptr, e4.Compile ().Invoke (ptr));
- //}
+ var v = false;
+ Assert<bool> (d || v, true, "#1");
- void QuoteTest ()
- {
- Expression<Func<Expression<Func<int>>>> e = () => () => 2;
- AssertNodeType (e, ExpressionType.Quote);
- Assert (2, e.Compile ().Invoke ().Compile ().Invoke ());
+ Assert (d || true, true, "#1a");
+
+ d = true;
+ Assert (d || d, true, "#2");
+
+ dynamic d3 = new MyType (-7);
+ Assert<MyType> (d3 || new MyType (6), new MyType (-7), "#3");
}
void RightShiftTest ()
{
- Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a >> b;
- AssertNodeType (e, ExpressionType.RightShift);
- Assert ((ulong) 0x1FD940L, e.Compile ().Invoke (0xFECA0000, 11));
- Assert ((ulong) 0x7FFFFFFF, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
+ dynamic d = (ulong) 0x7F000;
- // .net produces a strange result
- // see https://bugzilla.novell.com/show_bug.cgi?id=398358
- // Assert ((ulong)0, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
+ int v = 2;
+ Assert<ulong> (d >> v, 0x1FC00, "#1");
+ Assert<ulong> (d >> 1, 0x3F800, "#1a");
+ short s = 2;
+ Assert<ulong> (d >> s, 0x1FC00, "#1b");
+
+ d = 0x7F000;
+ MyTypeImplicitOnly v3 = new MyTypeImplicitOnly (3);
+ Assert (d >> v3, 0xFE00, "#3");
+ dynamic d3 = new MyType (-7);
+ Assert (d3 >> new MyTypeImplicitOnly (11), -1, "#3a");
}
- void RightShiftTest_2 ()
+ void RightShiftNullableTest ()
{
- Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a >> b;
- AssertNodeType (e2, ExpressionType.RightShift);
- var c2 = e2.Compile ();
- Assert (64, c2 (new MyType (256), new MyType (2)));
+ dynamic d = 5;
+
+ int? v2 = null;
+ Assert<int?> (d >> v2, null, "#1");
+ d = 5;
+ Assert<int?> (d >> null, null, "#1a");
+ d = 5;
+ Assert<int?> (null >> d, null, "#1b");
+
+ v2 = -2;
+ Assert (d >> v2, 0, "#2");
+ dynamic d2 = (int?) -200;
+ Assert (d2 >> 1, -100, "#2a");
+
+ dynamic d3 = (int?) null;
+ Assert (d3 >> (null >> null), (int?) null, "#3");
}
- void RightShiftTest_3 ()
+ void RightShiftAssignTest ()
{
- Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a >> b;
- AssertNodeType (e3, ExpressionType.RightShift);
- Assert (null, e3.Compile ().Invoke (null, 11));
- Assert (512, e3.Compile ().Invoke (1024, 1));
+ dynamic d = 0x7F000;
+
+ int v = 2;
+ d >>= v;
+ Assert (d, 0x1FC00, "#1");
+ d >>= 1;
+ Assert (d, 0xFE00, "#1a");
+ sbyte s = 2;
+ d >>= s;
+ Assert (d, 0x3F80, "#1b");
}
- void RightShiftTest_4 ()
+ void RightShiftAssignNullableTest ()
{
- Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a >> b;
- AssertNodeType (e4, ExpressionType.RightShift);
- var c4 = e4.Compile ();
- Assert (null, c4 (new MyType (8), null));
- Assert (null, c4 (null, new MyType (8)));
- Assert (64, c4 (new MyType (256), new MyType (2)));
+ dynamic d = 0x2A0;
+
+ var v2 = -2;
+ d >>= v2;
+ Assert (d, 0, "#2");
+ dynamic d2 = (int?) -2;
+ d2 >>= 1;
+ Assert (d2, -1, "#2a");
}
-
+
void SubtractTest ()
{
- Expression<Func<int, int, int>> e = (int a, int b) => a - b;
- AssertNodeType (e, ExpressionType.Subtract);
- Assert (-10, e.Compile ().Invoke (20, 30));
- }
-
- void SubtractTest_2 ()
- {
- Expression<Func<int?, int?, int?>> e2 = (a, b) => a - b;
- AssertNodeType (e2, ExpressionType.Subtract);
- Assert (null, e2.Compile ().Invoke (null, 3));
- }
-
- void SubtractTest_3 ()
- {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a - b;
- AssertNodeType (e3, ExpressionType.Subtract);
- Assert (-50, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
- }
-
- void SubtractTest_4 ()
- {
- Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a - b;
- AssertNodeType (e4, ExpressionType.Subtract);
- Assert (new MyType (-50), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
- Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
- }
-
- void SubtractTest_5 ()
- {
- Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a - b;
- AssertNodeType (e5, ExpressionType.Subtract);
- Assert (-29, e5.Compile ().Invoke (1, new MyType (30)));
- }
-
- void SubtractTest_6 ()
- {
- Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a - b;
- AssertNodeType (e6, ExpressionType.Subtract);
- Assert (-61, e6.Compile ().Invoke (-31, new MyType (30)));
- }
-
- void SubtractTest_7 ()
- {
- Expression<Func<ushort, int?>> e7 = (ushort a) => null - a;
- AssertNodeType (e7, ExpressionType.Subtract);
- Assert (null, e7.Compile ().Invoke (690));
- }
-
- void SubtractTest_8 ()
- {
- Expression<Func<MyEnum, byte, MyEnum>> e8 = (a, b) => a - b;
- AssertNodeType (e8, ExpressionType.Convert);
- Assert ((MyEnum)255, e8.Compile ().Invoke (MyEnum.Value_1, 2));
- }
-
- void SubtractTest_9 ()
- {
- Expression<Func<MyEnum, MyEnum, byte>> e9 = (a, b) => a - b;
- AssertNodeType (e9, ExpressionType.Convert);
- Assert (1, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
+ dynamic d = 5;
+
+ int v = 2;
+ Assert (d - v, 3, "#1");
+ double v2 = 0.5;
+ Assert (d - v2, 4.5, "#1a");
+
+ d = new MyType (5);
+ MyType v3 = new MyType (30);
+ Assert (d - v3, new MyType (-25), "#3");
+ dynamic d3 = new MyType (-7);
+ Assert (d3 - new MyType (6), new MyType (-13), "#3a");
+
+ d = new MyTypeImplicitOnly (5);
+ decimal v4 = 4m;
+ Assert (d - v4, 1m, "#4");
}
- // CSC bug
- void SubtractTest_10 ()
+ void SubtractNullableTest ()
{
- Expression<Func<MyEnum?, byte?, MyEnum?>> e10 = (a, b) => a - b;
- AssertNodeType (e10, ExpressionType.Convert);
- Assert ((MyEnum) 255, e10.Compile ().Invoke (MyEnum.Value_1, 2));
+ dynamic d = 5;
+
+ int? v2 = null;
+ Assert<int?> (d - v2, null, "#1");
+ Assert<int?> (d - null, null, "#1a");
+ Assert<int?> (null - d, null, "#1b");
+
+ v2 = -2;
+ Assert (d - v2, 7, "#2");
+ dynamic d2 = (int?) -2;
+ Assert (d2 - 1, -3, "#2a");
+
+ d = new MyType (5);
+ MyType? v3 = new MyType (30);
+ Assert (d - v3, new MyType (-25), "#3");
+ dynamic d3 = new MyType? (new MyType (-7));
+ Assert (d3 - new MyType (6), new MyType (-13), "#3a");
+ Assert<MyType?> (d3 - null, null, "#3b");
+
+ d = new MyTypeImplicitOnly (5);
+ decimal? v4 = 4m;
+ Assert (d - v4, 1m, "#4");
+ v4 = null;
+ Assert<decimal?> (d - v4, null, "#4a");
}
- // CSC bug
- void SubtractTest_11 ()
+ void SubtractEnumTest ()
{
- Expression<Func<MyEnum?, MyEnum?, byte?>> e11 = (a, b) => a - b;
- AssertNodeType (e11, ExpressionType.Convert);
- Assert<byte?> (1, e11.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
+ dynamic d = MyEnum.Value_1;
+
+ Assert<MyEnum> (d - 1, 0, "#1");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
+ Assert (d2 - (byte) 1, MyEnumUlong.Value_1, "#2");
+ Assert<MyEnumUlong?> (d2 - null, null, "#2a");
+
+ // CSC: Invalid System.InvalidOperationException
+ Assert<MyEnum?> (d - null, null, "#3");
}
void SubtractCheckedTest ()
{
checked {
- Expression<Func<long, long, long>> e = (long a, long b) => a - b;
- AssertNodeType (e, ExpressionType.SubtractChecked);
- try {
- e.Compile ().Invoke (long.MinValue, 309);
- throw new ApplicationException ("SubtractCheckedTest #1");
- } catch (OverflowException) { }
+ dynamic d = 5;
+
+ int v = int.MinValue;
+ AssertChecked (() => d - v, 7, "#1");
+
+ int? v2 = v;
+ AssertChecked (() => d - v2, null, "#2");
+
+ d = new MyType (5);
+ MyType v3 = new MyType (int.MinValue);
+ Assert (d - v3, new MyType (-2147483643), "#3");
}
}
- void SubtractCheckedTest_2 ()
+ void SubtractAssignTest ()
{
- checked {
- Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a - b;
- AssertNodeType (e2, ExpressionType.SubtractChecked);
- Assert (null, e2.Compile ().Invoke (null, 3));
- Assert (-55, e2.Compile ().Invoke (byte.MinValue, 55));
- }
+ dynamic d = 5;
+
+ int v = 2;
+ d -= v;
+ Assert (d, 3, "#1");
+
+ d = 5.0;
+ double v2 = 0.5;
+ d -= v2;
+ Assert (d, 4.5, "#1a");
+ d -= v;
+ Assert (d, 2.5, "#1b");
+
+ dynamic d3 = new MyType (-7);
+ d3 -= new MyType (6);
+ Assert<MyType> (d3, new MyType (-13), "#3");
+
+ d = 5m;
+ decimal v4 = 4m;
+ d -= v4;
+ Assert (d, 1m, "#4");
}
- void SubtractCheckedTest_3 ()
+ void SubtractAssignEnumTest ()
{
- checked {
- Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a - b;
- AssertNodeType (e3, ExpressionType.Subtract);
- Assert (-50, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
- }
+ dynamic d = MyEnum.Value_1;
+
+ d -= 1;
+ Assert<MyEnum> (d, 0, "#2");
+
+ dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
+ d2 -= (byte) 1;
+ Assert (d2, MyEnumUlong.Value_1, "#3");
}
- void SubtractCheckedTest_4 ()
+ void SubtractAssignCheckedTest ()
{
checked {
- Expression<Func<double, double, double>> e4 = (a, b) => a - b;
- AssertNodeType (e4, ExpressionType.Subtract);
- Assert (double.PositiveInfinity, e4.Compile ().Invoke (double.MinValue, double.NegativeInfinity));
+ dynamic d = 5;
+
+ int v = int.MinValue;
+ AssertChecked (() => { d -= v; Assert (d, 0, "#1a"); }, "#1");
+
+ d = new MyType (5);
+ MyType v3 = new MyType (int.MinValue);
+ d -= v3;
+ Assert (d, new MyType (-2147483643), "#3a");
}
}
-
- void TypeAsTest ()
- {
- Expression<Func<object, Tester>> e = (object a) => a as Tester;
- AssertNodeType (e, ExpressionType.TypeAs);
- Assert (this, e.Compile ().Invoke (this));
- }
-
- void TypeAsTest_2 ()
- {
- Expression<Func<object, int?>> e2 = (object a) => a as int?;
- AssertNodeType (e2, ExpressionType.TypeAs);
- Assert (null, e2.Compile ().Invoke (null));
- Assert (null, e2.Compile ().Invoke (this));
- Assert (44, e2.Compile ().Invoke (44));
- }
-
- void TypeAsTest_3 ()
- {
- Expression<Func<object, object>> e3 = (object a) => null as object;
- AssertNodeType (e3, ExpressionType.TypeAs);
- Assert (null, e3.Compile ().Invoke (null));
- }
- void TypeIsTest ()
- {
- Expression<Func<object, bool>> e = (object a) => a is Tester;
- AssertNodeType (e, ExpressionType.TypeIs);
- Assert (true, e.Compile ().Invoke (this));
- Assert (false, e.Compile ().Invoke (1));
- }
-
- void TypeIsTest_2 ()
- {
- Expression<Func<object, bool>> e2 = (object a) => a is int?;
- AssertNodeType (e2, ExpressionType.TypeIs);
- Assert (false, e2.Compile ().Invoke (null));
- Assert (true, e2.Compile ().Invoke (1));
- }
-
- void TypeIsTest_3 ()
- {
- Expression<Func<object, bool>> e3 = (object a) => null is object;
- AssertNodeType (e3, ExpressionType.TypeIs);
- Assert (false, e3.Compile ().Invoke (null));
- }
-
- void TypeIsTest_5 ()
- {
- Expression<Func<bool>> e5 = () => 1 is int;
- AssertNodeType (e5, ExpressionType.TypeIs);
- Assert (true, e5.Compile ().Invoke ());
- }
-
- void TypeIsTest_6 ()
- {
- Expression<Func<int?, bool>> e6 = (a) => a is int;
- AssertNodeType (e6, ExpressionType.TypeIs);
- Assert (true, e6.Compile ().Invoke (1));
- Assert (false, e6.Compile ().Invoke (null));
- }
-
- void UnaryPlusTest ()
- {
- Expression<Func<int, int>> e = (a) => +a;
- AssertNodeType (e, ExpressionType.Parameter);
- Assert (-30, e.Compile ().Invoke (-30));
- }
-
- void UnaryPlusTest_2 ()
+ void SubtractAssignEvent ()
{
- Expression<Func<long?, long?>> e2 = (a) => +a;
- AssertNodeType (e2, ExpressionType.Parameter);
+ Action print = () => { Console.WriteLine ("foo"); };
+ dynamic d = print;
+
+ // FIXME: Will have to special case events
+ //ev_assign -= d;
+ //ev_assign ();
}
-
- void UnaryPlusTest_3 ()
+
+ void UnaryDecrement ()
{
- Expression<Func<MyType, MyType>> e4 = (a) => +a;
- AssertNodeType (e4, ExpressionType.UnaryPlus);
- Assert (new MyType (-14), e4.Compile ().Invoke (new MyType (-14)));
+ dynamic d = 3;
+ Assert (3, d--, "#1");
+ Assert (2, d, "#1a");
+
+ d = 3;
+ Assert (2, --d, "#2");
+ Assert (2, d, "#2a");
+
+ d = new MyType (-3);
+ Assert (new MyType (-3), d--, "#3");
+ Assert (new MyType (-1), d, "#3a");
}
-
- void UnaryPlusTest_4 ()
+
+ void UnaryDecrementCheckedTest ()
{
- Expression<Func<MyType?, MyType?>> e5 = (a) => +a;
- AssertNodeType (e5, ExpressionType.UnaryPlus);
- Assert (new MyType (33), e5.Compile ().Invoke (new MyType (33)));
- Assert (null, e5.Compile ().Invoke (null));
+ checked {
+ dynamic d = int.MinValue;
+
+ AssertChecked (() => { d--; Assert (d, -1073741824, "#1a"); }, "#1");
+
+ d = new MyType (int.MinValue);
+ d--;
+ Assert (d, new MyType (-1073741824), "#2");
+ }
}
-
- void UnaryPlusTest_5 ()
+
+ void UnaryIncrement ()
{
- Expression<Func<sbyte?, long?>> e6 = (a) => +a;
- AssertNodeType (e6, ExpressionType.Convert);
- Assert (3, e6.Compile ().Invoke (3));
- Assert (null, e6.Compile ().Invoke (null));
- }
+ dynamic d = 3;
+ Assert (3, d++, "#1");
+ Assert (4, d, "#1a");
-#pragma warning restore 169
+ d = 3;
+ Assert (4, ++d, "#2");
+ Assert (4, d, "#2a");
- //
- // Test helpers
- //
- string InstanceMethod (string arg)
- {
- return arg;
+ d = new MyType (-3);
+ Assert (new MyType (-3), d++, "#3");
+ Assert (new MyType (-6), d, "#3a");
}
- object InstanceParamsMethod (int index, params object [] args)
+ void UnaryIncrementCheckedTest ()
{
- if (args == null)
- return "<null>";
- if (args.Length == 0)
- return "<empty>";
- return args [index];
+ checked {
+ dynamic d = int.MaxValue;
+
+ AssertChecked (() => { d++; Assert (d, 0, "#1a"); }, "#1");
+
+ d = new MyType (int.MaxValue);
+ d++;
+ Assert (d, new MyType (-2), "#2");
+ }
}
-
- static int TestInt ()
+
+ //void UnaryIsFalse ()
+ //{
+ // dynamic d = this;
+ // object r = d == null;
+ // Assert (false, (bool) r, "#1");
+ // Assert<object> (true, d != null, "#1a");
+ //}
+
+ void UnaryIsTrue ()
{
- return 29;
+ dynamic d = true;
+ Assert (3, d ? 3 : 5, "#1");
+
+ d = 4;
+ Assert (false, d < 1, "#2");
+
+ d = new InverseLogicalOperator (true);
+ Assert (1, d ? 1 : -1, "#3");
}
- T GenericMethod<T> (T t)
+ void UnaryPlus ()
{
- return t;
+ dynamic d = -8;
+ Assert (-8, +d, "#1");
+ Assert (-8, +(+d), "#1a");
+
+ d = new MyType (14);
+ Assert (new MyType (334455), +d, "#2");
+
+ d = new MyTypeImplicitOnly (4);
+ Assert (4, +d, "#3");
+
+ d = (uint) 7;
+ Assert<uint> (7, +d, "#4");
}
-
- static void RefMethod (ref int i)
+
+ void UnaryPlusNullable ()
{
- i = 867;
+ dynamic d = (int?) -8;
+ Assert (-8, +d, "#1");
+ Assert (-8, +(+d), "#1a");
+
+ MyType? n1 = new MyType (4);
+ d = n1;
+ Assert (new MyType (334455), +d, "#2");
+
+ MyTypeImplicitOnly? n2 = new MyTypeImplicitOnly (4);
+ d = n2;
+ Assert (4, +d, "#3");
+
+ d = (sbyte?) 7;
+ Assert (7, +d, "#4");
}
-*/
+
+#pragma warning restore 169
+
static bool RunTest (MethodInfo test)
{
Console.Write ("Running test {0, -25}", test.Name);
projects / mono.git / blobdiff