New tests.

[mono.git] / mcs / class / System.Core / Test / System.Linq.Expressions / ExpressionTest_Equal.cs

diff --git a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Equal.cs b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Equal.cs
index c98edc892f0b2bfabcd5e2226d6f86fddba78855..06612bdfa1820c312c899e87bfc69b27cde54db3 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Equal.cs
+++ b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Equal.cs
@@ -18,6 +18,7 @@
 //
 // Authors:
 //    Miguel de Icaza (miguel@novell.com)
+//    Jb Evain (jbevain@novell.com)
 //
 
 using System;
@@ -75,7 +76,9 @@ namespace MonoTests.System.Linq.Expressions
                        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]
@@ -92,7 +95,9 @@ namespace MonoTests.System.Linq.Expressions
                        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]
@@ -109,7 +114,9 @@ namespace MonoTests.System.Linq.Expressions
                        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]
@@ -135,8 +142,9 @@ namespace MonoTests.System.Linq.Expressions
                        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]
@@ -228,7 +236,6 @@ namespace MonoTests.System.Linq.Expressions
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void UserDefinedEqualLifted ()
                {
                        var l = Expression.Parameter (typeof (Slot?), "l");
@@ -250,7 +257,6 @@ namespace MonoTests.System.Linq.Expressions
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void UserDefinedEqualLiftedToNull ()
                {
                        var l = Expression.Parameter (typeof (Slot?), "l");
@@ -306,7 +312,6 @@ namespace MonoTests.System.Linq.Expressions
                }
 
                [Test]
-               [Category ("NotWorking")]
                [ExpectedException (typeof (InvalidOperationException))]
                public void UserDefinedToNullableEqualFromNullable ()
                {
@@ -371,7 +376,6 @@ namespace MonoTests.System.Linq.Expressions
                }
 
                [Test]
-               [Category ("NotWorking")]
                public void UserDefinedFromNullableToNullableEqual ()
                {
                        var l = Expression.Parameter (typeof (SlotFromNullableToNullable?), "l");
@@ -392,5 +396,67 @@ namespace MonoTests.System.Linq.Expressions
                        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));
+               }
        }
 }