mcs/class/System.Core/Test/System.Linq.Expressions/ExpressionTest_Equal.cs

   1 // Permission is hereby granted, free of charge, to any person obtaining
   2 // a copy of this software and associated documentation files (the
   3 // "Software"), to deal in the Software without restriction, including
   4 // without limitation the rights to use, copy, modify, merge, publish,
   5 // distribute, sublicense, and/or sell copies of the Software, and to
   6 // permit persons to whom the Software is furnished to do so, subject to
   7 // the following conditions:
   8 //
   9 // The above copyright notice and this permission notice shall be
  10 // included in all copies or substantial portions of the Software.
  11 //
  12 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  13 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  14 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  15 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  16 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  17 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  18 //
  19 // Authors:
  20 //    Miguel de Icaza (miguel@novell.com)
  21 //    Jb Evain (jbevain@novell.com)
  22 //
  23
  24 using System;
  25 using System.Reflection;
  26 using System.Linq;
  27 using System.Linq.Expressions;
  28 using NUnit.Framework;
  29
  30 namespace MonoTests.System.Linq.Expressions
  31 {
  32         [TestFixture]
  33         public class ExpressionTest_Equal
  34         {
  35                 [Test]
  36                 [ExpectedException (typeof (ArgumentNullException))]
  37                 public void Arg1Null ()
  38                 {
  39                         Expression.Equal (null, Expression.Constant (1));
  40                 }
  41
  42                 [Test]
  43                 [ExpectedException (typeof (ArgumentNullException))]
  44                 public void Arg2Null ()
  45                 {
  46                         Expression.Equal (Expression.Constant (1), null);
  47                 }
  48
  49                 [Test]
  50                 [ExpectedException (typeof (InvalidOperationException))]
  51                 public void ArgTypesDifferent ()
  52                 {
  53                         Expression.Equal (Expression.Constant (1), Expression.Constant (2.0));
  54                 }
  55
  56                 [Test]
  57                 public void ReferenceCompare ()
  58                 {
  59                         Expression.Equal (Expression.Constant (new NoOpClass ()), Expression.Constant (new NoOpClass ()));
  60                 }
  61
  62                 public struct D {
  63                 }
  64
  65                 [Test]
  66                 [ExpectedException (typeof (InvalidOperationException))]
  67                 public void NoOperatorClass ()
  68                 {
  69                         Expression.Equal (Expression.Constant (new D ()), Expression.Constant (new D ()));
  70                 }
  71
  72                 [Test]
  73                 public void Numeric ()
  74                 {
  75                         BinaryExpression expr = Expression.Equal (Expression.Constant (1), Expression.Constant (2));
  76                         Assert.AreEqual (ExpressionType.Equal, expr.NodeType);
  77                         Assert.AreEqual (typeof (bool), expr.Type);
  78                         Assert.IsNull (expr.Method);
  79 #if !NET_4_0
  80                         Assert.AreEqual ("(1 = 2)", expr.ToString ());
  81 #endif
  82                 }
  83
  84                 [Test]
  85                 public void PrimitiveNonNumeric ()
  86                 {
  87                         BinaryExpression expr = Expression.Equal (Expression.Constant ('a'), Expression.Constant ('b'));
  88                         Assert.AreEqual (ExpressionType.Equal, expr.NodeType);
  89                         Assert.AreEqual (typeof (bool), expr.Type);
  90                         Assert.IsNull (expr.Method);
  91
  92                         var eq = Expression.Lambda<Func<bool>> (expr).Compile ();
  93                         Assert.IsFalse (eq ());
  94                 }
  95
  96                 [Test]
  97                 public void Nullable_LiftToNull_SetToFalse ()
  98                 {
  99                         int? a = 1;
 100                         int? b = 2;
 101
 102                         BinaryExpression expr = Expression.Equal (Expression.Constant (a, typeof(int?)),
 103                                                                   Expression.Constant (b, typeof(int?)),
 104                                                                   false, null);
 105                         Assert.AreEqual (ExpressionType.Equal, expr.NodeType);
 106                         Assert.AreEqual (typeof (bool), expr.Type);
 107                         Assert.AreEqual (true, expr.IsLifted);
 108                         Assert.AreEqual (false, expr.IsLiftedToNull);
 109                         Assert.IsNull (expr.Method);
 110 #if !NET_4_0
 111                         Assert.AreEqual ("(1 = 2)", expr.ToString ());
 112 #endif
 113                 }
 114
 115                 [Test]
 116                 public void Nullable_LiftToNull_SetToTrue ()
 117                 {
 118                         int? a = 1;
 119                         int? b = 2;
 120
 121                         BinaryExpression expr = Expression.Equal (Expression.Constant (a, typeof(int?)),
 122                                                                   Expression.Constant (b, typeof(int?)),
 123                                                                   true, null);
 124                         Assert.AreEqual (ExpressionType.Equal, expr.NodeType);
 125                         Assert.AreEqual (typeof (bool?), expr.Type);
 126                         Assert.AreEqual (true, expr.IsLifted);
 127                         Assert.AreEqual (true, expr.IsLiftedToNull);
 128                         Assert.IsNull (expr.Method);
 129 #if !NET_4_0
 130                         Assert.AreEqual ("(1 = 2)", expr.ToString ());
 131 #endif
 132                 }
 133
 134                 [Test]
 135                 [ExpectedException(typeof (InvalidOperationException))]
 136                 public void Nullable_Mixed ()
 137                 {
 138                         int? a = 1;
 139                         int b = 2;
 140
 141                         Expression.Equal (Expression.Constant (a, typeof (int?)),
 142                                           Expression.Constant (b, typeof (int)));
 143                 }
 144
 145                 [Test]
 146                 public void UserDefinedClass ()
 147                 {
 148                         // We can use the simplest version of GetMethod because we already know only one
 149                         // exists in the very simple class we're using for the tests.
 150                         MethodInfo mi = typeof (OpClass).GetMethod ("op_Equality");
 151
 152                         BinaryExpression expr = Expression.Equal (Expression.Constant (new OpClass ()), Expression.Constant (new OpClass ()));
 153                         Assert.AreEqual (ExpressionType.Equal, expr.NodeType);
 154                         Assert.AreEqual (typeof (bool), expr.Type);
 155                         Assert.AreEqual (mi, expr.Method);
 156                         Assert.AreEqual ("op_Equality", expr.Method.Name);
 157 #if !NET_4_0
 158                         Assert.AreEqual ("(value(MonoTests.System.Linq.Expressions.OpClass) = value(MonoTests.System.Linq.Expressions.OpClass))", expr.ToString ());
 159 #endif
 160                 }
 161
 162                 [Test]
 163                 public void NullableInt32Equal ()
 164                 {
 165                         var l = Expression.Parameter (typeof (int?), "l");
 166                         var r = Expression.Parameter (typeof (int?), "r");
 167
 168                         var eq = Expression.Lambda<Func<int?, int?, bool>> (
 169                                 Expression.Equal (l, r), l, r).Compile ();
 170
 171                         Assert.IsTrue (eq (null, null));
 172                         Assert.IsFalse (eq (null, 1));
 173                         Assert.IsFalse (eq (1, null));
 174                         Assert.IsFalse (eq (1, 2));
 175                         Assert.IsTrue (eq (1, 1));
 176                         Assert.IsFalse (eq (null, 0));
 177                         Assert.IsFalse (eq (0, null));
 178                 }
 179
 180                 [Test]
 181                 public void NullableInt32EqualLiftedToNull ()
 182                 {
 183                         var l = Expression.Parameter (typeof (int?), "l");
 184                         var r = Expression.Parameter (typeof (int?), "r");
 185
 186                         var eq = Expression.Lambda<Func<int?, int?, bool?>> (
 187                                 Expression.Equal (l, r, true, null), l, r).Compile ();
 188
 189                         Assert.AreEqual ((bool?) null, eq (null, null));
 190                         Assert.AreEqual ((bool?) null, eq (null, 1));
 191                         Assert.AreEqual ((bool?) null, eq (1, null));
 192                         Assert.AreEqual ((bool?) false, eq (1, 2));
 193                         Assert.AreEqual ((bool?) true, eq (1, 1));
 194                         Assert.AreEqual ((bool?) null, eq (null, 0));
 195                         Assert.AreEqual ((bool?) null, eq (0, null));
 196                 }
 197
 198                 struct Slot {
 199                         public int Value;
 200
 201                         public Slot (int value)
 202                         {
 203                                 this.Value = value;
 204                         }
 205
 206                         public override bool Equals (object obj)
 207                         {
 208                                 if (!(obj is Slot))
 209                                         return false;
 210
 211                                 var other = (Slot) obj;
 212                                 return other.Value == this.Value;
 213                         }
 214
 215                         public override int GetHashCode ()
 216                         {
 217                                 return Value;
 218                         }
 219
 220                         public static bool operator == (Slot a, Slot b)
 221                         {
 222                                 return a.Value == b.Value;
 223                         }
 224
 225                         public static bool operator != (Slot a, Slot b)
 226                         {
 227                                 return a.Value != b.Value;
 228                         }
 229                 }
 230
 231                 [Test]
 232                 public void UserDefinedEqual ()
 233                 {
 234                         var l = Expression.Parameter (typeof (Slot), "l");
 235                         var r = Expression.Parameter (typeof (Slot), "r");
 236
 237                         var node = Expression.Equal (l, r);
 238
 239                         Assert.IsFalse (node.IsLifted);
 240                         Assert.IsFalse (node.IsLiftedToNull);
 241                         Assert.AreEqual (typeof (bool), node.Type);
 242                         Assert.IsNotNull (node.Method);
 243
 244                         var eq = Expression.Lambda<Func<Slot, Slot, bool>> (node, l, r).Compile ();
 245
 246                         Assert.AreEqual (true, eq (new Slot (21), new Slot (21)));
 247                         Assert.AreEqual (false, eq (new Slot (1), new Slot (-1)));
 248                 }
 249
 250                 [Test]
 251                 [Category ("NotWorkingInterpreter")]
 252                 public void UserDefinedEqualLifted ()
 253                 {
 254                         var l = Expression.Parameter (typeof (Slot?), "l");
 255                         var r = Expression.Parameter (typeof (Slot?), "r");
 256
 257                         var node = Expression.Equal (l, r);
 258
 259                         Assert.IsTrue (node.IsLifted);
 260                         Assert.IsFalse (node.IsLiftedToNull);
 261                         Assert.AreEqual (typeof (bool), node.Type);
 262                         Assert.IsNotNull (node.Method);
 263
 264                         var eq = Expression.Lambda<Func<Slot?, Slot?, bool>> (node, l, r).Compile ();
 265
 266                         Assert.AreEqual (true, eq (null, null));
 267                         Assert.AreEqual (false, eq ((Slot?) new Slot (2), null));
 268                         Assert.AreEqual (false, eq (null, (Slot?) new Slot (2)));
 269                         Assert.AreEqual (true, eq ((Slot?) new Slot (21), (Slot?) new Slot (21)));
 270                 }
 271
 272                 [Test]
 273                 [Category ("NotWorkingInterpreter")]
 274                 public void UserDefinedEqualLiftedToNull ()
 275                 {
 276                         var l = Expression.Parameter (typeof (Slot?), "l");
 277                         var r = Expression.Parameter (typeof (Slot?), "r");
 278
 279                         var node = Expression.Equal (l, r, true, null);
 280
 281                         Assert.IsTrue (node.IsLifted);
 282                         Assert.IsTrue (node.IsLiftedToNull);
 283                         Assert.AreEqual (typeof (bool?), node.Type);
 284                         Assert.IsNotNull (node.Method);
 285
 286                         var eq = Expression.Lambda<Func<Slot?, Slot?, bool?>> (node, l, r).Compile ();
 287
 288                         Assert.AreEqual ((bool?) null, eq (null, null));
 289                         Assert.AreEqual ((bool?) null, eq ((Slot?) new Slot (2), null));
 290                         Assert.AreEqual ((bool?) null, eq (null, (Slot?) new Slot (2)));
 291                         Assert.AreEqual ((bool?) true, eq ((Slot?) new Slot (21), (Slot?) new Slot (21)));
 292                         Assert.AreEqual ((bool?) false, eq ((Slot?) new Slot (21), (Slot?) new Slot (-21)));
 293                 }
 294
 295                 struct SlotToNullable {
 296                         public int Value;
 297
 298                         public SlotToNullable (int value)
 299                         {
 300                                 this.Value = value;
 301                         }
 302
 303                         public override int GetHashCode ()
 304                         {
 305                                 return Value;
 306                         }
 307
 308                         public override bool Equals (object obj)
 309                         {
 310                                 if (!(obj is SlotToNullable))
 311                                         return false;
 312
 313                                 var other = (SlotToNullable) obj;
 314                                 return other.Value == this.Value;
 315                         }
 316
 317                         public static bool? operator == (SlotToNullable a, SlotToNullable b)
 318                         {
 319                                 return (bool?) (a.Value == b.Value);
 320                         }
 321
 322                         public static bool? operator != (SlotToNullable a, SlotToNullable b)
 323                         {
 324                                 return (bool?) (a.Value != b.Value);
 325                         }
 326                 }
 327
 328                 [Test]
 329                 [ExpectedException (typeof (InvalidOperationException))]
 330                 public void UserDefinedToNullableEqualFromNullable ()
 331                 {
 332                         Expression.Equal (
 333                                 Expression.Parameter (typeof (SlotToNullable?), "l"),
 334                                 Expression.Parameter (typeof (SlotToNullable?), "r"));
 335                 }
 336
 337                 [Test]
 338                 public void UserDefinedToNullableEqual ()
 339                 {
 340                         var l = Expression.Parameter (typeof (SlotToNullable), "l");
 341                         var r = Expression.Parameter (typeof (SlotToNullable), "r");
 342
 343                         var node = Expression.Equal (l, r, false, null);
 344
 345                         Assert.IsFalse (node.IsLifted);
 346                         Assert.IsFalse (node.IsLiftedToNull);
 347                         Assert.AreEqual (typeof (bool?), node.Type);
 348                         Assert.IsNotNull (node.Method);
 349
 350                         var eq = Expression.Lambda<Func<SlotToNullable, SlotToNullable, bool?>> (node, l, r).Compile ();
 351
 352                         Assert.AreEqual ((bool?) true, eq (new SlotToNullable (2), new SlotToNullable (2)));
 353                         Assert.AreEqual ((bool?) false, eq (new SlotToNullable (2), new SlotToNullable (-2)));
 354                 }
 355
 356                 /*struct SlotFromNullableToNullable {
 357                         public int Value;
 358
 359                         public SlotFromNullableToNullable (int value)
 360                         {
 361                                 this.Value = value;
 362                         }
 363
 364                         public override bool Equals (object obj)
 365                         {
 366                                 if (!(obj is SlotFromNullableToNullable))
 367                                         return false;
 368
 369                                 var other = (SlotFromNullableToNullable) obj;
 370                                 return other.Value == this.Value;
 371                         }
 372
 373                         public override int GetHashCode ()
 374                         {
 375                                 return Value;
 376                         }
 377
 378                         public static bool? operator == (SlotFromNullableToNullable? a, SlotFromNullableToNullable? b)
 379                         {
 380                                 if (a.HasValue && b.HasValue)
 381                                         return (bool?) (a.Value.Value == b.Value.Value);
 382                                 else
 383                                         return null;
 384                         }
 385
 386                         public static bool? operator != (SlotFromNullableToNullable? a, SlotFromNullableToNullable? b)
 387                         {
 388                                 return !(a == b);
 389                         }
 390                 }
 391
 392                 [Test]
 393                 public void UserDefinedFromNullableToNullableEqual ()
 394                 {
 395                         var l = Expression.Parameter (typeof (SlotFromNullableToNullable?), "l");
 396                         var r = Expression.Parameter (typeof (SlotFromNullableToNullable?), "r");
 397
 398                         var node = Expression.Equal (l, r);
 399
 400                         Assert.IsFalse (node.IsLifted);
 401                         Assert.IsFalse (node.IsLiftedToNull);
 402                         Assert.AreEqual (typeof (bool?), node.Type);
 403                         Assert.IsNotNull (node.Method);
 404
 405                         var eq = Expression.Lambda<Func<SlotFromNullableToNullable?, SlotFromNullableToNullable?, bool?>> (node, l, r).Compile ();
 406
 407                         Assert.AreEqual ((bool?) null, eq (null, null));
 408                         Assert.AreEqual ((bool?) null, eq (new SlotFromNullableToNullable (2), null));
 409                         Assert.AreEqual ((bool?) null, eq (null, new SlotFromNullableToNullable (2)));
 410                         Assert.AreEqual ((bool?) true, eq (new SlotFromNullableToNullable (2), new SlotFromNullableToNullable (2)));
 411                         Assert.AreEqual ((bool?) false, eq (new SlotFromNullableToNullable (2), new SlotFromNullableToNullable (-2)));
 412                 }*/
 413
 414                 [Test]
 415                 public void NullableBoolEqualToBool ()
 416                 {
 417                         var l = Expression.Parameter (typeof (bool?), "l");
 418                         var r = Expression.Parameter (typeof (bool?), "r");
 419
 420                         var node = Expression.Equal (l, r);
 421                         Assert.IsTrue (node.IsLifted);
 422                         Assert.IsFalse (node.IsLiftedToNull);
 423                         Assert.AreEqual (typeof (bool), node.Type);
 424                         Assert.IsNull (node.Method);
 425
 426                         var eq = Expression.Lambda<Func<bool?, bool?, bool>> (node, l, r).Compile ();
 427
 428                         Assert.AreEqual (false, eq (true, null));
 429                         Assert.AreEqual (true, eq (null, null));
 430                         Assert.AreEqual (true, eq (false, false));
 431                 }
 432
 433                 public enum Foo {
 434                         Bar,
 435                         Baz,
 436                 }
 437
 438                 [Test]
 439                 public void EnumEqual ()
 440                 {
 441                         var l = Expression.Parameter (typeof (Foo), "l");
 442                         var r = Expression.Parameter (typeof (Foo), "r");
 443
 444                         var node = Expression.Equal (l, r);
 445                         Assert.IsFalse (node.IsLifted);
 446                         Assert.IsFalse (node.IsLiftedToNull);
 447                         Assert.AreEqual (typeof (bool), node.Type);
 448                         Assert.IsNull (node.Method);
 449
 450                         var eq = Expression.Lambda<Func<Foo, Foo, bool>> (node, l, r).Compile ();
 451
 452                         Assert.AreEqual (true, eq (Foo.Bar, Foo.Bar));
 453                         Assert.AreEqual (false, eq (Foo.Bar, Foo.Baz));
 454                 }
 455
 456                 [Test]
 457                 public void LiftedEnumEqual ()
 458                 {
 459                         var l = Expression.Parameter (typeof (Foo?), "l");
 460                         var r = Expression.Parameter (typeof (Foo?), "r");
 461
 462                         var node = Expression.Equal (l, r);
 463                         Assert.IsTrue (node.IsLifted);
 464                         Assert.IsFalse (node.IsLiftedToNull);
 465                         Assert.AreEqual (typeof (bool), node.Type);
 466                         Assert.IsNull (node.Method);
 467
 468                         var eq = Expression.Lambda<Func<Foo?, Foo?, bool>> (node, l, r).Compile ();
 469
 470                         Assert.AreEqual (true, eq (Foo.Bar, Foo.Bar));
 471                         Assert.AreEqual (false, eq (Foo.Bar, Foo.Baz));
 472                         Assert.AreEqual (false, eq (Foo.Bar, null));
 473                         Assert.AreEqual (true, eq (null, null));
 474                 }
 475
 476                 [Test]
 477                 [Category ("NotWorkingInterpreter")]
 478                 public void NullableNullEqual ()
 479                 {
 480                         var param = Expression.Parameter (typeof (DateTime?), "x");
 481
 482                         var node = Expression.Equal (param, Expression.Constant (null));
 483
 484                         Assert.IsTrue (node.IsLifted);
 485                         Assert.IsFalse (node.IsLiftedToNull);
 486                         Assert.AreEqual (typeof (bool), node.Type);
 487                         Assert.IsNull (node.Method);
 488
 489                         var eq = Expression.Lambda<Func<DateTime?, bool>> (node, new [] { param }).Compile ();
 490
 491                         Assert.AreEqual (true, eq (null));
 492                         Assert.AreEqual (false, eq (DateTime.Now));
 493                 }
 494         }
 495 }