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