tests/dtest-006.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Linq;
   4 using System.Linq.Expressions;
   5 using System.Reflection;
   6
   7 // Dynamic binary and unary operators tests
   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: Create a clone which uses +(MyType, int) pattern and an implicit conversion
  29 // is required to do the user-conversion
  30
  31 public struct MyType
  32 {
  33         int value;
  34
  35         public MyType (int value) : this ()
  36         {
  37                 this.value = value;
  38         }
  39
  40         public short ShortProp { get; set; }
  41
  42         public override int GetHashCode ()
  43         {
  44                 throw new NotImplementedException ();
  45         }
  46
  47         public static implicit operator int (MyType o)
  48         {
  49                 return o.value;
  50         }
  51
  52         public static bool operator true (MyType a)
  53         {
  54                 return a.value == a;
  55         }
  56
  57         public static bool operator false (MyType a)
  58         {
  59                 return a.value != a;
  60         }
  61
  62         public static MyType operator + (MyType a, MyType b)
  63         {
  64                 return new MyType (a.value + b.value);
  65         }
  66
  67         public static MyType operator - (MyType a, MyType b)
  68         {
  69                 return new MyType (a.value - b.value);
  70         }
  71
  72         public static MyType operator / (MyType a, MyType b)
  73         {
  74                 return new MyType (a.value / b.value);
  75         }
  76
  77         public static MyType operator * (MyType a, MyType b)
  78         {
  79                 return new MyType (a.value * b.value);
  80         }
  81
  82         public static MyType operator % (MyType a, MyType b)
  83         {
  84                 return new MyType (a.value % b.value);
  85         }
  86
  87         public static MyType operator &(MyType a, MyType b)
  88         {
  89                 return new MyType (a.value & b.value);
  90         }
  91
  92         public static MyType operator | (MyType a, MyType b)
  93         {
  94                 return new MyType (a.value | b.value);
  95         }
  96
  97         public static MyType operator ^ (MyType a, MyType b)
  98         {
  99                 return new MyType (a.value ^ b.value);
 100         }
 101
 102         public static bool operator == (MyType a, MyType b)
 103         {
 104                 return a.value == b.value;
 105         }
 106
 107         public static bool operator != (MyType a, MyType b)
 108         {
 109                 return a.value != b.value;
 110         }
 111
 112         public static bool operator > (MyType a, MyType b)
 113         {
 114                 return a.value > b.value;
 115         }
 116
 117         public static bool operator < (MyType a, MyType b)
 118         {
 119                 return a.value < b.value;
 120         }
 121
 122         public static bool operator >= (MyType a, MyType b)
 123         {
 124                 return a.value >= b.value;
 125         }
 126
 127         public static bool operator <= (MyType a, MyType b)
 128         {
 129                 return a.value <= b.value;
 130         }
 131
 132         public static bool operator ! (MyType a)
 133         {
 134                 return a.value > 0;
 135         }
 136
 137         public static int operator >> (MyType a, int b)
 138         {
 139                 return a.value >> b;
 140         }
 141
 142         public static int operator << (MyType a, int b)
 143         {
 144                 return a.value << b;
 145         }
 146
 147         public static MyType operator - (MyType a)
 148         {
 149                 return new MyType (-a.value);
 150         }
 151
 152         public static MyType operator + (MyType a)
 153         {
 154                 return new MyType (+a.value);
 155         }
 156
 157         public override string ToString ()
 158         {
 159                 return value.ToString ();
 160         }
 161 }
 162
 163
 164 class MyTypeExplicit
 165 {
 166         int value;
 167
 168         public MyTypeExplicit (int value)
 169         {
 170                 this.value = value;
 171         }
 172
 173         public static explicit operator int (MyTypeExplicit m)
 174         {
 175                 return m.value;
 176         }
 177 }
 178
 179 struct MyTypeImplicitOnly
 180 {
 181         short b;
 182
 183         public MyTypeImplicitOnly (short b)
 184         {
 185                 this.b = b;
 186         }
 187
 188         public static implicit operator short (MyTypeImplicitOnly m)
 189         {
 190                 return m.b;
 191         }
 192 }
 193
 194 enum MyEnum : byte
 195 {
 196         Value_1 = 1,
 197         Value_2 = 2
 198 }
 199
 200 enum MyEnumUlong : ulong
 201 {
 202         Value_1 = 1,
 203         Value_2 = 2
 204 }
 205
 206
 207 class Tester
 208 {
 209         delegate void EmptyDelegate ();
 210         delegate int IntDelegate ();
 211
 212         static void Assert<T> (T expected, T value, string name)
 213         {
 214                 if (!EqualityComparer<T>.Default.Equals (expected, value)) {
 215                         name += ": ";
 216                         throw new ApplicationException (name + expected + " != " + value);
 217                 }
 218         }
 219
 220         static void AssertChecked<T> (Func<T> expected, T value, string name)
 221         {
 222                 try {
 223                         Assert (expected (), value, name);
 224                         throw new ApplicationException (name + ": OverflowException expected");
 225                 } catch (OverflowException) {
 226                         // passed
 227                 }
 228         }
 229
 230         static void AssertChecked (Action expected, string name)
 231         {
 232                 try {
 233                         expected ();
 234                         throw new ApplicationException (name + ": OverflowException expected");
 235                 } catch (OverflowException) {
 236                         // passed
 237                 }
 238         }
 239
 240 #pragma warning disable 169
 241
 242         void AddTest ()
 243         {
 244                 dynamic d = 5;
 245
 246                 int v = 2;
 247                 Assert (d + v, 7, "#1");
 248                 double v2 = 0.5;
 249                 Assert (d + v2, 5.5, "#1a");
 250
 251                 MyType v3 = new MyType (30);
 252                 Assert (d + v3, new MyType (35), "#3");
 253                 dynamic d3 = new MyType (-7);
 254                 Assert<MyType> (d3 + new MyType (6), new MyType (-1), "#3a");
 255                 Assert (d3 + 11, 4, "#3b");
 256
 257                 decimal v4 = 4m;
 258                 Assert (d + v4, 9m, "#4");
 259         }
 260
 261         void AddNullableTest ()
 262         {
 263                 dynamic d = 5;
 264
 265                 int? v2 = null;
 266                 Assert<int?> (d + v2, null, "#1");
 267                 Assert<int?> (d + null, null, "#1a");
 268                 Assert<int?> (null + d, null, "#1b");
 269
 270                 v2 = -2;
 271                 Assert (d + v2, 3, "#2");
 272                 dynamic d2 = (int?) -2;
 273                 Assert (d2 + 1, -1, "#2a");
 274
 275                 MyType? v3 = new MyType (30);
 276                 Assert (d + v3, new MyType (35), "#3");
 277                 dynamic d3 = new MyType? (new MyType (-7));
 278                 Assert (d3 + new MyType (6), new MyType (-1), "#3a");
 279                 Assert<MyType?> (d3 + null, null, "#3b");
 280
 281                 decimal? v4 = 4m;
 282                 Assert (d + v4, 9m, "#4");
 283                 v4 = null;
 284                 Assert<decimal?> (d + v4, null, "#4a");
 285         }
 286
 287         void AddEnumTest ()
 288         {
 289                 dynamic d = MyEnum.Value_1;
 290
 291                 // CSC: Invalid System.InvalidOperationException
 292                 Assert (d + null, null, "#1");
 293
 294                 Assert (d + 1, MyEnum.Value_2, "#2");
 295
 296                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
 297                 Assert (d2 + (byte) 1, MyEnumUlong.Value_2, "#3");
 298                 Assert<MyEnumUlong?> (d2 + (object) null, null, "#3a");
 299         }
 300
 301         void AddCheckedTest ()
 302         {
 303                 checked {
 304                         dynamic d = 5;
 305
 306                         int v = int.MaxValue;
 307                         AssertChecked (() => d + v, 7, "#1");
 308
 309                         int? v2 = v;
 310                         AssertChecked (() => d + v2, null, "#2");
 311
 312                         MyType v3 = new MyType (int.MaxValue);
 313                         AssertChecked (() => d + v3, new MyType (35), "#3");
 314                 }
 315         }
 316
 317         void AddStringTest ()
 318         {
 319                 dynamic d = "foo";
 320                 string v = "->";
 321                 Assert (d + v, "foo->", "#1");
 322                 Assert (d + 1, "foo1", "#1a");
 323                 Assert (d + null, "foo", "#1b");
 324                 Assert (d + 1 + v, "foo1->", "#1a");
 325
 326                 uint? v2 = 4;
 327                 Assert (d + v2, "foo4", "#2");
 328         }
 329
 330         void AddAssignTest ()
 331         {
 332                 dynamic d = 5;
 333
 334                 int v = 2;
 335                 d += v;
 336                 Assert (d, 7, "#1");
 337
 338                 d = 5.0;
 339                 double v2 = 0.5;
 340                 d += v2;
 341                 Assert (d, 5.5, "#1a");
 342                 d += v;
 343                 Assert (d, 7.5, "#1b");
 344
 345                 dynamic d3 = new MyType (-7);
 346                 d3 += new MyType (6);
 347                 Assert<MyType> (d3, new MyType (-1), "#3");
 348
 349                 d = 5m;
 350                 decimal v4 = 4m;
 351                 d += v4;
 352                 Assert (d, 9m, "#4");
 353         }
 354
 355         void AddAssignNullableTest ()
 356         {
 357                 dynamic d = (int?) 5;
 358
 359                 // FEATURE
 360                 // For now it's impossible to use nullable compound assignment
 361                 // due to the way how DLR works. GetType () on nullable object returns
 362                 // underlying type and not nullable type, that means that
 363                 // C# binder is initialized with wrong operand type and any operation
 364                 // fails to resolve
 365 /*
 366                 long? v2 = null;
 367                 d += v2;
 368                 Assert<int?> (d, null, "#1");
 369                 d += null;
 370                 Assert<int?> (d, null, "#1a");
 371
 372                 long? l = (long?) 3;
 373                 d = l;
 374                 v2 = -2;
 375                 d += v2;
 376                 Assert (d, 3, "#2");
 377                 d = (int?) -2;
 378                 d += 1;
 379                 Assert (d, -1, "#2a");
 380
 381                 MyType? v3 = new MyType (30);
 382                 d += v3;
 383                 Assert (d, new MyType (35), "#3");
 384                 dynamic d3 = new MyType? (new MyType (-7));
 385                 Assert (d3 + new MyType (6), new MyType (-1), "#3a");
 386                 Assert<MyType?> (d3 + null, null, "#3b");
 387
 388                 decimal? v4 = 4m;
 389                 d = 2m;
 390                 d += v4;
 391                 Assert (d, 9m, "#4");
 392                 d += null;
 393                 Assert<decimal?> (d, null, "#4a");
 394  */
 395         }
 396
 397         void AddAssignEnumTest ()
 398         {
 399                 dynamic d = MyEnum.Value_1;
 400
 401                 d = MyEnum.Value_1;
 402                 d += 1;
 403                 Assert (d, MyEnum.Value_2, "#2");
 404
 405                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
 406                 d2 += (byte) 1;
 407                 Assert (d2, MyEnumUlong.Value_2, "#3");
 408         }
 409
 410         void AddAssignCheckedTest ()
 411         {
 412                 checked {
 413                         dynamic d = 5;
 414
 415                         int v = int.MaxValue;
 416                         AssertChecked (() => { d += v; Assert (d, 0, "#1-"); }, "#1");
 417
 418                         MyType v3 = new MyType (int.MaxValue);
 419                         AssertChecked (() => { d += v3; Assert (d, 0, "#3-"); }, "#3");
 420                 }
 421         }
 422
 423         void AddAssignStringTest ()
 424         {
 425                 dynamic d = "foo";
 426                 string v = "->";
 427                 d += v;
 428                 Assert (d, "foo->", "#1");
 429
 430                 d = "foo";
 431                 d += 1;
 432                 Assert (d, "foo1", "#1a");
 433
 434                 d += null;
 435                 Assert (d, "foo1", "#1b");
 436
 437                 uint? v2 = 4;
 438                 d = "foo";
 439                 d += v2;
 440                 Assert (d, "foo4", "#2");
 441         }
 442
 443         // TODO:
 444         void AddAssignmentEvent ()
 445         {
 446                 // IMPLEMENT
 447         }
 448
 449         void AndTest ()
 450         {
 451                 dynamic d = true;
 452
 453                 var v = false;
 454                 Assert (d & v, false, "#1");
 455                 Assert (d & true, true, "#1a");
 456
 457                 d = 42;
 458                 var v2 = 62;
 459                 Assert (d & v2, 42, "#2");
 460                 Assert (d & 0, 0, "#2a");
 461
 462                 MyType v3 = new MyType (30);
 463                 Assert (d & v3, new MyType (10), "#3");
 464                 dynamic d3 = new MyType (-7);
 465                 Assert<MyType> (d3 & new MyType (6), new MyType (0), "#3a");
 466                 Assert (d3 & 11, 9, "#3b");
 467         }
 468
 469         void AndTestEnum ()
 470         {
 471                 dynamic d = MyEnum.Value_1;
 472
 473                 Assert<MyEnum?> (d & null, null, "#1");
 474
 475                 Assert (d & d, MyEnum.Value_1, "#2");
 476
 477                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
 478                 Assert<MyEnumUlong> (d2 & MyEnumUlong.Value_2, 0, "#3");
 479         }
 480
 481         void AndTestNullable ()
 482         {
 483                 dynamic d = 5;
 484
 485                 int? v2 = null;
 486                 Assert<int?> (d & v2, null, "#1");
 487                 Assert<int?> (d & null, null, "#1a");
 488                 Assert<int?> (null & d, null, "#1b");
 489
 490                 v2 = -2;
 491                 Assert (d & v2, 4, "#2");
 492                 dynamic d2 = (int?) -2;
 493                 Assert (d2 & 1, 0, "#2a");
 494
 495                 MyType? v3 = new MyType (30);
 496                 Assert (d & v3, new MyType (4), "#3");
 497                 dynamic d3 = new MyType? (new MyType (-7));
 498                 Assert (d3 & new MyType (6), new MyType (0), "#3a");
 499                 Assert<MyType?> (d3 + null, null, "#3b");
 500         }
 501
 502         void AndAssignedTest ()
 503         {
 504                 dynamic d = true;
 505
 506                 var v = false;
 507                 d &= v;
 508                 Assert (d, false, "#1");
 509                 d = true;
 510                 d &= true;
 511                 Assert (d, true, "#1a");
 512
 513                 d = 42;
 514                 var v2 = 62;
 515                 d &= v2;
 516                 Assert (d, 42, "#2");
 517
 518                 MyType v3 = new MyType (30);
 519                 dynamic d3 = new MyType (-7);
 520                 d3 &= new MyType (6);
 521                 Assert<MyType> (d3, new MyType (0), "#3");
 522         }
 523
 524         void AndAssignedTestEnum ()
 525         {
 526                 dynamic d = MyEnum.Value_1;
 527                 d &= MyEnum.Value_2;
 528                 Assert<MyEnum>(d, 0, "#1");
 529
 530                 d = MyEnum.Value_2;
 531                 d &= d;
 532                 Assert (d, MyEnum.Value_2, "#2");
 533
 534                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
 535                 Assert<MyEnumUlong> (d2 & MyEnumUlong.Value_2, 0, "#3");
 536         }
 537
 538         void AndAlsoTest ()
 539         {
 540                 dynamic d = true;
 541
 542                 var v = false;
 543                 Assert<bool> (d && v, false, "#1");
 544
 545                 Assert (d && true, true, "#1a");
 546
 547                 d = true;
 548                 Assert (d && d, true, "#2");
 549
 550                 dynamic d3 = new MyType (-7);
 551                 Assert<MyType> (d3 && new MyType (6), new MyType (0), "#3");
 552
 553                 // This should not compile
 554                 Assert (d3 && 11, 9, "#3b");
 555         }
 556
 557         void DivideTest ()
 558         {
 559                 dynamic d = 5;
 560
 561                 int v = 2;
 562                 Assert (d / v, 2, "#1");
 563
 564                 MyType v3 = new MyType (30);
 565                 Assert (d / v3, new MyType (0), "#3");
 566                 dynamic d3 = new MyType (-7);
 567                 Assert<MyType> (d3 + new MyType (6), new MyType (-1), "#3a");
 568                 Assert (d3 / 11, 0, "#3b");
 569
 570                 decimal v4 = 4m;
 571                 Assert (d / v4, 1.25m, "#4");
 572         }
 573
 574         void DivideNullableTest ()
 575         {
 576                 dynamic d = 5;
 577
 578                 double? v2 = null;
 579                 Assert<double?> (d / v2, null, "#1");
 580                 Assert<double?> (d / null, null, "#1a");
 581                 Assert<double?> (null / d, null, "#1b");
 582
 583                 v2 = -2;
 584                 Assert (d / v2, -2.5, "#2");
 585                 dynamic d2 = (int?) -2;
 586                 Assert (d2 / 1, -2, "#2a");
 587
 588                 MyType? v3 = new MyType (30);
 589                 Assert (d / v3, new MyType (0), "#3");
 590                 dynamic d3 = new MyType? (new MyType (-7));
 591                 Assert (d3 / new MyType (6), new MyType (-1), "#3a");
 592                 Assert<MyType?> (d3 + null, null, "#3b");
 593
 594                 decimal? v4 = 4m;
 595                 Assert (d / v4, 1.25m, "#4");
 596                 v4 = null;
 597                 Assert<decimal?> (d / v4, null, "#4a");
 598         }
 599
 600         void DivideCheckedTest ()
 601         {
 602                 checked {
 603                         // TODO:
 604                 }
 605         }
 606
 607         void DivideAssignTest ()
 608         {
 609                 dynamic d = 5;
 610
 611                 int v = 2;
 612                 d /= v;
 613                 Assert (d, 2, "#1");
 614
 615                 d = 5.0;
 616                 double v2 = 0.5;
 617                 d /= v2;
 618                 Assert (d, 10, "#1a");
 619                 d /= v;
 620                 Assert (d, 5, "#1b");
 621
 622                 dynamic d3 = new MyType (-7);
 623                 d3 /= new MyType (6);
 624                 Assert<MyType> (d3, new MyType (-1), "#3");
 625
 626                 d = 5m;
 627                 decimal v4 = 4m;
 628                 d /= v4;
 629                 Assert (d, 1.25m, "#4");
 630         }
 631
 632         void DivideAssignCheckedTest ()
 633         {
 634                 checked {
 635                         // TODO:
 636                 }
 637         }
 638
 639         void EqualTest ()
 640         {
 641                 dynamic d = 5;
 642
 643                 int v = 2;
 644                 Assert (d == v, false, "#1");
 645                 double v2 = 5;
 646                 Assert (d == v2, true, "#1a");
 647
 648                 d = true;
 649                 Assert (d == false, false, "#2");
 650                 bool b2 = true;
 651                 Assert (d == b2, true, "#2a");
 652
 653                 d = new MyType (30);
 654                 MyType v3 = new MyType (30);
 655                 Assert (d == v3, true, "#3");
 656                 dynamic d3 = new MyType (-7);
 657                 Assert (d3 == new MyType (6), false, "#3a");
 658                 Assert (d3 == 11, false, "#3b");
 659
 660                 d = 2m;
 661                 decimal v4 = 4m;
 662                 Assert (d == v4, false, "#4");
 663                 Assert (d == 2m, true, "#4a");
 664
 665                 d = null;
 666                 Assert (d == null, true, "#5");
 667         }
 668
 669         void EqualNullableTest ()
 670         {
 671                 dynamic d = 5;
 672
 673                 int? v2 = null;
 674                 Assert (d == v2, false, "#1");
 675                 Assert (d == null, false, "#1a");
 676                 Assert (null == d, false, "#1b");
 677
 678                 v2 = -2;
 679                 Assert (d == v2, false, "#2");
 680                 dynamic d2 = (int?) -2;
 681                 Assert (d2 == 1, false, "#2a");
 682                 d2 = (uint?) 44;
 683                 Assert (d2 == 44, true, "#2b");
 684
 685                 d = new MyType (30);
 686                 MyType? v3 = new MyType (30);
 687                 Assert (d == v3, true, "#3");
 688                 dynamic d3 = new MyType? (new MyType (-7));
 689                 Assert (d3 == new MyType (6), false, "#3a");
 690                 Assert (d3 == null, false, "#3b");
 691
 692                 d = 4.1m;
 693                 decimal? v4 = 4m;
 694                 Assert (d == v4, false, "#4");
 695                 v4 = null;
 696                 Assert (d == v4, false, "#4a");
 697
 698                 d = (bool?) true;
 699                 Assert (d == true, true, "#5");
 700                 Assert (d == null, false, "#5a");
 701                 Assert (d == false, false, "#5b");
 702         }
 703
 704         void EqualEnumTest ()
 705         {
 706                 dynamic d = MyEnum.Value_1;
 707
 708                 Assert (d == null, false, "#1");
 709
 710                 Assert (d == MyEnum.Value_1, true, "#2");
 711                 Assert (d == 0, false, "#2a");
 712
 713                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
 714                 Assert (d2 == MyEnumUlong.Value_2, true, "#3");
 715                 Assert (d2 == null, false, "#3a");
 716         }
 717
 718         void EqualStringTest ()
 719         {
 720                 dynamic d = "text";
 721
 722                 Assert (d == "te", false, "#1");
 723                 Assert (d == "text", true, "#1a");
 724                 Assert (d == null, false, "#1b");
 725         }
 726
 727         void EqualDelegateTest ()
 728         {
 729                 dynamic d = this;
 730
 731 //              Assert (d == delegate { }, true, "#1");
 732
 733                 EmptyDelegate b = EqualDelegateTest;
 734                 d = b;
 735
 736                 //Assert (d == EqualDelegateTest, true, "#2");
 737
 738 /*
 739
 740         void EqualTestDelegate_2 ()
 741         {
 742                 EmptyDelegate ed = delegate () {};
 743
 744                 Expression<Func<EmptyDelegate, EmptyDelegate, bool>> e2 = (a, b) => a == b;
 745                 AssertNodeType (e2, ExpressionType.Equal);
 746                 Assert (false, e2.Compile ().Invoke (delegate () {}, null));
 747                 Assert (false, e2.Compile ().Invoke (delegate () {}, delegate {}));
 748                 Assert (false, e2.Compile ().Invoke (ed, delegate {}));
 749                 Assert (true, e2.Compile ().Invoke (ed, ed));
 750 */
 751         }
 752
 753         void ExclusiveOrTest ()
 754         {
 755                 dynamic d = true;
 756
 757                 var v = false;
 758                 Assert (d ^ v, true, "#1");
 759                 Assert (d ^ true, false, "#1a");
 760
 761                 d = 42;
 762                 var v2 = 62;
 763                 Assert (d ^ v2, 20, "#2");
 764                 Assert (d ^ 0, 42, "#2a");
 765
 766                 MyType v3 = new MyType (30);
 767                 Assert (d ^ v3, new MyType (52), "#3");
 768                 dynamic d3 = new MyType (-7);
 769                 Assert<MyType> (d3 ^ new MyType (6), new MyType (-1), "#3a");
 770                 Assert (d3 ^ 11, -14, "#3b");
 771         }
 772
 773         void ExclusiveOrNullableTest ()
 774         {
 775                 dynamic d = 5;
 776
 777                 int? v2 = null;
 778                 Assert<int?> (d ^ v2, null, "#1");
 779                 Assert<int?> (d ^ null, null, "#1a");
 780                 Assert<int?> (null ^ d, null, "#1b");
 781
 782                 v2 = -2;
 783                 Assert (d ^ v2, -5, "#2");
 784                 dynamic d2 = (int?) -2;
 785                 Assert (d2 ^ 1, -1, "#2a");
 786
 787                 MyType? v3 = new MyType (30);
 788                 Assert (d ^ v3, new MyType (27), "#3");
 789                 dynamic d3 = new MyType? (new MyType (-7));
 790                 Assert (d3 ^ new MyType (6), new MyType (-1), "#3a");
 791                 Assert<MyType?> (d3 ^ null, null, "#3b");
 792         }
 793
 794         void ExclusiveOrTestEnum ()
 795         {
 796                 dynamic d = MyEnum.Value_1;
 797
 798                 Assert<MyEnum?> (d ^ null, null, "#1");
 799
 800                 Assert<MyEnum> (d ^ d, 0, "#2");
 801
 802                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
 803                 Assert<MyEnumUlong> (d2 ^ MyEnumUlong.Value_2, (MyEnumUlong) 3, "#3");
 804         }
 805
 806         void ExclusiveOrAssignedTest ()
 807         {
 808                 dynamic d = true;
 809
 810                 var v = false;
 811                 d ^= v;
 812                 Assert (d, true, "#1");
 813                 d = true;
 814                 d ^= true;
 815                 Assert (d, false, "#1a");
 816
 817                 d = 42;
 818                 var v2 = 62;
 819                 d ^= v2;
 820                 Assert (d, 20, "#2");
 821
 822                 MyType v3 = new MyType (30);
 823                 dynamic d3 = new MyType (-7);
 824                 d3 ^= new MyType (6);
 825                 Assert (d3, new MyType (-1), "#3");
 826         }
 827
 828         void ExclusiveOrAssignedTestEnum ()
 829         {
 830                 dynamic d = MyEnum.Value_1;
 831                 d ^= MyEnum.Value_2;
 832                 Assert<MyEnum>(d, (MyEnum) 3, "#1");
 833
 834                 d = MyEnum.Value_2;
 835                 d ^= d;
 836                 Assert<MyEnum> (d, 0, "#2");
 837
 838                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
 839                 Assert (d2 ^ MyEnumUlong.Value_2, (MyEnumUlong)3, "#3");
 840         }
 841
 842         void GreaterThanTest ()
 843         {
 844                 dynamic d = 5;
 845
 846                 int v = 2;
 847                 Assert (d > v, true, "#1");
 848                 double v2 = 5;
 849                 Assert (d > v2, false, "#1a");
 850
 851                 d = 4.6;
 852                 Assert (d > 4.59, true, "#2");
 853                 var b2 = 4.6;
 854                 Assert (d > b2, false, "#2a");
 855
 856                 d = new MyType (30);
 857                 MyType v3 = new MyType (30);
 858                 Assert (d > v3, false, "#3");
 859                 dynamic d3 = new MyType (-7);
 860                 Assert (d3 > new MyType (6), false, "#3a");
 861                 Assert (d3 > 11, false, "#3b");
 862
 863                 d = 2m;
 864                 decimal v4 = 4m;
 865                 Assert (d > v4, false, "#4");
 866                 Assert (d > 2m, false, "#4a");
 867         }
 868
 869         void GreaterThanNullableTest ()
 870         {
 871                 dynamic d = 5;
 872
 873                 int? v2 = null;
 874                 Assert (d > v2, false, "#1");
 875                 Assert (d > null, false, "#1a");
 876                 Assert (null > d, false, "#1b");
 877
 878                 v2 = -2;
 879                 Assert (d > v2, true, "#2");
 880                 dynamic d2 = (int?) -2;
 881                 Assert (d2 > 1, false, "#2a");
 882                 d2 = (uint?) 44;
 883                 Assert (d2 > 44, false, "#2b");
 884
 885                 d = new MyType (30);
 886                 MyType? v3 = new MyType (30);
 887                 Assert (d > v3, false, "#3");
 888                 dynamic d3 = new MyType? (new MyType (-7));
 889                 Assert (d3 > new MyType (6), false, "#3a");
 890                 Assert (d3 > null, false, "#3b");
 891
 892                 d = 4.1m;
 893                 decimal? v4 = 4m;
 894                 Assert (d > v4, true, "#4");
 895                 v4 = null;
 896                 Assert (d > v4, false, "#4a");
 897         }
 898
 899         void GreaterThanEnumTest ()
 900         {
 901                 dynamic d = MyEnum.Value_1;
 902
 903                 Assert (d > null, false, "#1");
 904
 905                 Assert (d > MyEnum.Value_1, false, "#2");
 906                 Assert (d > 0, true, "#2a");
 907
 908                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
 909                 Assert (d2 > MyEnumUlong.Value_2, false, "#3");
 910                 Assert (d2 > null, false, "#3a");
 911         }
 912
 913         void GreaterThanEqualTest ()
 914         {
 915                 dynamic d = 5;
 916
 917                 int v = 2;
 918                 Assert (d >= v, true, "#1");
 919                 double v2 = 5;
 920                 Assert (d >= v2, true, "#1a");
 921
 922                 d = 4.6;
 923                 Assert (d >= 4.59, true, "#2");
 924                 var b2 = 4.6;
 925                 Assert (d >= b2, true, "#2a");
 926
 927                 d = new MyType (30);
 928                 MyType v3 = new MyType (30);
 929                 Assert (d >= v3, true, "#3");
 930                 dynamic d3 = new MyType (-7);
 931                 Assert (d3 >= new MyType (6), false, "#3a");
 932                 Assert (d3 >= 11, false, "#3b");
 933
 934                 d = 2m;
 935                 decimal v4 = 4m;
 936                 Assert (d >= v4, false, "#4");
 937                 Assert (d >= 2m, true, "#4a");
 938         }
 939
 940         void GreaterThanEqualNullableTest ()
 941         {
 942                 dynamic d = 5;
 943
 944                 int? v2 = null;
 945                 Assert (d >= v2, false, "#1");
 946                 Assert (d >= null, false, "#1a");
 947                 Assert (null >= d, false, "#1b");
 948
 949                 v2 = -2;
 950                 Assert (d >= v2, true, "#2");
 951                 dynamic d2 = (int?) -2;
 952                 Assert (d2 >= 1, false, "#2a");
 953                 d2 = (uint?) 44;
 954                 Assert (d2 >= 44, true, "#2b");
 955
 956                 d = new MyType (30);
 957                 MyType? v3 = new MyType (30);
 958                 Assert (d >= v3, true, "#3");
 959                 dynamic d3 = new MyType? (new MyType (-7));
 960                 Assert (d3 >= new MyType (6), false, "#3a");
 961                 Assert (d3 >= null, false, "#3b");
 962
 963                 d = 4.1m;
 964                 decimal? v4 = 4m;
 965                 Assert (d >= v4, true, "#4");
 966                 v4 = null;
 967                 Assert (d >= v4, false, "#4a");
 968         }
 969
 970         void GreaterThanEqualEnumTest ()
 971         {
 972                 dynamic d = MyEnum.Value_1;
 973
 974                 Assert (d >= null, false, "#1");
 975
 976                 Assert (d >= MyEnum.Value_1, true, "#2");
 977                 Assert (d >= 0, true, "#2a");
 978
 979                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
 980                 Assert (d2 >= MyEnumUlong.Value_2, true, "#3");
 981                 Assert (d2 >= null, false, "#3a");
 982         }
 983
 984         void LeftShiftTest ()
 985         {
 986                 dynamic d = (ulong) 0x7F000;
 987
 988                 int v = 2;
 989                 Assert<ulong> (d << v, 0x1FC000, "#1");
 990                 Assert<ulong> (d << 1, 0xFE000, "#1a");
 991                 short s = 2;
 992                 Assert<ulong> (d << s, 0x1FC000, "#1b");
 993
 994                 d = 0x7F000;
 995                 MyType v3 = new MyType (3);
 996                 Assert (d << v3, new MyType (0x3F8000), "#3");
 997                 dynamic d3 = new MyType (-7);
 998                 Assert (d3 << new MyType (6), new MyType (-448), "#3a");
 999                 Assert (d3 << 11, -14336, "#3b");
1000         }
1001
1002         void LeftShiftNullableTest ()
1003         {
1004                 dynamic d = 5;
1005
1006                 int? v2 = null;
1007                 Assert<int?> (d << v2, null, "#1");
1008                 d = 5;
1009                 Assert<int?> (d << null, null, "#1a");
1010                 d = 5;
1011                 Assert<int?> (null << d, null, "#1b");
1012
1013                 v2 = -2;
1014                 Assert (d << v2, 0x40000000, "#2");
1015                 dynamic d2 = (int?) -2;
1016                 Assert (d2 << 1, -4, "#2a");
1017
1018                 d = 0xFFFFFF;
1019                 MyType? v3 = new MyType (30);
1020                 Assert (d << v3, new MyType (-1073741824), "#3");
1021                 dynamic d3 = new MyType? (new MyType (-7));
1022                 Assert (d3 << new MyType (6), new MyType (-448), "#3a");
1023                 Assert<MyType?> (d3 << null, null, "#3b");
1024         }
1025
1026         void LeftShiftAssignTest ()
1027         {
1028                 dynamic d = 0x7F000;
1029
1030                 int v = 2;
1031                 d <<= v;
1032                 Assert (d, 0x1FC000, "#1");
1033                 d <<= 1;
1034                 Assert (d, 0x3F8000, "#1a");
1035                 sbyte s = 2;
1036                 d <<= s;
1037                 Assert (d, 0xFE0000, "#1b");
1038         }
1039
1040         void LeftShiftAssignNullableTest ()
1041         {
1042                 dynamic d = 5;
1043
1044                 var v2 = -2;
1045                 d <<= v2;
1046                 Assert (d, 0x40000000, "#2");
1047                 dynamic d2 = (int?) -2;
1048                 d2 <<= 1;
1049                 Assert (d2, -4, "#2a");
1050
1051                 d = 0xFFFFFF;
1052                 MyType? v3 = new MyType (30);
1053                 d <<= v3;
1054                 Assert (d, new MyType (-1073741824), "#3");
1055                 dynamic d3 = new MyType? (new MyType (-7));
1056         }
1057
1058         void LessThanTest ()
1059         {
1060                 dynamic d = 5;
1061
1062                 int v = 2;
1063                 Assert (d < v, false, "#1");
1064                 double v2 = 5;
1065                 Assert (d < v2, false, "#1a");
1066
1067                 d = 4.6;
1068                 Assert (d < 4.59, false, "#2");
1069                 var b2 = 4.6;
1070                 Assert (d < b2, false, "#2a");
1071
1072                 d = new MyType (30);
1073                 MyType v3 = new MyType (30);
1074                 Assert (d < v3, false, "#3");
1075                 dynamic d3 = new MyType (-7);
1076                 Assert (d3 < new MyType (6), true, "#3a");
1077                 Assert (d3 < 11, true, "#3b");
1078
1079                 d = 2m;
1080                 decimal v4 = 4m;
1081                 Assert (d < v4, true, "#4");
1082                 Assert (d < 2m, false, "#4a");
1083         }
1084
1085         void LessThanNullableTest ()
1086         {
1087                 dynamic d = 5;
1088
1089                 int? v2 = null;
1090                 Assert (d < v2, false, "#1");
1091                 Assert (d < null, false, "#1a");
1092                 Assert (null < d, false, "#1b");
1093
1094                 v2 = -2;
1095                 Assert (d < v2, false, "#2");
1096                 dynamic d2 = (int?) -2;
1097                 Assert (d2 < 1, true, "#2a");
1098                 d2 = (uint?) 44;
1099                 Assert (d2 < 44, false, "#2b");
1100
1101                 d = new MyType (30);
1102                 MyType? v3 = new MyType (30);
1103                 Assert (d < v3, false, "#3");
1104                 dynamic d3 = new MyType? (new MyType (-7));
1105                 Assert (d3 < new MyType (6), true, "#3a");
1106                 Assert (d3 < null, false, "#3b");
1107
1108                 d = 4.1m;
1109                 decimal? v4 = 4m;
1110                 Assert (d < v4, false, "#4");
1111                 v4 = null;
1112                 Assert (d < v4, false, "#4a");
1113         }
1114
1115         void LessThanEnumTest ()
1116         {
1117                 dynamic d = MyEnum.Value_1;
1118
1119                 Assert (d < null, false, "#1");
1120
1121                 Assert (d < MyEnum.Value_1, false, "#2");
1122                 Assert (d < 0, false, "#2a");
1123
1124                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
1125                 Assert (d2 < MyEnumUlong.Value_2, false, "#3");
1126                 Assert (d2 < null, false, "#3a");
1127         }
1128
1129         void LessThanOrEqualTest ()
1130         {
1131                 dynamic d = 5;
1132
1133                 int v = 2;
1134                 Assert (d <= v, false, "#1");
1135                 double v2 = 5;
1136                 Assert (d <= v2, true, "#1a");
1137
1138                 d = 4.6;
1139                 Assert (d <= 4.59, false, "#2");
1140                 var b2 = 4.6;
1141                 Assert (d <= b2, true, "#2a");
1142
1143                 d = new MyType (30);
1144                 MyType v3 = new MyType (30);
1145                 Assert (d <= v3, true, "#3");
1146                 dynamic d3 = new MyType (-7);
1147                 Assert (d3 <= new MyType (6), true, "#3a");
1148                 Assert (d3 <= 11, true, "#3b");
1149
1150                 d = 2m;
1151                 decimal v4 = 4m;
1152                 Assert (d <= v4, true, "#4");
1153                 Assert (d <= 2m, true, "#4a");
1154         }
1155
1156         void LessThanOrEqualNullableTest ()
1157         {
1158                 dynamic d = 5;
1159
1160                 int? v2 = null;
1161                 Assert (d <= v2, false, "#1");
1162                 Assert (d <= null, false, "#1a");
1163                 Assert (null <= d, false, "#1b");
1164
1165                 v2 = -2;
1166                 Assert (d <= v2, false, "#2");
1167                 dynamic d2 = (int?) -2;
1168                 Assert (d2 <= 1, true, "#2a");
1169                 d2 = (uint?) 44;
1170                 Assert (d2 <= 44, true, "#2b");
1171
1172                 d = new MyType (30);
1173                 MyType? v3 = new MyType (30);
1174                 Assert (d <= v3, true, "#3");
1175                 dynamic d3 = new MyType? (new MyType (-7));
1176                 Assert (d3 <= new MyType (6), true, "#3a");
1177                 Assert (d3 <= null, false, "#3b");
1178
1179                 d = 4.1m;
1180                 decimal? v4 = 4m;
1181                 Assert (d <= v4, false, "#4");
1182                 v4 = null;
1183                 Assert (d <= v4, false, "#4a");
1184         }
1185
1186         void LessThanOrEqualEnumTest ()
1187         {
1188                 dynamic d = MyEnum.Value_1;
1189
1190                 Assert (d <= null, false, "#1");
1191
1192                 Assert (d <= MyEnum.Value_1, true, "#2");
1193                 Assert (d <= 0, false, "#2a");
1194
1195                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
1196                 Assert (d2 <= MyEnumUlong.Value_2, true, "#3");
1197                 Assert (d2 <= null, false, "#3a");
1198         }
1199
1200         void ModuloTest ()
1201         {
1202                 dynamic d = 5;
1203
1204                 int v = 2;
1205                 Assert (d % v, 1, "#1");
1206
1207                 MyType v3 = new MyType (30);
1208                 Assert (d % v3, new MyType (5), "#3");
1209                 dynamic d3 = new MyType (-7);
1210                 Assert<MyType> (d3 + new MyType (6), new MyType (-1), "#3a");
1211                 Assert (d3 % 11, -7, "#3b");
1212
1213                 decimal v4 = 4m;
1214                 Assert (d % v4, 1m, "#4");
1215         }
1216
1217         void ModuloNullableTest ()
1218         {
1219                 dynamic d = 5;
1220
1221                 double? v2 = null;
1222                 Assert<double?> (d % v2, null, "#1");
1223                 Assert<double?> (d % null, null, "#1a");
1224                 Assert<double?> (null % d, null, "#1b");
1225
1226                 v2 = -2;
1227                 Assert (d % v2, 1, "#2");
1228                 dynamic d2 = (int?) -2;
1229                 Assert (d2 % 1, 0, "#2a");
1230
1231                 MyType? v3 = new MyType (30);
1232                 Assert (d % v3, new MyType (5), "#3");
1233                 dynamic d3 = new MyType? (new MyType (-7));
1234                 Assert (d3 % new MyType (6), new MyType (-1), "#3a");
1235                 Assert<MyType?> (d3 + null, null, "#3b");
1236
1237                 decimal? v4 = 4m;
1238                 Assert (d % v4, 1m, "#4");
1239                 v4 = null;
1240                 Assert<decimal?> (d % v4, null, "#4a");
1241         }
1242
1243         void ModuloAssignTest ()
1244         {
1245                 dynamic d = 5;
1246
1247                 int v = 2;
1248                 d %= v;
1249                 Assert (d, 1, "#1");
1250
1251                 d = 5.0;
1252                 double v2 = 0.5;
1253                 d %= v2;
1254                 Assert (d, 0, "#1a");
1255                 d %= v;
1256                 Assert (d, 0, "#1b");
1257
1258                 dynamic d3 = new MyType (-7);
1259                 d3 %= new MyType (6);
1260                 Assert<MyType> (d3, new MyType (-1), "#3");
1261
1262                 d = 5m;
1263                 decimal v4 = 4m;
1264                 d %= v4;
1265                 Assert (d, 1m, "#4");
1266         }
1267
1268         void MultiplyTest ()
1269         {
1270                 dynamic d = 5;
1271
1272                 int v = 2;
1273                 Assert (d * v, 10, "#1");
1274                 double v2 = 0.5;
1275                 Assert (d * v2, 2.5, "#1a");
1276
1277                 MyType v3 = new MyType (30);
1278                 Assert (d * v3, new MyType (150), "#3");
1279                 dynamic d3 = new MyType (-7);
1280                 Assert<MyType> (d3 * new MyType (6), new MyType (-42), "#3a");
1281                 Assert (d3 * 11, -77, "#3b");
1282
1283                 decimal v4 = 4m;
1284                 d = 7.9m;
1285                 Assert (d * v4, 31.6m, "#4");
1286         }
1287
1288         void MultiplyNullableTest ()
1289         {
1290                 dynamic d = 5;
1291
1292                 int? v2 = null;
1293                 Assert<int?> (d * v2, null, "#1");
1294                 Assert<int?> (d * null, null, "#1a");
1295                 Assert<int?> (null * d, null, "#1b");
1296
1297                 v2 = -2;
1298                 Assert (d * v2, -10, "#2");
1299                 dynamic d2 = (int?) -2;
1300                 Assert (d2 * 1, -2, "#2a");
1301
1302                 MyType? v3 = new MyType (30);
1303                 Assert (d * v3, new MyType (150), "#3");
1304                 dynamic d3 = new MyType? (new MyType (-7));
1305                 Assert (d3 * new MyType (6), new MyType (-42), "#3a");
1306                 Assert<MyType?> (d3 * null, null, "#3b");
1307
1308                 decimal? v4 = 4m;
1309                 Assert (d * v4, 20m, "#4");
1310                 v4 = null;
1311                 Assert<decimal?> (d * v4, null, "#4a");
1312         }
1313
1314         void MultiplyCheckedTest ()
1315         {
1316                 checked {
1317                         dynamic d = 5;
1318
1319                         int v = int.MaxValue;
1320                         AssertChecked (() => d * v, 7, "#1");
1321
1322                         int? v2 = v;
1323                         AssertChecked (() => d * v2, null, "#2");
1324
1325                         MyType v3 = new MyType (int.MaxValue);
1326                         AssertChecked (() => d * v3, new MyType (35), "#3");
1327                 }
1328         }
1329
1330         void MultiplyAssignTest ()
1331         {
1332                 dynamic d = 5;
1333
1334                 int v = 2;
1335                 d *= v;
1336                 Assert (d, 10, "#1");
1337
1338                 d = 5.0;
1339                 double v2 = 0.5;
1340                 d *= v2;
1341                 Assert (d, 2.5, "#1a");
1342                 d *= v;
1343                 Assert (d, 5, "#1b");
1344
1345                 dynamic d3 = new MyType (-7);
1346                 d3 *= new MyType (6);
1347                 Assert<MyType> (d3, new MyType (-42), "#3");
1348
1349                 d = 5m;
1350                 decimal v4 = 4m;
1351                 d *= v4;
1352                 Assert (d, 20m, "#4");
1353         }
1354
1355         void MultiplyAssignCheckedTest ()
1356         {
1357                 checked {
1358                         dynamic d = 5;
1359
1360                         int v = int.MaxValue;
1361                         AssertChecked (() => { d *= v; Assert (d, 0, "#1-"); }, "#1");
1362
1363                         MyType v3 = new MyType (int.MaxValue);
1364                         AssertChecked (() => { d *= v3; Assert (d, 0, "#3-"); }, "#3");
1365                 }
1366         }
1367
1368         void NotEqualTest ()
1369         {
1370                 dynamic d = 5;
1371
1372                 int v = 2;
1373                 Assert (d != v, true, "#1");
1374                 double v2 = 5;
1375                 Assert (d != v2, false, "#1a");
1376
1377                 d = true;
1378                 Assert (d != false, true, "#2");
1379                 bool b2 = true;
1380                 Assert (d != b2, false, "#2a");
1381
1382                 d = new MyType (30);
1383                 MyType v3 = new MyType (30);
1384                 Assert (d != v3, false, "#3");
1385                 dynamic d3 = new MyType (-7);
1386                 Assert (d3 != new MyType (6), true, "#3a");
1387                 Assert (d3 != 11, true, "#3b");
1388
1389                 d = 2m;
1390                 decimal v4 = 4m;
1391                 Assert (d != v4, true, "#4");
1392                 Assert (d != 2m, false, "#4a");
1393
1394                 d = null;
1395                 Assert (d != null, false, "#5");
1396         }
1397
1398         void NotEqualNullableTest ()
1399         {
1400                 dynamic d = 5;
1401
1402                 int? v2 = null;
1403                 Assert (d != v2, true, "#1");
1404                 Assert (d != null, true, "#1a");
1405                 Assert (null != d, true, "#1b");
1406
1407                 v2 = -2;
1408                 Assert (d != v2, true, "#2");
1409                 dynamic d2 = (int?) -2;
1410                 Assert (d2 != 1, true, "#2a");
1411                 d2 = (uint?) 44;
1412                 Assert (d2 != 44, false, "#2b");
1413
1414                 d = new MyType (30);
1415                 MyType? v3 = new MyType (30);
1416                 Assert (d != v3, false, "#3");
1417                 dynamic d3 = new MyType? (new MyType (-7));
1418                 Assert (d3 != new MyType (6), true, "#3a");
1419                 Assert (d3 != null, true, "#3b");
1420
1421                 d = 4.1m;
1422                 decimal? v4 = 4m;
1423                 Assert (d != v4, true, "#4");
1424                 v4 = null;
1425                 Assert (d != v4, true, "#4a");
1426
1427                 d = (bool?) true;
1428                 Assert (d != true, false, "#5");
1429                 Assert (d != null, true, "#5a");
1430                 Assert (d != false, true, "#5b");
1431         }
1432
1433         void NotEqualEnumTest ()
1434         {
1435                 dynamic d = MyEnum.Value_1;
1436
1437                 Assert (d != null, true, "#1");
1438
1439                 Assert (d != MyEnum.Value_1, false, "#2");
1440                 Assert (d != 0, true, "#2a");
1441
1442                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
1443                 Assert (d2 != MyEnumUlong.Value_2, false, "#3");
1444                 Assert (d2 != null, true, "#3a");
1445         }
1446
1447         void NotEqualStringTest ()
1448         {
1449                 dynamic d = "text";
1450
1451                 Assert (d != "te", true, "#1");
1452                 Assert (d != "text", false, "#1a");
1453                 Assert (d != null, true, "#1b");
1454         }
1455
1456         void OrTest ()
1457         {
1458                 dynamic d = true;
1459
1460                 var v = false;
1461                 Assert (d | v, true, "#1");
1462                 Assert (d | false, true, "#1a");
1463
1464                 d = 42;
1465                 var v2 = 62;
1466                 Assert (d | v2, 62, "#2");
1467                 Assert (d | 0, 42, "#2a");
1468
1469                 MyType v3 = new MyType (30);
1470                 Assert (d | v3, new MyType (62), "#3");
1471                 dynamic d3 = new MyType (-7);
1472                 Assert<MyType> (d3 | new MyType (6), new MyType (-1), "#3a");
1473                 Assert (d3 | 11, -5, "#3b");
1474         }
1475
1476         void OrTestEnum ()
1477         {
1478                 dynamic d = MyEnum.Value_1;
1479
1480                 Assert<MyEnum?> (d | null, null, "#1");
1481
1482                 Assert (d | d, MyEnum.Value_1, "#2");
1483
1484                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
1485                 Assert<MyEnumUlong> (d2 | MyEnumUlong.Value_2, (MyEnumUlong) 3, "#3");
1486         }
1487
1488         void OrTestNullable ()
1489         {
1490                 dynamic d = 5;
1491
1492                 int? v2 = null;
1493                 Assert<int?> (d | v2, null, "#1");
1494                 Assert<int?> (d | null, null, "#1a");
1495                 Assert<int?> (null | d, null, "#1b");
1496
1497                 v2 = -2;
1498                 Assert (d | v2, -1, "#2");
1499                 dynamic d2 = (int?) -2;
1500                 Assert (d2 | 1, -1, "#2a");
1501
1502                 MyType? v3 = new MyType (30);
1503                 Assert (d | v3, new MyType (31), "#3");
1504                 dynamic d3 = new MyType? (new MyType (-7));
1505                 Assert (d3 | new MyType (6), new MyType (-1), "#3a");
1506                 Assert<MyType?> (d3 + null, null, "#3b");
1507         }
1508
1509         void OrAssignedTest ()
1510         {
1511                 dynamic d = true;
1512
1513                 var v = false;
1514                 d |= v;
1515                 Assert (d, true, "#1");
1516                 d = true;
1517                 d |= true;
1518                 Assert (d, true, "#1a");
1519
1520                 d = 42;
1521                 var v2 = 62;
1522                 d |= v2;
1523                 Assert (d, 62, "#2");
1524
1525                 MyType v3 = new MyType (30);
1526                 dynamic d3 = new MyType (-7);
1527                 d3 |= new MyType (6);
1528                 Assert<MyType> (d3, new MyType (-1), "#3");
1529         }
1530
1531         void OrAssignedTestEnum ()
1532         {
1533                 dynamic d = MyEnum.Value_1;
1534                 d |= MyEnum.Value_2;
1535                 Assert<MyEnum> (d, (MyEnum) 3, "#1");
1536
1537                 d = MyEnum.Value_2;
1538                 d |= d;
1539                 Assert (d, MyEnum.Value_2, "#2");
1540
1541                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
1542                 Assert<MyEnumUlong> (d2 | MyEnumUlong.Value_2, (MyEnumUlong)3, "#3");
1543         }
1544
1545         void OrElseTest ()
1546         {
1547                 dynamic d = true;
1548
1549                 var v = false;
1550                 Assert<bool> (d || v, true, "#1");
1551
1552                 Assert (d || true, true, "#1a");
1553
1554                 d = true;
1555                 Assert (d || d, true, "#2");
1556
1557                 dynamic d3 = new MyType (-7);
1558                 Assert<MyType> (d3 || new MyType (6), new MyType (-7), "#3");
1559
1560                 Assert (d3 || 11, -7, "#3b");
1561         }
1562
1563         void RightShiftTest ()
1564         {
1565                 dynamic d = (ulong) 0x7F000;
1566
1567                 int v = 2;
1568                 Assert<ulong> (d >> v, 0x1FC00, "#1");
1569                 Assert<ulong> (d >> 1, 0x3F800, "#1a");
1570                 short s = 2;
1571                 Assert<ulong> (d >> s, 0x1FC00, "#1b");
1572
1573                 d = 0x7F000;
1574                 MyType v3 = new MyType (3);
1575                 Assert (d >> v3, new MyType (0xFE00), "#3");
1576                 dynamic d3 = new MyType (-7);
1577                 Assert (d3 >> new MyType (6), new MyType (-1), "#3a");
1578                 Assert (d3 >> 11, -1, "#3b");
1579         }
1580
1581         void RightShiftNullableTest ()
1582         {
1583                 dynamic d = 5;
1584
1585                 int? v2 = null;
1586                 Assert<int?> (d >> v2, null, "#1");
1587                 d = 5;
1588                 Assert<int?> (d >> null, null, "#1a");
1589                 d = 5;
1590                 Assert<int?> (null >> d, null, "#1b");
1591
1592                 v2 = -2;
1593                 Assert (d >> v2, 0, "#2");
1594                 dynamic d2 = (int?) -200;
1595                 Assert (d2 >> 1, -100, "#2a");
1596
1597                 d = 0xFFFFFF;
1598                 MyType? v3 = new MyType (3);
1599                 Assert (d >> v3, new MyType (0x1FFFFF), "#3");
1600                 dynamic d3 = new MyType? (new MyType (-7));
1601                 Assert (d3 >> new MyType (6), new MyType (-1), "#3a");
1602                 Assert<MyType?> (d3 >> null, null, "#3b");
1603         }
1604
1605         void RightShiftAssignTest ()
1606         {
1607                 dynamic d = 0x7F000;
1608
1609                 int v = 2;
1610                 d >>= v;
1611                 Assert (d, 0x1FC00, "#1");
1612                 d >>= 1;
1613                 Assert (d, 0xFE00, "#1a");
1614                 sbyte s = 2;
1615                 d >>= s;
1616                 Assert (d, 0x3F80, "#1b");
1617         }
1618
1619         void RightShiftAssignNullableTest ()
1620         {
1621                 dynamic d = 0x2A0;
1622
1623                 var v2 = -2;
1624                 d >>= v2;
1625                 Assert (d, 0, "#2");
1626                 dynamic d2 = (int?) -2;
1627                 d2 >>= 1;
1628                 Assert (d2, -1, "#2a");
1629
1630                 d = 0xFFFFFF;
1631                 MyType? v3 = new MyType (3);
1632                 d >>= v3;
1633                 Assert (d, new MyType (0x1FFFFF), "#3");
1634         }
1635
1636         void SubtractTest ()
1637         {
1638                 dynamic d = 5;
1639
1640                 int v = 2;
1641                 Assert (d - v, 3, "#1");
1642                 double v2 = 0.5;
1643                 Assert (d - v2, 4.5, "#1a");
1644
1645                 MyType v3 = new MyType (30);
1646                 Assert (d - v3, new MyType (-25), "#3");
1647                 dynamic d3 = new MyType (-7);
1648                 Assert<MyType> (d3 - new MyType (6), new MyType (-13), "#3a");
1649                 Assert (d3 - 11, -18, "#3b");
1650
1651                 decimal v4 = 4m;
1652                 Assert (d - v4, 1m, "#4");
1653         }
1654
1655         void SubtractNullableTest ()
1656         {
1657                 dynamic d = 5;
1658
1659                 int? v2 = null;
1660                 Assert<int?> (d - v2, null, "#1");
1661                 Assert<int?> (d - null, null, "#1a");
1662                 Assert<int?> (null - d, null, "#1b");
1663
1664                 v2 = -2;
1665                 Assert (d - v2, 7, "#2");
1666                 dynamic d2 = (int?) -2;
1667                 Assert (d2 - 1, -3, "#2a");
1668
1669                 MyType? v3 = new MyType (30);
1670                 Assert (d - v3, new MyType (-25), "#3");
1671                 dynamic d3 = new MyType? (new MyType (-7));
1672                 Assert (d3 - new MyType (6), new MyType (-13), "#3a");
1673                 Assert<MyType?> (d3 - null, null, "#3b");
1674
1675                 decimal? v4 = 4m;
1676                 Assert (d - v4, 1m, "#4");
1677                 v4 = null;
1678                 Assert<decimal?> (d - v4, null, "#4a");
1679         }
1680
1681         void SubtractEnumTest ()
1682         {
1683                 dynamic d = MyEnum.Value_1;
1684
1685                 // CSC: Invalid System.InvalidOperationException
1686                 Assert (d - null, null, "#1");
1687
1688                 Assert (d - 1, MyEnum.Value_2, "#2");
1689
1690                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_1;
1691                 Assert (d2 - (byte) 1, MyEnumUlong.Value_2, "#3");
1692                 Assert<MyEnumUlong?> (d2 - (object) null, null, "#3a");
1693         }
1694
1695         void SubtractCheckedTest ()
1696         {
1697                 checked {
1698                         dynamic d = 5;
1699
1700                         int v = int.MinValue;
1701                         AssertChecked (() => d - v, 7, "#1");
1702
1703                         int? v2 = v;
1704                         AssertChecked (() => d - v2, null, "#2");
1705
1706                         MyType v3 = new MyType (int.MinValue);
1707                         AssertChecked (() => d - v3, new MyType (35), "#3");
1708                 }
1709         }
1710
1711         void SubtractAssignTest ()
1712         {
1713                 dynamic d = 5;
1714
1715                 int v = 2;
1716                 d -= v;
1717                 Assert (d, 3, "#1");
1718
1719                 d = 5.0;
1720                 double v2 = 0.5;
1721                 d -= v2;
1722                 Assert (d, 4.5, "#1a");
1723                 d -= v;
1724                 Assert (d, 2.5, "#1b");
1725
1726                 dynamic d3 = new MyType (-7);
1727                 d3 -= new MyType (6);
1728                 Assert<MyType> (d3, new MyType (-13), "#3");
1729
1730                 d = 5m;
1731                 decimal v4 = 4m;
1732                 d -= v4;
1733                 Assert (d, 1m, "#4");
1734         }
1735
1736         void SubtractAssignEnumTest ()
1737         {
1738                 dynamic d = MyEnum.Value_1;
1739
1740                 d -= 1;
1741                 Assert<MyEnum> (d, 0, "#2");
1742
1743                 dynamic d2 = (MyEnumUlong?) MyEnumUlong.Value_2;
1744                 d2 -= (byte) 1;
1745                 Assert (d2, MyEnumUlong.Value_1, "#3");
1746         }
1747
1748         void SubtractAssignCheckedTest ()
1749         {
1750                 checked {
1751                         dynamic d = 5;
1752
1753                         int v = int.MinValue;
1754                         AssertChecked (() => { d -= v; Assert (d, 0, "#1a"); }, "#1");
1755
1756                         MyType v3 = new MyType (int.MinValue);
1757                         AssertChecked (() => { d -= v3; Assert (d, 0, "#3a"); }, "#3");
1758                 }
1759         }
1760
1761         // TODO:
1762         void SubtractAssignmentEvent ()
1763         {
1764                 // IMPLEMENT
1765         }
1766
1767 #pragma warning restore 169
1768
1769         static bool RunTest (MethodInfo test)
1770         {
1771                 Console.Write ("Running test {0, -25}", test.Name);
1772                 try {
1773                         test.Invoke (new Tester (), null);
1774                         Console.WriteLine ("OK");
1775                         return true;
1776                 } catch (Exception e) {
1777                         Console.WriteLine ("FAILED");
1778                         Console.WriteLine (e.InnerException.Message);
1779                         return false;
1780                 }
1781         }
1782
1783         public static int Main ()
1784         {
1785                 var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
1786                                         where test.GetParameters ().Length == 0
1787                                         orderby test.Name
1788                                         select RunTest (test);
1789
1790                 int failures = tests.Count (a => !a);
1791                 Console.WriteLine (failures + " tests failed");
1792                 return failures;
1793         }
1794 }
1795