mcs/tests/gtest-etree-01.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using System.Linq.Expressions;
   5
   6 public struct InverseLogicalOperator
   7 {
   8         bool value;
   9         public InverseLogicalOperator (bool value)
  10         {
  11                 this.value = value;
  12         }
  13
  14         public static bool operator true (InverseLogicalOperator u)
  15         {
  16                 return u.value;
  17         }
  18
  19         public static bool operator false (InverseLogicalOperator u)
  20         {
  21                 return u.value;
  22         }
  23 }
  24
  25 /* TODO: Add tests for every numeric expression where a type has only 1 implicit
  26                 numeric conversion
  27 public struct MyType<T>
  28 {
  29         T value;
  30
  31         public MyType (T value)
  32         {
  33                 this.value = value;
  34         }
  35
  36         public static implicit operator T (MyType<T> o)
  37         {
  38                 return o.value;
  39         }
  40 }
  41 */
  42
  43 public struct MyType
  44 {
  45         int value;
  46
  47         public MyType (int value)
  48         {
  49                 this.value = value;
  50         }
  51
  52         public override int GetHashCode ()
  53         {
  54                 throw new NotImplementedException ();
  55         }
  56
  57         public static implicit operator int (MyType o)
  58         {
  59                 return o.value;
  60         }
  61
  62         public static bool operator true (MyType a)
  63         {
  64                 return a.value == a;
  65         }
  66
  67         public static bool operator false (MyType a)
  68         {
  69                 return a.value != a;
  70         }
  71
  72         public static MyType operator +(MyType a, MyType b)
  73         {
  74                 return new MyType (a.value + b.value);
  75         }
  76
  77         public static MyType operator / (MyType a, MyType b)
  78         {
  79                 return new MyType (a.value / b.value);
  80         }
  81
  82         public static MyType operator &(MyType a, MyType b)
  83         {
  84                 return new MyType (a.value & b.value);
  85         }
  86
  87         public static MyType operator | (MyType a, MyType b)
  88         {
  89                 return new MyType (a.value | b.value);
  90         }
  91
  92         public static MyType operator ^ (MyType a, MyType b)
  93         {
  94                 return new MyType (a.value ^ b.value);
  95         }
  96
  97         public static bool operator == (MyType a, MyType b)
  98         {
  99                 return a.value == b.value;
 100         }
 101
 102         public static bool operator != (MyType a, MyType b)
 103         {
 104                 return a.value != b.value;
 105         }
 106
 107         public static bool operator > (MyType a, MyType b)
 108         {
 109                 return a.value > b.value;
 110         }
 111
 112         public static bool operator < (MyType a, MyType b)
 113         {
 114                 return a.value < b.value;
 115         }
 116
 117         public static bool operator >= (MyType a, MyType b)
 118         {
 119                 return a.value >= b.value;
 120         }
 121
 122         public static bool operator <= (MyType a, MyType b)
 123         {
 124                 return a.value <= b.value;
 125         }
 126
 127         public static bool operator ! (MyType a)
 128         {
 129                 return a.value > 0;
 130         }
 131
 132         public static int operator >> (MyType a, int b)
 133         {
 134                 return a.value >> b;
 135         }
 136
 137         public override string ToString ()
 138         {
 139                 return value.ToString ();
 140         }
 141 }
 142
 143 // TODO: Add more nullable tests, follow AddTest pattern.
 144
 145 class Tester
 146 {
 147         static void AssertNodeType (LambdaExpression e, ExpressionType et)
 148         {
 149                 if (e.Body.NodeType != et)
 150                         throw new ApplicationException (e.Body.NodeType + " != " + et);
 151         }
 152
 153         static void Assert<T> (T expected, T value)
 154         {
 155                 if (!EqualityComparer<T>.Default.Equals (expected, value))
 156                         throw new ApplicationException (expected + " != " + value);
 157         }
 158
 159         static void Assert<T> (T [] expected, T [] value)
 160         {
 161                 if (expected.Length != value.Length)
 162                         throw new ApplicationException ("Array length does not match " + expected.Length + " != " + value.Length);
 163
 164                 for (int i = 0; i < expected.Length; ++i) {
 165                         if (!EqualityComparer<T>.Default.Equals (expected [i], value [i]))
 166                                 throw new ApplicationException ("Index " + i + ": " + expected [i] + " != " + value [i]);
 167                 }
 168         }
 169
 170         void AddTest ()
 171         {
 172                 Expression<Func<int, int, int>> e = (int a, int b) => a + b;
 173                 AssertNodeType (e, ExpressionType.Add);
 174                 Assert (50, e.Compile ().Invoke (20, 30));
 175
 176                 Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
 177                 AssertNodeType (e2, ExpressionType.Add);
 178                 Assert (null, e2.Compile ().Invoke (null, 3));
 179
 180                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
 181                 AssertNodeType (e3, ExpressionType.Add);
 182                 Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
 183
 184                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a + b;
 185                 AssertNodeType (e4, ExpressionType.Add);
 186                 Assert (new MyType (10), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
 187                 Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
 188
 189                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a + b;
 190                 AssertNodeType (e5, ExpressionType.Add);
 191                 Assert (31, e5.Compile ().Invoke (1, new MyType (30)));
 192 /*
 193                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a + b;
 194                 AssertNodeType (e6, ExpressionType.Add);
 195                 Assert (-1, e6.Compile ().Invoke (-31, new MyType (30)));
 196 */
 197         }
 198
 199         void AddCheckedTest ()
 200         {
 201                 checked {
 202                 Expression<Func<int, int, int>> e = (int a, int b) => a + b;
 203                 AssertNodeType (e, ExpressionType.AddChecked);
 204                 Assert (50, e.Compile ().Invoke (20, 30));
 205
 206                 Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
 207                 AssertNodeType (e2, ExpressionType.AddChecked);
 208                 Assert (null, e2.Compile ().Invoke (null, 3));
 209
 210                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
 211                 AssertNodeType (e3, ExpressionType.Add);
 212                 Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
 213                 }
 214         }
 215
 216         void AndTest ()
 217         {
 218                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a & b;
 219
 220                 AssertNodeType (e, ExpressionType.And);
 221                 Func<bool, bool, bool> c = e.Compile ();
 222
 223                 Assert (true, c (true, true));
 224                 Assert (false, c (true, false));
 225                 Assert (false, c (false, true));
 226                 Assert (false, c (false, false));
 227
 228                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a & b;
 229
 230                 AssertNodeType (e2, ExpressionType.And);
 231                 var c2 = e2.Compile ();
 232
 233                 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
 234                 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
 235         }
 236
 237         void AndNullableTest ()
 238         {
 239                 Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a & b;
 240
 241                 AssertNodeType (e, ExpressionType.And);
 242                 Func<bool?, bool?, bool?> c = e.Compile ();
 243
 244                 Assert (true, c (true, true));
 245                 Assert (false, c (true, false));
 246                 Assert (false, c (false, true));
 247                 Assert (false, c (false, false));
 248
 249                 Assert (null, c (true, null));
 250                 Assert (false, c (false, null));
 251                 Assert (false, c (null, false));
 252                 Assert (null, c (true, null));
 253                 Assert (null, c (null, null));
 254
 255                 Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a & b;
 256
 257                 AssertNodeType (e2, ExpressionType.And);
 258                 var c2 = e2.Compile ();
 259
 260                 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
 261                 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
 262                 Assert (null, c2 (new MyType (0xFF), null));
 263         }
 264
 265         void AndAlsoTest ()
 266         {
 267                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a && b;
 268
 269                 AssertNodeType (e, ExpressionType.AndAlso);
 270                 Assert (false, e.Compile ().Invoke (true, false));
 271
 272                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a && b;
 273
 274                 AssertNodeType (e2, ExpressionType.AndAlso);
 275                 Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
 276                 Assert (new MyType (0), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
 277         }
 278
 279         void ArrayIndexTest ()
 280         {
 281                 Expression<Func<string [], long, string>> e = (string [] a, long i) => a [i];
 282                 AssertNodeType (e, ExpressionType.ArrayIndex);
 283                 Assert ("b", e.Compile ().Invoke (new string [] { "a", "b", "c" }, 1));
 284
 285                 Expression<Func<string [], string>> e2 = (string [] a) => a [0];
 286                 AssertNodeType (e2, ExpressionType.ArrayIndex);
 287                 Assert ("a", e2.Compile ().Invoke (new string [] { "a", "b" }));
 288
 289                 Expression<Func<object [,], int, int, object>> e3 = (object [,] a, int i, int j) => a [i, j];
 290                 AssertNodeType (e3, ExpressionType.Call);
 291
 292                 Assert ("z", e3.Compile ().Invoke (
 293                         new object [,] { { 1, 2 }, { "x", "z" } }, 1, 1));
 294
 295                 Expression<Func<decimal [] [], byte, decimal>> e4 = (decimal [] [] a, byte b) => a [b] [1];
 296                 AssertNodeType (e4, ExpressionType.ArrayIndex);
 297
 298                 decimal [] [] array = { new decimal [] { 1, 9 }, new decimal [] { 10, 90 } };
 299                 Assert (90, e4.Compile ().Invoke (array, 1));
 300         }
 301
 302         void ArrayLengthTest ()
 303         {
 304                 int o = new int [0].Length;
 305
 306                 Expression<Func<double [], int>> e = (double [] a) => a.Length;
 307                 AssertNodeType (e, ExpressionType.ArrayLength);
 308                 Assert (0, e.Compile ().Invoke (new double [0]));
 309                 Assert (9, e.Compile ().Invoke (new double [9]));
 310
 311                 // TODO: implement
 312                 //Expression<Func<string [,], int>> e2 = (string [,] a) => a.Length;
 313                 //AssertNodeType (e2, ExpressionType.MemberAccess);
 314                 //Assert (0, e2.Compile ().Invoke (new string [0, 0]));
 315         }
 316
 317         void CallTest ()
 318         {
 319                 Expression<Func<int, int>> e = (int a) => Math.Max (a, 5);
 320                 AssertNodeType (e, ExpressionType.Call);
 321                 Assert (5, e.Compile ().Invoke (2));
 322                 Assert (9, e.Compile ().Invoke (9));
 323
 324                 Expression<Func<string, string>> e2 = (string a) => InstanceMethod (a);
 325                 AssertNodeType (e2, ExpressionType.Call);
 326                 Assert ("abc", e2.Compile ().Invoke ("abc"));
 327
 328                 Expression<Func<int, string, int, object>> e3 = (int index, string a, int b) => InstanceParamsMethod (index, a, b);
 329                 AssertNodeType (e3, ExpressionType.Call);
 330                 Assert<object> (4, e3.Compile ().Invoke (1, "a", 4));
 331
 332                 Expression<Func<object>> e4 = () => InstanceParamsMethod (0);
 333                 AssertNodeType (e4, ExpressionType.Call);
 334                 Assert<object> ("<empty>", e4.Compile ().Invoke ());
 335
 336                 Expression<Func<int, int>> e5 = (int a) => GenericMethod (a);
 337                 AssertNodeType (e5, ExpressionType.Call);
 338                 Assert (5, e5.Compile ().Invoke (5));
 339         }
 340
 341         void CoalesceTest ()
 342         {
 343                 Expression<Func<uint?, uint>> e = (uint? a) => a ?? 99;
 344                 AssertNodeType (e, ExpressionType.Coalesce);
 345                 var r = e.Compile ();
 346                 Assert ((uint) 5, r.Invoke (5));
 347                 Assert ((uint) 99, r.Invoke (null));
 348
 349                 Expression<Func<MyType?, int>> e2 = (MyType? a) => a ?? -3;
 350                 AssertNodeType (e2, ExpressionType.Coalesce);
 351                 var r2 = e2.Compile ();
 352                 Assert (2, r2.Invoke (new MyType (2)));
 353                 Assert (-3, r2.Invoke (null));
 354         }
 355
 356         void ConditionTest ()
 357         {
 358                 Expression<Func<bool, byte, int, int>> e = (bool a, byte b, int c) => (a ? b : c);
 359                 AssertNodeType (e, ExpressionType.Conditional);
 360                 var r = e.Compile ();
 361                 Assert (3, r.Invoke (true, 3, 999999));
 362                 Assert (999999, r.Invoke (false, 3, 999999));
 363
 364                 Expression<Func<int, decimal, decimal?>> e2 = (int a, decimal d) => (a > 0 ? d : a < 0 ? -d : (decimal?) null);
 365                 AssertNodeType (e2, ExpressionType.Conditional);
 366                 var r2 = e2.Compile ();
 367                 Assert (null, r2.Invoke (0, 10));
 368                 Assert (50, r2.Invoke (1, 50));
 369                 Assert (30, r2.Invoke (-7, -30));
 370
 371                 Expression<Func<bool?, int?>> e3 = (bool? a) => ((bool) a ? 3 : -2);
 372                 AssertNodeType (e3, ExpressionType.Convert);
 373                 var r3 = e3.Compile ();
 374                 Assert (3, r3.Invoke (true));
 375                 Assert (-2, r3.Invoke (false));
 376
 377                 Expression<Func<InverseLogicalOperator, byte, byte, byte>> e4 = (InverseLogicalOperator a, byte b, byte c) => (a ? b : c);
 378                 AssertNodeType (e4, ExpressionType.Conditional);
 379                 var r4 = e4.Compile ();
 380                 Assert (3, r4.Invoke (new InverseLogicalOperator (true), 3, 4));
 381                 Assert (4, r4.Invoke (new InverseLogicalOperator (false), 3, 4));
 382         }
 383
 384         void ConvertTest ()
 385         {
 386                 Expression<Func<int, byte>> e = (int a) => ((byte) a);
 387                 AssertNodeType (e, ExpressionType.Convert);
 388                 Assert (100, e.Compile ().Invoke (100));
 389
 390                 Expression<Func<long, ushort>> e2 = (long a) => ((ushort) a);
 391                 AssertNodeType (e2, ExpressionType.Convert);
 392                 Assert (100, e2.Compile ().Invoke (100));
 393
 394                 Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
 395                 AssertNodeType (e3, ExpressionType.Convert);
 396                 Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
 397
 398                 Expression<Func<MyType, int>> e4 = (MyType a) => (a);
 399                 AssertNodeType (e4, ExpressionType.Convert);
 400                 Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
 401
 402                 Expression<Func<MyType, MyType, bool?>> e5 = (MyType a, MyType b) => a == b;
 403                 AssertNodeType (e5, ExpressionType.Convert);
 404         }
 405
 406         void ConvertCheckedTest ()
 407         {
 408                 Expression<Func<int, byte>> e = (int a) => checked((byte) a);
 409                 AssertNodeType (e, ExpressionType.ConvertChecked);
 410                 Assert (100, e.Compile ().Invoke (100));
 411
 412                 checked {
 413                         Expression<Func<long, ushort>> e2 = (long a) => unchecked((ushort) a);
 414                         AssertNodeType (e2, ExpressionType.Convert);
 415                         Assert (100, e2.Compile ().Invoke (100));
 416
 417                         Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
 418                         AssertNodeType (e3, ExpressionType.ConvertChecked);
 419                         Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
 420
 421                         Expression<Func<MyType, int>> e4 = (MyType a) => (a);
 422                         AssertNodeType (e4, ExpressionType.Convert);
 423                         Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
 424                 }
 425         }
 426
 427         void DivideTest ()
 428         {
 429                 Expression<Func<int, int, int>> e = (int a, int b) => a / b;
 430                 AssertNodeType (e, ExpressionType.Divide);
 431                 Assert (2, e.Compile ().Invoke (60, 30));
 432
 433                 Expression<Func<double?, double?, double?>> e2 = (a, b) => a / b;
 434                 AssertNodeType (e2, ExpressionType.Divide);
 435                 Assert (null, e2.Compile ().Invoke (null, 3));
 436                 Assert (1.5, e2.Compile ().Invoke (3, 2));
 437
 438                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a / b;
 439                 AssertNodeType (e3, ExpressionType.Divide);
 440                 Assert (1, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
 441
 442                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a / b;
 443                 AssertNodeType (e4, ExpressionType.Divide);
 444                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
 445                 Assert (new MyType (-6), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
 446         }
 447
 448         void EqualTest ()
 449         {
 450                 Expression<Func<int, int, bool>> e = (int a, int b) => a == b;
 451                 AssertNodeType (e, ExpressionType.Equal);
 452                 Assert (false, e.Compile ().Invoke (60, 30));
 453                 Assert (true, e.Compile ().Invoke (-1, -1));
 454
 455                 Expression<Func<double?, double?, bool>> e2 = (a, b) => a == b;
 456                 AssertNodeType (e2, ExpressionType.Equal);
 457                 Assert (true, e2.Compile ().Invoke (3, 3));
 458                 Assert (false, e2.Compile ().Invoke (3, 2));
 459
 460                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a == b;
 461                 AssertNodeType (e3, ExpressionType.Equal);
 462                 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
 463
 464                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a == b;
 465                 AssertNodeType (e4, ExpressionType.Equal);
 466                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
 467                 Assert (true, e4.Compile ().Invoke (null, null));
 468                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
 469         }
 470
 471         delegate void EmptyDelegate ();
 472
 473         static void EqualTestDelegate ()
 474         {
 475                 Expression<Func<Delegate, Delegate, bool>> e1 = (a, b) => a == b;
 476                 AssertNodeType (e1, ExpressionType.Equal);
 477                 Assert (true, e1.Compile ().Invoke (null, null));
 478
 479                 EmptyDelegate ed = delegate () {};
 480
 481                 Expression<Func<EmptyDelegate, EmptyDelegate, bool>> e2 = (a, b) => a == b;
 482                 AssertNodeType (e2, ExpressionType.Equal);
 483                 Assert (false, e2.Compile ().Invoke (delegate () {}, null));
 484                 Assert (false, e2.Compile ().Invoke (delegate () {}, delegate {}));
 485                 Assert (false, e2.Compile ().Invoke (ed, delegate {}));
 486                 Assert (true, e2.Compile ().Invoke (ed, ed));
 487         }
 488
 489         void ExclusiveOrTest ()
 490         {
 491                 Expression<Func<int, int, int>> e = (int a, int b) => a ^ b;
 492                 AssertNodeType (e, ExpressionType.ExclusiveOr);
 493                 Assert (34, e.Compile ().Invoke (60, 30));
 494 /* FIXME: missing conversion
 495                 Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a ^ b;
 496                 AssertNodeType (e2, ExpressionType.ExclusiveOr);
 497                 Assert (null, e2.Compile ().Invoke (null, 3));
 498                 Assert (1, e2.Compile ().Invoke (3, 2));
 499 */
 500                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a ^ b;
 501                 AssertNodeType (e3, ExpressionType.ExclusiveOr);
 502                 Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
 503
 504                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a ^ b;
 505                 AssertNodeType (e4, ExpressionType.ExclusiveOr);
 506                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
 507                 Assert (new MyType (-108), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
 508         }
 509
 510         void GreaterThanTest ()
 511         {/*
 512                 Expression<Func<int, int, bool>> e = (int a, int b) => a > b;
 513                 AssertNodeType (e, ExpressionType.GreaterThan);
 514                 Assert (true, e.Compile ().Invoke (60, 30));
 515 */
 516                 Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a > b;
 517                 AssertNodeType (e2, ExpressionType.GreaterThan);
 518                 Assert (false, e2.Compile ().Invoke (null, 3));
 519                 Assert (false, e2.Compile ().Invoke (2, 2));
 520 /*
 521                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a > b;
 522                 AssertNodeType (e3, ExpressionType.GreaterThan);
 523                 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
 524
 525                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a > b;
 526                 AssertNodeType (e4, ExpressionType.GreaterThan);
 527                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
 528                 Assert (false, e4.Compile ().Invoke (null, null));
 529                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
 530                 */
 531         }
 532
 533         void GreaterThanOrEqualTest ()
 534         {
 535                 Expression<Func<int, int, bool>> e = (int a, int b) => a >= b;
 536                 AssertNodeType (e, ExpressionType.GreaterThanOrEqual);
 537                 Assert (true, e.Compile ().Invoke (60, 30));
 538
 539                 Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a >= b;
 540                 AssertNodeType (e2, ExpressionType.GreaterThanOrEqual);
 541                 Assert (false, e2.Compile ().Invoke (null, 3));
 542                 Assert (true, e2.Compile ().Invoke (2, 2));
 543
 544                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a >= b;
 545                 AssertNodeType (e3, ExpressionType.GreaterThanOrEqual);
 546                 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
 547
 548                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a >= null;
 549                 AssertNodeType (e4, ExpressionType.GreaterThanOrEqual);
 550                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
 551                 Assert (false, e4.Compile ().Invoke (null, null));
 552                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
 553         }
 554
 555         void NewArrayInitTest ()
 556         {
 557                 Expression<Func<int []>> e = () => new int [0];
 558                 AssertNodeType (e, ExpressionType.NewArrayInit);
 559                 Assert (new int [0], e.Compile ().Invoke ());
 560
 561                 e = () => new int [] { };
 562                 AssertNodeType (e, ExpressionType.NewArrayInit);
 563                 Assert (new int [0], e.Compile ().Invoke ());
 564
 565                 Expression<Func<ushort, ulong? []>> e2 = (ushort a) => new ulong? [] { a };
 566                 AssertNodeType (e2, ExpressionType.NewArrayInit);
 567                 Assert (new ulong? [1] { ushort.MaxValue }, e2.Compile ().Invoke (ushort.MaxValue));
 568
 569                 Expression<Func<char [] []>> e3 = () => new char [] [] { new char [] { 'a' } };
 570                 AssertNodeType (e3, ExpressionType.NewArrayInit);
 571                 Assert (new char [] { 'a' }, e3.Compile ().Invoke () [0]);
 572         }
 573
 574         void NotTest ()
 575         {
 576                 Expression<Func<bool, bool>> e = (bool a) => !a;
 577                 AssertNodeType (e, ExpressionType.Not);
 578                 Assert (false, e.Compile ().Invoke (true));
 579
 580                 Expression<Func<MyType, bool>> e2 = (MyType a) => !a;
 581                 AssertNodeType (e2, ExpressionType.Not);
 582                 Assert (true, e2.Compile ().Invoke (new MyType (1)));
 583                 Assert (false, e2.Compile ().Invoke (new MyType (-1)));
 584         }
 585
 586         void NotNullableTest ()
 587         {
 588                 Expression<Func<bool?, bool?>> e = (bool? a) => !a;
 589                 AssertNodeType (e, ExpressionType.Not);
 590                 Assert (false, e.Compile ().Invoke (true));
 591                 Assert (null, e.Compile ().Invoke (null));
 592
 593                 Expression<Func<MyType?, bool?>> e2 = (MyType? a) => !a;
 594                 AssertNodeType (e2, ExpressionType.Not);
 595                 Assert (true, e2.Compile ().Invoke (new MyType (1)));
 596                 Assert (null, e2.Compile ().Invoke (null));
 597         }
 598
 599         void NotEqualTest ()
 600         {
 601                 Expression<Func<int, int, bool>> e = (int a, int b) => a != b;
 602                 AssertNodeType (e, ExpressionType.NotEqual);
 603                 Assert (true, e.Compile ().Invoke (60, 30));
 604                 Assert (false, e.Compile ().Invoke (-1, -1));
 605
 606                 Expression<Func<sbyte?, sbyte?, bool>> e2 = (a, b) => a != b;
 607                 AssertNodeType (e2, ExpressionType.NotEqual);
 608                 Assert (false, e2.Compile ().Invoke (3, 3));
 609                 Assert (true, e2.Compile ().Invoke (3, 2));
 610
 611                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a != b;
 612                 AssertNodeType (e3, ExpressionType.NotEqual);
 613                 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
 614
 615                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a != b;
 616                 AssertNodeType (e4, ExpressionType.NotEqual);
 617                 Assert (true, e4.Compile ().Invoke (null, new MyType (-20)));
 618                 Assert (false, e4.Compile ().Invoke (null, null));
 619                 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
 620         }
 621
 622         void OrTest ()
 623         {
 624                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a | b;
 625
 626                 AssertNodeType (e, ExpressionType.Or);
 627                 Func<bool, bool, bool> c = e.Compile ();
 628
 629                 Assert (true, c (true, true));
 630                 Assert (true, c (true, false));
 631                 Assert (true, c (false, true));
 632                 Assert (false, c (false, false));
 633
 634                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a | b;
 635                 AssertNodeType (e2, ExpressionType.Or);
 636                 var c2 = e2.Compile ();
 637                 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
 638         }
 639
 640         void OrNullableTest ()
 641         {
 642                 Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a | b;
 643
 644                 AssertNodeType (e, ExpressionType.Or);
 645                 Func<bool?, bool?, bool?> c = e.Compile ();
 646
 647                 Assert (true, c (true, true));
 648                 Assert (true, c (true, false));
 649                 Assert (true, c (false, true));
 650                 Assert (false, c (false, false));
 651
 652                 Assert (true, c (true, null));
 653                 Assert (null, c (false, null));
 654                 Assert (null, c (null, false));
 655                 Assert (true, c (true, null));
 656                 Assert (null, c (null, null));
 657
 658                 Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a | b;
 659                 AssertNodeType (e2, ExpressionType.Or);
 660                 var c2 = e2.Compile ();
 661                 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
 662                 Assert (null, c2 (new MyType (1), null));
 663         }
 664
 665         void OrElseTest ()
 666         {
 667                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a || b;
 668                 AssertNodeType (e, ExpressionType.OrElse);
 669                 Assert (true, e.Compile ().Invoke (true, false));
 670
 671                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a || b;
 672                 AssertNodeType (e2, ExpressionType.OrElse);
 673                 Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
 674                 Assert (new MyType (32), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
 675         }
 676
 677         void ParameterTest ()
 678         {
 679                 Expression<Func<string, string>> e = (string a) => a;
 680                 AssertNodeType (e, ExpressionType.Parameter);
 681                 Assert ("t", e.Compile ().Invoke ("t"));
 682
 683                 Expression<Func<object[], object[]>> e2 = (object[] a) => a;
 684                 AssertNodeType (e2, ExpressionType.Parameter);
 685                 Assert (new object[0], e2.Compile ().Invoke (new object[0]));
 686
 687                 Expression<Func<IntPtr, IntPtr>> e3 = a => a;
 688                 AssertNodeType (e3, ExpressionType.Parameter);
 689                 Assert (IntPtr.Zero, e3.Compile ().Invoke (IntPtr.Zero));
 690         }
 691
 692         void QuoteTest ()
 693         {
 694                 Expression<Func<Expression<Func<int>>>> e = () => () => 2;
 695                 AssertNodeType (e, ExpressionType.Quote);
 696                 Assert (2, e.Compile ().Invoke ().Compile ().Invoke ());
 697         }
 698
 699         void RightShiftTest ()
 700         {
 701                 Expression<Func<ulong, sbyte, ulong>> e = (ulong a, sbyte b) => a >> b;
 702                 AssertNodeType (e, ExpressionType.RightShift);
 703                 Assert ((ulong)0x1FD940L, e.Compile ().Invoke (0xFECA0000, 11));
 704
 705                 Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a >> b;
 706                 AssertNodeType (e2, ExpressionType.RightShift);
 707                 var c2 = e2.Compile ();
 708                 Assert (64, c2 (new MyType (256), new MyType (2)));
 709
 710                 Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a >> b;
 711                 AssertNodeType (e3, ExpressionType.RightShift);
 712                 Assert (null, e3.Compile ().Invoke (null, 11));
 713                 Assert (512, e3.Compile ().Invoke (1024, 1));
 714
 715                 Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a >> b;
 716                 AssertNodeType (e4, ExpressionType.RightShift);
 717                 var c4 = e4.Compile ();
 718                 Assert (null, c4 (new MyType (8), null));
 719                 Assert (null, c4 (null, new MyType (8)));
 720                 Assert (64, c4 (new MyType (256), new MyType (2)));
 721         }
 722
 723         //
 724         // Test helpers
 725         //
 726         string InstanceMethod (string arg)
 727         {
 728                 return arg;
 729         }
 730
 731         object InstanceParamsMethod (int index, params object [] args)
 732         {
 733                 if (args == null)
 734                         return "<null>";
 735                 if (args.Length == 0)
 736                         return "<empty>";
 737                 return args [index];
 738         }
 739
 740         T GenericMethod<T> (T t)
 741         {
 742                 return t;
 743         }
 744
 745
 746         public static int Main ()
 747         {
 748                 Tester e = new Tester ();
 749                 e.AddTest ();
 750                 e.AndNullableTest ();
 751                 e.AddCheckedTest ();
 752                 e.AndTest ();
 753                 e.AndAlsoTest ();
 754                 e.ArrayIndexTest ();
 755                 e.ArrayLengthTest ();
 756                 e.CallTest ();
 757                 e.CoalesceTest ();
 758                 e.ConditionTest ();
 759                 e.ConvertTest ();
 760                 e.ConvertCheckedTest ();
 761                 e.DivideTest ();
 762                 e.EqualTest ();
 763                 e.EqualTestDelegate ();
 764                 e.ExclusiveOrTest ();
 765                 e.GreaterThanTest ();
 766                 e.GreaterThanOrEqualTest ();
 767                 e.NewArrayInitTest ();
 768                 e.NotTest ();
 769                 e.NotNullableTest ();
 770                 e.NotEqualTest ();
 771                 e.OrTest ();
 772                 e.OrNullableTest ();
 773                 e.OrElseTest ();
 774                 e.ParameterTest ();
 775                 e.QuoteTest ();
 776                 e.RightShiftTest ();
 777
 778                 return 0;
 779         }
 780 }
 781