new tests

svn path=/trunk/mcs/; revision=105035

diff --git a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_GreaterThan.cs b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_GreaterThan.cs
index 954d6d1d4ec94af627f9fb0ab813a857ebcab46e..ab7df1852c1044a5cc21ec4496da0a1968d8a44f 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_GreaterThan.cs
+++ b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_GreaterThan.cs
@@ -170,5 +170,70 @@ namespace MonoTests.System.Linq.Expressions
                        Assert.AreEqual ((bool?) true, gt (2, 1));
                        Assert.AreEqual ((bool?) false, gt (1, 1));
                }
+
+               struct Slot {
+                       public int Value;
+
+                       public Slot (int val)
+                       {
+                               Value = val;
+                       }
+
+                       public static bool operator > (Slot a, Slot b)
+                       {
+                               return a.Value > b.Value;
+                       }
+
+                       public static bool operator < (Slot a, Slot b)
+                       {
+                               return a.Value < b.Value;
+                       }
+               }
+
+               [Test]
+               [Category ("NotWorking")]
+               public void UserDefinedGreaterThanLifted ()
+               {
+                       var l = Expression.Parameter (typeof (Slot?), "l");
+                       var r = Expression.Parameter (typeof (Slot?), "r");
+
+                       var node = Expression.GreaterThan (l, r);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsFalse (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (bool), node.Type);
+                       Assert.IsNotNull (node.Method);
+
+                       var gte = Expression.Lambda<Func<Slot?, Slot?, bool>> (node, l, r).Compile ();
+
+                       Assert.AreEqual (true, gte (new Slot (1), new Slot (0)));
+                       Assert.AreEqual (false, gte (new Slot (-1), new Slot (1)));
+                       Assert.AreEqual (false, gte (new Slot (1), new Slot (1)));
+                       Assert.AreEqual (false, gte (null, new Slot (1)));
+                       Assert.AreEqual (false, gte (new Slot (1), null));
+                       Assert.AreEqual (false, gte (null, null));
+               }
+
+               [Test]
+               [Category ("NotWorking")]
+               public void UserDefinedGreaterThanLiftedToNull ()
+               {
+                       var l = Expression.Parameter (typeof (Slot?), "l");
+                       var r = Expression.Parameter (typeof (Slot?), "r");
+
+                       var node = Expression.GreaterThan (l, r, true, null);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsTrue (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (bool?), node.Type);
+                       Assert.IsNotNull (node.Method);
+
+                       var gte = Expression.Lambda<Func<Slot?, Slot?, bool?>> (node, l, r).Compile ();
+
+                       Assert.AreEqual (true, gte (new Slot (1), new Slot (0)));
+                       Assert.AreEqual (false, gte (new Slot (-1), new Slot (1)));
+                       Assert.AreEqual (false, gte (new Slot (1), new Slot (1)));
+                       Assert.AreEqual (null, gte (null, new Slot (1)));
+                       Assert.AreEqual (null, gte (new Slot (1), null));
+                       Assert.AreEqual (null, gte (null, null));
+               }
        }
 }

diff --git a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_GreaterThanOrEqual.cs b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_GreaterThanOrEqual.cs
index 4b62e71b489102e1f2a690a0feaf95503a34d8c3..f613c0387e0d830f3201ba90c5b0ac9f69a9a81a 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_GreaterThanOrEqual.cs
+++ b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_GreaterThanOrEqual.cs
@@ -144,5 +144,70 @@ namespace MonoTests.System.Linq.Expressions
                        Assert.AreEqual ((bool?) true, gte (2, 1));
                        Assert.AreEqual ((bool?) true, gte (1, 1));
                }
