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