Merge pull request #820 from brendanzagaeski/master

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

diff --git a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Negate.cs b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Negate.cs
index 62e5febb3bfa1cdae61163962dec99928cd750f1..8c0149821b9a3be1b10a4fbc01577381dec0735f 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Negate.cs
+++ b/mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Negate.cs
@@ -69,7 +69,7 @@ namespace MonoTests.System.Linq.Expressions
                [ExpectedException (typeof (InvalidOperationException))]
                public void NegateBool ()
                {
-                       Expression.UnaryPlus (true.ToConstant ());
+                       Expression.Negate (true.ToConstant ());
                }
 
                [Test]
@@ -135,7 +135,7 @@ namespace MonoTests.System.Linq.Expressions
 
                        public static Slot operator - (Slot s)
                        {
-                               return new Slot () { Value = -s.Value };
+                               return new Slot (-s.Value);
                        }
                }
 
@@ -154,7 +154,60 @@ namespace MonoTests.System.Linq.Expressions
                        Assert.AreEqual (new Slot (42), negate (new Slot (-42)));
                }
 
-               /*struct SlotFromNullable {
+               [Test]
+               [Category ("NotWorkingInterpreter")]
+               public void UserDefinedNotNullableNegateNullable ()
+               {
+                       var s = Expression.Parameter (typeof (Slot?), "s");
+                       var node = Expression.Negate (s);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsTrue (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (Slot?), node.Type);
+
+                       var negate = Expression.Lambda<Func<Slot?, Slot?>> (node, s).Compile ();
+
+                       Assert.AreEqual (null, negate (null));
+                       Assert.AreEqual (new Slot (42), negate (new Slot (-42)));
+                       Assert.AreEqual (new Slot (-2), negate (new Slot (2)));
+               }
+
+               struct SlotToNullable {
+                       public int Value;
+
+                       public SlotToNullable (int value)
+                       {
+                               this.Value = value;
+                       }
+
+                       public static SlotToNullable? operator - (SlotToNullable s)
+                       {
+                               return new SlotToNullable (-s.Value);
+                       }
+               }
+
+               [Test]
+               [ExpectedException (typeof (InvalidOperationException))]
+               public void UserDefinedToNullableNegateFromNullable ()
+               {
+                       Expression.Negate (Expression.Parameter (typeof (SlotToNullable?), "s"));
+               }
+
+               [Test]
+               public void UserDefinedToNullableNegateNullable ()
+               {
+                       var s = Expression.Parameter (typeof (SlotToNullable), "s");
+                       var node = Expression.Negate (s);
+                       Assert.IsFalse (node.IsLifted);
+                       Assert.IsFalse (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (SlotToNullable?), node.Type);
+
+                       var negate = Expression.Lambda<Func<SlotToNullable, SlotToNullable?>> (node, s).Compile ();
+
+                       Assert.AreEqual ((SlotToNullable?) new SlotToNullable (42), negate (new SlotToNullable (-42)));
+                       Assert.AreEqual ((SlotToNullable?) new SlotToNullable (-2), negate (new SlotToNullable (2)));
+               }
+
+               struct SlotFromNullable {
                        public int Value;
 
                        public SlotFromNullable (int value)
@@ -167,7 +220,7 @@ namespace MonoTests.System.Linq.Expressions
                                if (s.HasValue)
                                        return new SlotFromNullable (-s.Value.Value);
                                else
-                                       return new SlotFromNullable (0);
+                                       return new SlotFromNullable (-1);
                        }
                }
 
@@ -184,7 +237,7 @@ namespace MonoTests.System.Linq.Expressions
 
                        Assert.AreEqual (new SlotFromNullable (-2), negate (new SlotFromNullable (2)));
                        Assert.AreEqual (new SlotFromNullable (42), negate (new SlotFromNullable (-42)));
-                       Assert.AreEqual (new SlotFromNullable (0), negate (null));
+                       Assert.AreEqual (new SlotFromNullable (-1), negate (null));
                }
 
                struct SlotFromNullableToNullable {
@@ -219,6 +272,44 @@ namespace MonoTests.System.Linq.Expressions
                        Assert.AreEqual (new SlotFromNullableToNullable (-2), negate (new SlotFromNullableToNullable (2)));
                        Assert.AreEqual (new SlotFromNullableToNullable (42), negate (new SlotFromNullableToNullable (-42)));
                        Assert.AreEqual (null, negate (null));
-               }*/
+               }
+
+               [Test]
+               public void NegateDecimal ()
+               {
+                       var d = Expression.Parameter (typeof (decimal), "l");
+
+                       var meth = typeof (decimal).GetMethod ("op_UnaryNegation", new [] { typeof (decimal) });
+
+                       var node = Expression.Negate (d);
+                       Assert.IsFalse (node.IsLifted);
+                       Assert.IsFalse (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (decimal), node.Type);
+                       Assert.AreEqual (meth, node.Method);
+
+                       var neg = Expression.Lambda<Func<decimal, decimal>> (node, d).Compile ();
+
+                       Assert.AreEqual (-2m, neg (2m));
+               }
+
+               [Test]
+               [Category ("NotWorkingInterpreter")]
+               public void NegateLiftedDecimal ()
+               {
+                       var d = Expression.Parameter (typeof (decimal?), "l");
+
+                       var meth = typeof (decimal).GetMethod ("op_UnaryNegation", new [] { typeof (decimal) });
+
+                       var node = Expression.Negate (d);
+                       Assert.IsTrue (node.IsLifted);
+                       Assert.IsTrue (node.IsLiftedToNull);
+                       Assert.AreEqual (typeof (decimal?), node.Type);
+                       Assert.AreEqual (meth, node.Method);
+
+                       var neg = Expression.Lambda<Func<decimal?, decimal?>> (node, d).Compile ();
+
+                       Assert.AreEqual (-2m, neg (2m));
+                       Assert.AreEqual (null, neg (null));
+               }
        }
 }