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