mcs/tests/test-async-13.cs

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