mcs/tests/gtest-etree-01.cs

   1 // Compiler options: -unsafe
   2
   3 using System;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Linq.Expressions;
   7 using System.Reflection;
   8
   9 public struct InverseLogicalOperator
  10 {
  11         bool value;
  12         public InverseLogicalOperator (bool value)
  13         {
  14                 this.value = value;
  15         }
  16
  17         public static bool operator true (InverseLogicalOperator u)
  18         {
  19                 return u.value;
  20         }
  21
  22         public static bool operator false (InverseLogicalOperator u)
  23         {
  24                 return u.value;
  25         }
  26 }
  27
  28 /* TODO: Add tests for every numeric expression where a type has only 1 implicit
  29                 numeric conversion
  30 public struct MyType<T>
  31 {
  32         T value;
  33
  34         public MyType (T value)
  35         {
  36                 this.value = value;
  37         }
  38
  39         public static implicit operator T (MyType<T> o)
  40         {
  41                 return o.value;
  42         }
  43 }
  44 */
  45
  46
  47 // TODO: Create a clone which uses +(MyType, int) pattern and an implicit conversion
  48 // is required to do the user-conversion
  49
  50 public struct MyType
  51 {
  52         int value;
  53
  54         public MyType (int value) : this ()
  55         {
  56                 this.value = value;
  57         }
  58
  59         public short ShortProp { get; set; }
  60
  61         public override int GetHashCode ()
  62         {
  63                 throw new NotImplementedException ();
  64         }
  65
  66         public static implicit operator int (MyType o)
  67         {
  68                 return o.value;
  69         }
  70
  71         public static bool operator true (MyType a)
  72         {
  73                 return a.value == a;
  74         }
  75
  76         public static bool operator false (MyType a)
  77         {
  78                 return a.value != a;
  79         }
  80
  81         public static MyType operator + (MyType a, MyType b)
  82         {
  83                 return new MyType (a.value + b.value);
  84         }
  85
  86         public static MyType operator - (MyType a, MyType b)
  87         {
  88                 return new MyType (a.value - b.value);
  89         }
  90
  91         public static MyType operator / (MyType a, MyType b)
  92         {
  93                 return new MyType (a.value / b.value);
  94         }
  95
  96         public static MyType operator * (MyType a, MyType b)
  97         {
  98                 return new MyType (a.value * b.value);
  99         }
 100
 101         public static MyType operator % (MyType a, MyType b)
 102         {
 103                 return new MyType (a.value % b.value);
 104         }
 105
 106         public static MyType operator &(MyType a, MyType b)
 107         {
 108                 return new MyType (a.value & b.value);
 109         }
 110
 111         public static MyType operator | (MyType a, MyType b)
 112         {
 113                 return new MyType (a.value | b.value);
 114         }
 115
 116         public static MyType operator ^ (MyType a, MyType b)
 117         {
 118                 return new MyType (a.value ^ b.value);
 119         }
 120
 121         public static bool operator == (MyType a, MyType b)
 122         {
 123                 return a.value == b.value;
 124         }
 125
 126         public static bool operator != (MyType a, MyType b)
 127         {
 128                 return a.value != b.value;
 129         }
 130
 131         public static bool operator > (MyType a, MyType b)
 132         {
 133                 return a.value > b.value;
 134         }
 135
 136         public static bool operator < (MyType a, MyType b)
 137         {
 138                 return a.value < b.value;
 139         }
 140
 141         public static bool operator >= (MyType a, MyType b)
 142         {
 143                 return a.value >= b.value;
 144         }
 145
 146         public static bool operator <= (MyType a, MyType b)
 147         {
 148                 return a.value <= b.value;
 149         }
 150
 151         public static bool operator ! (MyType a)
 152         {
 153                 return a.value > 0;
 154         }
 155
 156         public static int operator >> (MyType a, int b)
 157         {
 158                 return a.value >> b;
 159         }
 160
 161         public static int operator << (MyType a, int b)
 162         {
 163                 return a.value << b;
 164         }
 165
 166         public static MyType operator - (MyType a)
 167         {
 168                 return new MyType (-a.value);
 169         }
 170
 171         public static MyType operator + (MyType a)
 172         {
 173                 return new MyType (+a.value);
 174         }
 175
 176         public override string ToString ()
 177         {
 178                 return value.ToString ();
 179         }
 180 }
 181
 182
 183 class MyTypeExplicit
 184 {
 185         int value;
 186
 187         public MyTypeExplicit (int value)
 188         {
 189                 this.value = value;
 190         }
 191
 192         public static explicit operator int (MyTypeExplicit m)
 193         {
 194                 return m.value;
 195         }
 196 }
 197
 198 struct MyTypeImplicitOnly
 199 {
 200         short b;
 201
 202         public MyTypeImplicitOnly (short b)
 203         {
 204                 this.b = b;
 205         }
 206
 207         public static implicit operator short (MyTypeImplicitOnly m)
 208         {
 209                 return m.b;
 210         }
 211 }
 212
 213 struct StructWithUserConstructor
 214 {
 215         public StructWithUserConstructor ()
 216         {
 217
 218         }
 219 }
 220
 221 class MemberAccessData
 222 {
 223         public bool BoolValue;
 224         public static decimal DecimalValue = decimal.MinValue;
 225         public volatile uint VolatileValue;
 226         public string [] StringValues;
 227         public List<string> ListValues;
 228
 229         event Func<bool> EventField;
 230         public Expression<Func<Func<bool>>> GetEvent ()
 231         {
 232                 return () => EventField;
 233         }
 234
 235         MyType mt;
 236         public MyType MyTypeProperty {
 237                 set     {
 238                         mt = value;
 239                 }
 240                 get {
 241                         return mt;
 242                 }
 243         }
 244
 245         public static string StaticProperty {
 246                 get {
 247                         return "alo";
 248                 }
 249         }
 250
 251         public object SetOnly { set { } }
 252 }
 253
 254 enum MyEnum : byte
 255 {
 256         Value_1 = 1,
 257         Value_2 = 2
 258 }
 259
 260 enum MyEnumUlong : ulong
 261 {
 262         Value_1 = 1
 263 }
 264
 265 enum EnumInt
 266 {
 267         A,
 268         B,
 269         C
 270 }
 271
 272 class NewTest<T>
 273 {
 274         T [] t;
 275         public NewTest (T i)
 276         {
 277                 t = new T [] { i };
 278         }
 279
 280         public NewTest (params T [] t)
 281         {
 282                 this.t = t;
 283         }
 284
 285         public override int GetHashCode ()
 286         {
 287                 return base.GetHashCode ();
 288         }
 289
 290         public override bool Equals (object obj)
 291         {
 292                 NewTest<T> obj_t = obj as NewTest<T>;
 293                 if (obj_t == null)
 294                         return false;
 295
 296                 for (int i = 0; i < t.Length; ++i) {
 297                         if (!t [i].Equals (obj_t.t [i]))
 298                                 return false;
 299                 }
 300
 301                 return true;
 302         }
 303 }
 304
 305 class Indexer
 306 {
 307         public int this [int i] { get { return i; } set { } }
 308         public string this [params string[] i] { get { return string.Concat (i); } }
 309 }
 310
 311 class A { }
 312 class B : A { }
 313
 314 // TODO: Add more nullable tests, follow AddTest pattern.
 315
 316 class Tester
 317 {
 318         delegate void EmptyDelegate ();
 319         delegate int IntDelegate ();
 320         static int ReturnNumber ()
 321         {
 322                 return 8;
 323         }
 324
 325         static void AssertNodeType (LambdaExpression e, ExpressionType et)
 326         {
 327                 if (e.Body.NodeType != et)
 328                         throw new ApplicationException (e.Body.NodeType + " != " + et);
 329         }
 330
 331         static void Assert<T> (T expected, T value)
 332         {
 333                 Assert (expected, value, null);
 334         }
 335
 336         static void Assert<T> (T expected, T value, string name)
 337         {
 338                 if (!EqualityComparer<T>.Default.Equals (expected, value)) {
 339                         if (!string.IsNullOrEmpty (name))
 340                                 name += ": ";
 341                         throw new ApplicationException (name + expected + " != " + value);
 342                 }
 343         }
 344
 345         static void Assert<T> (T [] expected, T [] value)
 346         {
 347                 if (expected == null) {
 348                         if (value != null)
 349                                 throw new ApplicationException ("Both arrays expected to be null");
 350                         return;
 351                 }
 352
 353                 if (expected.Length != value.Length)
 354                         throw new ApplicationException ("Array length does not match " + expected.Length + " != " + value.Length);
 355
 356                 for (int i = 0; i < expected.Length; ++i) {
 357                         if (!EqualityComparer<T>.Default.Equals (expected [i], value [i]))
 358                                 throw new ApplicationException ("Index " + i + ": " + expected [i] + " != " + value [i]);
 359                 }
 360         }
 361
 362 #pragma warning disable 169
 363
 364         void AddTest ()
 365         {
 366                 Expression<Func<int, int, int>> e = (int a, int b) => a + b;
 367                 AssertNodeType (e, ExpressionType.Add);
 368                 Assert (50, e.Compile ().Invoke (20, 30));
 369         }
 370
 371         void AddTest_2 ()
 372         {
 373                 Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
 374                 AssertNodeType (e2, ExpressionType.Add);
 375                 Assert (null, e2.Compile ().Invoke (null, 3));
 376         }
 377
 378         void AddTest_3 ()
 379         {
 380                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
 381                 AssertNodeType (e3, ExpressionType.Add);
 382                 Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
 383         }
 384
 385         void AddTest_4 ()
 386         {
 387                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a + b;
 388                 AssertNodeType (e4, ExpressionType.Add);
 389                 Assert (new MyType (10), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
 390                 Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
 391         }
 392
 393         void AddTest_5 ()
 394         {
 395                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a + b;
 396                 AssertNodeType (e5, ExpressionType.Add);
 397                 Assert (31, e5.Compile ().Invoke (1, new MyType (30)));
 398         }
 399
 400         void AddTest_6 ()
 401         {
 402                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a + b;
 403                 AssertNodeType (e6, ExpressionType.Add);
 404                 Assert (-1, e6.Compile ().Invoke (-31, new MyType (30)));
 405         }
 406
 407         void AddTest_7 ()
 408         {
 409                 Expression<Func<MyEnum, byte, MyEnum>> e7 = (a, b) => a + b;
 410                 AssertNodeType (e7, ExpressionType.Convert);
 411                 Assert (MyEnum.Value_2, e7.Compile ().Invoke (MyEnum.Value_1, 1));
 412         }
 413
 414         void AddTest_8 ()
 415         {
 416                 // CSC BUG: probably due to missing numeric promotion
 417                 Expression<Func<MyEnum?, byte?, MyEnum?>> e8 = (a, b) => a + b;
 418                 AssertNodeType (e8, ExpressionType.Convert);
 419                 Assert<MyEnum?> (0, e8.Compile ().Invoke (MyEnum.Value_1, 255));
 420                 Assert (null, e8.Compile ().Invoke (MyEnum.Value_1, null));
 421                 Assert (null, e8.Compile ().Invoke (null, null));
 422         }
 423
 424         void AddTest_9 ()
 425         {
 426                 Expression<Func<byte, MyEnum, MyEnum>> e9 = (a, b) => a + b;
 427                 AssertNodeType (e9, ExpressionType.Convert);
 428                 Assert (MyEnum.Value_2, e9.Compile ().Invoke (1, MyEnum.Value_1));
 429         }
 430
 431         void AddCheckedTest ()
 432         {
 433                 checked {
 434                 Expression<Func<int, int, int>> e = (int a, int b) => a + b;
 435                 AssertNodeType (e, ExpressionType.AddChecked);
 436                 Assert (50, e.Compile ().Invoke (20, 30));
 437                 }
 438         }
 439
 440         void AddCheckedTest_2 ()
 441         {
 442                 checked {
 443                 Expression<Func<int?, int?, int?>> e2 = (a, b) => a + b;
 444                 AssertNodeType (e2, ExpressionType.AddChecked);
 445                 Assert (null, e2.Compile ().Invoke (null, 3));
 446                 }
 447         }
 448
 449         void AddCheckedTest_3 ()
 450         {
 451                 checked {
 452                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a + b;
 453                 AssertNodeType (e3, ExpressionType.Add);
 454                 Assert (10, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
 455                 }
 456         }
 457
 458         void AddStringTest ()
 459         {
 460                 Expression<Func<string, string>> e6 = (a) => 1 + a;
 461                 AssertNodeType (e6, ExpressionType.Add);
 462                 Assert ("1to", e6.Compile ().Invoke ("to"));
 463         }
 464
 465         void AddStringTest_2 ()
 466         {
 467                 Expression<Func<object, string, string>> e7 = (object a, string b) => a + b;
 468                 AssertNodeType (e7, ExpressionType.Add);
 469                 Assert ("testme", e7.Compile ().Invoke ("test", "me"));
 470                 Assert ("test", e7.Compile ().Invoke ("test", null));
 471                 Assert ("", e7.Compile ().Invoke (null, null));
 472         }
 473
 474         void AddStringTest_3 ()
 475         {
 476                 Expression<Func<string, int, string>> e8 = (a, b) => a + " " + "-" + "> " + b;
 477                 AssertNodeType (e8, ExpressionType.Add);
 478                 Assert ("test -> 2", e8.Compile ().Invoke ("test", 2));
 479         }
 480
 481         void AddStringTest_4 ()
 482         {
 483                 Expression<Func<string, ushort?, string>> e9 = (a, b) => a + b;
 484                 AssertNodeType (e9, ExpressionType.Add);
 485                 Assert ("test2", e9.Compile ().Invoke ("test", 2));
 486                 Assert ("test", e9.Compile ().Invoke ("test", null));
 487         }
 488
 489         void AndTest ()
 490         {
 491                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a & b;
 492
 493                 AssertNodeType (e, ExpressionType.And);
 494                 Func<bool, bool, bool> c = e.Compile ();
 495
 496                 Assert (true, c (true, true));
 497                 Assert (false, c (true, false));
 498                 Assert (false, c (false, true));
 499                 Assert (false, c (false, false));
 500         }
 501
 502         void AndTest_2 ()
 503         {
 504                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a & b;
 505
 506                 AssertNodeType (e2, ExpressionType.And);
 507                 var c2 = e2.Compile ();
 508
 509                 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
 510                 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
 511         }
 512
 513         void AndTest_3 ()
 514         {
 515                 Expression<Func<MyEnum, MyEnum, MyEnum>> e3 = (a, b) => a & b;
 516                 AssertNodeType (e3, ExpressionType.Convert);
 517                 Assert<MyEnum> (0, e3.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
 518                 Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
 519         }
 520
 521         void AndTest_4 ()
 522         {
 523                 Expression<Func<int, int>> e = (a) => a & 0;
 524                 AssertNodeType (e, ExpressionType.And);
 525                 var c = e.Compile ();
 526
 527                 Assert (0, c (1));
 528         }
 529
 530         void AndNullableTest ()
 531         {
 532                 Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a & b;
 533
 534                 AssertNodeType (e, ExpressionType.And);
 535                 Func<bool?, bool?, bool?> c = e.Compile ();
 536
 537                 Assert (true, c (true, true));
 538                 Assert (false, c (true, false));
 539                 Assert (false, c (false, true));
 540                 Assert (false, c (false, false));
 541
 542                 Assert (null, c (true, null));
 543                 Assert (false, c (false, null));
 544                 Assert (false, c (null, false));
 545                 Assert (null, c (true, null));
 546                 Assert (null, c (null, null));
 547         }
 548
 549         void AndNullableTest_2 ()
 550         {
 551                 Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a & b;
 552
 553                 AssertNodeType (e2, ExpressionType.And);
 554                 var c2 = e2.Compile ();
 555
 556                 Assert (new MyType (0), c2 (new MyType (0), new MyType (1)));
 557                 Assert (new MyType (1), c2 (new MyType (0xFF), new MyType (0x01)));
 558                 Assert (null, c2 (new MyType (0xFF), null));
 559         }
 560
 561         void AndNullableTest_3 ()
 562         {
 563                 Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e3 = (a, b) => a & b;
 564                 AssertNodeType (e3, ExpressionType.Convert);
 565                 Assert (null, e3.Compile ().Invoke (null, MyEnum.Value_2));
 566                 Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
 567         }
 568
 569         void AndAlsoTest ()
 570         {
 571                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a && b;
 572                 AssertNodeType (e, ExpressionType.AndAlso);
 573                 Assert (false, e.Compile ().Invoke (true, false));
 574         }
 575
 576         void AndAlsoTest_2 ()
 577         {
 578                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a && b;
 579                 AssertNodeType (e2, ExpressionType.AndAlso);
 580                 Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
 581                 Assert (new MyType (0), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
 582         }
 583
 584         void AndAlsoTest_3 ()
 585         {
 586                 Expression<Func<bool, bool>> e3 = (bool a) => a && true;
 587                 AssertNodeType (e3, ExpressionType.AndAlso);
 588                 Assert (false, e3.Compile ().Invoke (false));
 589                 Assert (true, e3.Compile ().Invoke (true));
 590         }
 591
 592         void ArrayIndexTest ()
 593         {
 594                 Expression<Func<string [], long, string>> e = (string [] a, long i) => a [i];
 595                 AssertNodeType (e, ExpressionType.ArrayIndex);
 596                 Assert ("b", e.Compile ().Invoke (new string [] { "a", "b", "c" }, 1));
 597         }
 598
 599         void ArrayIndexTest_2 ()
 600         {
 601                 Expression<Func<string [], string>> e2 = (string [] a) => a [0];
 602                 AssertNodeType (e2, ExpressionType.ArrayIndex);
 603                 Assert ("a", e2.Compile ().Invoke (new string [] { "a", "b" }));
 604         }
 605
 606         void ArrayIndexTest_3 ()
 607         {
 608                 Expression<Func<object [,], int, int, object>> e3 = (object [,] a, int i, int j) => a [i, j];
 609                 AssertNodeType (e3, ExpressionType.Call);
 610
 611                 Assert ("z", e3.Compile ().Invoke (
 612                         new object [,] { { 1, 2 }, { "x", "z" } }, 1, 1));
 613         }
 614
 615         void ArrayIndexTest_4 ()
 616         {
 617                 Expression<Func<decimal [] [], byte, decimal>> e4 = (decimal [] [] a, byte b) => a [b] [1];
 618                 AssertNodeType (e4, ExpressionType.ArrayIndex);
 619
 620                 decimal [] [] array = { new decimal [] { 1, 9 }, new decimal [] { 10, 90 } };
 621                 Assert (90, e4.Compile ().Invoke (array, 1));
 622         }
 623
 624         void ArrayIndexTest_5 ()
 625         {
 626                 Expression<Func<int>> e5 = () => (new int [1]) [0];
 627                 AssertNodeType (e5, ExpressionType.ArrayIndex);
 628                 Assert (0, e5.Compile ().Invoke ());
 629         }
 630
 631         void ArrayIndexTest_6 ()
 632         {
 633                 const ulong max = 3;
 634
 635                 Expression<Func<int[], int>> e = a => a [max];
 636                 AssertNodeType (e, ExpressionType.ArrayIndex);
 637                 Assert (4, e.Compile ().Invoke (new int [] { 1, 2, 3, 4, 5 }));
 638         }
 639
 640         void ArrayIndexTest_7 ()
 641         {
 642                 const ulong max = uint.MaxValue;
 643
 644                 Expression<Func<int[], int>> e = a => a [max];
 645                 AssertNodeType (e, ExpressionType.ArrayIndex);
 646
 647                 try {
 648                         e.Compile ().Invoke (new int [0]);
 649                         throw new ApplicationException ("ArrayIndexTest_7");
 650                 } catch (System.OverflowException) {
 651                         // Check whether CheckedConversion was generated
 652                 }
 653         }
 654
 655         void ArrayLengthTest ()
 656         {
 657                 Expression<Func<double [], int>> e = (double [] a) => a.Length;
 658                 AssertNodeType (e, ExpressionType.ArrayLength);
 659                 Assert (0, e.Compile ().Invoke (new double [0]));
 660                 Assert (9, e.Compile ().Invoke (new double [9]));
 661         }
 662
 663         void ArrayLengthTest_2 ()
 664         {
 665                 Expression<Func<string [,], int>> e2 = (string [,] a) => a.Length;
 666                 AssertNodeType (e2, ExpressionType.MemberAccess);
 667                 Assert (0, e2.Compile ().Invoke (new string [0, 0]));
 668         }
 669
 670         void CallTest ()
 671         {
 672                 Expression<Func<int, int>> e = (int a) => Math.Max (a, 5);
 673                 AssertNodeType (e, ExpressionType.Call);
 674                 Assert (5, e.Compile ().Invoke (2));
 675                 Assert (9, e.Compile ().Invoke (9));
 676         }
 677
 678         void CallTest_2 ()
 679         {
 680                 Expression<Func<string, string>> e2 = (string a) => InstanceMethod (a);
 681                 AssertNodeType (e2, ExpressionType.Call);
 682                 Assert ("abc", e2.Compile ().Invoke ("abc"));
 683         }
 684
 685         void CallTest_3 ()
 686         {
 687                 Expression<Func<int, string, int, object>> e3 = (int index, string a, int b) => InstanceParamsMethod (index, a, b);
 688                 AssertNodeType (e3, ExpressionType.Call);
 689                 Assert<object> (4, e3.Compile ().Invoke (1, "a", 4));
 690         }
 691
 692         void CallTest_4 ()
 693         {
 694                 Expression<Func<object>> e4 = () => InstanceParamsMethod (0);
 695                 AssertNodeType (e4, ExpressionType.Call);
 696                 Assert<object> ("<empty>", e4.Compile ().Invoke ());
 697         }
 698
 699         void CallTest_5 ()
 700         {
 701                 Expression<Func<int, int>> e5 = (int a) => GenericMethod (a);
 702                 AssertNodeType (e5, ExpressionType.Call);
 703                 Assert (5, e5.Compile ().Invoke (5));
 704         }
 705
 706         void CallTest_6 ()
 707         {
 708                 Expression<Action> e6 = () => Console.WriteLine ("call test");
 709                 AssertNodeType (e6, ExpressionType.Call);
 710         }
 711
 712         void CallTest_7 ()
 713         {
 714                 Expression<Func<Indexer, int, int>> e7 = (a, b) => a [b];
 715                 AssertNodeType (e7, ExpressionType.Call);
 716                 Assert (3, e7.Compile ().Invoke (new Indexer (), 3));
 717         }
 718
 719         void CallTest_8 ()
 720         {
 721                 Expression<Func<Indexer, string, string, string, string>> e8 = (a, b, c , d) => a [b, c, d];
 722                 AssertNodeType (e8, ExpressionType.Call);
 723                 Assert ("zyb", e8.Compile ().Invoke (new Indexer (), "z", "y", "b"));
 724         }
 725
 726         void CallTest_9 ()
 727         {
 728                 Expression<Action<int>> e9 = (a) => RefMethod (ref a);
 729                 AssertNodeType (e9, ExpressionType.Call);
 730                 e9.Compile ().Invoke (1);
 731         }
 732
 733         void CallTest_10 ()
 734         {
 735                 Expression<Func<string>> e = () => $"{int.MaxValue}";
 736                 AssertNodeType (e, ExpressionType.Call);
 737                 Assert (int.MaxValue.ToString (), e.Compile ().Invoke ());
 738         }
 739
 740         void CoalesceTest ()
 741         {
 742                 Expression<Func<uint?, uint>> e = (uint? a) => a ?? 99;
 743                 AssertNodeType (e, ExpressionType.Coalesce);
 744                 var r = e.Compile ();
 745                 Assert ((uint) 5, r.Invoke (5));
 746                 Assert ((uint) 99, r.Invoke (null));
 747         }
 748
 749         void CoalesceTest_2 ()
 750         {
 751                 Expression<Func<MyType?, int>> e2 = (MyType? a) => a ?? -3;
 752                 AssertNodeType (e2, ExpressionType.Coalesce);
 753                 var r2 = e2.Compile ();
 754                 Assert (2, r2.Invoke (new MyType (2)));
 755                 Assert (-3, r2.Invoke (null));
 756         }
 757
 758         void ConditionTest ()
 759         {
 760                 Expression<Func<bool, byte, int, int>> e = (bool a, byte b, int c) => (a ? b : c);
 761                 AssertNodeType (e, ExpressionType.Conditional);
 762                 var r = e.Compile ();
 763                 Assert (3, r.Invoke (true, 3, 999999));
 764                 Assert (999999, r.Invoke (false, 3, 999999));
 765         }
 766
 767         void ConditionTest_2 ()
 768         {
 769                 Expression<Func<int, decimal, decimal?>> e2 = (int a, decimal d) => (a > 0 ? d : a < 0 ? -d : (decimal?) null);
 770                 AssertNodeType (e2, ExpressionType.Conditional);
 771                 var r2 = e2.Compile ();
 772                 Assert (null, r2.Invoke (0, 10));
 773                 Assert (50, r2.Invoke (1, 50));
 774                 Assert (30, r2.Invoke (-7, -30));
 775         }
 776
 777         void ConditionTest_3 ()
 778         {
 779                 Expression<Func<bool?, int?>> e3 = (bool? a) => ((bool) a ? 3 : -2);
 780                 AssertNodeType (e3, ExpressionType.Convert);
 781                 var r3 = e3.Compile ();
 782                 Assert (3, r3.Invoke (true));
 783                 Assert (-2, r3.Invoke (false));
 784         }
 785
 786         void ConditionTest_4 ()
 787         {
 788                 Expression<Func<InverseLogicalOperator, byte, byte, byte>> e4 = (InverseLogicalOperator a, byte b, byte c) => (a ? b : c);
 789                 AssertNodeType (e4, ExpressionType.Conditional);
 790                 var r4 = e4.Compile ();
 791                 Assert (3, r4.Invoke (new InverseLogicalOperator (true), 3, 4));
 792                 Assert (4, r4.Invoke (new InverseLogicalOperator (false), 3, 4));
 793         }
 794
 795         void ConditionTest_5 ()
 796         {
 797                 // CSC bug ?
 798                 Expression<Func<int>> e = () => false ? 1 : 4;
 799                 AssertNodeType (e, ExpressionType.Conditional);
 800                 var r = e.Compile ();
 801                 Assert (4, r.Invoke ());
 802         }
 803
 804         void ConstantTest ()
 805         {
 806                 Expression<Func<int>> e1 = () => default (int);
 807                 AssertNodeType (e1, ExpressionType.Constant);
 808                 Assert (0, e1.Compile ().Invoke ());
 809         }
 810
 811         void ConstantTest_2 ()
 812         {
 813                 Expression<Func<int?>> e2 = () => default (int?);
 814                 AssertNodeType (e2, ExpressionType.Constant);
 815                 Assert (null, e2.Compile ().Invoke ());
 816         }
 817
 818         void ConstantTest_3 ()
 819         {
 820                 Expression<Func<Tester>> e3 = () => default (Tester);
 821                 AssertNodeType (e3, ExpressionType.Constant);
 822                 Assert (null, e3.Compile ().Invoke ());
 823         }
 824
 825         void ConstantTest_4 ()
 826         {
 827                 Expression<Func<object>> e4 = () => null;
 828                 AssertNodeType (e4, ExpressionType.Constant);
 829                 Assert (null, e4.Compile ().Invoke ());
 830         }
 831
 832         void ConstantTest_5 ()
 833         {
 834                 Expression<Func<int>> e5 = () => 8 / 4;
 835                 AssertNodeType (e5, ExpressionType.Constant);
 836                 Assert (2, e5.Compile ().Invoke ());
 837         }
 838
 839         void ConstantTest_6 ()
 840         {
 841                 Expression<Func<int>> e6 = () => 0xFFFFFF >> 0x40;
 842                 AssertNodeType (e6, ExpressionType.Constant);
 843                 Assert (0xFFFFFF, e6.Compile ().Invoke ());
 844         }
 845
 846         void ConstantTest_7 ()
 847         {
 848                 Expression<Func<object>> e7 = () => "Alleluia";
 849                 AssertNodeType (e7, ExpressionType.Constant);
 850                 Assert ("Alleluia", e7.Compile ().Invoke ());
 851         }
 852
 853         void ConstantTest_8 ()
 854         {
 855                 Expression<Func<Type>> e8 = () => typeof (int);
 856                 AssertNodeType (e8, ExpressionType.Constant);
 857                 Assert (typeof (int), e8.Compile ().Invoke ());
 858         }
 859
 860         void ConstantTest_9 ()
 861         {
 862                 Expression<Func<Type>> e9 = () => typeof (void);
 863                 AssertNodeType (e9, ExpressionType.Constant);
 864                 Assert (typeof (void), e9.Compile ().Invoke ());
 865         }
 866
 867         void ConstantTest_10 ()
 868         {
 869                 Expression<Func<Type>> e10 = () => typeof (Func<,>);
 870                 AssertNodeType (e10, ExpressionType.Constant);
 871                 Assert (typeof (Func<,>), e10.Compile ().Invoke ());
 872         }
 873
 874         void ConstantTest_11 ()
 875         {
 876                 Expression<Func<MyEnum>> e11 = () => MyEnum.Value_2;
 877                 AssertNodeType (e11, ExpressionType.Constant);
 878                 Assert (MyEnum.Value_2, e11.Compile ().Invoke ());
 879         }
 880
 881         void ConstantTest_13 ()
 882         {
 883                 Expression<Func<int>> e13 = () => sizeof (byte);
 884                 AssertNodeType (e13, ExpressionType.Constant);
 885                 Assert (1, e13.Compile ().Invoke ());
 886
 887         }
 888
 889         void ConstantTest_14 ()
 890         {
 891                 Expression<Func<Type>> e14 = () => typeof (bool*);
 892                 AssertNodeType (e14, ExpressionType.Constant);
 893                 Assert (typeof (bool*), e14.Compile ().Invoke ());
 894         }
 895
 896         void ConstantTest_15 ()
 897         {
 898                 Expression<Func<int?>> e15 = () => null;
 899                 AssertNodeType (e15, ExpressionType.Constant);
 900                 Assert (null, e15.Compile ().Invoke ());
 901         }
 902
 903         void ConvertTest ()
 904         {
 905                 Expression<Func<int, byte>> e = (int a) => ((byte) a);
 906                 AssertNodeType (e, ExpressionType.Convert);
 907                 Assert (100, e.Compile ().Invoke (100));
 908         }
 909
 910         void ConvertTest_2 ()
 911         {
 912                 Expression<Func<long, ushort>> e2 = (long a) => ((ushort) a);
 913                 AssertNodeType (e2, ExpressionType.Convert);
 914                 Assert (100, e2.Compile ().Invoke (100));
 915         }
 916
 917         void ConvertTest_3 ()
 918         {
 919                 Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
 920                 AssertNodeType (e3, ExpressionType.Convert);
 921                 Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
 922         }
 923
 924         void ConvertTest_4 ()
 925         {
 926                 Expression<Func<MyType, int>> e4 = (MyType a) => (a);
 927                 AssertNodeType (e4, ExpressionType.Convert);
 928                 Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
 929         }
 930
 931         void ConvertTest_5 ()
 932         {
 933                 Expression<Func<MyType, MyType, bool?>> e5 = (MyType a, MyType b) => a == b;
 934                 AssertNodeType (e5, ExpressionType.Convert);
 935         }
 936
 937         void ConvertTest_6 ()
 938         {
 939                 Expression<Func<MyType?, MyType?, bool?>> e6 = (MyType? a, MyType? b) => a == b;
 940                 AssertNodeType (e6, ExpressionType.Convert);
 941                 Assert (false, e6.Compile ().Invoke (null, new MyType (-20)));
 942                 Assert (true, e6.Compile ().Invoke (null, null));
 943                 Assert (true, e6.Compile ().Invoke (new MyType (120), new MyType (120)));
 944         }
 945
 946         void ConvertTest_7 ()
 947         {
 948                 Expression<Func<MyTypeExplicit, int?>> e7 = x => (int?)x;
 949                 AssertNodeType (e7, ExpressionType.Convert);
 950                 Assert (33, e7.Compile ().Invoke (new MyTypeExplicit (33)));
 951         }
 952
 953         void ConvertTest_8 ()
 954         {
 955                 Expression<Func<int?, object>> e8 = x => (object)x;
 956                 AssertNodeType (e8, ExpressionType.Convert);
 957                 Assert (null, e8.Compile ().Invoke (null));
 958                 Assert (-100, e8.Compile ().Invoke (-100));
 959         }
 960
 961         unsafe void ConvertTest_9 ()
 962         {
 963                 int*[] p = new int* [1];
 964                 Expression<Func<object>> e9 = () => (object)p;
 965                 AssertNodeType (e9, ExpressionType.Convert);
 966                 Assert (p, e9.Compile ().Invoke ());
 967         }
 968
 969         void ConvertTest_10 ()
 970         {
 971                 Expression<Func<Func<int>, Delegate>> e10 = (a) => a + a;
 972                 AssertNodeType (e10, ExpressionType.Convert);
 973                 Assert (null, e10.Compile ().Invoke (null));
 974                 Assert (new Func<int> (TestInt) + new Func<int> (TestInt), e10.Compile ().Invoke (TestInt));
 975         }
 976
 977         void ConvertTest_11 ()
 978         {
 979                 Expression<Func<Func<int>, Delegate>> e11 = (a) => a - a;
 980                 AssertNodeType (e11, ExpressionType.Convert);
 981                 Assert (null, e11.Compile ().Invoke (null));
 982         }
 983
 984         void ConvertTest_12 ()
 985         {
 986                 Expression<Func<Func<int>>> e12 = () => TestInt;
 987                 AssertNodeType (e12, ExpressionType.Convert);
 988                 Assert (29, e12.Compile ().Invoke () ());
 989         }
 990
 991         void ConvertTest_13 ()
 992         {
 993                 Expression<Func<decimal, sbyte>> e13 = a => (sbyte)a;
 994                 AssertNodeType (e13, ExpressionType.Convert);
 995                 Assert (6, e13.Compile ().Invoke (6));
 996         }
 997
 998         void ConvertTest_14 ()
 999         {
1000                 Expression<Func<long, decimal>> e14 = a => a;
1001                 AssertNodeType (e14, ExpressionType.Convert);
1002                 Assert (-66, e14.Compile ().Invoke (-66));
1003         }
1004
1005         void ConvertTest_15 ()
1006         {
1007                 Expression<Func<ulong?, decimal?>> e15 = a => a;
1008                 AssertNodeType (e15, ExpressionType.Convert);
1009                 Assert (null, e15.Compile ().Invoke (null));
1010                 Assert (9, e15.Compile ().Invoke (9));
1011         }
1012
1013         void ConvertTest_16 ()
1014         {
1015                 Expression<Func<sbyte, sbyte>> e16 = a => (sbyte)a;
1016                 AssertNodeType (e16, ExpressionType.Convert);
1017                 Assert (6, e16.Compile ().Invoke (6));
1018         }
1019
1020         void ConvertCheckedTest ()
1021         {
1022                 Expression<Func<int, byte>> e = (int a) => checked((byte) a);
1023                 AssertNodeType (e, ExpressionType.ConvertChecked);
1024                 Assert (100, e.Compile ().Invoke (100));
1025         }
1026
1027         void ConvertCheckedTest_2 ()
1028         {
1029                 checked {
1030                         Expression<Func<long, ushort>> e2 = (long a) => unchecked((ushort) a);
1031                         AssertNodeType (e2, ExpressionType.Convert);
1032                         Assert (100, e2.Compile ().Invoke (100));
1033                 }
1034         }
1035
1036         void ConvertCheckedTest_3 ()
1037         {
1038                 checked {
1039                         Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
1040                         AssertNodeType (e3, ExpressionType.ConvertChecked);
1041                         Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
1042                 }
1043         }
1044
1045         void ConvertCheckedTest_4 ()
1046         {
1047                 checked {
1048                         Expression<Func<MyType, int>> e4 = (MyType a) => (a);
1049                         AssertNodeType (e4, ExpressionType.Convert);
1050                         Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
1051                 }
1052         }
1053
1054         void DivideTest ()
1055         {
1056                 Expression<Func<int, int, int>> e = (int a, int b) => a / b;
1057                 AssertNodeType (e, ExpressionType.Divide);
1058                 Assert (2, e.Compile ().Invoke (60, 30));
1059         }
1060
1061         void DivideTest_2 ()
1062         {
1063                 Expression<Func<double?, double?, double?>> e2 = (a, b) => a / b;
1064                 AssertNodeType (e2, ExpressionType.Divide);
1065                 Assert (null, e2.Compile ().Invoke (null, 3));
1066                 Assert (1.5, e2.Compile ().Invoke (3, 2));
1067         }
1068
1069         void DivideTest_3 ()
1070         {
1071                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a / b;
1072                 AssertNodeType (e3, ExpressionType.Divide);
1073                 Assert (1, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1074         }
1075
1076         void DivideTest_4 ()
1077         {
1078                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a / b;
1079                 AssertNodeType (e4, ExpressionType.Divide);
1080                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1081                 Assert (new MyType (-6), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1082         }
1083
1084         void DivideTest_5 ()
1085         {
1086                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a / b;
1087                 AssertNodeType (e5, ExpressionType.Divide);
1088                 Assert (50, e5.Compile ().Invoke (100, new MyType (2)));
1089         }
1090
1091         void DivideTest_6 ()
1092         {
1093                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a / b;
1094                 AssertNodeType (e6, ExpressionType.Divide);
1095                 Assert (50, e6.Compile ().Invoke (100, new MyType (2)));
1096                 Assert (null, e6.Compile ().Invoke (20, null));
1097         }
1098
1099         void DivideTest_7 ()
1100         {
1101                 Expression<Func<float, uint?, float?>> e = (a, b) => a / b;
1102                 AssertNodeType (e, ExpressionType.Divide);
1103                 Assert (50, e.Compile () (100, 2));
1104                 Assert (null, e.Compile () (20, null));
1105         }
1106
1107         void EqualTest ()
1108         {
1109                 Expression<Func<int, int, bool>> e = (int a, int b) => a == b;
1110                 AssertNodeType (e, ExpressionType.Equal);
1111                 Assert (false, e.Compile ().Invoke (60, 30));
1112                 Assert (true, e.Compile ().Invoke (-1, -1));
1113         }
1114
1115         void EqualTest_2 ()
1116         {
1117                 Expression<Func<double?, double?, bool>> e2 = (a, b) => a == b;
1118                 AssertNodeType (e2, ExpressionType.Equal);
1119                 Assert (true, e2.Compile ().Invoke (3, 3));
1120                 Assert (false, e2.Compile ().Invoke (3, 2));
1121         }
1122
1123         void EqualTest_3 ()
1124         {
1125                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a == b;
1126                 AssertNodeType (e3, ExpressionType.Equal);
1127                 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1128         }
1129
1130         void EqualTest_4 ()
1131         {
1132                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a == b;
1133                 AssertNodeType (e4, ExpressionType.Equal);
1134                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1135                 Assert (true, e4.Compile ().Invoke (null, null));
1136                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
1137         }
1138
1139         void EqualTest_5 ()
1140         {
1141                 Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a == b;
1142                 AssertNodeType (e5, ExpressionType.Equal);
1143                 Assert (false, e5.Compile ().Invoke (true, null));
1144                 Assert (true, e5.Compile ().Invoke (null, null));
1145                 Assert (true, e5.Compile ().Invoke (false, false));
1146         }
1147
1148         void EqualTest_6 ()
1149         {
1150                 Expression<Func<bool, bool>> e6 = (bool a) => a == null;
1151                 AssertNodeType (e6, ExpressionType.Equal);
1152                 Assert (false, e6.Compile ().Invoke (true));
1153                 Assert (false, e6.Compile ().Invoke (false));
1154         }
1155
1156         void EqualTest_7 ()
1157         {
1158                 Expression<Func<string, string, bool>> e7 = (string a, string b) => a == b;
1159                 AssertNodeType (e7, ExpressionType.Equal);
1160                 Assert (true, e7.Compile ().Invoke (null, null));
1161                 Assert (false, e7.Compile ().Invoke ("a", "A"));
1162                 Assert (true, e7.Compile ().Invoke ("a", "a"));
1163         }
1164
1165         void EqualTest_8 ()
1166         {
1167                 Expression<Func<object, bool>> e8 = (object a) => null == a;
1168                 AssertNodeType (e8, ExpressionType.Equal);
1169                 Assert (true, e8.Compile ().Invoke (null));
1170                 Assert (false, e8.Compile ().Invoke ("a"));
1171                 Assert (false, e8.Compile ().Invoke (this));
1172         }
1173
1174         void EqualTest_9 ()
1175         {
1176                 Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a == b;
1177                 AssertNodeType (e9, ExpressionType.Equal);
1178                 Assert (false, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
1179                 Assert (true, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1180         }
1181
1182         void EqualTest_10 ()
1183         {
1184                 Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a == b;
1185                 AssertNodeType (e10, ExpressionType.Equal);
1186                 Assert (false, e10.Compile ().Invoke (MyEnum.Value_1, null));
1187                 Assert (true, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1188         }
1189
1190         void EqualTest_11 ()
1191         {
1192                 Expression<Func<MyEnum?, bool>> e11 = (a) => a == null;
1193                 AssertNodeType (e11, ExpressionType.Equal);
1194                 Assert (false, e11.Compile ().Invoke (MyEnum.Value_1));
1195                 Assert (true, e11.Compile ().Invoke (null));
1196         }
1197
1198         void EqualTest_12 ()
1199         {
1200                 Expression<Func<MyEnumUlong, bool>> e12 = (a) => a == 0;
1201                 AssertNodeType (e12, ExpressionType.Equal);
1202                 Assert (false, e12.Compile ().Invoke (MyEnumUlong.Value_1));
1203                 Assert (true, e12.Compile ().Invoke (0));
1204         }
1205
1206         void EqualTest_13 ()
1207         {
1208                 Expression<Func<MyEnum, bool>> e13 = (a) => a == MyEnum.Value_2;
1209                 AssertNodeType (e13, ExpressionType.Equal);
1210                 Assert (true, e13.Compile ().Invoke (MyEnum.Value_2));
1211                 Assert (false, e13.Compile ().Invoke (0));
1212         }
1213
1214         void EqualTest_14 ()
1215         {
1216                 Expression<Func<MyEnum, bool>> e = (a) => a == null;
1217                 AssertNodeType (e, ExpressionType.Equal);
1218                 Assert (false, e.Compile ().Invoke (MyEnum.Value_1));
1219         }
1220
1221         void EqualTest_15 ()
1222         {
1223                 Expression<Func<int?, uint, bool>> e = (a, b) => a == b;
1224                 AssertNodeType (e, ExpressionType.Equal);
1225                 Assert (false, e.Compile ().Invoke (null, 0));
1226                 Assert (true, e.Compile ().Invoke (4, 4));
1227         }
1228
1229         void EqualTest_16 ()
1230         {
1231                 Expression<Func<EnumInt?, EnumInt, bool?>> e = (x, y) => x == y;
1232                 AssertNodeType (e, ExpressionType.Convert);
1233                 Assert (false, e.Compile () (null, 0));
1234                 Assert (true, e.Compile () (EnumInt.B, EnumInt.B));
1235         }
1236
1237         void EqualTestDelegate ()
1238         {
1239                 Expression<Func<Delegate, Delegate, bool>> e1 = (a, b) => a == b;
1240                 AssertNodeType (e1, ExpressionType.Equal);
1241                 Assert (true, e1.Compile ().Invoke (null, null));
1242         }
1243
1244         void EqualTestDelegate_2 ()
1245         {
1246                 EmptyDelegate ed = delegate () {};
1247
1248                 Expression<Func<EmptyDelegate, EmptyDelegate, bool>> e2 = (a, b) => a == b;
1249                 AssertNodeType (e2, ExpressionType.Equal);
1250                 Assert (false, e2.Compile ().Invoke (delegate () {}, null));
1251                 Assert (false, e2.Compile ().Invoke (delegate () {}, delegate {}));
1252                 Assert (false, e2.Compile ().Invoke (ed, delegate {}));
1253                 Assert (true, e2.Compile ().Invoke (ed, ed));
1254         }
1255
1256         void EqualTestDelegate_3 ()
1257         {
1258                 Expression<Func<Func<int>, bool>> e1 = (a) => a == ReturnNumber;
1259                 AssertNodeType (e1, ExpressionType.Equal);
1260                 Assert (false, e1.Compile ().Invoke (null));
1261                 Assert (true, e1.Compile ().Invoke (ReturnNumber));
1262         }
1263
1264         void ExclusiveOrTest ()
1265         {
1266                 Expression<Func<int, short, int>> e = (int a, short b) => a ^ b;
1267                 AssertNodeType (e, ExpressionType.ExclusiveOr);
1268                 Assert (34, e.Compile ().Invoke (60, 30));
1269         }
1270
1271         void ExclusiveOrTest_2 ()
1272         {
1273                 Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a ^ b;
1274                 AssertNodeType (e2, ExpressionType.ExclusiveOr);
1275                 Assert (null, e2.Compile ().Invoke (null, 3));
1276                 Assert (1, e2.Compile ().Invoke (3, 2));
1277         }
1278
1279         void ExclusiveOrTest_3 ()
1280         {
1281                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a ^ b;
1282                 AssertNodeType (e3, ExpressionType.ExclusiveOr);
1283                 Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1284         }
1285
1286         void ExclusiveOrTest_4 ()
1287         {
1288                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a ^ b;
1289                 AssertNodeType (e4, ExpressionType.ExclusiveOr);
1290                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1291                 Assert (new MyType (-108), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1292         }
1293
1294         void ExclusiveOrTest_5 ()
1295         {
1296                 Expression<Func<MyType?, byte, int?>> e5 = (MyType? a, byte b) => a ^ b;
1297                 AssertNodeType (e5, ExpressionType.ExclusiveOr);
1298                 Assert (null, e5.Compile ().Invoke (null, 64));
1299                 Assert (96, e5.Compile ().Invoke (new MyType (64), 32));
1300         }
1301
1302         void ExclusiveOrTest_6 ()
1303         {
1304                 Expression<Func<MyEnum, MyEnum, MyEnum>> e6 = (a, b) => a ^ b;
1305                 AssertNodeType (e6, ExpressionType.Convert);
1306                 Assert ((MyEnum)3, e6.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
1307                 Assert<MyEnum> (0, e6.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1308         }
1309
1310         void ExclusiveOrTest_7 ()
1311         {
1312                 Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e7 = (a, b) => a ^ b;
1313                 AssertNodeType (e7, ExpressionType.Convert);
1314                 Assert (null, e7.Compile ().Invoke (MyEnum.Value_1, null));
1315                 Assert<MyEnum?> (0, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1316         }
1317
1318         void ExclusiveOrTest_8 ()
1319         {
1320                 Expression<Func<MyEnum?, MyEnum?>> e8 = (a) => a ^ null;
1321                 AssertNodeType (e8, ExpressionType.Convert);
1322                 Assert (null, e8.Compile ().Invoke (MyEnum.Value_1));
1323                 Assert (null, e8.Compile ().Invoke (null));
1324         }
1325
1326         void GreaterThanTest ()
1327         {
1328                 Expression<Func<int, int, bool>> e = (int a, int b) => a > b;
1329                 AssertNodeType (e, ExpressionType.GreaterThan);
1330                 Assert (true, e.Compile ().Invoke (60, 30));
1331         }
1332
1333         void GreaterThanTest_2 ()
1334         {
1335                 Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a > b;
1336                 AssertNodeType (e2, ExpressionType.GreaterThan);
1337                 Assert (false, e2.Compile ().Invoke (null, 3));
1338                 Assert (false, e2.Compile ().Invoke (2, 2));
1339         }
1340
1341         void GreaterThanTest_3 ()
1342         {
1343                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a > b;
1344                 AssertNodeType (e3, ExpressionType.GreaterThan);
1345                 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1346         }
1347
1348         void GreaterThanTest_4 ()
1349         {
1350                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a > b;
1351                 AssertNodeType (e4, ExpressionType.GreaterThan);
1352                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1353                 Assert (false, e4.Compile ().Invoke (null, null));
1354                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1355         }
1356
1357         void GreaterThanTest_5 ()
1358         {
1359                 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a > b;
1360                 AssertNodeType (e5, ExpressionType.GreaterThan);
1361                 Assert (false, e5.Compile ().Invoke (null, 33));
1362                 Assert (false, e5.Compile ().Invoke (null, 0));
1363                 Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
1364         }
1365
1366         void GreaterThanTest_6 ()
1367         {
1368                 Expression<Func<ushort, bool>> e6 = (ushort a) => a > null;
1369                 AssertNodeType (e6, ExpressionType.GreaterThan);
1370                 Assert (false, e6.Compile ().Invoke (60));
1371         }
1372
1373         void GreaterThanTest_7 ()
1374         {
1375                 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a > b;
1376                 AssertNodeType (e7, ExpressionType.GreaterThan);
1377                 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1378                 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1379         }
1380
1381         void GreaterThanTest_8 ()
1382         {
1383                 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a > b;
1384                 AssertNodeType (e8, ExpressionType.GreaterThan);
1385                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1386                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1387         }
1388
1389         void GreaterThanOrEqualTest ()
1390         {
1391                 Expression<Func<int, int, bool>> e = (int a, int b) => a >= b;
1392                 AssertNodeType (e, ExpressionType.GreaterThanOrEqual);
1393                 Assert (true, e.Compile ().Invoke (60, 30));
1394         }
1395
1396         void GreaterThanOrEqualTest_2 ()
1397         {
1398                 Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a >= b;
1399                 AssertNodeType (e2, ExpressionType.GreaterThanOrEqual);
1400                 Assert (false, e2.Compile ().Invoke (null, 3));
1401                 Assert (true, e2.Compile ().Invoke (2, 2));
1402         }
1403
1404         void GreaterThanOrEqualTest_3 ()
1405         {
1406                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a >= b;
1407                 AssertNodeType (e3, ExpressionType.GreaterThanOrEqual);
1408                 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
1409         }
1410
1411         void GreaterThanOrEqualTest_4 ()
1412         {
1413                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a >= b;
1414                 AssertNodeType (e4, ExpressionType.GreaterThanOrEqual);
1415                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1416                 Assert (false, e4.Compile ().Invoke (null, null));
1417                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1418         }
1419
1420         void GreaterThanOrEqualTest_5 ()
1421         {
1422                 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a >= b;
1423                 AssertNodeType (e5, ExpressionType.GreaterThanOrEqual);
1424                 Assert (false, e5.Compile ().Invoke (null, 33));
1425                 Assert (false, e5.Compile ().Invoke (null, 0));
1426                 Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
1427         }
1428
1429         void GreaterThanOrEqualTest_6 ()
1430         {
1431                 Expression<Func<ushort, bool>> e6 = (ushort a) => a >= null;
1432                 AssertNodeType (e6, ExpressionType.GreaterThanOrEqual);
1433                 Assert (false, e6.Compile ().Invoke (60));
1434         }
1435
1436         void GreaterThanOrEqualTest_7 ()
1437         {
1438                 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a >= b;
1439                 AssertNodeType (e7, ExpressionType.GreaterThanOrEqual);
1440                 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1441                 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1442         }
1443
1444         void GreaterThanOrEqualTest_8 ()
1445         {
1446                 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a >= b;
1447                 AssertNodeType (e8, ExpressionType.GreaterThanOrEqual);
1448                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1449                 Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1450         }
1451
1452         void InvokeTest ()
1453         {
1454                 var del = new IntDelegate (TestInt);
1455                 Expression<Func<IntDelegate, int>> e = (a) => a ();
1456                 AssertNodeType (e, ExpressionType.Invoke);
1457                 Assert (29, e.Compile ().Invoke (del));
1458         }
1459
1460         void InvokeTest_2 ()
1461         {
1462                 Expression<Func<Func<int, string>, int, string>> e2 = (a, b) => a (b);
1463                 AssertNodeType (e2, ExpressionType.Invoke);
1464                 Assert ("4", e2.Compile ().Invoke ((a) => (a+1).ToString (), 3));
1465         }
1466
1467         void LambdaTest ()
1468         {
1469                 Expression<Func<string, Func<string>>> e = (string s) => () => s;
1470                 AssertNodeType (e, ExpressionType.Lambda);
1471                 Assert ("xx", e.Compile ().Invoke ("xx") ());
1472         }
1473
1474         void LeftShiftTest ()
1475         {
1476                 Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a << b;
1477                 AssertNodeType (e, ExpressionType.LeftShift);
1478                 Assert ((ulong) 0x7F000, e.Compile ().Invoke (0xFE, 11));
1479                 Assert ((ulong) 0x1FFFFFFFE, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1480
1481                 // .net produces a strange result
1482                 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
1483                 // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1484         }
1485
1486         void LeftShiftTest_2 ()
1487         {
1488                 Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a << b;
1489                 AssertNodeType (e2, ExpressionType.LeftShift);
1490                 var c2 = e2.Compile ();
1491                 Assert (1024, c2 (new MyType (256), new MyType (2)));
1492         }
1493
1494         void LeftShiftTest_3 ()
1495         {
1496                 Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a << b;
1497                 AssertNodeType (e3, ExpressionType.LeftShift);
1498                 Assert (null, e3.Compile ().Invoke (null, 11));
1499                 Assert (2048, e3.Compile ().Invoke (1024, 1));
1500         }
1501
1502         void LeftShiftTest_4 ()
1503         {
1504                 Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a << b;
1505                 AssertNodeType (e4, ExpressionType.LeftShift);
1506                 var c4 = e4.Compile ();
1507                 Assert (null, c4 (new MyType (8), null));
1508                 Assert (null, c4 (null, new MyType (8)));
1509                 Assert (1024, c4 (new MyType (256), new MyType (2)));
1510         }
1511
1512         void LeftShiftTest_5 ()
1513         {
1514                 Expression<Func<ushort, int?>> e5 = (ushort a) => a << null;
1515                 AssertNodeType (e5, ExpressionType.LeftShift);
1516                 Assert (null, e5.Compile ().Invoke (30));
1517         }
1518
1519         void LeftShiftTest_6 ()
1520         {
1521                 Expression<Func<int, MyTypeImplicitOnly, int>> e = (a, b) => a << b;
1522                 AssertNodeType (e, ExpressionType.LeftShift);
1523                 Assert (0x7F0, e.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
1524         }
1525
1526         void LessThanTest ()
1527         {
1528                 Expression<Func<int, int, bool>> e = (int a, int b) => a < b;
1529                 AssertNodeType (e, ExpressionType.LessThan);
1530                 Assert (false, e.Compile ().Invoke (60, 30));
1531         }
1532
1533         void LessThanTest_2 ()
1534         {
1535                 Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a < b;
1536                 AssertNodeType (e2, ExpressionType.LessThan);
1537                 Assert (false, e2.Compile ().Invoke (null, 3));
1538                 Assert (false, e2.Compile ().Invoke (2, 2));
1539         }
1540
1541         void LessThanTest_3 ()
1542         {
1543                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a < b;
1544                 AssertNodeType (e3, ExpressionType.LessThan);
1545                 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1546         }
1547
1548         void LessThanTest_4 ()
1549         {
1550                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a < b;
1551                 AssertNodeType (e4, ExpressionType.LessThan);
1552                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1553                 Assert (false, e4.Compile ().Invoke (null, null));
1554                 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1555         }
1556
1557         void LessThanTest_5 ()
1558         {
1559                 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a < b;
1560                 AssertNodeType (e5, ExpressionType.LessThan);
1561                 Assert (false, e5.Compile ().Invoke (null, 33));
1562                 Assert (false, e5.Compile ().Invoke (null, 0));
1563                 Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
1564         }
1565
1566         void LessThanTest_6 ()
1567         {
1568                 Expression<Func<ushort, bool>> e6 = (ushort a) => a < null;
1569                 AssertNodeType (e6, ExpressionType.LessThan);
1570                 Assert (false, e6.Compile ().Invoke (60));
1571         }
1572
1573         void LessThanTest_7 ()
1574         {
1575                 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a < b;
1576                 AssertNodeType (e7, ExpressionType.LessThan);
1577                 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1578                 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1579         }
1580
1581         void LessThanTest_8 ()
1582         {
1583                 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a < b;
1584                 AssertNodeType (e8, ExpressionType.LessThan);
1585                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1586                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1587         }
1588
1589         void LessThanTest_9 ()
1590         {
1591                 Expression<Func<object, int?, bool>> e = (a, b) => (int) a < b;
1592                 AssertNodeType (e, ExpressionType.LessThan);
1593                 Assert (false, e.Compile ().Invoke (1, null));
1594                 Assert (false, e.Compile ().Invoke (3, 3));
1595                 Assert (true, e.Compile ().Invoke (1, 3));
1596         }
1597
1598         void LessThanOrEqualTest ()
1599         {
1600                 Expression<Func<int, int, bool>> e = (int a, int b) => a <= b;
1601                 AssertNodeType (e, ExpressionType.LessThanOrEqual);
1602                 Assert (false, e.Compile ().Invoke (60, 30));
1603         }
1604
1605         void LessThanOrEqualTest_2 ()
1606         {
1607                 Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a <= b;
1608                 AssertNodeType (e2, ExpressionType.LessThanOrEqual);
1609                 Assert (false, e2.Compile ().Invoke (null, 3));
1610                 Assert (true, e2.Compile ().Invoke (2, 2));
1611         }
1612
1613         void LessThanOrEqualTest_3 ()
1614         {
1615                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a <= b;
1616                 AssertNodeType (e3, ExpressionType.LessThanOrEqual);
1617                 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1618         }
1619
1620         void LessThanOrEqualTest_4 ()
1621         {
1622                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a <= b;
1623                 AssertNodeType (e4, ExpressionType.LessThanOrEqual);
1624                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1625                 Assert (false, e4.Compile ().Invoke (null, null));
1626                 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1627         }
1628
1629         void LessThanOrEqualTest_5 ()
1630         {
1631                 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a <= b;
1632                 AssertNodeType (e5, ExpressionType.LessThanOrEqual);
1633                 Assert (false, e5.Compile ().Invoke (null, 33));
1634                 Assert (false, e5.Compile ().Invoke (null, 0));
1635                 Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
1636         }
1637
1638         void LessThanOrEqualTest_6 ()
1639         {
1640                 Expression<Func<ushort, bool>> e6 = (ushort a) => a <= null;
1641                 AssertNodeType (e6, ExpressionType.LessThanOrEqual);
1642                 Assert (false, e6.Compile ().Invoke (60));
1643         }
1644
1645         void LessThanOrEqualTest_7 ()
1646         {
1647                 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a <= b;
1648                 AssertNodeType (e7, ExpressionType.LessThanOrEqual);
1649                 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1650                 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1651         }
1652
1653         void LessThanOrEqualTest_8 ()
1654         {
1655                 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a <= b;
1656                 AssertNodeType (e8, ExpressionType.LessThanOrEqual);
1657                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1658                 Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1659         }
1660
1661         void ListInitTest ()
1662         {
1663                 Expression<Func<List<object>>> e1 = () => new List<object> { "Hello", "", null, "World", 5 };
1664                 AssertNodeType (e1, ExpressionType.ListInit);
1665                 var re1 = e1.Compile ().Invoke ();
1666                 Assert (null, re1 [2]);
1667                 Assert ("World", re1 [3]);
1668                 Assert (5, re1 [4]);
1669         }
1670
1671         void ListInitTest_2 ()
1672         {
1673                 Expression<Func<int, Dictionary<string, int>>> e2 = (int value) => new Dictionary<string, int> (3) { { "A", value }, { "B", 2 } };
1674                 AssertNodeType (e2, ExpressionType.ListInit);
1675                 var re2 = e2.Compile ().Invoke (3456);
1676                 Assert (3456, re2 ["A"]);
1677         }
1678
1679         void MemberAccessTest ()
1680         {
1681                 MemberAccessData d = new MemberAccessData ();
1682                 d.BoolValue = true;
1683                 Expression<Func<bool>> e = () => d.BoolValue;
1684                 AssertNodeType (e, ExpressionType.MemberAccess);
1685                 Assert (true, e.Compile ().Invoke ());
1686                 d.BoolValue = false;
1687                 Assert (false, e.Compile ().Invoke ());
1688         }
1689
1690         void MemberAccessTest_2 ()
1691         {
1692                 Expression<Func<decimal>> e2 = () => MemberAccessData.DecimalValue;
1693                 AssertNodeType (e2, ExpressionType.MemberAccess);
1694                 Assert (decimal.MinValue, e2.Compile ().Invoke ());
1695         }
1696
1697         void MemberAccessTest_3 ()
1698         {
1699                 MemberAccessData d = new MemberAccessData ();
1700                 d.VolatileValue = 492;
1701                 Expression<Func<uint>> e3 = () => d.VolatileValue;
1702                 AssertNodeType (e3, ExpressionType.MemberAccess);
1703                 Assert<uint> (492, e3.Compile ().Invoke ());
1704         }
1705
1706         void MemberAccessTest_4 ()
1707         {
1708                 MemberAccessData d = new MemberAccessData ();
1709                 Expression<Func<string[]>> e4 = () => d.StringValues;
1710                 AssertNodeType (e4, ExpressionType.MemberAccess);
1711                 Assert (null, e4.Compile ().Invoke ());
1712         }
1713
1714         void MemberAccessTest_5 ()
1715         {
1716                 MemberAccessData d = new MemberAccessData ();
1717                 var e5 = d.GetEvent ();
1718                 AssertNodeType (e5, ExpressionType.MemberAccess);
1719                 Assert (null, e5.Compile ().Invoke ());
1720         }
1721
1722         void MemberAccessTest_6 ()
1723         {
1724                 MemberAccessData d = new MemberAccessData ();
1725                 Expression<Func<MyType>> e6 = () => d.MyTypeProperty;
1726                 AssertNodeType (e6, ExpressionType.MemberAccess);
1727                 Assert (new MyType (), e6.Compile ().Invoke ());
1728         }
1729
1730         void MemberAccessTest_7 ()
1731         {
1732                 MemberAccessData d = new MemberAccessData ();
1733                 Expression<Func<MyType, short>> e7 = a => a.ShortProp;
1734                 AssertNodeType (e7, ExpressionType.MemberAccess);
1735                 MyType mt = new MyType ();
1736                 mt.ShortProp = 124;
1737                 Assert (124, e7.Compile ().Invoke (mt));
1738         }
1739
1740         void MemberAccessTest_8 ()
1741         {
1742                 Expression<Func<string>> e8 = () => MemberAccessData.StaticProperty;
1743                 AssertNodeType (e8, ExpressionType.MemberAccess);
1744                 Assert ("alo", e8.Compile ().Invoke ());
1745         }
1746
1747         void MemberAccessTest_9 ()
1748         {
1749                 string s = "localvar";
1750                 Expression<Func<string>> e9 = () => s;
1751                 s = "changed";
1752
1753                 AssertNodeType (e9, ExpressionType.MemberAccess);
1754                 Assert ("changed", e9.Compile ().Invoke ());
1755         }
1756
1757         void MemberInitTest ()
1758         {
1759                 Expression<Func<MemberAccessData>> e = () => new MemberAccessData {
1760                         VolatileValue = 2, StringValues = new string [] { "sv" }, MyTypeProperty = new MyType (692)
1761                 };
1762                 AssertNodeType (e, ExpressionType.MemberInit);
1763                 var r1 = e.Compile ().Invoke ();
1764                 Assert<uint> (2, r1.VolatileValue);
1765                 Assert (new string[] { "sv" }, r1.StringValues);
1766                 Assert (new MyType (692), r1.MyTypeProperty);
1767         }
1768
1769         void MemberInitTest_2 ()
1770         {
1771                 Expression<Func<MemberAccessData>> e2 = () => new MemberAccessData {
1772                         ListValues = new List<string> { "a", null }
1773                 };
1774
1775                 AssertNodeType (e2, ExpressionType.MemberInit);
1776                 var r2 = e2.Compile ().Invoke ();
1777                 Assert ("a", r2.ListValues [0]);
1778         }
1779
1780         void MemberInitTest_3 ()
1781         {
1782                 Expression<Func<short, MyType>> e3 = a => new MyType { ShortProp = a };
1783                 AssertNodeType (e3, ExpressionType.MemberInit);
1784                 var r3 = e3.Compile ().Invoke (33);
1785                 Assert (33, r3.ShortProp);
1786         }
1787
1788         void MemberInitTest_4 ()
1789         {
1790                 Expression<Func<int>> e = () => new int { };
1791
1792                 AssertNodeType (e, ExpressionType.MemberInit);
1793                 var r = e.Compile ().Invoke ();
1794                 Assert (0, r);
1795         }
1796
1797         void MemberInitTest_5 ()
1798         {
1799                 Expression<Func<MemberAccessData>> e = () => new MemberAccessData { SetOnly = new object { } };
1800
1801                 AssertNodeType (e, ExpressionType.MemberInit);
1802                 e.Compile () ();
1803         }
1804
1805         void ModuloTest ()
1806         {
1807                 Expression<Func<int, int, int>> e = (int a, int b) => a % b;
1808                 AssertNodeType (e, ExpressionType.Modulo);
1809                 Assert (29, e.Compile ().Invoke (60, 31));
1810         }
1811
1812         void ModuloTest_2 ()
1813         {
1814                 Expression<Func<double?, double?, double?>> e2 = (a, b) => a % b;
1815                 AssertNodeType (e2, ExpressionType.Modulo);
1816                 Assert (null, e2.Compile ().Invoke (null, 3));
1817                 Assert (1.1, e2.Compile ().Invoke (3.1, 2));
1818         }
1819
1820         void ModuloTest_3 ()
1821         {
1822                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a % b;
1823                 AssertNodeType (e3, ExpressionType.Modulo);
1824                 Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1825         }
1826
1827         void ModuloTest_4 ()
1828         {
1829                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a % b;
1830                 AssertNodeType (e4, ExpressionType.Modulo);
1831                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1832                 Assert (new MyType (12), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
1833         }
1834
1835         void ModuloTest_5 ()
1836         {
1837                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a % b;
1838                 AssertNodeType (e5, ExpressionType.Modulo);
1839                 Assert (1, e5.Compile ().Invoke (99, new MyType (2)));
1840         }
1841
1842         void ModuloTest_6 ()
1843         {
1844                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a % b;
1845                 AssertNodeType (e6, ExpressionType.Modulo);
1846                 Assert (100, e6.Compile ().Invoke (100, new MyType (200)));
1847                 Assert (null, e6.Compile ().Invoke (20, null));
1848         }
1849
1850         void ModuloTest_7 ()
1851         {
1852                 Expression<Func<ushort, int?>> e7 = (ushort a) => a % null;
1853                 AssertNodeType (e7, ExpressionType.Modulo);
1854                 Assert (null, e7.Compile ().Invoke (60));
1855         }
1856
1857         void MultiplyTest ()
1858         {
1859                 Expression<Func<int, int, int>> e = (int a, int b) => a * b;
1860                 AssertNodeType (e, ExpressionType.Multiply);
1861                 Assert (1860, e.Compile ().Invoke (60, 31));
1862                 Assert (2147483617, e.Compile ().Invoke (int.MaxValue, 31));
1863         }
1864
1865         void MultiplyTest_2 ()
1866         {
1867                 Expression<Func<double?, double?, double?>> e2 = (a, b) => a * b;
1868                 AssertNodeType (e2, ExpressionType.Multiply);
1869                 Assert (null, e2.Compile ().Invoke (null, 3));
1870                 Assert (6.2, e2.Compile ().Invoke (3.1, 2));
1871         }
1872
1873         void MultiplyTest_3 ()
1874         {
1875                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
1876                 AssertNodeType (e3, ExpressionType.Multiply);
1877                 Assert (400, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1878         }
1879
1880         void MultiplyTest_4 ()
1881         {
1882                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a * b;
1883                 AssertNodeType (e4, ExpressionType.Multiply);
1884                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1885                 Assert (new MyType (-240), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
1886         }
1887
1888         void MultiplyTest_5 ()
1889         {
1890                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a * b;
1891                 AssertNodeType (e5, ExpressionType.Multiply);
1892                 Assert (198, e5.Compile ().Invoke (99, new MyType (2)));
1893         }
1894
1895         void MultiplyTest_6 ()
1896         {
1897                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a * b;
1898                 AssertNodeType (e6, ExpressionType.Multiply);
1899                 Assert (0, e6.Compile ().Invoke (int.MinValue, new MyType (200)));
1900                 Assert (null, e6.Compile ().Invoke (20, null));
1901         }
1902
1903         void MultiplyTest_7 ()
1904         {
1905                 Expression<Func<ushort, int?>> e7 = (ushort a) => a * null;
1906                 AssertNodeType (e7, ExpressionType.Multiply);
1907                 Assert (null, e7.Compile ().Invoke (60));
1908         }
1909
1910         void MultiplyTest_8 ()
1911         {
1912                 Expression<Func<double, ulong?, double?>> e = (a, b) => a * b;
1913                 AssertNodeType (e, ExpressionType.Multiply);
1914                 Assert (180, e.Compile () (60, 3));
1915                 Assert (null, e.Compile () (60, null));
1916         }
1917
1918         void MultiplyCheckedTest ()
1919         {
1920                 checked {
1921                         Expression<Func<int, int, int>> e = (int a, int b) => a * b;
1922                         AssertNodeType (e, ExpressionType.MultiplyChecked);
1923                         try {
1924                                 e.Compile ().Invoke (int.MaxValue, 309);
1925                                 throw new ApplicationException ("MultiplyCheckedTest #1");
1926                         } catch (OverflowException) { }
1927                 }
1928         }
1929
1930         void MultiplyCheckedTest_2 ()
1931         {
1932                 checked {
1933                         Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a * b;
1934                         AssertNodeType (e2, ExpressionType.MultiplyChecked);
1935                         Assert (null, e2.Compile ().Invoke (null, 3));
1936                         Assert (14025, e2.Compile ().Invoke (byte.MaxValue, 55));
1937                 }
1938         }
1939
1940         void MultiplyCheckedTest_3 ()
1941         {
1942                 checked {
1943                         Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
1944                         AssertNodeType (e3, ExpressionType.Multiply);
1945                         Assert (-600, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
1946                 }
1947         }
1948
1949         void MultiplyCheckedTest_4 ()
1950         {
1951                 checked {
1952                         Expression<Func<double, double, double>> e4 = (a, b) => a * b;
1953                         AssertNodeType (e4, ExpressionType.Multiply);
1954                         Assert (double.PositiveInfinity, e4.Compile ().Invoke (double.MaxValue, int.MaxValue));
1955                 }
1956         }
1957
1958         void MultiplyCheckedTest_5 ()
1959         {
1960                 checked {
1961                         Expression<Func<float?, float?, float?>> e5 = (a, b) => b * a;
1962                         AssertNodeType (e5, ExpressionType.MultiplyChecked);
1963                         Assert (float.PositiveInfinity, e5.Compile ().Invoke (float.Epsilon, float.PositiveInfinity));
1964                 }
1965         }
1966
1967         void NegateTest ()
1968         {
1969                 Expression<Func<int, int>> e = (a) => -a;
1970                 AssertNodeType (e, ExpressionType.Negate);
1971                 Assert (30, e.Compile ().Invoke (-30));
1972         }
1973
1974         void NegateTest_2 ()
1975         {
1976                 Expression<Func<sbyte, int>> e2 = (a) => -(-a);
1977                 AssertNodeType (e2, ExpressionType.Negate);
1978                 Assert (-10, e2.Compile ().Invoke (-10));
1979         }
1980
1981         void NegateTest_3 ()
1982         {
1983                 Expression<Func<long?, long?>> e3 = (a) => -a;
1984                 AssertNodeType (e3, ExpressionType.Negate);
1985                 Assert (long.MinValue + 1, e3.Compile ().Invoke (long.MaxValue));
1986                 Assert (null, e3.Compile ().Invoke (null));
1987         }
1988
1989         void NegateTest_4 ()
1990         {
1991                 Expression<Func<MyType, MyType>> e4 = (a) => -a;
1992                 AssertNodeType (e4, ExpressionType.Negate);
1993                 Assert (new MyType (14), e4.Compile ().Invoke (new MyType (-14)));
1994         }
1995
1996         void NegateTest_5 ()
1997         {
1998                 Expression<Func<MyType?, MyType?>> e5 = (a) => -a;
1999                 AssertNodeType (e5, ExpressionType.Negate);
2000                 Assert (new MyType (-33), e5.Compile ().Invoke (new MyType (33)));
2001                 Assert (null, e5.Compile ().Invoke (null));
2002         }
2003
2004         void NegateTest_6 ()
2005         {
2006                 Expression<Func<MyTypeImplicitOnly, int>> e6 = (MyTypeImplicitOnly a) => -a;
2007                 AssertNodeType (e6, ExpressionType.Negate);
2008                 Assert (-4, e6.Compile ().Invoke (new MyTypeImplicitOnly (4)));
2009         }
2010
2011         void NegateTest_7 ()
2012         {
2013                 Expression<Func<MyTypeImplicitOnly?, int?>> e7 = (MyTypeImplicitOnly? a) => -a;
2014                 AssertNodeType (e7, ExpressionType.Negate);
2015                 Assert (-46, e7.Compile ().Invoke (new MyTypeImplicitOnly (46)));
2016
2017                 // Another version of MS bug when predefined conversion is required on nullable user operator
2018                 // Assert (null, e7.Compile ().Invoke (null));
2019         }
2020
2021         void NegateTest_8 ()
2022         {
2023                 Expression<Func<sbyte?, int?>> e8 = (a) => -a;
2024                 AssertNodeType (e8, ExpressionType.Negate);
2025                 Assert (11, e8.Compile ().Invoke (-11));
2026         }
2027
2028         void NegateTest_9 ()
2029         {
2030                 Expression<Func<uint, long>> e9 = (a) => -a;
2031                 AssertNodeType (e9, ExpressionType.Negate);
2032                 Assert (-2, e9.Compile ().Invoke (2));
2033         }
2034
2035         void NegateTestChecked ()
2036         {
2037                 checked {
2038                         Expression<Func<int, int>> e = (int a) => -a;
2039                         AssertNodeType (e, ExpressionType.NegateChecked);
2040                         try {
2041                                 e.Compile ().Invoke (int.MinValue);
2042                                 throw new ApplicationException ("NegateTestChecked #1");
2043                         } catch (OverflowException) { }
2044                 }
2045         }
2046
2047         void NegateTestChecked_2 ()
2048         {
2049                 checked {
2050                         Expression<Func<byte?, int?>> e2 = (a) => -a;
2051                         AssertNodeType (e2, ExpressionType.NegateChecked);
2052                         Assert (null, e2.Compile ().Invoke (null));
2053                         Assert (-255, e2.Compile ().Invoke (byte.MaxValue));
2054                 }
2055         }
2056
2057         void NegateTestChecked_3 ()
2058         {
2059                 checked {
2060                         Expression<Func<MyType, MyType>> e3 = (MyType a) => -a;
2061                         AssertNodeType (e3, ExpressionType.Negate);
2062                         Assert (20, e3.Compile ().Invoke (new MyType (-20)));
2063                 }
2064         }
2065
2066         void NegateTestChecked_4 ()
2067         {
2068                 checked {
2069                         Expression<Func<double, double>> e4 = (a) => -a;
2070                         AssertNodeType (e4, ExpressionType.Negate);
2071                         Assert (double.NegativeInfinity, e4.Compile ().Invoke (double.PositiveInfinity));
2072                 }
2073         }
2074
2075         void NewArrayInitTest ()
2076         {
2077                 Expression<Func<int []>> e = () => new int [1] { 5 };
2078                 AssertNodeType (e, ExpressionType.NewArrayInit);
2079                 Assert (new int [1] { 5 }, e.Compile ().Invoke ());
2080         }
2081
2082         void NewArrayInitTest_2 ()
2083         {
2084                 Expression<Func<int []>> e1 = () => new int [] { };
2085                 AssertNodeType (e1, ExpressionType.NewArrayInit);
2086                 Assert (new int [0], e1.Compile ().Invoke ());
2087         }
2088
2089         void NewArrayInitTest_3 ()
2090         {
2091                 Expression<Func<ushort, ulong? []>> e2 = (ushort a) => new ulong? [] { a };
2092                 AssertNodeType (e2, ExpressionType.NewArrayInit);
2093                 Assert (new ulong? [1] { ushort.MaxValue }, e2.Compile ().Invoke (ushort.MaxValue));
2094         }
2095
2096         void NewArrayInitTest_4 ()
2097         {
2098                 Expression<Func<char [] []>> e3 = () => new char [] [] { new char [] { 'a' } };
2099                 AssertNodeType (e3, ExpressionType.NewArrayInit);
2100                 Assert (new char [] { 'a' }, e3.Compile ().Invoke () [0]);
2101         }
2102
2103         void NewArrayInitTest_5 ()
2104         {
2105                 Expression<Func<int?[]>> e = () => new int?[] { null, 3, 4 };
2106                 AssertNodeType (e, ExpressionType.NewArrayInit);
2107                 Assert (3, e.Compile ().Invoke ().Length);
2108         }
2109
2110         void NewArrayInitTest_6 ()
2111         {
2112                 Expression<Func<string []>> e = () => new [] { null, "a" };
2113                 AssertNodeType (e, ExpressionType.NewArrayInit);
2114                 Assert (2, e.Compile ().Invoke ().Length);
2115         }
2116
2117         void NewArrayBoundsTest ()
2118         {
2119                 Expression<Func<int [,]>> e = () => new int [2,3];
2120                 AssertNodeType (e, ExpressionType.NewArrayBounds);
2121                 Assert (new int [2,3].Length, e.Compile ().Invoke ().Length);
2122         }
2123
2124         void NewArrayBoundsTest_2 ()
2125         {
2126                 Expression<Func<int[,]>> e2 = () => new int [0,0];
2127                 AssertNodeType (e2, ExpressionType.NewArrayBounds);
2128                 Assert (new int [0, 0].Length, e2.Compile ().Invoke ().Length);
2129         }
2130
2131         void NewArrayBoundsTest_3 ()
2132         {
2133                 Expression<Func<int []>> e = () => new int [0];
2134                 AssertNodeType (e, ExpressionType.NewArrayBounds);
2135                 Assert (0, e.Compile ().Invoke ().Length);
2136         }
2137
2138         void NewArrayBoundsTest_4 ()
2139         {
2140                 const ulong max = ulong.MaxValue;
2141
2142                 Expression<Func<bool[]>> e = () => new bool [max];
2143                 AssertNodeType (e, ExpressionType.NewArrayBounds);
2144         }
2145
2146         void NewTest ()
2147         {
2148                 Expression<Func<MyType>> e = () => new MyType (2);
2149                 AssertNodeType (e, ExpressionType.New);
2150                 Assert (new MyType (2), e.Compile ().Invoke ());
2151         }
2152
2153         void NewTest_2 ()
2154         {
2155                 Expression<Func<MyType>> e2 = () => new MyType ();
2156                 AssertNodeType (e2, ExpressionType.New);
2157                 Assert (new MyType (), e2.Compile ().Invoke ());
2158         }
2159
2160         void NewTest_3 ()
2161         {
2162                 Expression<Func<NewTest<bool>>> e3 = () => new NewTest<bool> (true);
2163                 AssertNodeType (e3, ExpressionType.New);
2164                 Assert (new NewTest<bool> (true), e3.Compile ().Invoke ());
2165         }
2166
2167         void NewTest_4 ()
2168         {
2169                 Expression<Func<decimal, NewTest<decimal>>> e4 = (decimal d) => new NewTest<decimal> (1, 5, d);
2170                 AssertNodeType (e4, ExpressionType.New);
2171                 Assert (new NewTest<decimal> (1, 5, -9), e4.Compile ().Invoke (-9));
2172         }
2173
2174         void NewTest_5 ()
2175         {
2176                 Expression<Func<object>> e5 = () => new { A = 9, Value = "a" };
2177                 AssertNodeType (e5, ExpressionType.New);
2178                 var ne = ((NewExpression) e5.Body);
2179
2180                 Assert (2, ne.Members.Count, "members count");
2181
2182                 // Behaviour is different between .NET 3.5 and .NET 4.0
2183                 if (ne.Members [0].MemberType == MemberTypes.Property) {
2184                         Assert ("A", ne.Members [0].Name, "Name #1");
2185                         Assert ("Value", ne.Members [1].Name, "Name #2");
2186                 } else {
2187                         Assert ("get_A", ne.Members [0].Name, "Name #1");
2188                         Assert ("get_Value", ne.Members [1].Name, "Name #2");
2189                 }
2190
2191                 Assert (new { A = 9, Value = "a" }, e5.Compile ().Invoke ());
2192         }
2193
2194         void NewTest_6 ()
2195         {
2196                 Expression<Func<object>> e5 = () => new { A = 9, Value = new MyType (5) };
2197                 AssertNodeType (e5, ExpressionType.New);
2198         }
2199
2200         // CSC bug: emits new MyEnum as a constant
2201         void NewTest_7 ()
2202         {
2203                 Expression<Func<MyEnum>> e = () => new MyEnum ();
2204                 AssertNodeType (e, ExpressionType.New);
2205                 Assert<MyEnum> (0, e.Compile ().Invoke ());
2206         }
2207
2208         void NewTest_8 ()
2209         {
2210                 Expression<Func<DateTime>> e = () => new DateTime ();
2211                 AssertNodeType (e, ExpressionType.New);
2212                 Assert (null, ((NewExpression)e.Body).Constructor, "default ctor");
2213
2214                 Expression<Func<StructWithUserConstructor>> e2 = () => new StructWithUserConstructor ();
2215                 AssertNodeType (e2, ExpressionType.New);
2216                 Assert ("Void .ctor()", ((NewExpression)e2.Body).Constructor.ToString (), "user ctor");
2217         }
2218
2219         void NotTest ()
2220         {
2221                 Expression<Func<bool, bool>> e = (bool a) => !a;
2222                 AssertNodeType (e, ExpressionType.Not);
2223                 Assert (false, e.Compile ().Invoke (true));
2224         }
2225
2226         void NotTest_2 ()
2227         {
2228                 Expression<Func<MyType, bool>> e2 = (MyType a) => !a;
2229                 AssertNodeType (e2, ExpressionType.Not);
2230                 Assert (true, e2.Compile ().Invoke (new MyType (1)));
2231                 Assert (false, e2.Compile ().Invoke (new MyType (-1)));
2232         }
2233
2234         void NotTest_3 ()
2235         {
2236                 Expression<Func<int, int>> e3 = (int a) => ~a;
2237                 AssertNodeType (e3, ExpressionType.Not);
2238                 Assert (-8, e3.Compile ().Invoke (7));
2239         }
2240
2241         void NotTest_4 ()
2242         {
2243                 Expression<Func<MyType, int>> e4 = (MyType a) => ~a;
2244                 AssertNodeType (e4, ExpressionType.Not);
2245                 Assert (0, e4.Compile ().Invoke (new MyType (-1)));
2246         }
2247
2248         void NotTest_5 ()
2249         {
2250                 Expression<Func<ulong, ulong>> e5 = (ulong a) => ~a;
2251                 AssertNodeType (e5, ExpressionType.Not);
2252                 Assert<ulong> (18446744073709551608, e5.Compile ().Invoke (7));
2253         }
2254
2255         void NotTest_6 ()
2256         {
2257                 Expression<Func<MyEnum, MyEnum>> e6 = (MyEnum a) => ~a;
2258                 AssertNodeType (e6, ExpressionType.Convert);
2259                 Assert ((MyEnum)254, e6.Compile ().Invoke (MyEnum.Value_1));
2260         }
2261
2262         void NotNullableTest ()
2263         {
2264                 Expression<Func<bool?, bool?>> e = (bool? a) => !a;
2265                 AssertNodeType (e, ExpressionType.Not);
2266                 Assert (false, e.Compile ().Invoke (true));
2267                 Assert (null, e.Compile ().Invoke (null));
2268         }
2269
2270         void NotNullableTest_2 ()
2271         {
2272                 Expression<Func<MyType?, bool?>> e2 = (MyType? a) => !a;
2273                 AssertNodeType (e2, ExpressionType.Not);
2274                 Assert (true, e2.Compile ().Invoke (new MyType (1)));
2275                 Assert (null, e2.Compile ().Invoke (null));
2276         }
2277
2278         void NotNullableTest_3 ()
2279         {
2280                 Expression<Func<sbyte?, int?>> e3 = (sbyte? a) => ~a;
2281                 AssertNodeType (e3, ExpressionType.Not);
2282                 Assert (-5, e3.Compile ().Invoke (4));
2283                 Assert (null, e3.Compile ().Invoke (null));
2284         }
2285
2286         void NotNullableTest_4 ()
2287         {
2288                 Expression<Func<MyType?, int?>> e4 = (MyType? a) => ~a;
2289                 AssertNodeType (e4, ExpressionType.Not);
2290                 Assert (0, e4.Compile ().Invoke (new MyType (-1)));
2291                 Assert (null, e4.Compile ().Invoke (null));
2292         }
2293
2294         void NotNullableTest_5 ()
2295         {
2296                 Expression<Func<MyEnum?, MyEnum?>> e5 = (MyEnum? a) => ~a;
2297                 AssertNodeType (e5, ExpressionType.Convert);
2298                 Assert ((MyEnum) 254, e5.Compile ().Invoke (MyEnum.Value_1));
2299                 Assert (null, e5.Compile ().Invoke (null));
2300         }
2301
2302         void NotEqualTest ()
2303         {
2304                 Expression<Func<int, int, bool>> e = (int a, int b) => a != b;
2305                 AssertNodeType (e, ExpressionType.NotEqual);
2306                 Assert (true, e.Compile ().Invoke (60, 30));
2307                 Assert (false, e.Compile ().Invoke (-1, -1));
2308         }
2309
2310         void NotEqualTest_2 ()
2311         {
2312                 Expression<Func<sbyte?, sbyte?, bool>> e2 = (a, b) => a != b;
2313                 AssertNodeType (e2, ExpressionType.NotEqual);
2314                 Assert (false, e2.Compile ().Invoke (3, 3));
2315                 Assert (true, e2.Compile ().Invoke (3, 2));
2316         }
2317
2318         void NotEqualTest_3 ()
2319         {
2320                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a != b;
2321                 AssertNodeType (e3, ExpressionType.NotEqual);
2322                 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
2323         }
2324
2325         void NotEqualTest_4 ()
2326         {
2327                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a != b;
2328                 AssertNodeType (e4, ExpressionType.NotEqual);
2329                 Assert (true, e4.Compile ().Invoke (null, new MyType (-20)));
2330                 Assert (false, e4.Compile ().Invoke (null, null));
2331                 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
2332         }
2333
2334         void NotEqualTest_5 ()
2335         {
2336                 Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a != b;
2337                 AssertNodeType (e5, ExpressionType.NotEqual);
2338                 Assert (true, e5.Compile ().Invoke (true, null));
2339                 Assert (false, e5.Compile ().Invoke (null, null));
2340                 Assert (false, e5.Compile ().Invoke (false, false));
2341         }
2342
2343         void NotEqualTest_6 ()
2344         {
2345                 Expression<Func<bool, bool>> e6 = (bool a) => a != null;
2346                 AssertNodeType (e6, ExpressionType.NotEqual);
2347                 Assert (true, e6.Compile ().Invoke (true));
2348                 Assert (true, e6.Compile ().Invoke (false));
2349         }
2350
2351         void NotEqualTest_7 ()
2352         {
2353                 Expression<Func<string, string, bool>> e7 = (string a, string b) => a != b;
2354                 AssertNodeType (e7, ExpressionType.NotEqual);
2355                 Assert (false, e7.Compile ().Invoke (null, null));
2356                 Assert (true, e7.Compile ().Invoke ("a", "A"));
2357                 Assert (false, e7.Compile ().Invoke ("a", "a"));
2358         }
2359
2360         void NotEqualTest_8 ()
2361         {
2362                 Expression<Func<object, bool>> e8 = (object a) => null != a;
2363                 AssertNodeType (e8, ExpressionType.NotEqual);
2364                 Assert (false, e8.Compile ().Invoke (null));
2365                 Assert (true, e8.Compile ().Invoke ("a"));
2366                 Assert (true, e8.Compile ().Invoke (this));
2367         }
2368
2369         void NotEqualTest_9 ()
2370         {
2371                 Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a != b;
2372                 AssertNodeType (e9, ExpressionType.NotEqual);
2373                 Assert (true, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2374                 Assert (false, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2375         }
2376
2377         void NotEqualTest_10 ()
2378         {
2379                 Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a != b;
2380                 AssertNodeType (e10, ExpressionType.NotEqual);
2381                 Assert (true, e10.Compile ().Invoke (MyEnum.Value_1, null));
2382                 Assert (false, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2383         }
2384
2385         void NotEqualTest_11 ()
2386         {
2387                 Expression<Func<MyEnum?, bool>> e11 = (a) => a != null;
2388                 AssertNodeType (e11, ExpressionType.NotEqual);
2389                 Assert (true, e11.Compile ().Invoke (MyEnum.Value_1));
2390                 Assert (false, e11.Compile ().Invoke (null));
2391         }
2392
2393         void OrTest ()
2394         {
2395                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a | b;
2396
2397                 AssertNodeType (e, ExpressionType.Or);
2398                 Func<bool, bool, bool> c = e.Compile ();
2399
2400                 Assert (true, c (true, true));
2401                 Assert (true, c (true, false));
2402                 Assert (true, c (false, true));
2403                 Assert (false, c (false, false));
2404         }
2405
2406         void OrTest_2 ()
2407         {
2408                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a | b;
2409                 AssertNodeType (e2, ExpressionType.Or);
2410                 var c2 = e2.Compile ();
2411                 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2412         }
2413
2414         void OrTest_3 ()
2415         {
2416                 Expression<Func<MyEnum, MyEnum, MyEnum>> e3 = (a, b) => a | b;
2417                 AssertNodeType (e3, ExpressionType.Convert);
2418                 Assert ((MyEnum)3, e3.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2419                 Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2420         }
2421
2422         void OrNullableTest ()
2423         {
2424                 Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a | b;
2425
2426                 AssertNodeType (e, ExpressionType.Or);
2427                 Func<bool?, bool?, bool?> c = e.Compile ();
2428
2429                 Assert (true, c (true, true));
2430                 Assert (true, c (true, false));
2431                 Assert (true, c (false, true));
2432                 Assert (false, c (false, false));
2433
2434                 Assert (true, c (true, null));
2435                 Assert (null, c (false, null));
2436                 Assert (null, c (null, false));
2437                 Assert (true, c (true, null));
2438                 Assert (null, c (null, null));
2439         }
2440
2441         void OrNullableTest_2 ()
2442         {
2443                 Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a | b;
2444                 AssertNodeType (e2, ExpressionType.Or);
2445                 var c2 = e2.Compile ();
2446                 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2447                 Assert (null, c2 (new MyType (1), null));
2448         }
2449
2450         void OrNullableTest_3 ()
2451         {
2452                 Expression<Func<MyType?, uint, long?>> e3 = (MyType? a, uint b) => a | b;
2453                 AssertNodeType (e3, ExpressionType.Or);
2454                 var c3 = e3.Compile ();
2455                 Assert (9, c3 (new MyType (1), 8));
2456         }
2457
2458         void OrNullableTest_4 ()
2459         {
2460                 Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e4 = (a, b) => a | b;
2461                 AssertNodeType (e4, ExpressionType.Convert);
2462                 Assert (null, e4.Compile ().Invoke (null, MyEnum.Value_2));
2463                 Assert ((MyEnum)3, e4.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2464         }
2465
2466         void OrElseTest ()
2467         {
2468                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a || b;
2469                 AssertNodeType (e, ExpressionType.OrElse);
2470                 Assert (true, e.Compile ().Invoke (true, false));
2471         }
2472
2473         void OrElseTest_2 ()
2474         {
2475                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a || b;
2476                 AssertNodeType (e2, ExpressionType.OrElse);
2477                 Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
2478                 Assert (new MyType (32), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
2479         }
2480
2481         void ParameterTest ()
2482         {
2483                 Expression<Func<string, string>> e = (string a) => a;
2484                 AssertNodeType (e, ExpressionType.Parameter);
2485                 Assert ("t", e.Compile ().Invoke ("t"));
2486         }
2487
2488         void ParameterTest_2 ()
2489         {
2490                 Expression<Func<object[], object[]>> e2 = (object[] a) => a;
2491                 AssertNodeType (e2, ExpressionType.Parameter);
2492                 Assert (new object [0], e2.Compile ().Invoke (new object [0]));
2493         }
2494
2495         void ParameterTest_3 ()
2496         {
2497                 Expression<Func<IntPtr, IntPtr>> e3 = a => a;
2498                 AssertNodeType (e3, ExpressionType.Parameter);
2499                 Assert (IntPtr.Zero, e3.Compile ().Invoke (IntPtr.Zero));
2500         }
2501
2502         unsafe void ParameterTest_4 ()
2503         {
2504                 Expression<Func<int*[], int* []>> e4 = (a) => a;
2505                 AssertNodeType (e4, ExpressionType.Parameter);
2506                 Assert<int*[]> (null, e4.Compile ().Invoke (null));
2507                 int* e4_el = stackalloc int [5];
2508                 int*[] ptr = new int*[] { e4_el };
2509                 Assert<int*[]> (ptr, e4.Compile ().Invoke (ptr));
2510         }
2511
2512         void QuoteTest ()
2513         {
2514                 Expression<Func<Expression<Func<int>>>> e = () => () => 2;
2515                 AssertNodeType (e, ExpressionType.Quote);
2516                 Assert (2, e.Compile ().Invoke ().Compile ().Invoke ());
2517         }
2518
2519         void QuoteTest_2 ()
2520         {
2521                 Expression<Func<string, Expression<Func<string>>>> e = (string s) => () => s;
2522                 AssertNodeType (e, ExpressionType.Quote);
2523
2524                 Assert ("data", e.Compile ().Invoke ("data").Compile ().Invoke ());
2525         }
2526
2527         void RightShiftTest ()
2528         {
2529                 Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a >> b;
2530                 AssertNodeType (e, ExpressionType.RightShift);
2531                 Assert ((ulong) 0x1FD940L, e.Compile ().Invoke (0xFECA0000, 11));
2532                 Assert ((ulong) 0x7FFFFFFF, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2533
2534                 // .net produces a strange result
2535                 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
2536                 // Assert ((ulong)0, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2537         }
2538
2539         void RightShiftTest_2 ()
2540         {
2541                 Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a >> b;
2542                 AssertNodeType (e2, ExpressionType.RightShift);
2543                 var c2 = e2.Compile ();
2544                 Assert (64, c2 (new MyType (256), new MyType (2)));
2545         }
2546
2547         void RightShiftTest_3 ()
2548         {
2549                 Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a >> b;
2550                 AssertNodeType (e3, ExpressionType.RightShift);
2551                 Assert (null, e3.Compile ().Invoke (null, 11));
2552                 Assert (512, e3.Compile ().Invoke (1024, 1));
2553         }
2554
2555         void RightShiftTest_4 ()
2556         {
2557                 Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a >> b;
2558                 AssertNodeType (e4, ExpressionType.RightShift);
2559                 var c4 = e4.Compile ();
2560                 Assert (null, c4 (new MyType (8), null));
2561                 Assert (null, c4 (null, new MyType (8)));
2562                 Assert (64, c4 (new MyType (256), new MyType (2)));
2563         }
2564
2565         void RightShiftTest_5 ()
2566         {
2567                 Expression<Func<int, MyTypeImplicitOnly, int>> e = (a, b) => a >> b;
2568                 AssertNodeType (e, ExpressionType.RightShift);
2569                 Assert (31, e.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
2570         }
2571
2572         void RightShiftTest_6 ()
2573         {
2574                 Expression<Func<ulong, byte?, ulong?>> e = (a, b) => a >> b;
2575                 AssertNodeType (e, ExpressionType.RightShift);
2576                 Assert (null, e.Compile () (2, null));
2577         }
2578
2579         void SubtractTest ()
2580         {
2581                 Expression<Func<int, int, int>> e = (int a, int b) => a - b;
2582                 AssertNodeType (e, ExpressionType.Subtract);
2583                 Assert (-10, e.Compile ().Invoke (20, 30));
2584         }
2585
2586         void SubtractTest_2 ()
2587         {
2588                 Expression<Func<int?, int?, int?>> e2 = (a, b) => a - b;
2589                 AssertNodeType (e2, ExpressionType.Subtract);
2590                 Assert (null, e2.Compile ().Invoke (null, 3));
2591         }
2592
2593         void SubtractTest_3 ()
2594         {
2595                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a - b;
2596                 AssertNodeType (e3, ExpressionType.Subtract);
2597                 Assert (-50, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
2598         }
2599
2600         void SubtractTest_4 ()
2601         {
2602                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a - b;
2603                 AssertNodeType (e4, ExpressionType.Subtract);
2604                 Assert (new MyType (-50), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
2605                 Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
2606         }
2607
2608         void SubtractTest_5 ()
2609         {
2610                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a - b;
2611                 AssertNodeType (e5, ExpressionType.Subtract);
2612                 Assert (-29, e5.Compile ().Invoke (1, new MyType (30)));
2613         }
2614
2615         void SubtractTest_6 ()
2616         {
2617                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a - b;
2618                 AssertNodeType (e6, ExpressionType.Subtract);
2619                 Assert (-61, e6.Compile ().Invoke (-31, new MyType (30)));
2620         }
2621
2622         void SubtractTest_7 ()
2623         {
2624                 Expression<Func<ushort, int?>> e7 = (ushort a) => null - a;
2625                 AssertNodeType (e7, ExpressionType.Subtract);
2626                 Assert (null, e7.Compile ().Invoke (690));
2627         }
2628
2629         void SubtractTest_8 ()
2630         {
2631                 Expression<Func<MyEnum, byte, MyEnum>> e8 = (a, b) => a - b;
2632                 AssertNodeType (e8, ExpressionType.Convert);
2633                 Assert ((MyEnum)255, e8.Compile ().Invoke (MyEnum.Value_1, 2));
2634         }
2635
2636         void SubtractTest_9 ()
2637         {
2638                 Expression<Func<MyEnum, MyEnum, byte>> e9 = (a, b) => a - b;
2639                 AssertNodeType (e9, ExpressionType.Convert);
2640                 Assert (1, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
2641         }
2642
2643         void SubtractTest_10 ()
2644         {
2645                 Expression<Func<MyEnum?, byte?, MyEnum?>> e10 = (a, b) => a - b;
2646                 AssertNodeType (e10, ExpressionType.Convert);
2647                 Assert ((MyEnum) 255, e10.Compile ().Invoke (MyEnum.Value_1, 2));
2648         }
2649
2650         // CSC bug
2651         void SubtractTest_11 ()
2652         {
2653                 Expression<Func<MyEnum?, MyEnum?, byte?>> e11 = (a, b) => a - b;
2654                 AssertNodeType (e11, ExpressionType.Convert);
2655                 Assert<byte?> (1, e11.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
2656         }
2657
2658         void SubtractCheckedTest ()
2659         {
2660                 checked {
2661                         Expression<Func<long, long, long>> e = (long a, long b) => a - b;
2662                         AssertNodeType (e, ExpressionType.SubtractChecked);
2663                         try {
2664                                 e.Compile ().Invoke (long.MinValue, 309);
2665                                 throw new ApplicationException ("SubtractCheckedTest #1");
2666                         } catch (OverflowException) { }
2667                 }
2668         }
2669
2670         void SubtractCheckedTest_2 ()
2671         {
2672                 checked {
2673                         Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a - b;
2674                         AssertNodeType (e2, ExpressionType.SubtractChecked);
2675                         Assert (null, e2.Compile ().Invoke (null, 3));
2676                         Assert (-55, e2.Compile ().Invoke (byte.MinValue, 55));
2677                 }
2678         }
2679
2680         void SubtractCheckedTest_3 ()
2681         {
2682                 checked {
2683                         Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a - b;
2684                         AssertNodeType (e3, ExpressionType.Subtract);
2685                         Assert (-50, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
2686                 }
2687         }
2688
2689         void SubtractCheckedTest_4 ()
2690         {
2691                 checked {
2692                         Expression<Func<double, double, double>> e4 = (a, b) => a - b;
2693                         AssertNodeType (e4, ExpressionType.Subtract);
2694                         Assert (double.PositiveInfinity, e4.Compile ().Invoke (double.MinValue, double.NegativeInfinity));
2695                 }
2696         }
2697
2698         void TypeAsTest ()
2699         {
2700                 Expression<Func<object, Tester>> e = (object a) => a as Tester;
2701                 AssertNodeType (e, ExpressionType.TypeAs);
2702                 Assert (this, e.Compile ().Invoke (this));
2703         }
2704
2705         void TypeAsTest_2 ()
2706         {
2707                 Expression<Func<object, int?>> e2 = (object a) => a as int?;
2708                 AssertNodeType (e2, ExpressionType.TypeAs);
2709                 Assert (null, e2.Compile ().Invoke (null));
2710                 Assert (null, e2.Compile ().Invoke (this));
2711                 Assert (44, e2.Compile ().Invoke (44));
2712         }
2713
2714         void TypeAsTest_3 ()
2715         {
2716                 Expression<Func<object, object>> e3 = (object a) => null as object;
2717                 AssertNodeType (e3, ExpressionType.TypeAs);
2718                 Assert (null, e3.Compile ().Invoke (null));
2719         }
2720
2721         void TypeAsTest_4 ()
2722         {
2723                 Expression<Func<int, IConvertible>> e = a => a as IConvertible;
2724                 AssertNodeType (e, ExpressionType.TypeAs);
2725                 Assert (ExpressionType.Parameter, ((UnaryExpression) e.Body).Operand.NodeType);
2726                 Assert (5, e.Compile ().Invoke (5));
2727         }
2728
2729         void TypeIsTest ()
2730         {
2731                 Expression<Func<object, bool>> e = (object a) => a is Tester;
2732                 AssertNodeType (e, ExpressionType.TypeIs);
2733                 Assert (true, e.Compile ().Invoke (this));
2734                 Assert (false, e.Compile ().Invoke (1));
2735         }
2736
2737         void TypeIsTest_2 ()
2738         {
2739                 Expression<Func<object, bool>> e2 = (object a) => a is int?;
2740                 AssertNodeType (e2, ExpressionType.TypeIs);
2741                 Assert (false, e2.Compile ().Invoke (null));
2742                 Assert (true, e2.Compile ().Invoke (1));
2743         }
2744
2745         void TypeIsTest_3 ()
2746         {
2747                 Expression<Func<object, bool>> e3 = (object a) => null is object;
2748                 AssertNodeType (e3, ExpressionType.TypeIs);
2749                 Assert (false, e3.Compile ().Invoke (null));
2750         }
2751
2752         void TypeIsTest_4 ()
2753         {
2754                 Expression<Func<B, bool>> e = l => l is A;
2755                 AssertNodeType (e, ExpressionType.TypeIs);
2756                 Assert (false, e.Compile ().Invoke (null));
2757         }
2758
2759         void TypeIsTest_5 ()
2760         {
2761                 Expression<Func<bool>> e5 = () => 1 is int;
2762                 AssertNodeType (e5, ExpressionType.TypeIs);
2763                 Assert (true, e5.Compile ().Invoke ());
2764         }
2765
2766         void TypeIsTest_6 ()
2767         {
2768                 Expression<Func<int?, bool>> e6 = (a) => a is int;
2769                 AssertNodeType (e6, ExpressionType.TypeIs);
2770                 Assert (true, e6.Compile ().Invoke (1));
2771                 Assert (false, e6.Compile ().Invoke (null));
2772         }
2773
2774         void UnaryPlusTest ()
2775         {
2776                 Expression<Func<int, int>> e = (a) => +a;
2777                 AssertNodeType (e, ExpressionType.Parameter);
2778                 Assert (-30, e.Compile ().Invoke (-30));
2779         }
2780
2781         void UnaryPlusTest_2 ()
2782         {
2783                 Expression<Func<long?, long?>> e2 = (a) => +a;
2784                 AssertNodeType (e2, ExpressionType.Parameter);
2785         }
2786
2787         void UnaryPlusTest_3 ()
2788         {
2789                 Expression<Func<MyType, MyType>> e4 = (a) => +a;
2790                 AssertNodeType (e4, ExpressionType.UnaryPlus);
2791                 Assert (new MyType (-14), e4.Compile ().Invoke (new MyType (-14)));
2792         }
2793
2794         void UnaryPlusTest_4 ()
2795         {
2796                 Expression<Func<MyType?, MyType?>> e5 = (a) => +a;
2797                 AssertNodeType (e5, ExpressionType.UnaryPlus);
2798                 Assert (new MyType (33), e5.Compile ().Invoke (new MyType (33)));
2799                 Assert (null, e5.Compile ().Invoke (null));
2800         }
2801
2802         void UnaryPlusTest_5 ()
2803         {
2804                 Expression<Func<sbyte?, long?>> e6 = (a) => +a;
2805                 AssertNodeType (e6, ExpressionType.Convert);
2806                 Assert (3, e6.Compile ().Invoke (3));
2807                 Assert (null, e6.Compile ().Invoke (null));
2808         }
2809
2810 #pragma warning restore 169
2811
2812         //
2813         // Test helpers
2814         //
2815         string InstanceMethod (string arg)
2816         {
2817                 return arg;
2818         }
2819
2820         object InstanceParamsMethod (int index, params object [] args)
2821         {
2822                 if (args == null)
2823                         return "<null>";
2824                 if (args.Length == 0)
2825                         return "<empty>";
2826                 return args [index];
2827         }
2828
2829         static int TestInt ()
2830         {
2831                 return 29;
2832         }
2833
2834         T GenericMethod<T> (T t)
2835         {
2836                 return t;
2837         }
2838
2839         static void RefMethod (ref int i)
2840         {
2841                 i = 867;
2842         }
2843
2844         static bool RunTest (MethodInfo test)
2845         {
2846                 Console.Write ("Running test {0, -25}", test.Name);
2847                 try {
2848                         test.Invoke (new Tester (), null);
2849                         Console.WriteLine ("OK");
2850                         return true;
2851                 } catch (Exception e) {
2852                         Console.WriteLine ("FAILED");
2853                         Console.WriteLine (e.ToString ());
2854                         return false;
2855                 }
2856         }
2857
2858         public static int Main ()
2859         {
2860                 var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
2861                                         where test.GetParameters ().Length == 0
2862                                         orderby test.Name
2863                                         select RunTest (test);
2864
2865                 int failures = tests.Count (a => !a);
2866                 Console.WriteLine (failures + " tests failed");
2867                 return failures;
2868         }
2869 }
2870