//
// Authors:
// Miguel de Icaza (miguel@novell.com)
+// Jb Evain (jbevain@novell.com)
//
using System;
Assert.AreEqual (ExpressionType.Equal, expr.NodeType);
Assert.AreEqual (typeof (bool), expr.Type);
Assert.IsNull (expr.Method);
+#if !NET_4_0
Assert.AreEqual ("(1 = 2)", expr.ToString ());
+#endif
+ }
+
+ [Test]
+ public void PrimitiveNonNumeric ()
+ {
+ BinaryExpression expr = Expression.Equal (Expression.Constant ('a'), Expression.Constant ('b'));
+ Assert.AreEqual (ExpressionType.Equal, expr.NodeType);
+ Assert.AreEqual (typeof (bool), expr.Type);
+ Assert.IsNull (expr.Method);
+
+ var eq = Expression.Lambda<Func<bool>> (expr).Compile ();
+ Assert.IsFalse (eq ());
}
[Test]
Assert.AreEqual (true, expr.IsLifted);
Assert.AreEqual (false, expr.IsLiftedToNull);
Assert.IsNull (expr.Method);
+#if !NET_4_0
Assert.AreEqual ("(1 = 2)", expr.ToString ());
+#endif
}
[Test]
Assert.AreEqual (true, expr.IsLifted);
Assert.AreEqual (true, expr.IsLiftedToNull);
Assert.IsNull (expr.Method);
+#if !NET_4_0
Assert.AreEqual ("(1 = 2)", expr.ToString ());
+#endif
}
[Test]
Assert.AreEqual (typeof (bool), expr.Type);
Assert.AreEqual (mi, expr.Method);
Assert.AreEqual ("op_Equality", expr.Method.Name);
-
+#if !NET_4_0
Assert.AreEqual ("(value(MonoTests.System.Linq.Expressions.OpClass) = value(MonoTests.System.Linq.Expressions.OpClass))", expr.ToString ());
+#endif
}
[Test]
}
[Test]
- [Category ("NotWorking")]
public void UserDefinedEqual ()
{
var l = Expression.Parameter (typeof (Slot), "l");
}
[Test]
- [Category ("NotWorking")]
+ [Category ("NotWorkingInterpreter")]
public void UserDefinedEqualLifted ()
{
var l = Expression.Parameter (typeof (Slot?), "l");
}
[Test]
- [Category ("NotWorking")]
+ [Category ("NotWorkingInterpreter")]
public void UserDefinedEqualLiftedToNull ()
{
var l = Expression.Parameter (typeof (Slot?), "l");
}
[Test]
- [Category ("NotWorking")]
[ExpectedException (typeof (InvalidOperationException))]
public void UserDefinedToNullableEqualFromNullable ()
{
}
[Test]
- [Category ("NotWorking")]
public void UserDefinedToNullableEqual ()
{
var l = Expression.Parameter (typeof (SlotToNullable), "l");
}
[Test]
- [Category ("NotWorking")]
public void UserDefinedFromNullableToNullableEqual ()
{
var l = Expression.Parameter (typeof (SlotFromNullableToNullable?), "l");
Assert.AreEqual ((bool?) true, eq (new SlotFromNullableToNullable (2), new SlotFromNullableToNullable (2)));
Assert.AreEqual ((bool?) false, eq (new SlotFromNullableToNullable (2), new SlotFromNullableToNullable (-2)));
}*/
+
+ [Test]
+ public void NullableBoolEqualToBool ()
+ {
+ var l = Expression.Parameter (typeof (bool?), "l");
+ var r = Expression.Parameter (typeof (bool?), "r");
+
+ var node = Expression.Equal (l, r);
+ Assert.IsTrue (node.IsLifted);
+ Assert.IsFalse (node.IsLiftedToNull);
+ Assert.AreEqual (typeof (bool), node.Type);
+ Assert.IsNull (node.Method);
+
+ var eq = Expression.Lambda<Func<bool?, bool?, bool>> (node, l, r).Compile ();
+
+ Assert.AreEqual (false, eq (true, null));
+ Assert.AreEqual (true, eq (null, null));
+ Assert.AreEqual (true, eq (false, false));
+ }
+
+ public enum Foo {
+ Bar,
+ Baz,
+ }
+
+ [Test]
+ public void EnumEqual ()
+ {
+ var l = Expression.Parameter (typeof (Foo), "l");
+ var r = Expression.Parameter (typeof (Foo), "r");
+
+ var node = Expression.Equal (l, r);
+ Assert.IsFalse (node.IsLifted);
+ Assert.IsFalse (node.IsLiftedToNull);
+ Assert.AreEqual (typeof (bool), node.Type);
+ Assert.IsNull (node.Method);
+
+ var eq = Expression.Lambda<Func<Foo, Foo, bool>> (node, l, r).Compile ();
+
+ Assert.AreEqual (true, eq (Foo.Bar, Foo.Bar));
+ Assert.AreEqual (false, eq (Foo.Bar, Foo.Baz));
+ }
+
+ [Test]
+ public void LiftedEnumEqual ()
+ {
+ var l = Expression.Parameter (typeof (Foo?), "l");
+ var r = Expression.Parameter (typeof (Foo?), "r");
+
+ var node = Expression.Equal (l, r);
+ Assert.IsTrue (node.IsLifted);
+ Assert.IsFalse (node.IsLiftedToNull);
+ Assert.AreEqual (typeof (bool), node.Type);
+ Assert.IsNull (node.Method);
+
+ var eq = Expression.Lambda<Func<Foo?, Foo?, bool>> (node, l, r).Compile ();
+
+ Assert.AreEqual (true, eq (Foo.Bar, Foo.Bar));
+ Assert.AreEqual (false, eq (Foo.Bar, Foo.Baz));
+ Assert.AreEqual (false, eq (Foo.Bar, null));
+ Assert.AreEqual (true, eq (null, null));
+ }
+
+ [Test]
+ [Category ("NotWorkingInterpreter")]
+ public void NullableNullEqual ()
+ {
+ var param = Expression.Parameter (typeof (DateTime?), "x");
+
+ var node = Expression.Equal (param, Expression.Constant (null));
+
+ Assert.IsTrue (node.IsLifted);
+ Assert.IsFalse (node.IsLiftedToNull);
+ Assert.AreEqual (typeof (bool), node.Type);
+ Assert.IsNull (node.Method);
+
+ var eq = Expression.Lambda<Func<DateTime?, bool>> (node, new [] { param }).Compile ();
+
+ Assert.AreEqual (true, eq (null));
+ Assert.AreEqual (false, eq (DateTime.Now));
+ }
}
}