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