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