mcs/tests/test-async-13.cs

   1 // Compiler options: -langversion:future
   2
   3 using System;
   4 using System.Threading.Tasks;
   5 using System.Threading;
   6 using System.Reflection;
   7 using System.Linq;
   8
   9 struct S
  10 {
  11         public int Value;
  12
  13         public S (int a1, string a2)
  14         {
  15                 Value = a1;
  16         }
  17
  18         public void SetValue (int value)
  19         {
  20                 Value = value;
  21         }
  22
  23         public static implicit operator S (Base b)
  24         {
  25                 return new S (400, "a");
  26         }
  27
  28         public static S operator + (S a, S b)
  29         {
  30                 return new S () {
  31                         Value = a.Value + b.Value
  32                 };
  33         }
  34 }
  35
  36 enum E
  37 {
  38         E_1 = 1
  39 }
  40
  41 class Base
  42 {
  43         public volatile int field_int;
  44         protected int field_this;
  45         protected int property_this_counter;
  46
  47         public event Action Event;
  48
  49         public Base ()
  50         {
  51         }
  52
  53         public Base (int arg, int arg2)
  54         {
  55                 field_int = arg;
  56         }
  57
  58         public bool PropertyBool {
  59                 get {
  60                         return true;
  61                 }
  62         }
  63
  64         public int PropertyInt {
  65                 get {
  66                         return field_int;
  67                 }
  68                 set {
  69                         field_int += value;
  70                 }
  71         }
  72
  73         protected Base PropertyThis {
  74                 get {
  75                         ++property_this_counter;
  76                         return this;
  77                 }
  78         }
  79
  80         public int this [int arg] {
  81                 get {
  82                         return field_this;
  83                 }
  84                 set {
  85                         field_this += value * arg;
  86                 }
  87         }
  88
  89         public static bool operator true (Base a)
  90         {
  91                 return true;
  92         }
  93
  94         public static bool operator false (Base a)
  95         {
  96                 return false;
  97         }
  98
  99         public static Base operator & (Base a, Base b)
 100         {
 101                 return new Base () {
 102                         field_int = 100
 103                 };
 104         }
 105
 106         public static Base operator | (Base a, Base b)
 107         {
 108                 return new Base () {
 109                         field_int = 200
 110                 };
 111         }
 112
 113         protected int Call (int arg1, int arg2, int arg3)
 114         {
 115                 if (arg1 != 5)
 116                         return 1;
 117
 118                 if (arg2 != -3)
 119                         return 2;
 120
 121                 if (arg3 != 6)
 122                         return 3;
 123
 124                 return 0;
 125         }
 126
 127         protected int Call(ref char ch, int arg)
 128         {
 129                 ch = 'z';
 130                 return arg;
 131         }
 132
 133         public void CallBool (bool b)
 134         {
 135         }
 136
 137         public int CallS (S s)
 138         {
 139                 return s.Value;
 140         }
 141
 142         public T[] CreateArray<T> (int size)
 143         {
 144                 return new T [size];
 145         }
 146
 147         protected static void CallRefParams (ref int i, params int[] i2)
 148         {
 149                 i = 5;
 150         }
 151
 152         protected int CallNamed (int a, int b)
 153         {
 154                 return a - b;
 155         }
 156
 157         protected void CallEvent ()
 158         {
 159                 Event ();
 160         }
 161 }
 162
 163 class Tester : Base
 164 {
 165         async Task<bool> ArrayAccessTest_1 ()
 166         {
 167                 bool[] b = new bool[1];
 168                 b [0] = await Task.Factory.StartNew (() => true);
 169                 return b[await Task.Factory.StartNew (() => 0)];
 170         }
 171
 172         async Task<int> ArrayAccessTest_2 ()
 173         {
 174                 double[] b = new double[2];
 175                 b [await Task.Factory.StartNew (() => 1)] = 5.5;
 176                 if (b [1] != 5.5)
 177                         return 1;
 178
 179                 var d = b [await Task.Factory.StartNew (() => 1)] = 2.5;
 180                 if (b [1] != 2.5)
 181                         return 2;
 182
 183                 if (d != 2.5)
 184                         return 3;
 185
 186                 d = b [await Task.Factory.StartNew (() => 1)] = await Task.Factory.StartNew (() => 4.4);
 187                 if (d != 4.4)
 188                         return 4;
 189
 190                 return 0;
 191         }
 192
 193         async Task<int> ArrayAccessTest_3 ()
 194         {
 195                 decimal[] d = new decimal [4];
 196                 d[1] = 4;
 197
 198                 var r = ++d[await Task.Factory.StartNew (() => 1)];
 199                 if (r != 5)
 200                         return 1;
 201
 202                 d [1] = 6;
 203                 d [await Task.Factory.StartNew (() => 1)] += await Task.Factory.StartNew (() => 9.9m);
 204                 if (d [1] != 15.9m)
 205                         return 2;
 206
 207                 d [1] = 6;
 208                 r =  d [await Task.Factory.StartNew (() => 1)] -= await Task.Factory.StartNew (() => 5.9m);
 209                 if (d [1] != 0.1m)
 210                         return 3;
 211
 212                 return 0;
 213         }
 214
 215         async Task<bool> ArrayAccessTest_4 ()
 216         {
 217                 string[] s = new string [4];
 218                 s[1] = "a";
 219
 220                 s [await Task.Factory.StartNew (() => 1)] += await Task.Factory.StartNew (() => "b");
 221                 return s [1] == "ab";
 222         }
 223
 224         async Task<bool> ArrayAccessTest_5 ()
 225         {
 226                 int[][] a = new int[3][];
 227                 a [1] = new int [5];
 228                 int index = 1;
 229                 CallRefParams (ref a[await Task.Factory.StartNew (() => index++)][0], await Task.Factory.StartNew (() => 3));
 230                 return a [1][0] == 5;
 231         }
 232
 233         async Task<int> ArrayAccessTest_6 ()
 234         {
 235                 int value = -6;
 236                 int[] a = new int[3] { 3, 6, 9 };
 237                 return a [await Task.Factory.StartNew (() => (long)1)] + value;
 238         }
 239
 240         async Task<bool> ArrayAccessTest_7 ()
 241         {
 242                 short?[] s = new short?[] { 3, 2, 1 };
 243                 var r = s [await Task.Factory.StartNew (() => 1)]++;
 244                 return r == 2;
 245         }
 246
 247         async Task<int> ArrayAccessTest_8 ()
 248         {
 249                 var s = new byte?[] { 3, 2, 1 };
 250                 var r = s [await Task.Factory.StartNew (() => 1)] += await Task.Factory.StartNew (() => (byte)30);
 251                 if (r != 32)
 252                         return 1;
 253
 254                 if (s [1] != 32)
 255                         return 2;
 256
 257                 return 0;
 258         }
 259
 260         async Task<int> ArrayAccessTest_9 ()
 261         {
 262                 var s = new Base ();
 263                 s.CreateArray<int> (await Task.Factory.StartNew (() => 5)) [2] += 9;
 264                 s.CreateArray<int> (await Task.Factory.StartNew (() => 5)) [2] += await Task.Factory.StartNew (() => 9);
 265
 266                 var res = s.CreateArray<int> (await Task.Factory.StartNew (() => 5)) [2] += await Task.Factory.StartNew (() => 9);
 267                 if (res != 9)
 268                         return 1;
 269
 270                 s.CreateArray<S> (await Task.Factory.StartNew (() => 5)) [2] += await Task.Factory.StartNew (() => new S () { Value = 4 });
 271                 return 0;
 272         }
 273
 274         async Task<int> AssignTest_1 ()
 275         {
 276                 field_int = await Task.Factory.StartNew (() => 0);
 277                 return field_int;
 278         }
 279
 280         async Task<bool> AssignTest_2 ()
 281         {
 282                 long? l = await Task.Factory.StartNew<sbyte?> (() => null);
 283                 return l == null;
 284         }
 285
 286         async Task<int> AssignTest_3 ()
 287         {
 288                 int a = await Task.Factory.StartNew (() => 1), b = await Task.Factory.StartNew (() => 2);
 289                 if (a != 1)
 290                         return 1;
 291                 if (b != 2)
 292                         return b;
 293
 294                 return 0;
 295         }
 296
 297         async Task<int> BinaryTest_1 ()
 298         {
 299                 return await Task.Factory.StartNew (() => { Thread.Sleep (10); return 5; }) +
 300                         await Task.Factory.StartNew (() => -3) +
 301                         await Task.Factory.StartNew (() => -2);
 302         }
 303
 304         async Task<int> BinaryTest_2 ()
 305         {
 306                 int i = 1;
 307                 var b = await Task.Factory.StartNew (() => { i += 3; return true; }) &&
 308                         await Task.Factory.StartNew (() => { i += 4; return false; }) &&
 309                         await Task.Factory.StartNew (() => { i += 5; return true; });
 310
 311                 return b ? -1 : i == 8 ? 0 : i;
 312         }
 313
 314         async Task<int> BinaryTest_3 ()
 315         {
 316                 var r = await Task.Factory.StartNew<bool?> (() => true) & await Task.Factory.StartNew<bool?> (() => null);
 317                 if (r != null)
 318                         return 1;
 319
 320                 r = await Task.Factory.StartNew<bool?> (() => null) | await Task.Factory.StartNew<bool?> (() => true);
 321                 if (r != true)
 322                         return 2;
 323
 324                 r = await Task.Factory.StartNew<bool?> (() => null) != await Task.Factory.StartNew<bool?> (() => true);
 325                 if (r != true)
 326                         return 3;
 327
 328                 return 0;
 329         }
 330
 331         async Task<int> BinaryTest_4 ()
 332         {
 333                 var r1 = await Task.Factory.StartNew<short?> (() => 2) * await Task.Factory.StartNew<byte?> (() => null);
 334                 if (r1 != null)
 335                         return 1;
 336
 337                 var r2 = await Task.Factory.StartNew<decimal?> (() => 100) / await Task.Factory.StartNew<decimal?> (() => null);
 338                 if (r2 != null)
 339                         return 2;
 340
 341                 return 0;
 342         }
 343
 344         async Task<int> CallTest_1 ()
 345         {
 346                 return Call (
 347                         await Task.Factory.StartNew (() => { Thread.Sleep (10); return 5; }),
 348                         await Task.Factory.StartNew (() => -3),
 349                         await Task.Factory.StartNew (() => 6));
 350         }
 351
 352         async Task<bool> CallTest_2 ()
 353         {
 354                 char ch = 'a';
 355                 var r = Call (
 356                         ref ch,
 357                         await Task.Factory.StartNew (() => { Thread.Sleep (10); return 5; }));
 358
 359                 return ch == 'z' && r == 5;
 360         }
 361
 362         async Task<int> CallTest_3 ()
 363         {
 364                 S s = new S ();
 365                 s.SetValue (await Task.Factory.StartNew (() => 10));
 366                 return s.Value - 10;
 367         }
 368
 369         async Task<bool> CallTest_4 ()
 370         {
 371                 return E.E_1.Equals (unchecked (await Task.Factory.StartNew (() => E.E_1)));
 372         }
 373
 374         async Task<int> CallTest_5 ()
 375         {
 376                 int value = 9;
 377                 return CallNamed (
 378                         b: await Task.Factory.StartNew (() => value++),
 379                         a: value) - 1;
 380         }
 381
 382         async Task<bool> CastTest_1 ()
 383         {
 384                 decimal value = 67;
 385                 return (value - await Task.Factory.StartNew (() => 66m)) == 1;
 386         }
 387
 388         async Task<bool> CastTest_2 ()
 389         {
 390                 var t = new Tester ();
 391                 return t.CallS (await Task.Factory.StartNew (() => this)) == 400;
 392         }
 393
 394         async Task<bool> CoalescingTest_1 ()
 395         {
 396                 var r = await Task.Factory.StartNew<string> (() => null)  ?? await Task.Factory.StartNew (() => "x");
 397                 return r == "x";
 398         }
 399
 400         async Task<bool> CoalescingTest_2 ()
 401         {
 402                 var r = await Task.Factory.StartNew<short?> (() => null)  ?? await Task.Factory.StartNew<byte> (() => 2);
 403                 return r == 2;
 404         }
 405
 406         async Task<int> ConditionalTest_1 ()
 407         {
 408                 // TODO: problem with Resumable point setup when the expression never emitted
 409                 //bool b = true;
 410                 //return true ? await Task.Factory.StartNew (() => 0) : await Task.Factory.StartNew (() => 1);
 411                 return 0;
 412         }
 413
 414         async Task<int> ConditionalTest_2 ()
 415         {
 416                 return PropertyBool ? await Task.Factory.StartNew (() => 0) : await Task.Factory.StartNew (() => 1);
 417         }
 418
 419         async Task<int> ConditionalTest_3 ()
 420         {
 421                 int v = 5;
 422                 return v * (await Task.Factory.StartNew (() => true) ? 0 : await Task.Factory.StartNew (() => 1));
 423         }
 424
 425         async Task<int> ConditionalTest_4 ()
 426         {
 427                 int v = 5;
 428                 return v * (v == 2 ? 3 : await Task.Factory.StartNew (() => 0));
 429         }
 430
 431         async Task<int> DelegateInvoke_4 ()
 432         {
 433                 Func<int, int> d = l => l - 3;
 434                 int value = 1;
 435                 return value + d (await Task.Factory.StartNew (() => 2));
 436         }
 437
 438         async Task<int> EventInvoke_1 ()
 439         {
 440                 int value = 0;
 441                 Event += await Task.Factory.StartNew (() => {
 442                         Action a = () => { value = 5; };
 443                         return a;
 444                 });
 445
 446                 CallEvent ();
 447                 return value - 5;
 448         }
 449
 450         async Task<int> FieldTest_1 ()
 451         {
 452                 var s = new Base ();
 453                 s.field_int = 3;
 454                 s.field_int += await Task.Factory.StartNew (() => 6);
 455                 if (s.field_int != 9)
 456                         return 1;
 457
 458                 var r = s.field_int -= await Task.Factory.StartNew (() => 5);
 459                 if (r != 4)
 460                         return 2;
 461
 462                 if (s.field_int != 4)
 463                         return 3;
 464                 return 0;
 465         }
 466
 467         async Task<bool> IndexerTest_1 ()
 468         {
 469                 this[2] = await Task.Factory.StartNew (() => 6);
 470                 return this[2] == 12;
 471         }
 472
 473         async Task<bool> IndexerTest_2 ()
 474         {
 475                 this[await Task.Factory.StartNew (() => 3)] = await Task.Factory.StartNew (() => 6);
 476                 return this[3] == 18;
 477         }
 478
 479         async Task<int> IndexerTest_3 ()
 480         {
 481                 int value = -5;
 482                 this[await Task.Factory.StartNew (() => value++)] += await Task.Factory.StartNew (() => 5);
 483                 return this[3] + 25;
 484         }
 485
 486         async Task<int> IndexerTest_4 ()
 487         {
 488                 int value = 3;
 489                 PropertyThis[await Task.Factory.StartNew (() => value++)] += await Task.Factory.StartNew (() => -5);
 490                 return PropertyThis[3] + value + 11;
 491         }
 492
 493         async Task<int> IndexerTest_5 ()
 494         {
 495                 int value = 3;
 496                 field_this = 6;
 497                 int res = PropertyThis[await Task.Factory.StartNew (() => value++)]++;
 498                 if (res != 6)
 499                         return 1;
 500
 501                 if (PropertyThis[0] != 27)
 502                         return 2;
 503
 504                 return PropertyThis[5] -= await Task.Factory.StartNew (() => 27);
 505         }
 506
 507         async Task<int> IndexerTest_6 ()
 508         {
 509                 var r = this[3] = await Task.Factory.StartNew (() => 9);
 510                 if (r != 9)
 511                         return 1;
 512
 513                 var r2 = this[await Task.Factory.StartNew (() => 55)] = await Task.Factory.StartNew (() => 8);
 514
 515                 if (r2 != 8)
 516                         return 2;
 517
 518                 return 0;
 519         }
 520
 521         async Task<bool> IndexerTest_7 ()
 522         {
 523                 int value = -5;
 524                 var res = ++this[await Task.Factory.StartNew (() => value++)];
 525                 return res == 1;
 526         }
 527
 528         async Task<bool> IsTest_1 ()
 529         {
 530                 new Tester ().CallBool (await Task.Factory.StartNew (() => new Tester ()) is Base);
 531                 return true;
 532         }
 533
 534         async Task<bool> IsTest_2 ()
 535         {
 536                 var r = await Task.Factory.StartNew<uint?> (() => 1) is uint;
 537                 return r;
 538         }
 539
 540         async Task<bool> LogicalUserOperator_1 ()
 541         {
 542                 var r = await Task.Factory.StartNew (() => new Base ()) && await Task.Factory.StartNew (() => new Base ());
 543                 return r.field_int == 100;
 544         }
 545
 546         async Task<bool> LogicalUserOperator_2 ()
 547         {
 548                 var r = new Base () && await Task.Factory.StartNew (() => new Base ());
 549                 return r.field_int == 100;
 550         }
 551
 552         async Task<bool> LogicalUserOperator_3 ()
 553         {
 554                 var r = await Task.Factory.StartNew (() => new Base ()) || await Task.Factory.StartNew (() => new Base ());
 555                 return r.field_int == 0;
 556         }
 557
 558         async Task<bool> NewTest_1 ()
 559         {
 560                 int value = 9;
 561                 var b = new Base (value, await Task.Factory.StartNew (() => 33));
 562                 return b.field_int == 9;
 563         }
 564
 565         async Task<bool> NewTest_2 ()
 566         {
 567                 var s = new S (await Task.Factory.StartNew (() => 77), await Task.Factory.StartNew (() => "b"));
 568                 return s.Value == 77;
 569         }
 570
 571         async Task<int> NewInitTest_1 ()
 572         {
 573                 int value = 9;
 574
 575                 var b = new Base (value, await Task.Factory.StartNew (() => 33)) { };
 576                 if (b.field_int != 9)
 577                         return 1;
 578
 579                 b = new Base (value, await Task.Factory.StartNew (() => 11)) {
 580                         field_int = await Task.Factory.StartNew (() => 12),
 581                         PropertyInt = await Task.Factory.StartNew (() => 13)
 582                 };
 583
 584                 if (b.field_int != 25)
 585                         return 2;
 586
 587                 b = new Base () {
 588                         field_int = await Task.Factory.StartNew (() => 12),
 589                         PropertyInt = await Task.Factory.StartNew (() => 13)
 590                 };
 591
 592                 if (b.field_int != 25)
 593                         return 3;
 594
 595                 return 0;
 596         }
 597
 598         async Task<int> NewInitTest_2 ()
 599         {
 600                 int value = 9;
 601
 602                 var s = new S (value, await Task.Factory.StartNew (() => "x")) { };
 603                 if (s.Value != 9)
 604                         return 1;
 605
 606                 s = new S (value, await Task.Factory.StartNew (() => "y")) {
 607                         Value = await Task.Factory.StartNew (() => 12)
 608                 };
 609
 610                 if (s.Value != 12)
 611                         return 2;
 612
 613                 s = new S () {
 614                         Value = await Task.Factory.StartNew (() => 13)
 615                 };
 616
 617                 if (s.Value != 13)
 618                         return 3;
 619
 620                 return 0;
 621         }
 622
 623         async Task<bool> NewArrayInitTest_1 ()
 624         {
 625                 var a = new int[await Task.Factory.StartNew (() => 5)];
 626                 return a.Length == 5;
 627         }
 628
 629         async Task<bool> NewArrayInitTest_2 ()
 630         {
 631                 var a = new short[await Task.Factory.StartNew (() => 3), await Task.Factory.StartNew (() => 4)];
 632                 return a.Length == 12;
 633         }
 634
 635         async Task<int> NewArrayInitTest_3 ()
 636         {
 637                 var a = new byte[] { await Task.Factory.StartNew (() => (byte)5) };
 638                 return a [0] - 5;
 639         }
 640
 641         async Task<bool> NewArrayInitTest_4 ()
 642         {
 643                 var a = new ushort[,] {
 644                         { await Task.Factory.StartNew (() => (ushort) 5), 50 },
 645                         { 30, await Task.Factory.StartNew (() => (ushort) 3) }
 646                 };
 647
 648                 return a [0, 0] * a [1, 1] == 15;
 649         }
 650
 651         async Task<int> NewArrayInitTest_5 ()
 652         {
 653                 var a = new S[] { await Task.Factory.StartNew (() => new S () { Value = 4 }) };
 654                 return a [0].Value - 4;
 655         }
 656
 657         async Task<bool> NewArrayInitTest_6 ()
 658         {
 659                 var a = new int[] { 2, 3, 2, 3, 5, 6, 7, 2, 4, await Task.Factory.StartNew (() => 5), 11, 23, 45 };
 660                 return a.Length == 13;
 661         }
 662
 663         async Task<bool> PropertyTest_1 ()
 664         {
 665                 PropertyInt = await Task.Factory.StartNew (() => 6);
 666                 return PropertyInt == 6;
 667         }
 668
 669         async Task<int> PropertyTest_2 ()
 670         {
 671                 PropertyThis.PropertyInt += await Task.Factory.StartNew (() => 6);
 672                 if (property_this_counter != 1)
 673                         return 1;
 674
 675                 return PropertyInt - 6;
 676         }
 677
 678         async Task<int> PropertyTest_3 ()
 679         {
 680                 var r = PropertyThis.PropertyInt = await Task.Factory.StartNew (() => 9);
 681                 if (r != 9)
 682                         return 1;
 683
 684                 PropertyThis.PropertyInt = 4;
 685                 int[] a = new int[4];
 686                 a [await Task.Factory.StartNew (() => 1)] = PropertyThis.PropertyInt += await Task.Factory.StartNew (() => 8);
 687                 if (a[1] != 21)
 688                         return 2;
 689
 690                 if (PropertyThis.PropertyInt != 34)
 691                         return 3;
 692
 693                 return 0;
 694         }
 695
 696         async Task<bool> StringConcatTest_1 ()
 697         {
 698                 return (await Task.Factory.StartNew (() => "a") +
 699                         await Task.Factory.StartNew (() => "b") +
 700                         await Task.Factory.StartNew (() => (string) null) == "ab");
 701         }
 702
 703         async Task<bool> UnaryTest_1 ()
 704         {
 705                 long a = 1;
 706                 return (a + checked (-await Task.Factory.StartNew (() => 2))) == -1;
 707         }
 708
 709         async Task<bool> UnaryTest_2 ()
 710         {
 711                 short? s = 2;
 712                 int value = 2;
 713                 return (value * ~await Task.Factory.StartNew (() => s)) == -6;
 714         }
 715
 716         async Task<bool> UnaryTest_3 ()
 717         {
 718                 var d = new decimal? [2];
 719                 d[1] = 4;
 720                 var r = ++d[await Task.Factory.StartNew (() => 1)];
 721                 return r == 5;
 722         }
 723
 724         static bool RunTest (MethodInfo test)
 725         {
 726                 Console.Write ("Running test {0, -25}", test.Name);
 727                 try {
 728                         Task t = test.Invoke (new Tester (), null) as Task;
 729                         if (!Task.WaitAll (new[] { t }, 1000)) {
 730                                 Console.WriteLine ("FAILED (Timeout)");
 731                                 return false;
 732                         }
 733
 734                         var ti = t as Task<int>;
 735                         if (ti != null) {
 736                                 if (ti.Result != 0) {
 737                                         Console.WriteLine ("FAILED (Result={0})", ti.Result);
 738                                         return false;
 739                                 }
 740                         } else {
 741                                 var tb = t as Task<bool>;
 742                                 if (tb != null) {
 743                                         if (!tb.Result) {
 744                                                 Console.WriteLine ("FAILED (Result={0})", tb.Result);
 745                                                 return false;
 746                                         }
 747                                 }
 748                         }
 749
 750                         Console.WriteLine ("OK");
 751                         return true;
 752                 } catch (Exception e) {
 753                         Console.WriteLine ("FAILED");
 754                         Console.WriteLine (e.ToString ());
 755                         return false;
 756                 }
 757         }
 758
 759         public static int Main ()
 760         {
 761                 var tests = from test in typeof (Tester).GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)
 762                                         where test.GetParameters ().Length == 0
 763                                         orderby test.Name
 764                                         select RunTest (test);
 765
 766                 int failures = tests.Count (a => !a);
 767                 Console.WriteLine (failures + " tests failed");
 768                 return failures;
 769         }
 770 }