+
+               struct Slot {
+                       public int Value;
+
+                       public Slot (int val)
+                       {
+                               Value = val;
+                       }
+
+                       public static bool operator >= (Slot a, Slot b)
+                       {
+                               return a.Value >= b.Value;
+                       }
+
+                       public static bool operator <= (Slot a, Slot b)
+                       {
+                               return a.Value <= b.Value;
+                       }
+               }
+
+               [Test]
+               [Category ("NotWorking")]
+               public void UserDefinedGreaterThanOrEqualLifted ()
+               {
+                       var l = Expression.Parameter (typeof (Slot?), "l");
+                       var r = Expression.Parameter (typeof (Slot?), "r");
+
+                       var node = Expression.GreaterThanOrEqual (l, r);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsFalse (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (bool), node.Type);
+                       Assert.IsNotNull (node.Method);
+
+                       var gte = Expression.Lambda<Func<Slot?, Slot?, bool>> (node, l, r).Compile ();
+
+                       Assert.AreEqual (true, gte (new Slot (1), new Slot (0)));
+                       Assert.AreEqual (false, gte (new Slot (-1), new Slot (1)));
+                       Assert.AreEqual (true, gte (new Slot (1), new Slot (1)));
+                       Assert.AreEqual (false, gte (null, new Slot (1)));
+                       Assert.AreEqual (false, gte (new Slot (1), null));
+                       Assert.AreEqual (false, gte (null, null));
+               }
+
+               [Test]
+               [Category ("NotWorking")]
+               public void UserDefinedGreaterThanOrEqualLiftedToNull ()
+               {
+                       var l = Expression.Parameter (typeof (Slot?), "l");
+                       var r = Expression.Parameter (typeof (Slot?), "r");
+
+                       var node = Expression.GreaterThanOrEqual (l, r, true, null);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsTrue (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (bool?), node.Type);
+                       Assert.IsNotNull (node.Method);
+
+                       var gte = Expression.Lambda<Func<Slot?, Slot?, bool?>> (node, l, r).Compile ();
+
+                       Assert.AreEqual (true, gte (new Slot (1), new Slot (0)));
+                       Assert.AreEqual (false, gte (new Slot (-1), new Slot (1)));
+                       Assert.AreEqual (true, gte (new Slot (1), new Slot (1)));
+                       Assert.AreEqual (null, gte (null, new Slot (1)));
+                       Assert.AreEqual (null, gte (new Slot (1), null));
+                       Assert.AreEqual (null, gte (null, null));
+               }
        }
 }

diff --git a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_LessThan.cs b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_LessThan.cs
index 3ef3a3707918bf1abf496141d5164ed9832be479..08f0948c1e36a3c0712083a4e94fc8c571eda238 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_LessThan.cs
+++ b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_LessThan.cs
@@ -144,5 +144,70 @@ namespace MonoTests.System.Linq.Expressions
                        Assert.AreEqual ((bool?) false, lt (2, 1));
                        Assert.AreEqual ((bool?) false, lt (1, 1));
                }
+
+               struct Slot {
+                       public int Value;
+
+                       public Slot (int val)
+                       {
+                               Value = val;
+                       }
+
+                       public static bool operator > (Slot a, Slot b)
+                       {
+                               return a.Value > b.Value;
+                       }
+
+                       public static bool operator < (Slot a, Slot b)
+                       {
+                               return a.Value < b.Value;
+                       }
+               }
+
+               [Test]
+               [Category ("NotWorking")]
+               public void UserDefinedLessThanLifted ()
+               {
+                       var l = Expression.Parameter (typeof (Slot?), "l");
+                       var r = Expression.Parameter (typeof (Slot?), "r");
+
+                       var node = Expression.LessThan (l, r);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsFalse (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (bool), node.Type);
+                       Assert.IsNotNull (node.Method);
+
+                       var lte = Expression.Lambda<Func<Slot?, Slot?, bool>> (node, l, r).Compile ();
+
+                       Assert.AreEqual (false, lte (new Slot (1), new Slot (0)));
+                       Assert.AreEqual (true, lte (new Slot (-1), new Slot (1)));
+                       Assert.AreEqual (false, lte (new Slot (1), new Slot (1)));
+                       Assert.AreEqual (false, lte (null, new Slot (1)));
+                       Assert.AreEqual (false, lte (new Slot (1), null));
+                       Assert.AreEqual (false, lte (null, null));
+               }
+
+               [Test]
+               [Category ("NotWorking")]
+               public void UserDefinedLessThanLiftedToNull ()
+               {
+                       var l = Expression.Parameter (typeof (Slot?), "l");
+                       var r = Expression.Parameter (typeof (Slot?), "r");
+
+                       var node = Expression.LessThan (l, r, true, null);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsTrue (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (bool?), node.Type);
+                       Assert.IsNotNull (node.Method);
+
+                       var lte = Expression.Lambda<Func<Slot?, Slot?, bool?>> (node, l, r).Compile ();
+
+                       Assert.AreEqual (false, lte (new Slot (1), new Slot (0)));
+                       Assert.AreEqual (true, lte (new Slot (-1), new Slot (1)));
+                       Assert.AreEqual (false, lte (new Slot (1), new Slot (1)));
+                       Assert.AreEqual (null, lte (null, new Slot (1)));
+                       Assert.AreEqual (null, lte (new Slot (1), null));
+                       Assert.AreEqual (null, lte (null, null));
+               }
        }
 }

