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 CoalesceTest ()
 734         {
 735                 Expression<Func<uint?, uint>> e = (uint? a) => a ?? 99;
 736                 AssertNodeType (e, ExpressionType.Coalesce);
 737                 var r = e.Compile ();
 738                 Assert ((uint) 5, r.Invoke (5));
 739                 Assert ((uint) 99, r.Invoke (null));
 740         }
 741
 742         void CoalesceTest_2 ()
 743         {
 744                 Expression<Func<MyType?, int>> e2 = (MyType? a) => a ?? -3;
 745                 AssertNodeType (e2, ExpressionType.Coalesce);
 746                 var r2 = e2.Compile ();
 747                 Assert (2, r2.Invoke (new MyType (2)));
 748                 Assert (-3, r2.Invoke (null));
 749         }
 750
 751         void ConditionTest ()
 752         {
 753                 Expression<Func<bool, byte, int, int>> e = (bool a, byte b, int c) => (a ? b : c);
 754                 AssertNodeType (e, ExpressionType.Conditional);
 755                 var r = e.Compile ();
 756                 Assert (3, r.Invoke (true, 3, 999999));
 757                 Assert (999999, r.Invoke (false, 3, 999999));
 758         }
 759
 760         void ConditionTest_2 ()
 761         {
 762                 Expression<Func<int, decimal, decimal?>> e2 = (int a, decimal d) => (a > 0 ? d : a < 0 ? -d : (decimal?) null);
 763                 AssertNodeType (e2, ExpressionType.Conditional);
 764                 var r2 = e2.Compile ();
 765                 Assert (null, r2.Invoke (0, 10));
 766                 Assert (50, r2.Invoke (1, 50));
 767                 Assert (30, r2.Invoke (-7, -30));
 768         }
 769
 770         void ConditionTest_3 ()
 771         {
 772                 Expression<Func<bool?, int?>> e3 = (bool? a) => ((bool) a ? 3 : -2);
 773                 AssertNodeType (e3, ExpressionType.Convert);
 774                 var r3 = e3.Compile ();
 775                 Assert (3, r3.Invoke (true));
 776                 Assert (-2, r3.Invoke (false));
 777         }
 778
 779         void ConditionTest_4 ()
 780         {
 781                 Expression<Func<InverseLogicalOperator, byte, byte, byte>> e4 = (InverseLogicalOperator a, byte b, byte c) => (a ? b : c);
 782                 AssertNodeType (e4, ExpressionType.Conditional);
 783                 var r4 = e4.Compile ();
 784                 Assert (3, r4.Invoke (new InverseLogicalOperator (true), 3, 4));
 785                 Assert (4, r4.Invoke (new InverseLogicalOperator (false), 3, 4));
 786         }
 787
 788         void ConditionTest_5 ()
 789         {
 790                 // CSC bug ?
 791                 Expression<Func<int>> e = () => false ? 1 : 4;
 792                 AssertNodeType (e, ExpressionType.Conditional);
 793                 var r = e.Compile ();
 794                 Assert (4, r.Invoke ());
 795         }
 796
 797         void ConstantTest ()
 798         {
 799                 Expression<Func<int>> e1 = () => default (int);
 800                 AssertNodeType (e1, ExpressionType.Constant);
 801                 Assert (0, e1.Compile ().Invoke ());
 802         }
 803
 804         void ConstantTest_2 ()
 805         {
 806                 Expression<Func<int?>> e2 = () => default (int?);
 807                 AssertNodeType (e2, ExpressionType.Constant);
 808                 Assert (null, e2.Compile ().Invoke ());
 809         }
 810
 811         void ConstantTest_3 ()
 812         {
 813                 Expression<Func<Tester>> e3 = () => default (Tester);
 814                 AssertNodeType (e3, ExpressionType.Constant);
 815                 Assert (null, e3.Compile ().Invoke ());
 816         }
 817
 818         void ConstantTest_4 ()
 819         {
 820                 Expression<Func<object>> e4 = () => null;
 821                 AssertNodeType (e4, ExpressionType.Constant);
 822                 Assert (null, e4.Compile ().Invoke ());
 823         }
 824
 825         void ConstantTest_5 ()
 826         {
 827                 Expression<Func<int>> e5 = () => 8 / 4;
 828                 AssertNodeType (e5, ExpressionType.Constant);
 829                 Assert (2, e5.Compile ().Invoke ());
 830         }
 831
 832         void ConstantTest_6 ()
 833         {
 834                 Expression<Func<int>> e6 = () => 0xFFFFFF >> 0x40;
 835                 AssertNodeType (e6, ExpressionType.Constant);
 836                 Assert (0xFFFFFF, e6.Compile ().Invoke ());
 837         }
 838
 839         void ConstantTest_7 ()
 840         {
 841                 Expression<Func<object>> e7 = () => "Alleluia";
 842                 AssertNodeType (e7, ExpressionType.Constant);
 843                 Assert ("Alleluia", e7.Compile ().Invoke ());
 844         }
 845
 846         void ConstantTest_8 ()
 847         {
 848                 Expression<Func<Type>> e8 = () => typeof (int);
 849                 AssertNodeType (e8, ExpressionType.Constant);
 850                 Assert (typeof (int), e8.Compile ().Invoke ());
 851         }
 852
 853         void ConstantTest_9 ()
 854         {
 855                 Expression<Func<Type>> e9 = () => typeof (void);
 856                 AssertNodeType (e9, ExpressionType.Constant);
 857                 Assert (typeof (void), e9.Compile ().Invoke ());
 858         }
 859
 860         void ConstantTest_10 ()
 861         {
 862                 Expression<Func<Type>> e10 = () => typeof (Func<,>);
 863                 AssertNodeType (e10, ExpressionType.Constant);
 864                 Assert (typeof (Func<,>), e10.Compile ().Invoke ());
 865         }
 866
 867         void ConstantTest_11 ()
 868         {
 869                 Expression<Func<MyEnum>> e11 = () => MyEnum.Value_2;
 870                 AssertNodeType (e11, ExpressionType.Constant);
 871                 Assert (MyEnum.Value_2, e11.Compile ().Invoke ());
 872         }
 873
 874         void ConstantTest_13 ()
 875         {
 876                 Expression<Func<int>> e13 = () => sizeof (byte);
 877                 AssertNodeType (e13, ExpressionType.Constant);
 878                 Assert (1, e13.Compile ().Invoke ());
 879
 880         }
 881
 882         void ConstantTest_14 ()
 883         {
 884                 Expression<Func<Type>> e14 = () => typeof (bool*);
 885                 AssertNodeType (e14, ExpressionType.Constant);
 886                 Assert (typeof (bool*), e14.Compile ().Invoke ());
 887         }
 888
 889         void ConstantTest_15 ()
 890         {
 891                 Expression<Func<int?>> e15 = () => null;
 892                 AssertNodeType (e15, ExpressionType.Constant);
 893                 Assert (null, e15.Compile ().Invoke ());
 894         }
 895
 896         void ConvertTest ()
 897         {
 898                 Expression<Func<int, byte>> e = (int a) => ((byte) a);
 899                 AssertNodeType (e, ExpressionType.Convert);
 900                 Assert (100, e.Compile ().Invoke (100));
 901         }
 902
 903         void ConvertTest_2 ()
 904         {
 905                 Expression<Func<long, ushort>> e2 = (long a) => ((ushort) a);
 906                 AssertNodeType (e2, ExpressionType.Convert);
 907                 Assert (100, e2.Compile ().Invoke (100));
 908         }
 909
 910         void ConvertTest_3 ()
 911         {
 912                 Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
 913                 AssertNodeType (e3, ExpressionType.Convert);
 914                 Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
 915         }
 916
 917         void ConvertTest_4 ()
 918         {
 919                 Expression<Func<MyType, int>> e4 = (MyType a) => (a);
 920                 AssertNodeType (e4, ExpressionType.Convert);
 921                 Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
 922         }
 923
 924         void ConvertTest_5 ()
 925         {
 926                 Expression<Func<MyType, MyType, bool?>> e5 = (MyType a, MyType b) => a == b;
 927                 AssertNodeType (e5, ExpressionType.Convert);
 928         }
 929
 930         void ConvertTest_6 ()
 931         {
 932                 Expression<Func<MyType?, MyType?, bool?>> e6 = (MyType? a, MyType? b) => a == b;
 933                 AssertNodeType (e6, ExpressionType.Convert);
 934                 Assert (false, e6.Compile ().Invoke (null, new MyType (-20)));
 935                 Assert (true, e6.Compile ().Invoke (null, null));
 936                 Assert (true, e6.Compile ().Invoke (new MyType (120), new MyType (120)));
 937         }
 938
 939         void ConvertTest_7 ()
 940         {
 941                 Expression<Func<MyTypeExplicit, int?>> e7 = x => (int?)x;
 942                 AssertNodeType (e7, ExpressionType.Convert);
 943                 Assert (33, e7.Compile ().Invoke (new MyTypeExplicit (33)));
 944         }
 945
 946         void ConvertTest_8 ()
 947         {
 948                 Expression<Func<int?, object>> e8 = x => (object)x;
 949                 AssertNodeType (e8, ExpressionType.Convert);
 950                 Assert (null, e8.Compile ().Invoke (null));
 951                 Assert (-100, e8.Compile ().Invoke (-100));
 952         }
 953
 954         unsafe void ConvertTest_9 ()
 955         {
 956                 int*[] p = new int* [1];
 957                 Expression<Func<object>> e9 = () => (object)p;
 958                 AssertNodeType (e9, ExpressionType.Convert);
 959                 Assert (p, e9.Compile ().Invoke ());
 960         }
 961
 962         void ConvertTest_10 ()
 963         {
 964                 Expression<Func<Func<int>, Delegate>> e10 = (a) => a + a;
 965                 AssertNodeType (e10, ExpressionType.Convert);
 966                 Assert (null, e10.Compile ().Invoke (null));
 967                 Assert (new Func<int> (TestInt) + new Func<int> (TestInt), e10.Compile ().Invoke (TestInt));
 968         }
 969
 970         void ConvertTest_11 ()
 971         {
 972                 Expression<Func<Func<int>, Delegate>> e11 = (a) => a - a;
 973                 AssertNodeType (e11, ExpressionType.Convert);
 974                 Assert (null, e11.Compile ().Invoke (null));
 975         }
 976
 977         void ConvertTest_12 ()
 978         {
 979                 Expression<Func<Func<int>>> e12 = () => TestInt;
 980                 AssertNodeType (e12, ExpressionType.Convert);
 981                 Assert (29, e12.Compile ().Invoke () ());
 982         }
 983
 984         void ConvertTest_13 ()
 985         {
 986                 Expression<Func<decimal, sbyte>> e13 = a => (sbyte)a;
 987                 AssertNodeType (e13, ExpressionType.Convert);
 988                 Assert (6, e13.Compile ().Invoke (6));
 989         }
 990
 991         void ConvertTest_14 ()
 992         {
 993                 Expression<Func<long, decimal>> e14 = a => a;
 994                 AssertNodeType (e14, ExpressionType.Convert);
 995                 Assert (-66, e14.Compile ().Invoke (-66));
 996         }
 997
 998         void ConvertTest_15 ()
 999         {
1000                 Expression<Func<ulong?, decimal?>> e15 = a => a;
1001                 AssertNodeType (e15, ExpressionType.Convert);
1002                 Assert (null, e15.Compile ().Invoke (null));
1003                 Assert (9, e15.Compile ().Invoke (9));
1004         }
1005
1006         void ConvertTest_16 ()
1007         {
1008                 Expression<Func<sbyte, sbyte>> e16 = a => (sbyte)a;
1009                 AssertNodeType (e16, ExpressionType.Convert);
1010                 Assert (6, e16.Compile ().Invoke (6));
1011         }
1012
1013         void ConvertCheckedTest ()
1014         {
1015                 Expression<Func<int, byte>> e = (int a) => checked((byte) a);
1016                 AssertNodeType (e, ExpressionType.ConvertChecked);
1017                 Assert (100, e.Compile ().Invoke (100));
1018         }
1019
1020         void ConvertCheckedTest_2 ()
1021         {
1022                 checked {
1023                         Expression<Func<long, ushort>> e2 = (long a) => unchecked((ushort) a);
1024                         AssertNodeType (e2, ExpressionType.Convert);
1025                         Assert (100, e2.Compile ().Invoke (100));
1026                 }
1027         }
1028
1029         void ConvertCheckedTest_3 ()
1030         {
1031                 checked {
1032                         Expression<Func<float?, float>> e3 = (float? a) => ((float) a);
1033                         AssertNodeType (e3, ExpressionType.ConvertChecked);
1034                         Assert (-0.456f, e3.Compile ().Invoke (-0.456f));
1035                 }
1036         }
1037
1038         void ConvertCheckedTest_4 ()
1039         {
1040                 checked {
1041                         Expression<Func<MyType, int>> e4 = (MyType a) => (a);
1042                         AssertNodeType (e4, ExpressionType.Convert);
1043                         Assert (-9, e4.Compile ().Invoke (new MyType (-9)));
1044                 }
1045         }
1046
1047         void DivideTest ()
1048         {
1049                 Expression<Func<int, int, int>> e = (int a, int b) => a / b;
1050                 AssertNodeType (e, ExpressionType.Divide);
1051                 Assert (2, e.Compile ().Invoke (60, 30));
1052         }
1053
1054         void DivideTest_2 ()
1055         {
1056                 Expression<Func<double?, double?, double?>> e2 = (a, b) => a / b;
1057                 AssertNodeType (e2, ExpressionType.Divide);
1058                 Assert (null, e2.Compile ().Invoke (null, 3));
1059                 Assert (1.5, e2.Compile ().Invoke (3, 2));
1060         }
1061
1062         void DivideTest_3 ()
1063         {
1064                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a / b;
1065                 AssertNodeType (e3, ExpressionType.Divide);
1066                 Assert (1, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1067         }
1068
1069         void DivideTest_4 ()
1070         {
1071                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a / b;
1072                 AssertNodeType (e4, ExpressionType.Divide);
1073                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1074                 Assert (new MyType (-6), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1075         }
1076
1077         void DivideTest_5 ()
1078         {
1079                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a / b;
1080                 AssertNodeType (e5, ExpressionType.Divide);
1081                 Assert (50, e5.Compile ().Invoke (100, new MyType (2)));
1082         }
1083
1084         void DivideTest_6 ()
1085         {
1086                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a / b;
1087                 AssertNodeType (e6, ExpressionType.Divide);
1088                 Assert (50, e6.Compile ().Invoke (100, new MyType (2)));
1089                 Assert (null, e6.Compile ().Invoke (20, null));
1090         }
1091
1092         void DivideTest_7 ()
1093         {
1094                 Expression<Func<float, uint?, float?>> e = (a, b) => a / b;
1095                 AssertNodeType (e, ExpressionType.Divide);
1096                 Assert (50, e.Compile () (100, 2));
1097                 Assert (null, e.Compile () (20, null));
1098         }
1099
1100         void EqualTest ()
1101         {
1102                 Expression<Func<int, int, bool>> e = (int a, int b) => a == b;
1103                 AssertNodeType (e, ExpressionType.Equal);
1104                 Assert (false, e.Compile ().Invoke (60, 30));
1105                 Assert (true, e.Compile ().Invoke (-1, -1));
1106         }
1107
1108         void EqualTest_2 ()
1109         {
1110                 Expression<Func<double?, double?, bool>> e2 = (a, b) => a == b;
1111                 AssertNodeType (e2, ExpressionType.Equal);
1112                 Assert (true, e2.Compile ().Invoke (3, 3));
1113                 Assert (false, e2.Compile ().Invoke (3, 2));
1114         }
1115
1116         void EqualTest_3 ()
1117         {
1118                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a == b;
1119                 AssertNodeType (e3, ExpressionType.Equal);
1120                 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1121         }
1122
1123         void EqualTest_4 ()
1124         {
1125                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a == b;
1126                 AssertNodeType (e4, ExpressionType.Equal);
1127                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1128                 Assert (true, e4.Compile ().Invoke (null, null));
1129                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
1130         }
1131
1132         void EqualTest_5 ()
1133         {
1134                 Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a == b;
1135                 AssertNodeType (e5, ExpressionType.Equal);
1136                 Assert (false, e5.Compile ().Invoke (true, null));
1137                 Assert (true, e5.Compile ().Invoke (null, null));
1138                 Assert (true, e5.Compile ().Invoke (false, false));
1139         }
1140
1141         void EqualTest_6 ()
1142         {
1143                 Expression<Func<bool, bool>> e6 = (bool a) => a == null;
1144                 AssertNodeType (e6, ExpressionType.Equal);
1145                 Assert (false, e6.Compile ().Invoke (true));
1146                 Assert (false, e6.Compile ().Invoke (false));
1147         }
1148
1149         void EqualTest_7 ()
1150         {
1151                 Expression<Func<string, string, bool>> e7 = (string a, string b) => a == b;
1152                 AssertNodeType (e7, ExpressionType.Equal);
1153                 Assert (true, e7.Compile ().Invoke (null, null));
1154                 Assert (false, e7.Compile ().Invoke ("a", "A"));
1155                 Assert (true, e7.Compile ().Invoke ("a", "a"));
1156         }
1157
1158         void EqualTest_8 ()
1159         {
1160                 Expression<Func<object, bool>> e8 = (object a) => null == a;
1161                 AssertNodeType (e8, ExpressionType.Equal);
1162                 Assert (true, e8.Compile ().Invoke (null));
1163                 Assert (false, e8.Compile ().Invoke ("a"));
1164                 Assert (false, e8.Compile ().Invoke (this));
1165         }
1166
1167         void EqualTest_9 ()
1168         {
1169                 Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a == b;
1170                 AssertNodeType (e9, ExpressionType.Equal);
1171                 Assert (false, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
1172                 Assert (true, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1173         }
1174
1175         void EqualTest_10 ()
1176         {
1177                 Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a == b;
1178                 AssertNodeType (e10, ExpressionType.Equal);
1179                 Assert (false, e10.Compile ().Invoke (MyEnum.Value_1, null));
1180                 Assert (true, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1181         }
1182
1183         void EqualTest_11 ()
1184         {
1185                 Expression<Func<MyEnum?, bool>> e11 = (a) => a == null;
1186                 AssertNodeType (e11, ExpressionType.Equal);
1187                 Assert (false, e11.Compile ().Invoke (MyEnum.Value_1));
1188                 Assert (true, e11.Compile ().Invoke (null));
1189         }
1190
1191         void EqualTest_12 ()
1192         {
1193                 Expression<Func<MyEnumUlong, bool>> e12 = (a) => a == 0;
1194                 AssertNodeType (e12, ExpressionType.Equal);
1195                 Assert (false, e12.Compile ().Invoke (MyEnumUlong.Value_1));
1196                 Assert (true, e12.Compile ().Invoke (0));
1197         }
1198
1199         void EqualTest_13 ()
1200         {
1201                 Expression<Func<MyEnum, bool>> e13 = (a) => a == MyEnum.Value_2;
1202                 AssertNodeType (e13, ExpressionType.Equal);
1203                 Assert (true, e13.Compile ().Invoke (MyEnum.Value_2));
1204                 Assert (false, e13.Compile ().Invoke (0));
1205         }
1206
1207         void EqualTest_14 ()
1208         {
1209                 Expression<Func<MyEnum, bool>> e = (a) => a == null;
1210                 AssertNodeType (e, ExpressionType.Equal);
1211                 Assert (false, e.Compile ().Invoke (MyEnum.Value_1));
1212         }
1213
1214         void EqualTest_15 ()
1215         {
1216                 Expression<Func<int?, uint, bool>> e = (a, b) => a == b;
1217                 AssertNodeType (e, ExpressionType.Equal);
1218                 Assert (false, e.Compile ().Invoke (null, 0));
1219                 Assert (true, e.Compile ().Invoke (4, 4));
1220         }
1221
1222         void EqualTest_16 ()
1223         {
1224                 Expression<Func<EnumInt?, EnumInt, bool?>> e = (x, y) => x == y;
1225                 AssertNodeType (e, ExpressionType.Convert);
1226                 Assert (false, e.Compile () (null, 0));
1227                 Assert (true, e.Compile () (EnumInt.B, EnumInt.B));
1228         }
1229
1230         void EqualTestDelegate ()
1231         {
1232                 Expression<Func<Delegate, Delegate, bool>> e1 = (a, b) => a == b;
1233                 AssertNodeType (e1, ExpressionType.Equal);
1234                 Assert (true, e1.Compile ().Invoke (null, null));
1235         }
1236
1237         void EqualTestDelegate_2 ()
1238         {
1239                 EmptyDelegate ed = delegate () {};
1240
1241                 Expression<Func<EmptyDelegate, EmptyDelegate, bool>> e2 = (a, b) => a == b;
1242                 AssertNodeType (e2, ExpressionType.Equal);
1243                 Assert (false, e2.Compile ().Invoke (delegate () {}, null));
1244                 Assert (false, e2.Compile ().Invoke (delegate () {}, delegate {}));
1245                 Assert (false, e2.Compile ().Invoke (ed, delegate {}));
1246                 Assert (true, e2.Compile ().Invoke (ed, ed));
1247         }
1248
1249         void EqualTestDelegate_3 ()
1250         {
1251                 Expression<Func<Func<int>, bool>> e1 = (a) => a == ReturnNumber;
1252                 AssertNodeType (e1, ExpressionType.Equal);
1253                 Assert (false, e1.Compile ().Invoke (null));
1254                 Assert (true, e1.Compile ().Invoke (ReturnNumber));
1255         }
1256
1257         void ExclusiveOrTest ()
1258         {
1259                 Expression<Func<int, short, int>> e = (int a, short b) => a ^ b;
1260                 AssertNodeType (e, ExpressionType.ExclusiveOr);
1261                 Assert (34, e.Compile ().Invoke (60, 30));
1262         }
1263
1264         void ExclusiveOrTest_2 ()
1265         {
1266                 Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a ^ b;
1267                 AssertNodeType (e2, ExpressionType.ExclusiveOr);
1268                 Assert (null, e2.Compile ().Invoke (null, 3));
1269                 Assert (1, e2.Compile ().Invoke (3, 2));
1270         }
1271
1272         void ExclusiveOrTest_3 ()
1273         {
1274                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a ^ b;
1275                 AssertNodeType (e3, ExpressionType.ExclusiveOr);
1276                 Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1277         }
1278
1279         void ExclusiveOrTest_4 ()
1280         {
1281                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a ^ b;
1282                 AssertNodeType (e4, ExpressionType.ExclusiveOr);
1283                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1284                 Assert (new MyType (-108), e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1285         }
1286
1287         void ExclusiveOrTest_5 ()
1288         {
1289                 Expression<Func<MyType?, byte, int?>> e5 = (MyType? a, byte b) => a ^ b;
1290                 AssertNodeType (e5, ExpressionType.ExclusiveOr);
1291                 Assert (null, e5.Compile ().Invoke (null, 64));
1292                 Assert (96, e5.Compile ().Invoke (new MyType (64), 32));
1293         }
1294
1295         void ExclusiveOrTest_6 ()
1296         {
1297                 Expression<Func<MyEnum, MyEnum, MyEnum>> e6 = (a, b) => a ^ b;
1298                 AssertNodeType (e6, ExpressionType.Convert);
1299                 Assert ((MyEnum)3, e6.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
1300                 Assert<MyEnum> (0, e6.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1301         }
1302
1303         void ExclusiveOrTest_7 ()
1304         {
1305                 Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e7 = (a, b) => a ^ b;
1306                 AssertNodeType (e7, ExpressionType.Convert);
1307                 Assert (null, e7.Compile ().Invoke (MyEnum.Value_1, null));
1308                 Assert<MyEnum?> (0, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1309         }
1310
1311         void ExclusiveOrTest_8 ()
1312         {
1313                 Expression<Func<MyEnum?, MyEnum?>> e8 = (a) => a ^ null;
1314                 AssertNodeType (e8, ExpressionType.Convert);
1315                 Assert (null, e8.Compile ().Invoke (MyEnum.Value_1));
1316                 Assert (null, e8.Compile ().Invoke (null));
1317         }
1318
1319         void GreaterThanTest ()
1320         {
1321                 Expression<Func<int, int, bool>> e = (int a, int b) => a > b;
1322                 AssertNodeType (e, ExpressionType.GreaterThan);
1323                 Assert (true, e.Compile ().Invoke (60, 30));
1324         }
1325
1326         void GreaterThanTest_2 ()
1327         {
1328                 Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a > b;
1329                 AssertNodeType (e2, ExpressionType.GreaterThan);
1330                 Assert (false, e2.Compile ().Invoke (null, 3));
1331                 Assert (false, e2.Compile ().Invoke (2, 2));
1332         }
1333
1334         void GreaterThanTest_3 ()
1335         {
1336                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a > b;
1337                 AssertNodeType (e3, ExpressionType.GreaterThan);
1338                 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1339         }
1340
1341         void GreaterThanTest_4 ()
1342         {
1343                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a > b;
1344                 AssertNodeType (e4, ExpressionType.GreaterThan);
1345                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1346                 Assert (false, e4.Compile ().Invoke (null, null));
1347                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1348         }
1349
1350         void GreaterThanTest_5 ()
1351         {
1352                 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a > b;
1353                 AssertNodeType (e5, ExpressionType.GreaterThan);
1354                 Assert (false, e5.Compile ().Invoke (null, 33));
1355                 Assert (false, e5.Compile ().Invoke (null, 0));
1356                 Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
1357         }
1358
1359         void GreaterThanTest_6 ()
1360         {
1361                 Expression<Func<ushort, bool>> e6 = (ushort a) => a > null;
1362                 AssertNodeType (e6, ExpressionType.GreaterThan);
1363                 Assert (false, e6.Compile ().Invoke (60));
1364         }
1365
1366         void GreaterThanTest_7 ()
1367         {
1368                 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a > b;
1369                 AssertNodeType (e7, ExpressionType.GreaterThan);
1370                 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1371                 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1372         }
1373
1374         void GreaterThanTest_8 ()
1375         {
1376                 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a > b;
1377                 AssertNodeType (e8, ExpressionType.GreaterThan);
1378                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1379                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1380         }
1381
1382         void GreaterThanOrEqualTest ()
1383         {
1384                 Expression<Func<int, int, bool>> e = (int a, int b) => a >= b;
1385                 AssertNodeType (e, ExpressionType.GreaterThanOrEqual);
1386                 Assert (true, e.Compile ().Invoke (60, 30));
1387         }
1388
1389         void GreaterThanOrEqualTest_2 ()
1390         {
1391                 Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a >= b;
1392                 AssertNodeType (e2, ExpressionType.GreaterThanOrEqual);
1393                 Assert (false, e2.Compile ().Invoke (null, 3));
1394                 Assert (true, e2.Compile ().Invoke (2, 2));
1395         }
1396
1397         void GreaterThanOrEqualTest_3 ()
1398         {
1399                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a >= b;
1400                 AssertNodeType (e3, ExpressionType.GreaterThanOrEqual);
1401                 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)), "D1");
1402         }
1403
1404         void GreaterThanOrEqualTest_4 ()
1405         {
1406                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a >= b;
1407                 AssertNodeType (e4, ExpressionType.GreaterThanOrEqual);
1408                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1409                 Assert (false, e4.Compile ().Invoke (null, null));
1410                 Assert (true, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1411         }
1412
1413         void GreaterThanOrEqualTest_5 ()
1414         {
1415                 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a >= b;
1416                 AssertNodeType (e5, ExpressionType.GreaterThanOrEqual);
1417                 Assert (false, e5.Compile ().Invoke (null, 33));
1418                 Assert (false, e5.Compile ().Invoke (null, 0));
1419                 Assert (true, e5.Compile ().Invoke (new MyType (120), 3));
1420         }
1421
1422         void GreaterThanOrEqualTest_6 ()
1423         {
1424                 Expression<Func<ushort, bool>> e6 = (ushort a) => a >= null;
1425                 AssertNodeType (e6, ExpressionType.GreaterThanOrEqual);
1426                 Assert (false, e6.Compile ().Invoke (60));
1427         }
1428
1429         void GreaterThanOrEqualTest_7 ()
1430         {
1431                 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a >= b;
1432                 AssertNodeType (e7, ExpressionType.GreaterThanOrEqual);
1433                 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1434                 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1435         }
1436
1437         void GreaterThanOrEqualTest_8 ()
1438         {
1439                 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a >= b;
1440                 AssertNodeType (e8, ExpressionType.GreaterThanOrEqual);
1441                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1442                 Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1443         }
1444
1445         void InvokeTest ()
1446         {
1447                 var del = new IntDelegate (TestInt);
1448                 Expression<Func<IntDelegate, int>> e = (a) => a ();
1449                 AssertNodeType (e, ExpressionType.Invoke);
1450                 Assert (29, e.Compile ().Invoke (del));
1451         }
1452
1453         void InvokeTest_2 ()
1454         {
1455                 Expression<Func<Func<int, string>, int, string>> e2 = (a, b) => a (b);
1456                 AssertNodeType (e2, ExpressionType.Invoke);
1457                 Assert ("4", e2.Compile ().Invoke ((a) => (a+1).ToString (), 3));
1458         }
1459
1460         void LambdaTest ()
1461         {
1462                 Expression<Func<string, Func<string>>> e = (string s) => () => s;
1463                 AssertNodeType (e, ExpressionType.Lambda);
1464                 Assert ("xx", e.Compile ().Invoke ("xx") ());
1465         }
1466
1467         void LeftShiftTest ()
1468         {
1469                 Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a << b;
1470                 AssertNodeType (e, ExpressionType.LeftShift);
1471                 Assert ((ulong) 0x7F000, e.Compile ().Invoke (0xFE, 11));
1472                 Assert ((ulong) 0x1FFFFFFFE, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1473
1474                 // .net produces a strange result
1475                 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
1476                 // Assert ((ulong) 0xFFFFFFFE00000000, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
1477         }
1478
1479         void LeftShiftTest_2 ()
1480         {
1481                 Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a << b;
1482                 AssertNodeType (e2, ExpressionType.LeftShift);
1483                 var c2 = e2.Compile ();
1484                 Assert (1024, c2 (new MyType (256), new MyType (2)));
1485         }
1486
1487         void LeftShiftTest_3 ()
1488         {
1489                 Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a << b;
1490                 AssertNodeType (e3, ExpressionType.LeftShift);
1491                 Assert (null, e3.Compile ().Invoke (null, 11));
1492                 Assert (2048, e3.Compile ().Invoke (1024, 1));
1493         }
1494
1495         void LeftShiftTest_4 ()
1496         {
1497                 Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a << b;
1498                 AssertNodeType (e4, ExpressionType.LeftShift);
1499                 var c4 = e4.Compile ();
1500                 Assert (null, c4 (new MyType (8), null));
1501                 Assert (null, c4 (null, new MyType (8)));
1502                 Assert (1024, c4 (new MyType (256), new MyType (2)));
1503         }
1504
1505         void LeftShiftTest_5 ()
1506         {
1507                 Expression<Func<ushort, int?>> e5 = (ushort a) => a << null;
1508                 AssertNodeType (e5, ExpressionType.LeftShift);
1509                 Assert (null, e5.Compile ().Invoke (30));
1510         }
1511
1512         void LeftShiftTest_6 ()
1513         {
1514                 Expression<Func<int, MyTypeImplicitOnly, int>> e = (a, b) => a << b;
1515                 AssertNodeType (e, ExpressionType.LeftShift);
1516                 Assert (0x7F0, e.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
1517         }
1518
1519         void LessThanTest ()
1520         {
1521                 Expression<Func<int, int, bool>> e = (int a, int b) => a < b;
1522                 AssertNodeType (e, ExpressionType.LessThan);
1523                 Assert (false, e.Compile ().Invoke (60, 30));
1524         }
1525
1526         void LessThanTest_2 ()
1527         {
1528                 Expression<Func<uint?, byte?, bool>> e2 = (a, b) => a < b;
1529                 AssertNodeType (e2, ExpressionType.LessThan);
1530                 Assert (false, e2.Compile ().Invoke (null, 3));
1531                 Assert (false, e2.Compile ().Invoke (2, 2));
1532         }
1533
1534         void LessThanTest_3 ()
1535         {
1536                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a < b;
1537                 AssertNodeType (e3, ExpressionType.LessThan);
1538                 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1539         }
1540
1541         void LessThanTest_4 ()
1542         {
1543                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a < b;
1544                 AssertNodeType (e4, ExpressionType.LessThan);
1545                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1546                 Assert (false, e4.Compile ().Invoke (null, null));
1547                 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1548         }
1549
1550         void LessThanTest_5 ()
1551         {
1552                 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a < b;
1553                 AssertNodeType (e5, ExpressionType.LessThan);
1554                 Assert (false, e5.Compile ().Invoke (null, 33));
1555                 Assert (false, e5.Compile ().Invoke (null, 0));
1556                 Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
1557         }
1558
1559         void LessThanTest_6 ()
1560         {
1561                 Expression<Func<ushort, bool>> e6 = (ushort a) => a < null;
1562                 AssertNodeType (e6, ExpressionType.LessThan);
1563                 Assert (false, e6.Compile ().Invoke (60));
1564         }
1565
1566         void LessThanTest_7 ()
1567         {
1568                 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a < b;
1569                 AssertNodeType (e7, ExpressionType.LessThan);
1570                 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1571                 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1572         }
1573
1574         void LessThanTest_8 ()
1575         {
1576                 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a < b;
1577                 AssertNodeType (e8, ExpressionType.LessThan);
1578                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1579                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1580         }
1581
1582         void LessThanTest_9 ()
1583         {
1584                 Expression<Func<object, int?, bool>> e = (a, b) => (int) a < b;
1585                 AssertNodeType (e, ExpressionType.LessThan);
1586                 Assert (false, e.Compile ().Invoke (1, null));
1587                 Assert (false, e.Compile ().Invoke (3, 3));
1588                 Assert (true, e.Compile ().Invoke (1, 3));
1589         }
1590
1591         void LessThanOrEqualTest ()
1592         {
1593                 Expression<Func<int, int, bool>> e = (int a, int b) => a <= b;
1594                 AssertNodeType (e, ExpressionType.LessThanOrEqual);
1595                 Assert (false, e.Compile ().Invoke (60, 30));
1596         }
1597
1598         void LessThanOrEqualTest_2 ()
1599         {
1600                 Expression<Func<byte?, byte?, bool>> e2 = (a, b) => a <= b;
1601                 AssertNodeType (e2, ExpressionType.LessThanOrEqual);
1602                 Assert (false, e2.Compile ().Invoke (null, 3));
1603                 Assert (true, e2.Compile ().Invoke (2, 2));
1604         }
1605
1606         void LessThanOrEqualTest_3 ()
1607         {
1608                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a <= b;
1609                 AssertNodeType (e3, ExpressionType.LessThanOrEqual);
1610                 Assert (true, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1611         }
1612
1613         void LessThanOrEqualTest_4 ()
1614         {
1615                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a <= b;
1616                 AssertNodeType (e4, ExpressionType.LessThanOrEqual);
1617                 Assert (false, e4.Compile ().Invoke (null, new MyType (-20)));
1618                 Assert (false, e4.Compile ().Invoke (null, null));
1619                 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (-20)));
1620         }
1621
1622         void LessThanOrEqualTest_5 ()
1623         {
1624                 Expression<Func<MyType?, sbyte, bool>> e5 = (MyType? a, sbyte b) => a <= b;
1625                 AssertNodeType (e5, ExpressionType.LessThanOrEqual);
1626                 Assert (false, e5.Compile ().Invoke (null, 33));
1627                 Assert (false, e5.Compile ().Invoke (null, 0));
1628                 Assert (false, e5.Compile ().Invoke (new MyType (120), 3));
1629         }
1630
1631         void LessThanOrEqualTest_6 ()
1632         {
1633                 Expression<Func<ushort, bool>> e6 = (ushort a) => a <= null;
1634                 AssertNodeType (e6, ExpressionType.LessThanOrEqual);
1635                 Assert (false, e6.Compile ().Invoke (60));
1636         }
1637
1638         void LessThanOrEqualTest_7 ()
1639         {
1640                 Expression<Func<MyEnum, MyEnum, bool>> e7 = (a, b) => a <= b;
1641                 AssertNodeType (e7, ExpressionType.LessThanOrEqual);
1642                 Assert (false, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
1643                 Assert (true, e7.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1644         }
1645
1646         void LessThanOrEqualTest_8 ()
1647         {
1648                 Expression<Func<MyEnum?, MyEnum?, bool>> e8 = (a, b) => a <= b;
1649                 AssertNodeType (e8, ExpressionType.LessThanOrEqual);
1650                 Assert (false, e8.Compile ().Invoke (MyEnum.Value_1, null));
1651                 Assert (true, e8.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
1652         }
1653
1654         void ListInitTest ()
1655         {
1656                 Expression<Func<List<object>>> e1 = () => new List<object> { "Hello", "", null, "World", 5 };
1657                 AssertNodeType (e1, ExpressionType.ListInit);
1658                 var re1 = e1.Compile ().Invoke ();
1659                 Assert (null, re1 [2]);
1660                 Assert ("World", re1 [3]);
1661                 Assert (5, re1 [4]);
1662         }
1663
1664         void ListInitTest_2 ()
1665         {
1666                 Expression<Func<int, Dictionary<string, int>>> e2 = (int value) => new Dictionary<string, int> (3) { { "A", value }, { "B", 2 } };
1667                 AssertNodeType (e2, ExpressionType.ListInit);
1668                 var re2 = e2.Compile ().Invoke (3456);
1669                 Assert (3456, re2 ["A"]);
1670         }
1671
1672         void MemberAccessTest ()
1673         {
1674                 MemberAccessData d = new MemberAccessData ();
1675                 d.BoolValue = true;
1676                 Expression<Func<bool>> e = () => d.BoolValue;
1677                 AssertNodeType (e, ExpressionType.MemberAccess);
1678                 Assert (true, e.Compile ().Invoke ());
1679                 d.BoolValue = false;
1680                 Assert (false, e.Compile ().Invoke ());
1681         }
1682
1683         void MemberAccessTest_2 ()
1684         {
1685                 Expression<Func<decimal>> e2 = () => MemberAccessData.DecimalValue;
1686                 AssertNodeType (e2, ExpressionType.MemberAccess);
1687                 Assert (decimal.MinValue, e2.Compile ().Invoke ());
1688         }
1689
1690         void MemberAccessTest_3 ()
1691         {
1692                 MemberAccessData d = new MemberAccessData ();
1693                 d.VolatileValue = 492;
1694                 Expression<Func<uint>> e3 = () => d.VolatileValue;
1695                 AssertNodeType (e3, ExpressionType.MemberAccess);
1696                 Assert<uint> (492, e3.Compile ().Invoke ());
1697         }
1698
1699         void MemberAccessTest_4 ()
1700         {
1701                 MemberAccessData d = new MemberAccessData ();
1702                 Expression<Func<string[]>> e4 = () => d.StringValues;
1703                 AssertNodeType (e4, ExpressionType.MemberAccess);
1704                 Assert (null, e4.Compile ().Invoke ());
1705         }
1706
1707         void MemberAccessTest_5 ()
1708         {
1709                 MemberAccessData d = new MemberAccessData ();
1710                 var e5 = d.GetEvent ();
1711                 AssertNodeType (e5, ExpressionType.MemberAccess);
1712                 Assert (null, e5.Compile ().Invoke ());
1713         }
1714
1715         void MemberAccessTest_6 ()
1716         {
1717                 MemberAccessData d = new MemberAccessData ();
1718                 Expression<Func<MyType>> e6 = () => d.MyTypeProperty;
1719                 AssertNodeType (e6, ExpressionType.MemberAccess);
1720                 Assert (new MyType (), e6.Compile ().Invoke ());
1721         }
1722
1723         void MemberAccessTest_7 ()
1724         {
1725                 MemberAccessData d = new MemberAccessData ();
1726                 Expression<Func<MyType, short>> e7 = a => a.ShortProp;
1727                 AssertNodeType (e7, ExpressionType.MemberAccess);
1728                 MyType mt = new MyType ();
1729                 mt.ShortProp = 124;
1730                 Assert (124, e7.Compile ().Invoke (mt));
1731         }
1732
1733         void MemberAccessTest_8 ()
1734         {
1735                 Expression<Func<string>> e8 = () => MemberAccessData.StaticProperty;
1736                 AssertNodeType (e8, ExpressionType.MemberAccess);
1737                 Assert ("alo", e8.Compile ().Invoke ());
1738         }
1739
1740         void MemberAccessTest_9 ()
1741         {
1742                 string s = "localvar";
1743                 Expression<Func<string>> e9 = () => s;
1744                 s = "changed";
1745
1746                 AssertNodeType (e9, ExpressionType.MemberAccess);
1747                 Assert ("changed", e9.Compile ().Invoke ());
1748         }
1749
1750         void MemberInitTest ()
1751         {
1752                 Expression<Func<MemberAccessData>> e = () => new MemberAccessData {
1753                         VolatileValue = 2, StringValues = new string [] { "sv" }, MyTypeProperty = new MyType (692)
1754                 };
1755                 AssertNodeType (e, ExpressionType.MemberInit);
1756                 var r1 = e.Compile ().Invoke ();
1757                 Assert<uint> (2, r1.VolatileValue);
1758                 Assert (new string[] { "sv" }, r1.StringValues);
1759                 Assert (new MyType (692), r1.MyTypeProperty);
1760         }
1761
1762         void MemberInitTest_2 ()
1763         {
1764                 Expression<Func<MemberAccessData>> e2 = () => new MemberAccessData {
1765                         ListValues = new List<string> { "a", null }
1766                 };
1767
1768                 AssertNodeType (e2, ExpressionType.MemberInit);
1769                 var r2 = e2.Compile ().Invoke ();
1770                 Assert ("a", r2.ListValues [0]);
1771         }
1772
1773         void MemberInitTest_3 ()
1774         {
1775                 Expression<Func<short, MyType>> e3 = a => new MyType { ShortProp = a };
1776                 AssertNodeType (e3, ExpressionType.MemberInit);
1777                 var r3 = e3.Compile ().Invoke (33);
1778                 Assert (33, r3.ShortProp);
1779         }
1780
1781         void MemberInitTest_4 ()
1782         {
1783                 Expression<Func<int>> e = () => new int { };
1784
1785                 AssertNodeType (e, ExpressionType.MemberInit);
1786                 var r = e.Compile ().Invoke ();
1787                 Assert (0, r);
1788         }
1789
1790         void MemberInitTest_5 ()
1791         {
1792                 Expression<Func<MemberAccessData>> e = () => new MemberAccessData { SetOnly = new object { } };
1793
1794                 AssertNodeType (e, ExpressionType.MemberInit);
1795                 e.Compile () ();
1796         }
1797
1798         void ModuloTest ()
1799         {
1800                 Expression<Func<int, int, int>> e = (int a, int b) => a % b;
1801                 AssertNodeType (e, ExpressionType.Modulo);
1802                 Assert (29, e.Compile ().Invoke (60, 31));
1803         }
1804
1805         void ModuloTest_2 ()
1806         {
1807                 Expression<Func<double?, double?, double?>> e2 = (a, b) => a % b;
1808                 AssertNodeType (e2, ExpressionType.Modulo);
1809                 Assert (null, e2.Compile ().Invoke (null, 3));
1810                 Assert (1.1, e2.Compile ().Invoke (3.1, 2));
1811         }
1812
1813         void ModuloTest_3 ()
1814         {
1815                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a % b;
1816                 AssertNodeType (e3, ExpressionType.Modulo);
1817                 Assert (0, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1818         }
1819
1820         void ModuloTest_4 ()
1821         {
1822                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a % b;
1823                 AssertNodeType (e4, ExpressionType.Modulo);
1824                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1825                 Assert (new MyType (12), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
1826         }
1827
1828         void ModuloTest_5 ()
1829         {
1830                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a % b;
1831                 AssertNodeType (e5, ExpressionType.Modulo);
1832                 Assert (1, e5.Compile ().Invoke (99, new MyType (2)));
1833         }
1834
1835         void ModuloTest_6 ()
1836         {
1837                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a % b;
1838                 AssertNodeType (e6, ExpressionType.Modulo);
1839                 Assert (100, e6.Compile ().Invoke (100, new MyType (200)));
1840                 Assert (null, e6.Compile ().Invoke (20, null));
1841         }
1842
1843         void ModuloTest_7 ()
1844         {
1845                 Expression<Func<ushort, int?>> e7 = (ushort a) => a % null;
1846                 AssertNodeType (e7, ExpressionType.Modulo);
1847                 Assert (null, e7.Compile ().Invoke (60));
1848         }
1849
1850         void MultiplyTest ()
1851         {
1852                 Expression<Func<int, int, int>> e = (int a, int b) => a * b;
1853                 AssertNodeType (e, ExpressionType.Multiply);
1854                 Assert (1860, e.Compile ().Invoke (60, 31));
1855                 Assert (2147483617, e.Compile ().Invoke (int.MaxValue, 31));
1856         }
1857
1858         void MultiplyTest_2 ()
1859         {
1860                 Expression<Func<double?, double?, double?>> e2 = (a, b) => a * b;
1861                 AssertNodeType (e2, ExpressionType.Multiply);
1862                 Assert (null, e2.Compile ().Invoke (null, 3));
1863                 Assert (6.2, e2.Compile ().Invoke (3.1, 2));
1864         }
1865
1866         void MultiplyTest_3 ()
1867         {
1868                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
1869                 AssertNodeType (e3, ExpressionType.Multiply);
1870                 Assert (400, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
1871         }
1872
1873         void MultiplyTest_4 ()
1874         {
1875                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a * b;
1876                 AssertNodeType (e4, ExpressionType.Multiply);
1877                 Assert (null, e4.Compile ().Invoke (null, new MyType (-20)));
1878                 Assert (new MyType (-240), e4.Compile ().Invoke (new MyType (12), new MyType (-20)));
1879         }
1880
1881         void MultiplyTest_5 ()
1882         {
1883                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a * b;
1884                 AssertNodeType (e5, ExpressionType.Multiply);
1885                 Assert (198, e5.Compile ().Invoke (99, new MyType (2)));
1886         }
1887
1888         void MultiplyTest_6 ()
1889         {
1890                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a * b;
1891                 AssertNodeType (e6, ExpressionType.Multiply);
1892                 Assert (0, e6.Compile ().Invoke (int.MinValue, new MyType (200)));
1893                 Assert (null, e6.Compile ().Invoke (20, null));
1894         }
1895
1896         void MultiplyTest_7 ()
1897         {
1898                 Expression<Func<ushort, int?>> e7 = (ushort a) => a * null;
1899                 AssertNodeType (e7, ExpressionType.Multiply);
1900                 Assert (null, e7.Compile ().Invoke (60));
1901         }
1902
1903         void MultiplyTest_8 ()
1904         {
1905                 Expression<Func<double, ulong?, double?>> e = (a, b) => a * b;
1906                 AssertNodeType (e, ExpressionType.Multiply);
1907                 Assert (180, e.Compile () (60, 3));
1908                 Assert (null, e.Compile () (60, null));
1909         }
1910
1911         void MultiplyCheckedTest ()
1912         {
1913                 checked {
1914                         Expression<Func<int, int, int>> e = (int a, int b) => a * b;
1915                         AssertNodeType (e, ExpressionType.MultiplyChecked);
1916                         try {
1917                                 e.Compile ().Invoke (int.MaxValue, 309);
1918                                 throw new ApplicationException ("MultiplyCheckedTest #1");
1919                         } catch (OverflowException) { }
1920                 }
1921         }
1922
1923         void MultiplyCheckedTest_2 ()
1924         {
1925                 checked {
1926                         Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a * b;
1927                         AssertNodeType (e2, ExpressionType.MultiplyChecked);
1928                         Assert (null, e2.Compile ().Invoke (null, 3));
1929                         Assert (14025, e2.Compile ().Invoke (byte.MaxValue, 55));
1930                 }
1931         }
1932
1933         void MultiplyCheckedTest_3 ()
1934         {
1935                 checked {
1936                         Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a * b;
1937                         AssertNodeType (e3, ExpressionType.Multiply);
1938                         Assert (-600, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
1939                 }
1940         }
1941
1942         void MultiplyCheckedTest_4 ()
1943         {
1944                 checked {
1945                         Expression<Func<double, double, double>> e4 = (a, b) => a * b;
1946                         AssertNodeType (e4, ExpressionType.Multiply);
1947                         Assert (double.PositiveInfinity, e4.Compile ().Invoke (double.MaxValue, int.MaxValue));
1948                 }
1949         }
1950
1951         void MultiplyCheckedTest_5 ()
1952         {
1953                 checked {
1954                         Expression<Func<float?, float?, float?>> e5 = (a, b) => b * a;
1955                         AssertNodeType (e5, ExpressionType.MultiplyChecked);
1956                         Assert (float.PositiveInfinity, e5.Compile ().Invoke (float.Epsilon, float.PositiveInfinity));
1957                 }
1958         }
1959
1960         void NegateTest ()
1961         {
1962                 Expression<Func<int, int>> e = (a) => -a;
1963                 AssertNodeType (e, ExpressionType.Negate);
1964                 Assert (30, e.Compile ().Invoke (-30));
1965         }
1966
1967         void NegateTest_2 ()
1968         {
1969                 Expression<Func<sbyte, int>> e2 = (a) => -(-a);
1970                 AssertNodeType (e2, ExpressionType.Negate);
1971                 Assert (-10, e2.Compile ().Invoke (-10));
1972         }
1973
1974         void NegateTest_3 ()
1975         {
1976                 Expression<Func<long?, long?>> e3 = (a) => -a;
1977                 AssertNodeType (e3, ExpressionType.Negate);
1978                 Assert (long.MinValue + 1, e3.Compile ().Invoke (long.MaxValue));
1979                 Assert (null, e3.Compile ().Invoke (null));
1980         }
1981
1982         void NegateTest_4 ()
1983         {
1984                 Expression<Func<MyType, MyType>> e4 = (a) => -a;
1985                 AssertNodeType (e4, ExpressionType.Negate);
1986                 Assert (new MyType (14), e4.Compile ().Invoke (new MyType (-14)));
1987         }
1988
1989         void NegateTest_5 ()
1990         {
1991                 Expression<Func<MyType?, MyType?>> e5 = (a) => -a;
1992                 AssertNodeType (e5, ExpressionType.Negate);
1993                 Assert (new MyType (-33), e5.Compile ().Invoke (new MyType (33)));
1994                 Assert (null, e5.Compile ().Invoke (null));
1995         }
1996
1997         void NegateTest_6 ()
1998         {
1999                 Expression<Func<MyTypeImplicitOnly, int>> e6 = (MyTypeImplicitOnly a) => -a;
2000                 AssertNodeType (e6, ExpressionType.Negate);
2001                 Assert (-4, e6.Compile ().Invoke (new MyTypeImplicitOnly (4)));
2002         }
2003
2004         void NegateTest_7 ()
2005         {
2006                 Expression<Func<MyTypeImplicitOnly?, int?>> e7 = (MyTypeImplicitOnly? a) => -a;
2007                 AssertNodeType (e7, ExpressionType.Negate);
2008                 Assert (-46, e7.Compile ().Invoke (new MyTypeImplicitOnly (46)));
2009
2010                 // Another version of MS bug when predefined conversion is required on nullable user operator
2011                 // Assert (null, e7.Compile ().Invoke (null));
2012         }
2013
2014         void NegateTest_8 ()
2015         {
2016                 Expression<Func<sbyte?, int?>> e8 = (a) => -a;
2017                 AssertNodeType (e8, ExpressionType.Negate);
2018                 Assert (11, e8.Compile ().Invoke (-11));
2019         }
2020
2021         void NegateTest_9 ()
2022         {
2023                 Expression<Func<uint, long>> e9 = (a) => -a;
2024                 AssertNodeType (e9, ExpressionType.Negate);
2025                 Assert (-2, e9.Compile ().Invoke (2));
2026         }
2027
2028         void NegateTestChecked ()
2029         {
2030                 checked {
2031                         Expression<Func<int, int>> e = (int a) => -a;
2032                         AssertNodeType (e, ExpressionType.NegateChecked);
2033                         try {
2034                                 e.Compile ().Invoke (int.MinValue);
2035                                 throw new ApplicationException ("NegateTestChecked #1");
2036                         } catch (OverflowException) { }
2037                 }
2038         }
2039
2040         void NegateTestChecked_2 ()
2041         {
2042                 checked {
2043                         Expression<Func<byte?, int?>> e2 = (a) => -a;
2044                         AssertNodeType (e2, ExpressionType.NegateChecked);
2045                         Assert (null, e2.Compile ().Invoke (null));
2046                         Assert (-255, e2.Compile ().Invoke (byte.MaxValue));
2047                 }
2048         }
2049
2050         void NegateTestChecked_3 ()
2051         {
2052                 checked {
2053                         Expression<Func<MyType, MyType>> e3 = (MyType a) => -a;
2054                         AssertNodeType (e3, ExpressionType.Negate);
2055                         Assert (20, e3.Compile ().Invoke (new MyType (-20)));
2056                 }
2057         }
2058
2059         void NegateTestChecked_4 ()
2060         {
2061                 checked {
2062                         Expression<Func<double, double>> e4 = (a) => -a;
2063                         AssertNodeType (e4, ExpressionType.Negate);
2064                         Assert (double.NegativeInfinity, e4.Compile ().Invoke (double.PositiveInfinity));
2065                 }
2066         }
2067
2068         void NewArrayInitTest ()
2069         {
2070                 Expression<Func<int []>> e = () => new int [1] { 5 };
2071                 AssertNodeType (e, ExpressionType.NewArrayInit);
2072                 Assert (new int [1] { 5 }, e.Compile ().Invoke ());
2073         }
2074
2075         void NewArrayInitTest_2 ()
2076         {
2077                 Expression<Func<int []>> e1 = () => new int [] { };
2078                 AssertNodeType (e1, ExpressionType.NewArrayInit);
2079                 Assert (new int [0], e1.Compile ().Invoke ());
2080         }
2081
2082         void NewArrayInitTest_3 ()
2083         {
2084                 Expression<Func<ushort, ulong? []>> e2 = (ushort a) => new ulong? [] { a };
2085                 AssertNodeType (e2, ExpressionType.NewArrayInit);
2086                 Assert (new ulong? [1] { ushort.MaxValue }, e2.Compile ().Invoke (ushort.MaxValue));
2087         }
2088
2089         void NewArrayInitTest_4 ()
2090         {
2091                 Expression<Func<char [] []>> e3 = () => new char [] [] { new char [] { 'a' } };
2092                 AssertNodeType (e3, ExpressionType.NewArrayInit);
2093                 Assert (new char [] { 'a' }, e3.Compile ().Invoke () [0]);
2094         }
2095
2096         void NewArrayInitTest_5 ()
2097         {
2098                 Expression<Func<int?[]>> e = () => new int?[] { null, 3, 4 };
2099                 AssertNodeType (e, ExpressionType.NewArrayInit);
2100                 Assert (3, e.Compile ().Invoke ().Length);
2101         }
2102
2103         void NewArrayInitTest_6 ()
2104         {
2105                 Expression<Func<string []>> e = () => new [] { null, "a" };
2106                 AssertNodeType (e, ExpressionType.NewArrayInit);
2107                 Assert (2, e.Compile ().Invoke ().Length);
2108         }
2109
2110         void NewArrayBoundsTest ()
2111         {
2112                 Expression<Func<int [,]>> e = () => new int [2,3];
2113                 AssertNodeType (e, ExpressionType.NewArrayBounds);
2114                 Assert (new int [2,3].Length, e.Compile ().Invoke ().Length);
2115         }
2116
2117         void NewArrayBoundsTest_2 ()
2118         {
2119                 Expression<Func<int[,]>> e2 = () => new int [0,0];
2120                 AssertNodeType (e2, ExpressionType.NewArrayBounds);
2121                 Assert (new int [0, 0].Length, e2.Compile ().Invoke ().Length);
2122         }
2123
2124         void NewArrayBoundsTest_3 ()
2125         {
2126                 Expression<Func<int []>> e = () => new int [0];
2127                 AssertNodeType (e, ExpressionType.NewArrayBounds);
2128                 Assert (0, e.Compile ().Invoke ().Length);
2129         }
2130
2131         void NewArrayBoundsTest_4 ()
2132         {
2133                 const ulong max = ulong.MaxValue;
2134
2135                 Expression<Func<bool[]>> e = () => new bool [max];
2136                 AssertNodeType (e, ExpressionType.NewArrayBounds);
2137         }
2138
2139         void NewTest ()
2140         {
2141                 Expression<Func<MyType>> e = () => new MyType (2);
2142                 AssertNodeType (e, ExpressionType.New);
2143                 Assert (new MyType (2), e.Compile ().Invoke ());
2144         }
2145
2146         void NewTest_2 ()
2147         {
2148                 Expression<Func<MyType>> e2 = () => new MyType ();
2149                 AssertNodeType (e2, ExpressionType.New);
2150                 Assert (new MyType (), e2.Compile ().Invoke ());
2151         }
2152
2153         void NewTest_3 ()
2154         {
2155                 Expression<Func<NewTest<bool>>> e3 = () => new NewTest<bool> (true);
2156                 AssertNodeType (e3, ExpressionType.New);
2157                 Assert (new NewTest<bool> (true), e3.Compile ().Invoke ());
2158         }
2159
2160         void NewTest_4 ()
2161         {
2162                 Expression<Func<decimal, NewTest<decimal>>> e4 = (decimal d) => new NewTest<decimal> (1, 5, d);
2163                 AssertNodeType (e4, ExpressionType.New);
2164                 Assert (new NewTest<decimal> (1, 5, -9), e4.Compile ().Invoke (-9));
2165         }
2166
2167         void NewTest_5 ()
2168         {
2169                 Expression<Func<object>> e5 = () => new { A = 9, Value = "a" };
2170                 AssertNodeType (e5, ExpressionType.New);
2171                 var ne = ((NewExpression) e5.Body);
2172
2173                 Assert (2, ne.Members.Count, "members count");
2174
2175                 // Behaviour is different between .NET 3.5 and .NET 4.0
2176                 if (ne.Members [0].MemberType == MemberTypes.Property) {
2177                         Assert ("A", ne.Members [0].Name, "Name #1");
2178                         Assert ("Value", ne.Members [1].Name, "Name #2");
2179                 } else {
2180                         Assert ("get_A", ne.Members [0].Name, "Name #1");
2181                         Assert ("get_Value", ne.Members [1].Name, "Name #2");
2182                 }
2183
2184                 Assert (new { A = 9, Value = "a" }, e5.Compile ().Invoke ());
2185         }
2186
2187         void NewTest_6 ()
2188         {
2189                 Expression<Func<object>> e5 = () => new { A = 9, Value = new MyType (5) };
2190                 AssertNodeType (e5, ExpressionType.New);
2191         }
2192
2193         // CSC bug: emits new MyEnum as a constant
2194         void NewTest_7 ()
2195         {
2196                 Expression<Func<MyEnum>> e = () => new MyEnum ();
2197                 AssertNodeType (e, ExpressionType.New);
2198                 Assert<MyEnum> (0, e.Compile ().Invoke ());
2199         }
2200
2201         void NewTest_8 ()
2202         {
2203                 Expression<Func<DateTime>> e = () => new DateTime ();
2204                 AssertNodeType (e, ExpressionType.New);
2205                 Assert (null, ((NewExpression)e.Body).Constructor, "default ctor");
2206
2207                 Expression<Func<StructWithUserConstructor>> e2 = () => new StructWithUserConstructor ();
2208                 AssertNodeType (e2, ExpressionType.New);
2209                 Assert ("Void .ctor()", ((NewExpression)e2.Body).Constructor.ToString (), "user ctor");
2210         }
2211
2212         void NotTest ()
2213         {
2214                 Expression<Func<bool, bool>> e = (bool a) => !a;
2215                 AssertNodeType (e, ExpressionType.Not);
2216                 Assert (false, e.Compile ().Invoke (true));
2217         }
2218
2219         void NotTest_2 ()
2220         {
2221                 Expression<Func<MyType, bool>> e2 = (MyType a) => !a;
2222                 AssertNodeType (e2, ExpressionType.Not);
2223                 Assert (true, e2.Compile ().Invoke (new MyType (1)));
2224                 Assert (false, e2.Compile ().Invoke (new MyType (-1)));
2225         }
2226
2227         void NotTest_3 ()
2228         {
2229                 Expression<Func<int, int>> e3 = (int a) => ~a;
2230                 AssertNodeType (e3, ExpressionType.Not);
2231                 Assert (-8, e3.Compile ().Invoke (7));
2232         }
2233
2234         void NotTest_4 ()
2235         {
2236                 Expression<Func<MyType, int>> e4 = (MyType a) => ~a;
2237                 AssertNodeType (e4, ExpressionType.Not);
2238                 Assert (0, e4.Compile ().Invoke (new MyType (-1)));
2239         }
2240
2241         void NotTest_5 ()
2242         {
2243                 Expression<Func<ulong, ulong>> e5 = (ulong a) => ~a;
2244                 AssertNodeType (e5, ExpressionType.Not);
2245                 Assert<ulong> (18446744073709551608, e5.Compile ().Invoke (7));
2246         }
2247
2248         void NotTest_6 ()
2249         {
2250                 Expression<Func<MyEnum, MyEnum>> e6 = (MyEnum a) => ~a;
2251                 AssertNodeType (e6, ExpressionType.Convert);
2252                 Assert ((MyEnum)254, e6.Compile ().Invoke (MyEnum.Value_1));
2253         }
2254
2255         void NotNullableTest ()
2256         {
2257                 Expression<Func<bool?, bool?>> e = (bool? a) => !a;
2258                 AssertNodeType (e, ExpressionType.Not);
2259                 Assert (false, e.Compile ().Invoke (true));
2260                 Assert (null, e.Compile ().Invoke (null));
2261         }
2262
2263         void NotNullableTest_2 ()
2264         {
2265                 Expression<Func<MyType?, bool?>> e2 = (MyType? a) => !a;
2266                 AssertNodeType (e2, ExpressionType.Not);
2267                 Assert (true, e2.Compile ().Invoke (new MyType (1)));
2268                 Assert (null, e2.Compile ().Invoke (null));
2269         }
2270
2271         void NotNullableTest_3 ()
2272         {
2273                 Expression<Func<sbyte?, int?>> e3 = (sbyte? a) => ~a;
2274                 AssertNodeType (e3, ExpressionType.Not);
2275                 Assert (-5, e3.Compile ().Invoke (4));
2276                 Assert (null, e3.Compile ().Invoke (null));
2277         }
2278
2279         void NotNullableTest_4 ()
2280         {
2281                 Expression<Func<MyType?, int?>> e4 = (MyType? a) => ~a;
2282                 AssertNodeType (e4, ExpressionType.Not);
2283                 Assert (0, e4.Compile ().Invoke (new MyType (-1)));
2284                 Assert (null, e4.Compile ().Invoke (null));
2285         }
2286
2287         void NotNullableTest_5 ()
2288         {
2289                 Expression<Func<MyEnum?, MyEnum?>> e5 = (MyEnum? a) => ~a;
2290                 AssertNodeType (e5, ExpressionType.Convert);
2291                 Assert ((MyEnum) 254, e5.Compile ().Invoke (MyEnum.Value_1));
2292                 Assert (null, e5.Compile ().Invoke (null));
2293         }
2294
2295         void NotEqualTest ()
2296         {
2297                 Expression<Func<int, int, bool>> e = (int a, int b) => a != b;
2298                 AssertNodeType (e, ExpressionType.NotEqual);
2299                 Assert (true, e.Compile ().Invoke (60, 30));
2300                 Assert (false, e.Compile ().Invoke (-1, -1));
2301         }
2302
2303         void NotEqualTest_2 ()
2304         {
2305                 Expression<Func<sbyte?, sbyte?, bool>> e2 = (a, b) => a != b;
2306                 AssertNodeType (e2, ExpressionType.NotEqual);
2307                 Assert (false, e2.Compile ().Invoke (3, 3));
2308                 Assert (true, e2.Compile ().Invoke (3, 2));
2309         }
2310
2311         void NotEqualTest_3 ()
2312         {
2313                 Expression<Func<MyType, MyType, bool>> e3 = (MyType a, MyType b) => a != b;
2314                 AssertNodeType (e3, ExpressionType.NotEqual);
2315                 Assert (false, e3.Compile ().Invoke (new MyType (-20), new MyType (-20)));
2316         }
2317
2318         void NotEqualTest_4 ()
2319         {
2320                 Expression<Func<MyType?, MyType?, bool>> e4 = (MyType? a, MyType? b) => a != b;
2321                 AssertNodeType (e4, ExpressionType.NotEqual);
2322                 Assert (true, e4.Compile ().Invoke (null, new MyType (-20)));
2323                 Assert (false, e4.Compile ().Invoke (null, null));
2324                 Assert (false, e4.Compile ().Invoke (new MyType (120), new MyType (120)));
2325         }
2326
2327         void NotEqualTest_5 ()
2328         {
2329                 Expression<Func<bool?, bool?, bool>> e5 = (bool? a, bool? b) => a != b;
2330                 AssertNodeType (e5, ExpressionType.NotEqual);
2331                 Assert (true, e5.Compile ().Invoke (true, null));
2332                 Assert (false, e5.Compile ().Invoke (null, null));
2333                 Assert (false, e5.Compile ().Invoke (false, false));
2334         }
2335
2336         void NotEqualTest_6 ()
2337         {
2338                 Expression<Func<bool, bool>> e6 = (bool a) => a != null;
2339                 AssertNodeType (e6, ExpressionType.NotEqual);
2340                 Assert (true, e6.Compile ().Invoke (true));
2341                 Assert (true, e6.Compile ().Invoke (false));
2342         }
2343
2344         void NotEqualTest_7 ()
2345         {
2346                 Expression<Func<string, string, bool>> e7 = (string a, string b) => a != b;
2347                 AssertNodeType (e7, ExpressionType.NotEqual);
2348                 Assert (false, e7.Compile ().Invoke (null, null));
2349                 Assert (true, e7.Compile ().Invoke ("a", "A"));
2350                 Assert (false, e7.Compile ().Invoke ("a", "a"));
2351         }
2352
2353         void NotEqualTest_8 ()
2354         {
2355                 Expression<Func<object, bool>> e8 = (object a) => null != a;
2356                 AssertNodeType (e8, ExpressionType.NotEqual);
2357                 Assert (false, e8.Compile ().Invoke (null));
2358                 Assert (true, e8.Compile ().Invoke ("a"));
2359                 Assert (true, e8.Compile ().Invoke (this));
2360         }
2361
2362         void NotEqualTest_9 ()
2363         {
2364                 Expression<Func<MyEnum, MyEnum, bool>> e9 = (a, b) => a != b;
2365                 AssertNodeType (e9, ExpressionType.NotEqual);
2366                 Assert (true, e9.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2367                 Assert (false, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2368         }
2369
2370         void NotEqualTest_10 ()
2371         {
2372                 Expression<Func<MyEnum?, MyEnum?, bool>> e10 = (a, b) => a != b;
2373                 AssertNodeType (e10, ExpressionType.NotEqual);
2374                 Assert (true, e10.Compile ().Invoke (MyEnum.Value_1, null));
2375                 Assert (false, e10.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2376         }
2377
2378         void NotEqualTest_11 ()
2379         {
2380                 Expression<Func<MyEnum?, bool>> e11 = (a) => a != null;
2381                 AssertNodeType (e11, ExpressionType.NotEqual);
2382                 Assert (true, e11.Compile ().Invoke (MyEnum.Value_1));
2383                 Assert (false, e11.Compile ().Invoke (null));
2384         }
2385
2386         void OrTest ()
2387         {
2388                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a | b;
2389
2390                 AssertNodeType (e, ExpressionType.Or);
2391                 Func<bool, bool, bool> c = e.Compile ();
2392
2393                 Assert (true, c (true, true));
2394                 Assert (true, c (true, false));
2395                 Assert (true, c (false, true));
2396                 Assert (false, c (false, false));
2397         }
2398
2399         void OrTest_2 ()
2400         {
2401                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a | b;
2402                 AssertNodeType (e2, ExpressionType.Or);
2403                 var c2 = e2.Compile ();
2404                 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2405         }
2406
2407         void OrTest_3 ()
2408         {
2409                 Expression<Func<MyEnum, MyEnum, MyEnum>> e3 = (a, b) => a | b;
2410                 AssertNodeType (e3, ExpressionType.Convert);
2411                 Assert ((MyEnum)3, e3.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2412                 Assert (MyEnum.Value_2, e3.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_2));
2413         }
2414
2415         void OrNullableTest ()
2416         {
2417                 Expression<Func<bool?, bool?, bool?>> e = (bool? a, bool? b) => a | b;
2418
2419                 AssertNodeType (e, ExpressionType.Or);
2420                 Func<bool?, bool?, bool?> c = e.Compile ();
2421
2422                 Assert (true, c (true, true));
2423                 Assert (true, c (true, false));
2424                 Assert (true, c (false, true));
2425                 Assert (false, c (false, false));
2426
2427                 Assert (true, c (true, null));
2428                 Assert (null, c (false, null));
2429                 Assert (null, c (null, false));
2430                 Assert (true, c (true, null));
2431                 Assert (null, c (null, null));
2432         }
2433
2434         void OrNullableTest_2 ()
2435         {
2436                 Expression<Func<MyType?, MyType?, MyType?>> e2 = (MyType? a, MyType? b) => a | b;
2437                 AssertNodeType (e2, ExpressionType.Or);
2438                 var c2 = e2.Compile ();
2439                 Assert (new MyType (3), c2 (new MyType (1), new MyType (2)));
2440                 Assert (null, c2 (new MyType (1), null));
2441         }
2442
2443         void OrNullableTest_3 ()
2444         {
2445                 Expression<Func<MyType?, uint, long?>> e3 = (MyType? a, uint b) => a | b;
2446                 AssertNodeType (e3, ExpressionType.Or);
2447                 var c3 = e3.Compile ();
2448                 Assert (9, c3 (new MyType (1), 8));
2449         }
2450
2451         void OrNullableTest_4 ()
2452         {
2453                 Expression<Func<MyEnum?, MyEnum?, MyEnum?>> e4 = (a, b) => a | b;
2454                 AssertNodeType (e4, ExpressionType.Convert);
2455                 Assert (null, e4.Compile ().Invoke (null, MyEnum.Value_2));
2456                 Assert ((MyEnum)3, e4.Compile ().Invoke (MyEnum.Value_1, MyEnum.Value_2));
2457         }
2458
2459         void OrElseTest ()
2460         {
2461                 Expression<Func<bool, bool, bool>> e = (bool a, bool b) => a || b;
2462                 AssertNodeType (e, ExpressionType.OrElse);
2463                 Assert (true, e.Compile ().Invoke (true, false));
2464         }
2465
2466         void OrElseTest_2 ()
2467         {
2468                 Expression<Func<MyType, MyType, MyType>> e2 = (MyType a, MyType b) => a || b;
2469                 AssertNodeType (e2, ExpressionType.OrElse);
2470                 Assert (new MyType (64), e2.Compile ().Invoke (new MyType (64), new MyType (64)));
2471                 Assert (new MyType (32), e2.Compile ().Invoke (new MyType (32), new MyType (64)));
2472         }
2473
2474         void ParameterTest ()
2475         {
2476                 Expression<Func<string, string>> e = (string a) => a;
2477                 AssertNodeType (e, ExpressionType.Parameter);
2478                 Assert ("t", e.Compile ().Invoke ("t"));
2479         }
2480
2481         void ParameterTest_2 ()
2482         {
2483                 Expression<Func<object[], object[]>> e2 = (object[] a) => a;
2484                 AssertNodeType (e2, ExpressionType.Parameter);
2485                 Assert (new object [0], e2.Compile ().Invoke (new object [0]));
2486         }
2487
2488         void ParameterTest_3 ()
2489         {
2490                 Expression<Func<IntPtr, IntPtr>> e3 = a => a;
2491                 AssertNodeType (e3, ExpressionType.Parameter);
2492                 Assert (IntPtr.Zero, e3.Compile ().Invoke (IntPtr.Zero));
2493         }
2494
2495         unsafe void ParameterTest_4 ()
2496         {
2497                 Expression<Func<int*[], int* []>> e4 = (a) => a;
2498                 AssertNodeType (e4, ExpressionType.Parameter);
2499                 Assert<int*[]> (null, e4.Compile ().Invoke (null));
2500                 int* e4_el = stackalloc int [5];
2501                 int*[] ptr = new int*[] { e4_el };
2502                 Assert<int*[]> (ptr, e4.Compile ().Invoke (ptr));
2503         }
2504
2505         void QuoteTest ()
2506         {
2507                 Expression<Func<Expression<Func<int>>>> e = () => () => 2;
2508                 AssertNodeType (e, ExpressionType.Quote);
2509                 Assert (2, e.Compile ().Invoke ().Compile ().Invoke ());
2510         }
2511
2512         void QuoteTest_2 ()
2513         {
2514                 Expression<Func<string, Expression<Func<string>>>> e = (string s) => () => s;
2515                 AssertNodeType (e, ExpressionType.Quote);
2516
2517                 Assert ("data", e.Compile ().Invoke ("data").Compile ().Invoke ());
2518         }
2519
2520         void RightShiftTest ()
2521         {
2522                 Expression<Func<ulong, short, ulong>> e = (ulong a, short b) => a >> b;
2523                 AssertNodeType (e, ExpressionType.RightShift);
2524                 Assert ((ulong) 0x1FD940L, e.Compile ().Invoke (0xFECA0000, 11));
2525                 Assert ((ulong) 0x7FFFFFFF, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2526
2527                 // .net produces a strange result
2528                 // see https://bugzilla.novell.com/show_bug.cgi?id=398358
2529                 // Assert ((ulong)0, e.Compile ().Invoke (0xFFFFFFFF, 0xA01));
2530         }
2531
2532         void RightShiftTest_2 ()
2533         {
2534                 Expression<Func<MyType, MyType, int>> e2 = (MyType a, MyType b) => a >> b;
2535                 AssertNodeType (e2, ExpressionType.RightShift);
2536                 var c2 = e2.Compile ();
2537                 Assert (64, c2 (new MyType (256), new MyType (2)));
2538         }
2539
2540         void RightShiftTest_3 ()
2541         {
2542                 Expression<Func<long?, sbyte, long?>> e3 = (long? a, sbyte b) => a >> b;
2543                 AssertNodeType (e3, ExpressionType.RightShift);
2544                 Assert (null, e3.Compile ().Invoke (null, 11));
2545                 Assert (512, e3.Compile ().Invoke (1024, 1));
2546         }
2547
2548         void RightShiftTest_4 ()
2549         {
2550                 Expression<Func<MyType?, MyType?, int?>> e4 = (MyType? a, MyType? b) => a >> b;
2551                 AssertNodeType (e4, ExpressionType.RightShift);
2552                 var c4 = e4.Compile ();
2553                 Assert (null, c4 (new MyType (8), null));
2554                 Assert (null, c4 (null, new MyType (8)));
2555                 Assert (64, c4 (new MyType (256), new MyType (2)));
2556         }
2557
2558         void RightShiftTest_5 ()
2559         {
2560                 Expression<Func<int, MyTypeImplicitOnly, int>> e = (a, b) => a >> b;
2561                 AssertNodeType (e, ExpressionType.RightShift);
2562                 Assert (31, e.Compile ().Invoke (0xFE, new MyTypeImplicitOnly (3)));
2563         }
2564
2565         void RightShiftTest_6 ()
2566         {
2567                 Expression<Func<ulong, byte?, ulong?>> e = (a, b) => a >> b;
2568                 AssertNodeType (e, ExpressionType.RightShift);
2569                 Assert (null, e.Compile () (2, null));
2570         }
2571
2572         void SubtractTest ()
2573         {
2574                 Expression<Func<int, int, int>> e = (int a, int b) => a - b;
2575                 AssertNodeType (e, ExpressionType.Subtract);
2576                 Assert (-10, e.Compile ().Invoke (20, 30));
2577         }
2578
2579         void SubtractTest_2 ()
2580         {
2581                 Expression<Func<int?, int?, int?>> e2 = (a, b) => a - b;
2582                 AssertNodeType (e2, ExpressionType.Subtract);
2583                 Assert (null, e2.Compile ().Invoke (null, 3));
2584         }
2585
2586         void SubtractTest_3 ()
2587         {
2588                 Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a - b;
2589                 AssertNodeType (e3, ExpressionType.Subtract);
2590                 Assert (-50, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
2591         }
2592
2593         void SubtractTest_4 ()
2594         {
2595                 Expression<Func<MyType?, MyType?, MyType?>> e4 = (MyType? a, MyType? b) => a - b;
2596                 AssertNodeType (e4, ExpressionType.Subtract);
2597                 Assert (new MyType (-50), e4.Compile ().Invoke (new MyType (-20), new MyType (30)));
2598                 Assert (null, e4.Compile ().Invoke (null, new MyType (30)));
2599         }
2600
2601         void SubtractTest_5 ()
2602         {
2603                 Expression<Func<int, MyType, int>> e5 = (int a, MyType b) => a - b;
2604                 AssertNodeType (e5, ExpressionType.Subtract);
2605                 Assert (-29, e5.Compile ().Invoke (1, new MyType (30)));
2606         }
2607
2608         void SubtractTest_6 ()
2609         {
2610                 Expression<Func<int, MyType?, int?>> e6 = (int a, MyType? b) => a - b;
2611                 AssertNodeType (e6, ExpressionType.Subtract);
2612                 Assert (-61, e6.Compile ().Invoke (-31, new MyType (30)));
2613         }
2614
2615         void SubtractTest_7 ()
2616         {
2617                 Expression<Func<ushort, int?>> e7 = (ushort a) => null - a;
2618                 AssertNodeType (e7, ExpressionType.Subtract);
2619                 Assert (null, e7.Compile ().Invoke (690));
2620         }
2621
2622         void SubtractTest_8 ()
2623         {
2624                 Expression<Func<MyEnum, byte, MyEnum>> e8 = (a, b) => a - b;
2625                 AssertNodeType (e8, ExpressionType.Convert);
2626                 Assert ((MyEnum)255, e8.Compile ().Invoke (MyEnum.Value_1, 2));
2627         }
2628
2629         void SubtractTest_9 ()
2630         {
2631                 Expression<Func<MyEnum, MyEnum, byte>> e9 = (a, b) => a - b;
2632                 AssertNodeType (e9, ExpressionType.Convert);
2633                 Assert (1, e9.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
2634         }
2635
2636         void SubtractTest_10 ()
2637         {
2638                 Expression<Func<MyEnum?, byte?, MyEnum?>> e10 = (a, b) => a - b;
2639                 AssertNodeType (e10, ExpressionType.Convert);
2640                 Assert ((MyEnum) 255, e10.Compile ().Invoke (MyEnum.Value_1, 2));
2641         }
2642
2643         // CSC bug
2644         void SubtractTest_11 ()
2645         {
2646                 Expression<Func<MyEnum?, MyEnum?, byte?>> e11 = (a, b) => a - b;
2647                 AssertNodeType (e11, ExpressionType.Convert);
2648                 Assert<byte?> (1, e11.Compile ().Invoke (MyEnum.Value_2, MyEnum.Value_1));
2649         }
2650
2651         void SubtractCheckedTest ()
2652         {
2653                 checked {
2654                         Expression<Func<long, long, long>> e = (long a, long b) => a - b;
2655                         AssertNodeType (e, ExpressionType.SubtractChecked);
2656                         try {
2657                                 e.Compile ().Invoke (long.MinValue, 309);
2658                                 throw new ApplicationException ("SubtractCheckedTest #1");
2659                         } catch (OverflowException) { }
2660                 }
2661         }
2662
2663         void SubtractCheckedTest_2 ()
2664         {
2665                 checked {
2666                         Expression<Func<byte?, byte?, int?>> e2 = (a, b) => a - b;
2667                         AssertNodeType (e2, ExpressionType.SubtractChecked);
2668                         Assert (null, e2.Compile ().Invoke (null, 3));
2669                         Assert (-55, e2.Compile ().Invoke (byte.MinValue, 55));
2670                 }
2671         }
2672
2673         void SubtractCheckedTest_3 ()
2674         {
2675                 checked {
2676                         Expression<Func<MyType, MyType, MyType>> e3 = (MyType a, MyType b) => a - b;
2677                         AssertNodeType (e3, ExpressionType.Subtract);
2678                         Assert (-50, e3.Compile ().Invoke (new MyType (-20), new MyType (30)));
2679                 }
2680         }
2681
2682         void SubtractCheckedTest_4 ()
2683         {
2684                 checked {
2685                         Expression<Func<double, double, double>> e4 = (a, b) => a - b;
2686                         AssertNodeType (e4, ExpressionType.Subtract);
2687                         Assert (double.PositiveInfinity, e4.Compile ().Invoke (double.MinValue, double.NegativeInfinity));
2688                 }
2689         }
2690
2691         void TypeAsTest ()
2692         {
2693                 Expression<Func<object, Tester>> e = (object a) => a as Tester;
2694                 AssertNodeType (e, ExpressionType.TypeAs);
2695                 Assert (this, e.Compile ().Invoke (this));
2696         }
2697
2698         void TypeAsTest_2 ()
2699         {
2700                 Expression<Func<object, int?>> e2 = (object a) => a as int?;
2701                 AssertNodeType (e2, ExpressionType.TypeAs);
2702                 Assert (null, e2.Compile ().Invoke (null));
2703                 Assert (null, e2.Compile ().Invoke (this));
2704                 Assert (44, e2.Compile ().Invoke (44));
2705         }
2706
2707         void TypeAsTest_3 ()
2708         {
2709                 Expression<Func<object, object>> e3 = (object a) => null as object;
2710                 AssertNodeType (e3, ExpressionType.TypeAs);
2711                 Assert (null, e3.Compile ().Invoke (null));
2712         }
2713
2714         void TypeAsTest_4 ()
2715         {
2716                 Expression<Func<int, IConvertible>> e = a => a as IConvertible;
2717                 AssertNodeType (e, ExpressionType.TypeAs);
2718                 Assert (ExpressionType.Parameter, ((UnaryExpression) e.Body).Operand.NodeType);
2719                 Assert (5, e.Compile ().Invoke (5));
2720         }
2721
2722         void TypeIsTest ()
2723         {
2724                 Expression<Func<object, bool>> e = (object a) => a is Tester;
2725                 AssertNodeType (e, ExpressionType.TypeIs);
2726                 Assert (true, e.Compile ().Invoke (this));
2727                 Assert (false, e.Compile ().Invoke (1));
2728         }
2729
2730         void TypeIsTest_2 ()
2731         {
2732                 Expression<Func<object, bool>> e2 = (object a) => a is int?;
2733                 AssertNodeType (e2, ExpressionType.TypeIs);
2734                 Assert (false, e2.Compile ().Invoke (null));
2735                 Assert (true, e2.Compile ().Invoke (1));
2736         }
2737
2738         void TypeIsTest_3 ()
2739         {
2740                 Expression<Func<object, bool>> e3 = (object a) => null is object;
2741                 AssertNodeType (e3, ExpressionType.TypeIs);
2742                 Assert (false, e3.Compile ().Invoke (null));
2743         }
2744
2745         void TypeIsTest_4 ()
2746         {
2747                 Expression<Func<B, bool>> e = l => l is A;
2748                 AssertNodeType (e, ExpressionType.TypeIs);
2749                 Assert (false, e.Compile ().Invoke (null));
2750         }
2751
2752         void TypeIsTest_5 ()
2753         {
2754                 Expression<Func<bool>> e5 = () => 1 is int;
2755                 AssertNodeType (e5, ExpressionType.TypeIs);
2756                 Assert (true, e5.Compile ().Invoke ());
2757         }
2758
2759         void TypeIsTest_6 ()
2760         {
2761                 Expression<Func<int?, bool>> e6 = (a) => a is int;
2762                 AssertNodeType (e6, ExpressionType.TypeIs);
2763                 Assert (true, e6.Compile ().Invoke (1));
2764                 Assert (false, e6.Compile ().Invoke (null));
2765         }
2766
2767         void UnaryPlusTest ()
2768         {
2769                 Expression<Func<int, int>> e = (a) => +a;
2770                 AssertNodeType (e, ExpressionType.Parameter);
2771                 Assert (-30, e.Compile ().Invoke (-30));
2772         }
2773
2774         void UnaryPlusTest_2 ()
2775         {
2776                 Expression<Func<long?, long?>> e2 = (a) => +a;
2777                 AssertNodeType (e2, ExpressionType.Parameter);
2778         }
2779
2780         void UnaryPlusTest_3 ()
2781         {
2782                 Expression<Func<MyType, MyType>> e4 = (a) => +a;
2783                 AssertNodeType (e4, ExpressionType.UnaryPlus);
2784                 Assert (new MyType (-14), e4.Compile ().Invoke (new MyType (-14)));
2785         }
2786
2787         void UnaryPlusTest_4 ()
2788         {
2789                 Expression<Func<MyType?, MyType?>> e5 = (a) => +a;
2790                 AssertNodeType (e5, ExpressionType.UnaryPlus);
2791                 Assert (new MyType (33), e5.Compile ().Invoke (new MyType (33)));
2792                 Assert (null, e5.Compile ().Invoke (null));
2793         }
2794
2795         void UnaryPlusTest_5 ()
2796         {
2797                 Expression<Func<sbyte?, long?>> e6 = (a) => +a;
2798                 AssertNodeType (e6, ExpressionType.Convert);
2799                 Assert (3, e6.Compile ().Invoke (3));
2800                 Assert (null, e6.Compile ().Invoke (null));
2801         }
2802
2803 #pragma warning restore 169
2804
2805         //
2806         // Test helpers
2807         //
2808         string InstanceMethod (string arg)
2809         {
2810                 return arg;
2811         }
2812
2813         object InstanceParamsMethod (int index, params object [] args)
2814         {
2815                 if (args == null)
2816                         return "<null>";
2817                 if (args.Length == 0)
2818                         return "<empty>";
2819                 return args [index];
2820         }
2821
2822         static int TestInt ()
2823         {
2824                 return 29;
2825         }
2826
2827         T GenericMethod<T> (T t)
2828         {
2829                 return t;
2830         }
2831
2832         static void RefMethod (ref int i)
2833         {
2834                 i = 867;
2835         }
2836
2837         static bool RunTest (MethodInfo test)
2838         {
2839                 Console.Write ("Running test {0, -25}", test.Name);
2840                 try {
2841                         test.Invoke (new Tester (), null);
2842                         Console.WriteLine ("OK");
2843                         return true;
2844                 } catch (Exception e) {
2845                         Console.WriteLine ("FAILED");
2846                         Console.WriteLine (e.ToString ());
2847                         return false;
2848                 }
2849         }
2850
2851         public static int Main ()
2852         {
2853                 var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
2854                                         where test.GetParameters ().Length == 0
2855                                         orderby test.Name
2856                                         select RunTest (test);
2857
2858                 int failures = tests.Count (a => !a);
2859                 Console.WriteLine (failures + " tests failed");
2860                 return failures;
2861         }
2862 }
2863