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