diff --git a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_LessThanOrEqual.cs b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_LessThanOrEqual.cs
index 2a101eb9665887d75ba6201e0f4bb692d9f3a2c7..256165d2bee7635b8ec7a2151b8be85aba74c446 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_LessThanOrEqual.cs
+++ b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_LessThanOrEqual.cs
@@ -144,5 +144,70 @@ namespace MonoTests.System.Linq.Expressions
                        Assert.AreEqual ((bool?) false, lte (2, 1));
                        Assert.AreEqual ((bool?) true, lte (1, 1));
                }
+
+               struct Slot {
+                       public int Value;
+
+                       public Slot (int val)
+                       {
+                               Value = val;
+                       }
+
+                       public static bool operator >= (Slot a, Slot b)
+                       {
+                               return a.Value >= b.Value;
+                       }
+
+                       public static bool operator <= (Slot a, Slot b)
+                       {
+                               return a.Value <= b.Value;
+                       }
+               }
+
+               [Test]
+               [Category ("NotWorking")]
+               public void UserDefinedLessThanOrEqualLifted ()
+               {
+                       var l = Expression.Parameter (typeof (Slot?), "l");
+                       var r = Expression.Parameter (typeof (Slot?), "r");
+
+                       var node = Expression.LessThanOrEqual (l, r);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsFalse (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (bool), node.Type);
+                       Assert.IsNotNull (node.Method);
+
+                       var lte = Expression.Lambda<Func<Slot?, Slot?, bool>> (node, l, r).Compile ();
+
+                       Assert.AreEqual (false, lte (new Slot (1), new Slot (0)));
+                       Assert.AreEqual (true, lte (new Slot (-1), new Slot (1)));
+                       Assert.AreEqual (true, lte (new Slot (1), new Slot (1)));
+                       Assert.AreEqual (false, lte (null, new Slot (1)));
+                       Assert.AreEqual (false, lte (new Slot (1), null));
+                       Assert.AreEqual (false, lte (null, null));
+               }
+
+               [Test]
+               [Category ("NotWorking")]
+               public void UserDefinedLessThanOrEqualLiftedToNull ()
+               {
+                       var l = Expression.Parameter (typeof (Slot?), "l");
+                       var r = Expression.Parameter (typeof (Slot?), "r");
+
+                       var node = Expression.LessThanOrEqual (l, r, true, null);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsTrue (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (bool?), node.Type);
+                       Assert.IsNotNull (node.Method);
+
+                       var lte = Expression.Lambda<Func<Slot?, Slot?, bool?>> (node, l, r).Compile ();
+
+                       Assert.AreEqual (false, lte (new Slot (1), new Slot (0)));
+                       Assert.AreEqual (true, lte (new Slot (-1), new Slot (1)));
+                       Assert.AreEqual (true, lte (new Slot (1), new Slot (1)));
+                       Assert.AreEqual (null, lte (null, new Slot (1)));
+                       Assert.AreEqual (null, lte (new Slot (1), null));
+                       Assert.AreEqual (null, lte (null, null));
+               }
        }
 }