mcs/class/corlib/Test/System.Threading.Tasks/TaskTest.cs

   1 //
   2 // TaskTest.cs
   3 //
   4 // Authors:
   5 //      Marek Safar  <marek.safar@gmail.com>
   6 //
   7 // Copyright (c) 2008 Jérémie "Garuma" Laval
   8 // Copyright (C) 2011 Xamarin Inc (http://www.xamarin.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining a copy
  11 // of this software and associated documentation files (the "Software"), to deal
  12 // in the Software without restriction, including without limitation the rights
  13 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14 // copies of the Software, and to permit persons to whom the Software is
  15 // furnished to do so, subject to the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be included in
  18 // all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  26 // THE SOFTWARE.
  27 //
  28 //
  29
  30 #if NET_4_0
  31
  32 using System;
  33 using System.Threading;
  34 using System.Threading.Tasks;
  35 using System.Collections.Generic;
  36 using NUnit.Framework;
  37
  38 #if !MOBILE
  39 using NUnit.Framework.SyntaxHelpers;
  40 #endif
  41
  42 namespace MonoTests.System.Threading.Tasks
  43 {
  44         [TestFixture]
  45         public class TaskTests
  46         {
  47                 class MockScheduler : TaskScheduler
  48                 {
  49                         public event Action<Task, bool> TryExecuteTaskInlineHandler;
  50
  51                         protected override IEnumerable<Task> GetScheduledTasks ()
  52                         {
  53                                 throw new NotImplementedException ();
  54                         }
  55
  56                         protected override void QueueTask (Task task)
  57                         {
  58                                 return;
  59                         }
  60
  61                         protected override bool TryExecuteTaskInline (Task task, bool taskWasPreviouslyQueued)
  62                         {
  63                                 if (TryExecuteTaskInlineHandler != null)
  64                                         TryExecuteTaskInlineHandler (task, taskWasPreviouslyQueued);
  65
  66                                 return base.TryExecuteTask (task);
  67                         }
  68                 }
  69
  70                 class NonInlineableScheduler : TaskScheduler
  71                 {
  72                         protected override IEnumerable<Task> GetScheduledTasks ()
  73                         {
  74                                 throw new NotImplementedException ();
  75                         }
  76
  77                         protected override void QueueTask (Task task)
  78                         {
  79                                 if (!base.TryExecuteTask (task))
  80                                         throw new ApplicationException ();
  81                         }
  82
  83                         protected override bool TryExecuteTaskInline (Task task, bool taskWasPreviouslyQueued)
  84                         {
  85                                 return false;
  86                         }
  87                 }
  88
  89                 class ExceptionScheduler : TaskScheduler
  90                 {
  91                         protected override IEnumerable<Task> GetScheduledTasks ()
  92                         {
  93                                 throw new ApplicationException ("1");
  94                         }
  95
  96                         protected override void QueueTask (Task task)
  97                         {
  98                                 throw new ApplicationException ("2");
  99                         }
 100
 101                         protected override bool TryExecuteTaskInline (Task task, bool taskWasPreviouslyQueued)
 102                         {
 103                                 throw new ApplicationException ("3");
 104                         }
 105                 }
 106
 107                 int workerThreads;
 108                 int completionPortThreads;
 109
 110                 Task[] tasks;
 111                 const int max = 6;
 112
 113                 [SetUp]
 114                 public void Setup()
 115                 {
 116                         ThreadPool.GetMinThreads (out workerThreads, out completionPortThreads);
 117                         ThreadPool.SetMinThreads (1, 1);
 118
 119                         tasks = new Task[max];
 120                 }
 121
 122                 [TearDown]
 123                 public void Teardown()
 124                 {
 125                         ThreadPool.SetMinThreads (workerThreads, completionPortThreads);
 126                 }
 127
 128                 void InitWithDelegate(Action action)
 129                 {
 130                         for (int i = 0; i < max; i++) {
 131                                 tasks[i] = Task.Factory.StartNew(action);
 132                         }
 133                 }
 134
 135                 [Test]
 136                 public void WaitAnyTest()
 137                 {
 138                         ParallelTestHelper.Repeat (delegate {
 139                                 int flag = 0;
 140                                 int finished = 0;
 141
 142                                 InitWithDelegate(delegate {
 143                                         int times = Interlocked.Exchange (ref flag, 1);
 144                                         if (times == 1) {
 145                                                 SpinWait sw = new SpinWait ();
 146                                                 while (finished == 0) sw.SpinOnce ();
 147                                         } else {
 148                                                 Interlocked.Increment (ref finished);
 149                                         }
 150                                 });
 151
 152                                 int index = Task.WaitAny(tasks, 1000);
 153
 154                                 Assert.AreNotEqual (-1, index, "#3");
 155                                 Assert.AreEqual (1, flag, "#1");
 156                                 Assert.AreEqual (1, finished, "#2");
 157                         });
 158                 }
 159
 160                 [Test]
 161                 public void WaitAny_Empty ()
 162                 {
 163                         Assert.AreEqual (-1, Task.WaitAny (new Task[0]));
 164                 }
 165
 166                 [Test]
 167                 public void WaitAny_Zero ()
 168                 {
 169                         Assert.AreEqual (-1, Task.WaitAny (new[] { new Task (delegate { })}, 0), "#1");
 170                         Assert.AreEqual (-1, Task.WaitAny (new[] { new Task (delegate { }) }, 20), "#1");
 171                 }
 172
 173                 [Test]
 174                 public void WaitAny_Cancelled ()
 175                 {
 176                         var cancelation = new CancellationTokenSource ();
 177                         var tasks = new Task[] {
 178                                 new Task (delegate { }),
 179                                 new Task (delegate { }, cancelation.Token)
 180                         };
 181
 182                         cancelation.Cancel ();
 183
 184                         Assert.AreEqual (1, Task.WaitAny (tasks, 1000), "#1");
 185                         Assert.IsTrue (tasks[1].IsCompleted, "#2");
 186                         Assert.IsTrue (tasks[1].IsCanceled, "#3");
 187                 }
 188
 189                 [Test]
 190                 public void WaitAny_CancelledWithoutExecution ()
 191                 {
 192                         var cancelation = new CancellationTokenSource ();
 193                         var tasks = new Task[] {
 194                                 new Task (delegate { }),
 195                                 new Task (delegate { })
 196                         };
 197
 198                         int res = 0;
 199                         var mre = new ManualResetEventSlim (false);
 200                         ThreadPool.QueueUserWorkItem (delegate {
 201                                 res = Task.WaitAny (tasks, 20);
 202                                 mre.Set ();
 203                         });
 204
 205                         cancelation.Cancel ();
 206                         Assert.IsTrue (mre.Wait (1000), "#1");
 207                         Assert.AreEqual (-1, res);
 208                 }
 209
 210                 [Test]
 211                 public void WaitAny_OneException ()
 212                 {
 213                         var mre = new ManualResetEventSlim (false);
 214                         var tasks = new Task[] {
 215                                 Task.Factory.StartNew (delegate { mre.Wait (1000); }),
 216                                 Task.Factory.StartNew (delegate { throw new ApplicationException (); })
 217                         };
 218
 219                         Assert.AreEqual (1, Task.WaitAny (tasks, 1000), "#1");
 220                         Assert.IsFalse (tasks[0].IsCompleted, "#2");
 221                         Assert.IsTrue (tasks[1].IsFaulted, "#3");
 222
 223                         mre.Set ();
 224                 }
 225
 226                 [Test]
 227                 public void WaitAny_SingleCanceled ()
 228                 {
 229                         var src = new CancellationTokenSource ();
 230                         var t = Task.Factory.StartNew (() => { Thread.Sleep (200); src.Cancel (); src.Token.ThrowIfCancellationRequested (); }, src.Token);
 231                         Assert.AreEqual (0, Task.WaitAny (new [] { t }));
 232                 }
 233
 234                 public void WaitAny_ManyExceptions ()
 235                 {
 236                         CountdownEvent cde = new CountdownEvent (3);
 237                         var tasks = new [] {
 238                                 Task.Factory.StartNew (delegate { try { throw new ApplicationException (); } finally { cde.Signal (); } }),
 239                                 Task.Factory.StartNew (delegate { try { throw new ApplicationException (); } finally { cde.Signal (); } }),
 240                                 Task.Factory.StartNew (delegate { try { throw new ApplicationException (); } finally { cde.Signal (); } })
 241                         };
 242
 243                         Assert.IsTrue (cde.Wait (1000), "#1");
 244
 245                         try {
 246                                 Assert.IsTrue (Task.WaitAll (tasks, 1000), "#2");
 247                         } catch (AggregateException e) {
 248                                 Assert.AreEqual (3, e.InnerExceptions.Count, "#3");
 249                         }
 250                 }
 251
 252                 [Test]
 253                 public void WaitAny_ManyCanceled ()
 254                 {
 255                         var cancellation = new CancellationToken (true);
 256                         var tasks = new[] {
 257                                 Task.Factory.StartNew (delegate { }, cancellation),
 258                                 Task.Factory.StartNew (delegate { }, cancellation),
 259                                 Task.Factory.StartNew (delegate { }, cancellation)
 260                         };
 261
 262                         try {
 263                                 Assert.IsTrue (Task.WaitAll (tasks, 1000), "#1");
 264                         } catch (AggregateException e) {
 265                                 Assert.AreEqual (3, e.InnerExceptions.Count, "#2");
 266                         }
 267                 }
 268
 269                 [Test]
 270                 public void WaitAllTest ()
 271                 {
 272                         ParallelTestHelper.Repeat (delegate {
 273                                 int achieved = 0;
 274                                 InitWithDelegate(delegate { Interlocked.Increment(ref achieved); });
 275                                 Task.WaitAll(tasks);
 276                                 Assert.AreEqual(max, achieved, "#1");
 277                         });
 278                 }
 279
 280                 [Test]
 281                 public void WaitAll_ManyTasks ()
 282                 {
 283                         for (int r = 0; r < 2000; ++r) {
 284                                 var tasks = new Task[60];
 285
 286                                 for (int i = 0; i < tasks.Length; i++) {
 287                                         tasks[i] = Task.Factory.StartNew (delegate { Thread.Sleep (0); });
 288                                 }
 289
 290                                 Assert.IsTrue (Task.WaitAll (tasks, 5000));
 291                         }
 292                 }
 293
 294                 [Test]
 295                 public void WaitAll_Zero ()
 296                 {
 297                         Assert.IsFalse (Task.WaitAll (new Task[1] { new Task (delegate { }) }, 0), "#0");
 298                         Assert.IsFalse (Task.WaitAll (new Task[1] { new Task (delegate { }) }, 10), "#1");
 299                 }
 300
 301                 [Test]
 302                 public void WaitAll_WithExceptions ()
 303                 {
 304                         InitWithDelegate (delegate { throw new ApplicationException (); });
 305
 306                         try {
 307                                 Task.WaitAll (tasks);
 308                                 Assert.Fail ("#1");
 309                         } catch (AggregateException e) {
 310                                 Assert.AreEqual (6, e.InnerExceptions.Count, "#2");
 311                         }
 312
 313                         Assert.IsNotNull (tasks[0].Exception, "#3");
 314                 }
 315
 316                 [Test]
 317                 public void WaitAll_TimeoutWithExceptionsAfter ()
 318                 {
 319                         CountdownEvent cde = new CountdownEvent (2);
 320                         var mre = new ManualResetEvent (false);
 321                         var tasks = new[] {
 322                                 Task.Factory.StartNew (delegate { mre.WaitOne (); }),
 323                                 Task.Factory.StartNew (delegate { try { throw new ApplicationException (); } finally { cde.Signal (); } }),
 324                                 Task.Factory.StartNew (delegate { try { throw new ApplicationException (); } finally { cde.Signal (); } })
 325                         };
 326
 327                         Assert.IsTrue (cde.Wait (1000), "#1");
 328                         Assert.IsFalse (Task.WaitAll (tasks, 1000), "#2");
 329
 330                         mre.Set ();
 331
 332                         try {
 333                                 Assert.IsTrue (Task.WaitAll (tasks, 1000), "#3");
 334                                 Assert.Fail ("#4");
 335                         } catch (AggregateException e) {
 336                                 Assert.AreEqual (2, e.InnerExceptions.Count, "#5");
 337                         }
 338                 }
 339
 340                 [Test]
 341                 public void WaitAll_TimeoutWithExceptionsBefore ()
 342                 {
 343                         CountdownEvent cde = new CountdownEvent (2);
 344                         var mre = new ManualResetEvent (false);
 345                         var tasks = new[] {
 346                                 Task.Factory.StartNew (delegate { try { throw new ApplicationException (); } finally { cde.Signal (); } }),
 347                                 Task.Factory.StartNew (delegate { try { throw new ApplicationException (); } finally { cde.Signal (); } }),
 348                                 Task.Factory.StartNew (delegate { mre.WaitOne (); })
 349                         };
 350
 351                         Assert.IsTrue (cde.Wait (1000), "#1");
 352                         Assert.IsFalse (Task.WaitAll (tasks, 1000), "#2");
 353
 354                         mre.Set ();
 355
 356                         try {
 357                                 Assert.IsTrue (Task.WaitAll (tasks, 1000), "#3");
 358                                 Assert.Fail ("#4");
 359                         } catch (AggregateException e) {
 360                                 Assert.AreEqual (2, e.InnerExceptions.Count, "#5");
 361                         }
 362                 }
 363
 364                 [Test]
 365                 public void WaitAll_Cancelled ()
 366                 {
 367                         var cancelation = new CancellationTokenSource ();
 368                         var tasks = new Task[] {
 369                                 new Task (delegate { cancelation.Cancel (); }),
 370                                 new Task (delegate { }, cancelation.Token)
 371                         };
 372
 373                         tasks[0].Start ();
 374
 375                         try {
 376                                 Task.WaitAll (tasks);
 377                                 Assert.Fail ("#1");
 378                         } catch (AggregateException e) {
 379                                 var inner = (TaskCanceledException) e.InnerException;
 380                                 Assert.AreEqual (tasks[1], inner.Task, "#2");
 381                         }
 382
 383                         Assert.IsTrue (tasks[0].IsCompleted, "#3");
 384                         Assert.IsTrue (tasks[1].IsCanceled, "#4");
 385                 }
 386
 387 #if NET_4_5
 388                 [Test]
 389                 public void WaitAll_CancelledAndTimeout ()
 390                 {
 391                         var ct = new CancellationToken (true);
 392                         var t1 = new Task (() => {}, ct);
 393                         var t2 = Task.Delay (3000);
 394                         Assert.IsFalse (Task.WaitAll (new[] { t1, t2 }, 10));
 395                 }
 396 #endif
 397
 398                 [Test]
 399                 public void WaitAllExceptionThenCancelled ()
 400                 {
 401                         var cancelation = new CancellationTokenSource ();
 402                         var tasks = new Task[] {
 403                                 new Task (delegate { cancelation.Cancel (); throw new ApplicationException (); }),
 404                                 new Task (delegate { }, cancelation.Token)
 405                         };
 406
 407                         tasks[0].Start ();
 408
 409                         try {
 410                                 Task.WaitAll (tasks);
 411                                 Assert.Fail ("#1");
 412                         } catch (AggregateException e) {
 413                                 Assert.That (e.InnerException, Is.TypeOf (typeof (ApplicationException)), "#2");
 414                                 var inner = (TaskCanceledException) e.InnerExceptions[1];
 415                                 Assert.AreEqual (tasks[1], inner.Task, "#3");
 416                         }
 417
 418                         Assert.IsTrue (tasks[0].IsCompleted, "#4");
 419                         Assert.IsTrue (tasks[1].IsCanceled, "#5");
 420                 }
 421
 422                 [Test]
 423                 public void WaitAll_StartedUnderWait ()
 424                 {
 425                         var task1 = new Task (delegate { });
 426
 427                         ThreadPool.QueueUserWorkItem (delegate {
 428                                 // Sleep little to let task to start and hit internal wait
 429                                 Thread.Sleep (20);
 430                                 task1.Start ();
 431                         });
 432
 433                         Assert.IsTrue (Task.WaitAll (new [] { task1 }, 1000), "#1");
 434                 }
 435
 436                 [Test]
 437                 public void CancelBeforeStart ()
 438                 {
 439                         var src = new CancellationTokenSource ();
 440
 441                         Task t = new Task (delegate { }, src.Token);
 442                         src.Cancel ();
 443                         Assert.AreEqual (TaskStatus.Canceled, t.Status, "#1");
 444
 445                         try {
 446                                 t.Start ();
 447                                 Assert.Fail ("#2");
 448                         } catch (InvalidOperationException) {
 449                         }
 450                 }
 451
 452                 [Test]
 453                 public void Wait_CancelledTask ()
 454                 {
 455                         var src = new CancellationTokenSource ();
 456
 457                         Task t = new Task (delegate { }, src.Token);
 458                         src.Cancel ();
 459
 460                         try {
 461                                 t.Wait (1000);
 462                                 Assert.Fail ("#1");
 463                         } catch (AggregateException e) {
 464                                 var details = (TaskCanceledException) e.InnerException;
 465                                 Assert.AreEqual (t, details.Task, "#1e");
 466                         }
 467
 468                         try {
 469                                 t.Wait ();
 470                                 Assert.Fail ("#2");
 471                         } catch (AggregateException e) {
 472                                 var details = (TaskCanceledException) e.InnerException;
 473                                 Assert.AreEqual (t, details.Task, "#2e");
 474                                 Assert.IsNull (details.Task.Exception, "#2e2");
 475                         }
 476                 }
 477
 478                 [Test]
 479                 public void Wait_Inlined ()
 480                 {
 481                         bool? previouslyQueued = null;
 482
 483                         var scheduler = new MockScheduler ();
 484                         scheduler.TryExecuteTaskInlineHandler += (task, b) => {
 485                                 previouslyQueued = b;
 486                         };
 487
 488                         var tf = new TaskFactory (scheduler);
 489                         var t = tf.StartNew (() => { });
 490                         t.Wait ();
 491
 492                         Assert.AreEqual (true, previouslyQueued);
 493                 }
 494
 495                 [Test, ExpectedException (typeof (InvalidOperationException))]
 496                 public void CreationWhileInitiallyCanceled ()
 497                 {
 498                         var token = new CancellationToken (true);
 499                         var task = new Task (() => { }, token);
 500                         Assert.AreEqual (TaskStatus.Canceled, task.Status);
 501                         task.Start ();
 502                 }
 503
 504                 [Test]
 505                 public void ContinueWithInvalidArguments ()
 506                 {
 507                         var task = new Task (() => { });
 508                         try {
 509                                 task.ContinueWith (null);
 510                                 Assert.Fail ("#1");
 511                         } catch (ArgumentException) {
 512                         }
 513
 514                         try {
 515                                 task.ContinueWith (delegate { }, null);
 516                                 Assert.Fail ("#2");
 517                         } catch (ArgumentException) {
 518                         }
 519
 520                         try {
 521                                 task.ContinueWith (delegate { }, TaskContinuationOptions.OnlyOnCanceled | TaskContinuationOptions.NotOnCanceled);
 522                                 Assert.Fail ("#3");
 523                         } catch (ArgumentException) {
 524                         }
 525
 526                         try {
 527                                 task.ContinueWith (delegate { }, TaskContinuationOptions.OnlyOnRanToCompletion | TaskContinuationOptions.NotOnRanToCompletion);
 528                                 Assert.Fail ("#4");
 529                         } catch (ArgumentException) {
 530                         }
 531                 }
 532
 533                 [Test]
 534                 public void ContinueWithOnAnyTestCase()
 535                 {
 536                         ParallelTestHelper.Repeat (delegate {
 537                                 bool result = false;
 538
 539                                 Task t = Task.Factory.StartNew(delegate { });
 540                                 Task cont = t.ContinueWith(delegate { result = true; }, TaskContinuationOptions.None);
 541                                 Assert.IsTrue (t.Wait (2000), "First wait, (status, {0})", t.Status);
 542                                 Assert.IsTrue (cont.Wait(2000), "Cont wait, (result, {0}) (parent status, {2}) (status, {1})", result, cont.Status, t.Status);
 543                                 Assert.IsNull(cont.Exception, "#1");
 544                                 Assert.IsNotNull(cont, "#2");
 545                                 Assert.IsTrue(result, "#3");
 546                         });
 547                 }
 548
 549                 [Test]
 550                 public void ContinueWithOnCompletedSuccessfullyTestCase()
 551                 {
 552                         ParallelTestHelper.Repeat (delegate {
 553                                 bool result = false;
 554
 555                                 Task t = Task.Factory.StartNew(delegate { });
 556                                 Task cont = t.ContinueWith(delegate { result = true; }, TaskContinuationOptions.OnlyOnRanToCompletion);
 557                                 Assert.IsTrue (t.Wait(1000), "#4");
 558                                 Assert.IsTrue (cont.Wait(1000), "#5");
 559
 560                                 Assert.IsNull(cont.Exception, "#1");
 561                                 Assert.IsNotNull(cont, "#2");
 562                                 Assert.IsTrue(result, "#3");
 563                         });
 564                 }
 565
 566                 [Test]
 567                 public void ContinueWithOnAbortedTestCase()
 568                 {
 569                         bool result = false;
 570                         bool taskResult = false;
 571
 572                         CancellationTokenSource src = new CancellationTokenSource ();
 573                         Task t = new Task (delegate { taskResult = true; }, src.Token);
 574
 575                         Task cont = t.ContinueWith (delegate { result = true; },
 576                                 TaskContinuationOptions.OnlyOnCanceled | TaskContinuationOptions.ExecuteSynchronously);
 577
 578                         src.Cancel ();
 579
 580                         Assert.AreEqual (TaskStatus.Canceled, t.Status, "#1a");
 581                         Assert.IsTrue (cont.IsCompleted, "#1b");
 582                         Assert.IsTrue (result, "#1c");
 583
 584                         try {
 585                                 t.Start ();
 586                                 Assert.Fail ("#2");
 587                         } catch (InvalidOperationException) {
 588                         }
 589
 590                         Assert.IsTrue (cont.Wait (1000), "#3");
 591
 592                         Assert.IsFalse (taskResult, "#4");
 593
 594                         Assert.IsNull (cont.Exception, "#5");
 595                         Assert.AreEqual (TaskStatus.RanToCompletion, cont.Status, "#6");
 596                 }
 597
 598                 [Test]
 599                 public void ContinueWithOnFailedTestCase()
 600                 {
 601                         ParallelTestHelper.Repeat (delegate {
 602                                 bool result = false;
 603
 604                                 Task t = Task.Factory.StartNew(delegate { throw new Exception("foo"); });
 605                                 Task cont = t.ContinueWith(delegate { result = true; }, TaskContinuationOptions.OnlyOnFaulted);
 606
 607                                 Assert.IsTrue (cont.Wait(1000), "#0");
 608                                 Assert.IsNotNull (t.Exception, "#1");
 609                                 Assert.IsNotNull (cont, "#2");
 610                                 Assert.IsTrue (result, "#3");
 611                         });
 612                 }
 613
 614                 [Test]
 615                 public void ContinueWithWithStart ()
 616                 {
 617                         Task t = new Task<int> (() => 1);
 618                         t = t.ContinueWith (l => { });
 619                         try {
 620                                 t.Start ();
 621                                 Assert.Fail ();
 622                         } catch (InvalidOperationException) {
 623                         }
 624                 }
 625
 626                 [Test]
 627                 public void ContinueWithChildren ()
 628                 {
 629                         ParallelTestHelper.Repeat (delegate {
 630                                 bool result = false;
 631
 632                                 var t = Task.Factory.StartNew (() => Task.Factory.StartNew (() => {}, TaskCreationOptions.AttachedToParent));
 633
 634                                 var mre = new ManualResetEvent (false);
 635                                 t.ContinueWith (l => {
 636                                         result = true;
 637                                         mre.Set ();
 638                                 });
 639
 640                                 Assert.IsTrue (mre.WaitOne (1000), "#1");
 641                                 Assert.IsTrue (result, "#2");
 642                         }, 2);
 643                 }
 644
 645                 [Test]
 646                 public void ContinueWithDifferentOptionsAreCanceledTest ()
 647                 {
 648                         var mre = new ManualResetEventSlim ();
 649                         var task = Task.Factory.StartNew (() => mre.Wait (200));
 650                         var contFailed = task.ContinueWith (t => {}, TaskContinuationOptions.OnlyOnFaulted);
 651                         var contCanceled = task.ContinueWith (t => {}, TaskContinuationOptions.OnlyOnCanceled);
 652                         var contSuccess = task.ContinueWith (t => {}, TaskContinuationOptions.OnlyOnRanToCompletion);
 653
 654                         mre.Set ();
 655                         contSuccess.Wait (100);
 656
 657                         Assert.IsTrue (contSuccess.IsCompleted);
 658                         Assert.IsTrue (contFailed.IsCompleted);
 659                         Assert.IsTrue (contCanceled.IsCompleted);
 660                         Assert.IsFalse (contSuccess.IsCanceled);
 661                         Assert.IsTrue (contFailed.IsCanceled);
 662                         Assert.IsTrue (contCanceled.IsCanceled);
 663                 }
 664
 665                 [Test]
 666                 public void MultipleTasks()
 667                 {
 668                         ParallelTestHelper.Repeat (delegate {
 669                                 bool r1 = false, r2 = false, r3 = false;
 670
 671                                 Task t1 = Task.Factory.StartNew(delegate {
 672                                         r1 = true;
 673                                 });
 674                                 Task t2 = Task.Factory.StartNew(delegate {
 675                                         r2 = true;
 676                                 });
 677                                 Task t3 = Task.Factory.StartNew(delegate {
 678                                         r3 = true;
 679                                 });
 680
 681                                 t1.Wait(2000);
 682                                 t2.Wait(2000);
 683                                 t3.Wait(2000);
 684
 685                                 Assert.IsTrue(r1, "#1");
 686                                 Assert.IsTrue(r2, "#2");
 687                                 Assert.IsTrue(r3, "#3");
 688                         }, 100);
 689                 }
 690
 691                 [Test]
 692                 public void WaitChildTestCase()
 693                 {
 694                         ParallelTestHelper.Repeat (delegate {
 695                                 bool r1 = false, r2 = false, r3 = false;
 696                                 var mre = new ManualResetEventSlim (false);
 697                                 var mreStart = new ManualResetEventSlim (false);
 698
 699                                 Task t = Task.Factory.StartNew(delegate {
 700                                         Task.Factory.StartNew(delegate {
 701                                                 mre.Wait (300);
 702                                                 r1 = true;
 703                                         }, TaskCreationOptions.AttachedToParent);
 704                                         Task.Factory.StartNew(delegate {
 705                                                 r2 = true;
 706                                         }, TaskCreationOptions.AttachedToParent);
 707                                         Task.Factory.StartNew(delegate {
 708                                                 r3 = true;
 709                                         }, TaskCreationOptions.AttachedToParent);
 710                                         mreStart.Set ();
 711                                 });
 712
 713                                 mreStart.Wait (300);
 714                                 Assert.IsFalse (t.Wait (10), "#0a");
 715                                 mre.Set ();
 716                                 Assert.IsTrue (t.Wait (500), "#0b");
 717                                 Assert.IsTrue(r2, "#1");
 718                                 Assert.IsTrue(r3, "#2");
 719                                 Assert.IsTrue(r1, "#3");
 720                                 Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#4");
 721                         }, 10);
 722                 }
 723
 724                 Task parent_wfc;
 725
 726                 [Test]
 727                 public void WaitingForChildrenToComplete ()
 728                 {
 729                         Task nested = null;
 730                         var mre = new ManualResetEvent (false);
 731
 732                         parent_wfc = Task.Factory.StartNew (() => {
 733                                 nested = Task.Factory.StartNew (() => {
 734                                         Assert.IsTrue (mre.WaitOne (4000), "parent_wfc needs to be set first");
 735                                         Assert.IsFalse (parent_wfc.Wait (10), "#1a");
 736                                         Assert.AreEqual (TaskStatus.WaitingForChildrenToComplete, parent_wfc.Status, "#1b");
 737                                 }, TaskCreationOptions.AttachedToParent).ContinueWith (l => {
 738                                         Assert.IsTrue (parent_wfc.Wait (2000), "#2a");
 739                                         Assert.AreEqual (TaskStatus.RanToCompletion, parent_wfc.Status, "#2b");
 740                                 }, TaskContinuationOptions.ExecuteSynchronously);
 741                         });
 742
 743                         mre.Set ();
 744                         Assert.IsTrue (parent_wfc.Wait (2000), "#3");
 745                         Assert.IsTrue (nested.Wait (2000), "#4");
 746                 }
 747
 748                 [Test]
 749                 public void WaitChildWithContinuationAttachedTest ()
 750                 {
 751                         bool result = false;
 752                         var task = new Task(() =>
 753                         {
 754                                 Task.Factory.StartNew(() =>     {
 755                                         Thread.Sleep (200);
 756                                 }, TaskCreationOptions.AttachedToParent).ContinueWith(t => {
 757                                         Thread.Sleep (200);
 758                                         result = true;
 759                                 }, TaskContinuationOptions.AttachedToParent);
 760                         });
 761                         task.Start();
 762                         task.Wait();
 763                         Assert.IsTrue (result);
 764                 }
 765
 766                 [Test]
 767                 public void WaitChildWithContinuationNotAttachedTest ()
 768                 {
 769                         var task = new Task(() =>
 770                         {
 771                                 Task.Factory.StartNew(() =>     {
 772                                         Thread.Sleep (200);
 773                                 }, TaskCreationOptions.AttachedToParent).ContinueWith(t => {
 774                                         Thread.Sleep (3000);
 775                                 });
 776                         });
 777                         task.Start();
 778                         Assert.IsTrue (task.Wait(400));
 779                 }
 780
 781                 [Test]
 782                 public void WaitChildWithNesting ()
 783                 {
 784                         var result = false;
 785                         var t = Task.Factory.StartNew (() => {
 786                                 Task.Factory.StartNew (() => {
 787                                         Task.Factory.StartNew (() => {
 788                                                 Thread.Sleep (500);
 789                                                 result = true;
 790                                         }, TaskCreationOptions.AttachedToParent);
 791                                 }, TaskCreationOptions.AttachedToParent);
 792                         });
 793                         Assert.IsTrue (t.Wait (4000), "#1");
 794                         Assert.IsTrue (result, "#2");
 795                 }
 796
 797                 [Test]
 798                 public void DoubleWaitTest ()
 799                 {
 800                         ParallelTestHelper.Repeat (delegate {
 801                                 var evt = new ManualResetEventSlim ();
 802                                 var monitor = new object ();
 803                                 int finished = 0;
 804                                 var t = Task.Factory.StartNew (delegate {
 805                                                 var r = evt.Wait (5000);
 806                                                 lock (monitor) {
 807                                                         finished ++;
 808                                                         Monitor.Pulse (monitor);
 809                                                 }
 810                                                 return r;
 811                                         });
 812                                 var cntd = new CountdownEvent (2);
 813                                 var cntd2 = new CountdownEvent (2);
 814
 815                                 bool r1 = false, r2 = false;
 816                                 ThreadPool.QueueUserWorkItem (delegate {
 817                                                 cntd.Signal ();
 818                                                 r1 = t.Wait (1000) && t.Result;
 819                                                 cntd2.Signal ();
 820                                                 lock (monitor) {
 821                                                         finished ++;
 822                                                         Monitor.Pulse (monitor);
 823                                                 }
 824                                         });
 825                                 ThreadPool.QueueUserWorkItem (delegate {
 826                                                 cntd.Signal ();
 827                                                 r2 = t.Wait (1000) && t.Result;
 828                                                 cntd2.Signal ();
 829                                                 lock (monitor) {
 830                                                         finished ++;
 831                                                         Monitor.Pulse (monitor);
 832                                                 }
 833                                         });
 834                                 Assert.IsTrue (cntd.Wait (2000), "#1");
 835                                 evt.Set ();
 836                                 Assert.IsTrue (cntd2.Wait (2000), "#2");
 837                                 Assert.IsTrue (r1, "r1");
 838                                 Assert.IsTrue (r2, "r2");
 839
 840                                 // Wait for everything to finish to avoid overloading the tpool
 841                                 lock (monitor) {
 842                                         while (true) {
 843                                                 if (finished == 3)
 844                                                         break;
 845                                                 else
 846                                                         Monitor.Wait (monitor);
 847                                         }
 848                                 }
 849                         }, 10);
 850                 }
 851
 852                 [Test]
 853                 public void DoubleTimeoutedWaitTest ()
 854                 {
 855                         var evt = new ManualResetEventSlim ();
 856                         var t = new Task (delegate { });
 857                         var cntd = new CountdownEvent (2);
 858
 859                         bool r1 = false, r2 = false;
 860                         ThreadPool.QueueUserWorkItem (delegate { r1 = !t.Wait (100); cntd.Signal (); });
 861                         ThreadPool.QueueUserWorkItem (delegate { r2 = !t.Wait (100); cntd.Signal (); });
 862
 863                         cntd.Wait (2000);
 864                         Assert.IsTrue (r1);
 865                         Assert.IsTrue (r2);
 866                 }
 867
 868                 [Test]
 869                 public void RunSynchronously ()
 870                 {
 871                         var val = 0;
 872                         Task t = new Task (() => { Thread.Sleep (100); val = 1; });
 873                         t.RunSynchronously ();
 874
 875                         Assert.AreEqual (1, val, "#1");
 876
 877                         t = new Task (() => { Thread.Sleep (0); val = 2; });
 878
 879                         bool? previouslyQueued = null;
 880
 881                         var scheduler = new MockScheduler ();
 882                         scheduler.TryExecuteTaskInlineHandler += (task, b) => {
 883                                 previouslyQueued = b;
 884                         };
 885
 886                         t.RunSynchronously (scheduler);
 887
 888                         Assert.AreEqual (2, val, "#2");
 889                         Assert.AreEqual (false, previouslyQueued, "#2a");
 890                 }
 891
 892                 [Test]
 893                 public void RunSynchronouslyArgumentChecks ()
 894                 {
 895                         Task t = new Task (() => { });
 896                         try {
 897                                 t.RunSynchronously (null);
 898                                 Assert.Fail ("#1");
 899                         } catch (ArgumentNullException) {
 900                         }
 901                 }
 902
 903                 [Test]
 904                 public void RunSynchronously_SchedulerException ()
 905                 {
 906                         var scheduler = new MockScheduler ();
 907                         scheduler.TryExecuteTaskInlineHandler += (task, b) => {
 908                                 throw new ApplicationException ();
 909                         };
 910
 911                         Task t = new Task (() => { });
 912                         try {
 913                                 t.RunSynchronously (scheduler);
 914                                 Assert.Fail ();
 915                         } catch (Exception e) {
 916                                 Assert.AreEqual (t.Exception.InnerException, e);
 917                         }
 918                 }
 919
 920                 [Test]
 921                 public void RunSynchronouslyWithAttachedChildren ()
 922                 {
 923                         var result = false;
 924                         var t = new Task (() => {
 925                                 Task.Factory.StartNew (() => { Thread.Sleep (500); result = true; }, TaskCreationOptions.AttachedToParent);
 926                         });
 927                         t.RunSynchronously ();
 928                         Assert.IsTrue (result);
 929                 }
 930
 931                 [Test]
 932                 public void RunSynchronouslyOnContinuation ()
 933                 {
 934                         Task t = new Task<int> (() => 1);
 935                         t = t.ContinueWith (l => { });
 936                         try {
 937                                 t.RunSynchronously ();
 938                                 Assert.Fail ("#1");
 939                         } catch (InvalidOperationException) {
 940                         }
 941                 }
 942
 943                 [Test]
 944                 public void UnobservedExceptionOnFinalizerThreadTest ()
 945                 {
 946                         bool wasCalled = false;
 947                         TaskScheduler.UnobservedTaskException += (o, args) => {
 948                                 wasCalled = true;
 949                                 args.SetObserved ();
 950                         };
 951                         var inner = new ApplicationException ();
 952                         Thread t = new Thread (delegate () {
 953                                         Task.Factory.StartNew (() => { throw inner; });
 954                                 });
 955                         t.Start ();
 956                         t.Join ();
 957                         Thread.Sleep (1000);
 958                         GC.Collect ();
 959                         Thread.Sleep (1000);
 960                         GC.WaitForPendingFinalizers ();
 961
 962                         Assert.IsTrue (wasCalled);
 963                 }
 964
 965                 [Test, ExpectedException (typeof (InvalidOperationException))]
 966                 public void StartFinishedTaskTest ()
 967                 {
 968                         var t = Task.Factory.StartNew (delegate () { });
 969                         t.Wait ();
 970
 971                         t.Start ();
 972                 }
 973
 974                 [Test]
 975                 public void Start_NullArgument ()
 976                 {
 977                         var t = Task.Factory.StartNew (delegate () { });
 978                         try {
 979                                 t.Start (null);
 980                                 Assert.Fail ();
 981                         } catch (ArgumentNullException) {
 982                         }
 983                 }
 984
 985                 [Test, ExpectedException (typeof (InvalidOperationException))]
 986                 public void DisposeUnstartedTest ()
 987                 {
 988                         var t = new Task (() => { });
 989                         t.Dispose ();
 990                 }
 991
 992                 [Test]
 993                 public void ThrowingUnrelatedCanceledExceptionTest ()
 994                 {
 995                         Task t = new Task (() => {
 996                                 throw new TaskCanceledException ();
 997                         });
 998
 999                         t.RunSynchronously ();
1000                         Assert.IsTrue (t.IsFaulted);
1001                         Assert.IsFalse (t.IsCanceled);
1002                 }
1003
1004                 [Test]
1005                 public void CanceledContinuationExecuteSynchronouslyTest ()
1006                 {
1007                         var source = new CancellationTokenSource();
1008                         var token = source.Token;
1009                         var evt = new ManualResetEventSlim ();
1010                         bool result = false;
1011                         bool thrown = false;
1012
1013                         var task = Task.Factory.StartNew (() => evt.Wait (100));
1014                         var cont = task.ContinueWith (t => result = true, token, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
1015
1016                         source.Cancel();
1017                         evt.Set ();
1018                         task.Wait (100);
1019                         try {
1020                                 cont.Wait (100);
1021                         } catch (Exception ex) {
1022                                 thrown = true;
1023                         }
1024
1025                         Assert.IsTrue (task.IsCompleted);
1026                         Assert.IsTrue (cont.IsCanceled);
1027                         Assert.IsFalse (result);
1028                         Assert.IsTrue (thrown);
1029                 }
1030
1031                 [Test]
1032                 public void WhenChildTaskErrorIsThrownParentTaskShouldBeFaulted ()
1033                 {
1034                         Task innerTask = null;
1035                         var testTask = new Task (() =>
1036                         {
1037                                 innerTask = new Task (() =>
1038                                 {
1039                                         throw new InvalidOperationException ();
1040                                 }, TaskCreationOptions.AttachedToParent);
1041                                 innerTask.RunSynchronously ();
1042                         });
1043                         testTask.RunSynchronously ();
1044
1045                         Assert.AreNotEqual (TaskStatus.Running, testTask.Status);
1046                         Assert.IsNotNull (innerTask);
1047                         Assert.IsTrue (innerTask.IsFaulted);
1048                         Assert.IsNotNull (testTask.Exception);
1049                         Assert.IsTrue (testTask.IsFaulted);
1050                         Assert.IsNotNull (innerTask.Exception);
1051                 }
1052
1053                 [Test]
1054                 public void WhenChildTaskErrorIsThrownOnlyOnFaultedContinuationShouldExecute ()
1055                 {
1056                         var continuationRan = false;
1057                         var testTask = new Task (() =>
1058                         {
1059                                 var task = new Task (() =>
1060                                 {
1061                                         throw new InvalidOperationException();
1062                                 }, TaskCreationOptions.AttachedToParent);
1063                                 task.RunSynchronously ();
1064                         });
1065                         var onErrorTask = testTask.ContinueWith (x => continuationRan = true, TaskContinuationOptions.OnlyOnFaulted);
1066                         testTask.RunSynchronously ();
1067                         onErrorTask.Wait (100);
1068                         Assert.IsTrue (continuationRan);
1069                 }
1070
1071                 [Test]
1072                 public void WhenChildTaskErrorIsThrownNotOnFaultedContinuationShouldNotBeExecuted ()
1073                 {
1074                         var continuationRan = false;
1075                         var testTask = new Task (() =>
1076                         {
1077                                 var task = new Task (() =>
1078                                 {
1079                                         throw new InvalidOperationException();
1080                                 }, TaskCreationOptions.AttachedToParent);
1081                                 task.RunSynchronously();
1082                         });
1083                         var onErrorTask = testTask.ContinueWith (x => continuationRan = true, TaskContinuationOptions.NotOnFaulted);
1084                         testTask.RunSynchronously ();
1085                         Assert.IsTrue (onErrorTask.IsCompleted);
1086                         Assert.IsFalse (onErrorTask.IsFaulted);
1087                         Assert.IsFalse (continuationRan);
1088                 }
1089
1090                 [Test]
1091                 public void WhenChildTaskSeveralLevelsDeepHandlesAggregateExceptionErrorStillBubblesToParent ()
1092                 {
1093                         var continuationRan = false;
1094                         AggregateException e = null;
1095                         var testTask = new Task (() =>
1096                         {
1097                                 var child1 = new Task (() =>
1098                                 {
1099                                         var child2 = new Task (() =>
1100                                         {
1101                                                 throw new InvalidOperationException();
1102                                         }, TaskCreationOptions.AttachedToParent);
1103                                         child2.RunSynchronously ();
1104                                 }, TaskCreationOptions.AttachedToParent);
1105
1106                                 child1.RunSynchronously();
1107                                 e = child1.Exception;
1108                                 child1.Exception.Handle (ex => true);
1109                         });
1110                         var onErrorTask = testTask.ContinueWith (x => continuationRan = true, TaskContinuationOptions.OnlyOnFaulted);
1111                         testTask.RunSynchronously ();
1112                         onErrorTask.Wait (100);
1113                         Assert.IsNotNull (e);
1114                         Assert.IsTrue (continuationRan);
1115                 }
1116
1117                 [Test]
1118                 public void AlreadyCompletedChildTaskShouldRunContinuationImmediately ()
1119                 {
1120                         string result = "Failed";
1121                         var testTask = new Task (() =>
1122                         {
1123                                 var child = new Task<string> (() =>
1124                                 {
1125                                         return "Success";
1126                                 }, TaskCreationOptions.AttachedToParent);
1127                                 child.RunSynchronously ();
1128                                 child.ContinueWith (x => { Thread.Sleep (50); result = x.Result; }, TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.NotOnFaulted);
1129                         });
1130                         testTask.RunSynchronously ();
1131
1132                         Assert.AreEqual ("Success", result);
1133                 }
1134
1135                 [Test]
1136                 public void InlineNotTrashingParentRelationship ()
1137                 {
1138                         bool r1 = false, r2 = false;
1139                         var t = new Task (() => {
1140                                 new Task (() => { r1 = true; }, TaskCreationOptions.AttachedToParent).RunSynchronously ();
1141                                 Task.Factory.StartNew (() => { Thread.Sleep (100); r2 = true; }, TaskCreationOptions.AttachedToParent);
1142                         });
1143                         t.RunSynchronously ();
1144
1145                         Assert.IsTrue (r1);
1146                         Assert.IsTrue (r2);
1147                 }
1148
1149                 [Test]
1150                 public void AsyncWaitHandleSet ()
1151                 {
1152                         var task = new TaskFactory ().StartNew (() => { });
1153                         var ar = (IAsyncResult)task;
1154                         Assert.IsFalse (ar.CompletedSynchronously, "#1");
1155                         Assert.IsTrue (ar.AsyncWaitHandle.WaitOne (5000), "#2");
1156                 }
1157
1158                 [Test]
1159                 public void StartOnBrokenScheduler ()
1160                 {
1161                         var t = new Task (delegate { });
1162
1163                         try {
1164                                 t.Start (new ExceptionScheduler ());
1165                                 Assert.Fail ("#1");
1166                         } catch (TaskSchedulerException e) {
1167                                 Assert.AreEqual (TaskStatus.Faulted, t.Status, "#2");
1168                                 Assert.AreSame (e, t.Exception.InnerException, "#3");
1169                                 Assert.IsTrue (e.InnerException is ApplicationException, "#4");
1170                         }
1171                 }
1172
1173 #if NET_4_5
1174                 [Test]
1175                 public void ContinuationOnBrokenScheduler ()
1176                 {
1177                         var s = new ExceptionScheduler ();
1178                         Task t = new Task(delegate {});
1179
1180                         var t2 = t.ContinueWith (delegate {
1181                         }, TaskContinuationOptions.ExecuteSynchronously, s);
1182
1183                         var t3 = t.ContinueWith (delegate {
1184                         }, TaskContinuationOptions.ExecuteSynchronously, s);
1185
1186                         t.Start ();
1187
1188                         try {
1189                                 Assert.IsTrue (t3.Wait (2000), "#0");
1190                                 Assert.Fail ("#1");
1191                         } catch (AggregateException e) {
1192                         }
1193
1194                         Assert.AreEqual (TaskStatus.Faulted, t2.Status, "#2");
1195                         Assert.AreEqual (TaskStatus.Faulted, t3.Status, "#3");
1196                 }
1197
1198                 [Test]
1199                 public void Delay_Invalid ()
1200                 {
1201                         try {
1202                                 Task.Delay (-100);
1203                         } catch (ArgumentOutOfRangeException) {
1204                         }
1205                 }
1206
1207                 [Test]
1208                 public void Delay_Start ()
1209                 {
1210                         var t = Task.Delay (5000);
1211                         try {
1212                                 t.Start ();
1213                         } catch (InvalidOperationException) {
1214                         }
1215                 }
1216
1217                 [Test]
1218                 public void Delay_Simple ()
1219                 {
1220                         var t = Task.Delay (300);
1221                         Assert.IsTrue (TaskStatus.WaitingForActivation == t.Status || TaskStatus.Running == t.Status, "#1");
1222                         Assert.IsTrue (t.Wait (400), "#2");
1223                 }
1224
1225                 [Test]
1226                 public void Delay_Cancelled ()
1227                 {
1228                         var cancelation = new CancellationTokenSource ();
1229
1230                         var t = Task.Delay (5000, cancelation.Token);
1231                         Assert.IsTrue (TaskStatus.WaitingForActivation == t.Status || TaskStatus.Running == t.Status, "#1");
1232                         cancelation.Cancel ();
1233                         try {
1234                                 t.Wait (1000);
1235                                 Assert.Fail ("#2");
1236                         } catch (AggregateException) {
1237                                 Assert.AreEqual (TaskStatus.Canceled, t.Status, "#3");
1238                         }
1239
1240                         cancelation = new CancellationTokenSource ();
1241                         t = Task.Delay (Timeout.Infinite, cancelation.Token);
1242                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#11");
1243                         cancelation.Cancel ();
1244                         try {
1245                                 t.Wait (1000);
1246                                 Assert.Fail ("#12");
1247                         } catch (AggregateException) {
1248                                 Assert.AreEqual (TaskStatus.Canceled, t.Status, "#13");
1249                         }
1250                 }
1251
1252                 [Test]
1253                 public void Delay_TimeManagement ()
1254                 {
1255                         var delay1 = Task.Delay(50);
1256                         var delay2 = Task.Delay(25);
1257                         Assert.IsTrue (Task.WhenAny(new[] { delay1, delay2 }).Wait (1000));
1258                         Assert.AreEqual (TaskStatus.RanToCompletion, delay2.Status);
1259                 }
1260
1261                 [Test]
1262                 public void WaitAny_WithNull ()
1263                 {
1264                         var tasks = new [] {
1265                                 Task.FromResult (2),
1266                                 null
1267                         };
1268
1269                         try {
1270                                 Task.WaitAny (tasks);
1271                                 Assert.Fail ();
1272                         } catch (ArgumentException) {
1273                         }
1274                 }
1275
1276                 [Test]
1277                 public void WhenAll_Empty ()
1278                 {
1279                         var tasks = new Task[0];
1280
1281                         Task t = Task.WhenAll(tasks);
1282
1283                         Assert.IsTrue(t.Wait(1000), "#1");
1284                 }
1285
1286                 [Test]
1287                 public void WhenAll_WithNull ()
1288                 {
1289                         var tasks = new[] {
1290                                 Task.FromResult (2),
1291                                 null
1292                         };
1293
1294                         try {
1295                                 Task.WhenAll (tasks);
1296                                 Assert.Fail ("#1");
1297                         } catch (ArgumentException) {
1298                         }
1299
1300                         tasks = null;
1301                         try {
1302                                 Task.WhenAll (tasks);
1303                                 Assert.Fail ("#2");
1304                         } catch (ArgumentException) {
1305                         }
1306                 }
1307
1308                 [Test]
1309                 public void WhenAll_Start ()
1310                 {
1311                         Task[] tasks = new[] {
1312                                 Task.FromResult (2),
1313                         };
1314
1315                         var t = Task.WhenAll (tasks);
1316                         Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#1");
1317
1318                         try {
1319                                 t.Start ();
1320                                 Assert.Fail ("#2");
1321                         } catch (InvalidOperationException) {
1322                         }
1323
1324                         tasks = new [] {
1325                                 new Task (delegate { }),
1326                         };
1327
1328                         t = Task.WhenAll (tasks);
1329                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#11");
1330
1331                         try {
1332                                 t.Start ();
1333                                 Assert.Fail ("#12");
1334                         } catch (InvalidOperationException) {
1335                         }
1336                 }
1337
1338                 [Test]
1339                 public void WhenAll_Cancelled ()
1340                 {
1341                         var cancelation = new CancellationTokenSource ();
1342                         var tasks = new Task[] {
1343                                 new Task (delegate { }),
1344                                 new Task (delegate { }, cancelation.Token)
1345                         };
1346
1347                         cancelation.Cancel ();
1348
1349                         var t = Task.WhenAll (tasks);
1350                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#1");
1351                         tasks[0].Start ();
1352
1353                         try {
1354                                 Assert.IsTrue (t.Wait (1000), "#2");
1355                                 Assert.Fail ("#2a");
1356                         } catch (AggregateException e) {
1357                                 Assert.That (e.InnerException, Is.TypeOf (typeof (TaskCanceledException)), "#3");
1358                         }
1359                 }
1360
1361                 [Test]
1362                 public void WhenAll_Faulted ()
1363                 {
1364                         var tcs = new TaskCompletionSource<object> ();
1365                         tcs.SetException (new ApplicationException ());
1366
1367                         var tcs2 = new TaskCompletionSource<object> ();
1368                         tcs2.SetException (new InvalidTimeZoneException ());
1369
1370                         var cancelation = new CancellationTokenSource ();
1371                         var tasks = new Task[] {
1372                                 new Task (delegate { }),
1373                                 new Task (delegate { }, cancelation.Token),
1374                                 tcs.Task,
1375                                 tcs2.Task
1376                         };
1377
1378                         cancelation.Cancel ();
1379
1380                         var t = Task.WhenAll (tasks);
1381                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#1");
1382                         tasks[0].Start ();
1383
1384                         try {
1385                                 Assert.IsTrue (t.Wait (1000), "#2");
1386                                 Assert.Fail ("#2a");
1387                         } catch (AggregateException e) {
1388                                 Assert.That (e.InnerException, Is.TypeOf (typeof (ApplicationException)), "#3");
1389                                 Assert.That (e.InnerExceptions[1], Is.TypeOf (typeof (InvalidTimeZoneException)), "#4");
1390                         }
1391                 }
1392
1393                 [Test]
1394                 public void WhenAll ()
1395                 {
1396                         var t1 = new Task (delegate { });
1397                         var t2 = new Task (delegate { t1.Start (); });
1398
1399                         var tasks = new Task[] {
1400                                 t1,
1401                                 t2,
1402                         };
1403
1404                         var t = Task.WhenAll (tasks);
1405                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#1");
1406                         t2.Start ();
1407
1408                         Assert.IsTrue (t.Wait (1000), "#2");
1409                 }
1410
1411                 [Test]
1412                 public void WhenAllResult_Empty ()
1413                 {
1414                         var tasks = new Task<int>[0];
1415
1416                         Task<int[]> t = Task.WhenAll(tasks);
1417
1418                         Assert.IsTrue(t.Wait(1000), "#1");
1419                         Assert.IsNotNull(t.Result, "#2");
1420                         Assert.AreEqual(t.Result.Length, 0, "#3");
1421                 }
1422
1423                 [Test]
1424                 public void WhenAllResult_WithNull ()
1425                 {
1426                         var tasks = new[] {
1427                                 Task.FromResult (2),
1428                                 null
1429                         };
1430
1431                         try {
1432                                 Task.WhenAll<int> (tasks);
1433                                 Assert.Fail ("#1");
1434                         } catch (ArgumentException) {
1435                         }
1436
1437                         tasks = null;
1438                         try {
1439                                 Task.WhenAll<int> (tasks);
1440                                 Assert.Fail ("#2");
1441                         } catch (ArgumentException) {
1442                         }
1443                 }
1444
1445                 [Test]
1446                 public void WhenAllResult_Cancelled ()
1447                 {
1448                         var cancelation = new CancellationTokenSource ();
1449                         var tasks = new [] {
1450                                 new Task<int> (delegate { return 9; }),
1451                                 new Task<int> (delegate { return 1; }, cancelation.Token)
1452                         };
1453
1454                         cancelation.Cancel ();
1455
1456                         var t = Task.WhenAll (tasks);
1457                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#1");
1458                         tasks[0].Start ();
1459
1460                         try {
1461                                 Assert.IsTrue (t.Wait (1000), "#2");
1462                                 Assert.Fail ("#2a");
1463                         } catch (AggregateException e) {
1464                                 Assert.That (e.InnerException, Is.TypeOf (typeof (TaskCanceledException)), "#3");
1465                         }
1466
1467                         try {
1468                                 var r = t.Result;
1469                                 Assert.Fail ("#4");
1470                         } catch (AggregateException) {
1471                         }
1472                 }
1473
1474                 [Test]
1475                 public void WhenAllResult ()
1476                 {
1477                         var t1 = new Task<string> (delegate { return "a"; });
1478                         var t2 = new Task<string> (delegate { t1.Start (); return "b"; });
1479
1480                         var tasks = new [] {
1481                                 t1,
1482                                 t2,
1483                         };
1484
1485                         var t = Task.WhenAll<string> (tasks);
1486                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#1");
1487                         t2.Start ();
1488
1489                         Assert.IsTrue (t.Wait (1000), "#2");
1490                         Assert.AreEqual (2, t.Result.Length, "#3");
1491                         Assert.AreEqual ("a", t.Result[0], "#3a");
1492                         Assert.AreEqual ("b", t.Result[1], "#3b");
1493                 }
1494
1495                 [Test]
1496                 public void WhenAllResult_Completed ()
1497                 {
1498                         var tasks = new[] {
1499                                 Task.FromResult (1),
1500                                 Task.FromResult (2)
1501                         };
1502
1503                         var t = Task.WhenAll<int> (tasks);
1504                         Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#1");
1505                         Assert.AreEqual (2, t.Result.Length, "#2");
1506                         Assert.AreEqual (1, t.Result[0], "#2a");
1507                         Assert.AreEqual (2, t.Result[1], "#2b");
1508                 }
1509
1510                 [Test]
1511                 public void WhenAny_WithNull ()
1512                 {
1513                         var tasks = new Task[] {
1514                                 Task.FromResult (2),
1515                                 null
1516                         };
1517
1518                         try {
1519                                 Task.WhenAny (tasks);
1520                                 Assert.Fail ("#1");
1521                         } catch (ArgumentException) {
1522                         }
1523
1524                         tasks = null;
1525                         try {
1526                                 Task.WhenAny (tasks);
1527                                 Assert.Fail ("#2");
1528                         } catch (ArgumentException) {
1529                         }
1530
1531                         try {
1532                                 Task.WhenAny (new Task[0]);
1533                                 Assert.Fail ("#3");
1534                         } catch (ArgumentException) {
1535                         }
1536                 }
1537
1538                 [Test]
1539                 public void WhenAny_Start ()
1540                 {
1541                         Task[] tasks = new[] {
1542                                 Task.FromResult (2),
1543                         };
1544
1545                         var t = Task.WhenAny (tasks);
1546                         Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#1");
1547
1548                         try {
1549                                 t.Start ();
1550                                 Assert.Fail ("#2");
1551                         } catch (InvalidOperationException) {
1552                         }
1553
1554                         tasks = new[] {
1555                                 new Task (delegate { }),
1556                         };
1557
1558                         t = Task.WhenAny (tasks);
1559                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#11");
1560
1561                         try {
1562                                 t.Start ();
1563                                 Assert.Fail ("#12");
1564                         } catch (InvalidOperationException) {
1565                         }
1566                 }
1567
1568                 [Test]
1569                 public void WhenAny_Cancelled ()
1570                 {
1571                         var cancelation = new CancellationTokenSource ();
1572                         var tasks = new Task[] {
1573                                 new Task (delegate { }),
1574                                 new Task (delegate { }, cancelation.Token)
1575                         };
1576
1577                         cancelation.Cancel ();
1578
1579                         var t = Task.WhenAny (tasks);
1580                         Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#1");
1581                         tasks[0].Start ();
1582
1583                         Assert.IsTrue (t.Wait (1000), "#2");
1584                         Assert.AreEqual (TaskStatus.Canceled, t.Result.Status, "#3");
1585                 }
1586
1587                 [Test]
1588                 public void WhenAny_Faulted ()
1589                 {
1590                         var tcs = new TaskCompletionSource<object> ();
1591                         tcs.SetException (new ApplicationException ());
1592
1593                         var tcs2 = new TaskCompletionSource<object> ();
1594                         tcs2.SetException (new InvalidTimeZoneException ());
1595
1596                         var cancelation = new CancellationTokenSource ();
1597                         var tasks = new Task[] {
1598                                 new Task (delegate { }),
1599                                 tcs.Task,
1600                                 new Task (delegate { }, cancelation.Token),
1601                                 tcs2.Task
1602                         };
1603
1604                         cancelation.Cancel ();
1605
1606                         var t = Task.WhenAny (tasks);
1607                         Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#1");
1608                         tasks[0].Start ();
1609
1610                         Assert.IsTrue (t.Wait (1000), "#2");
1611                         Assert.IsNull (t.Exception, "#3");
1612
1613                         Assert.That (t.Result.Exception.InnerException, Is.TypeOf (typeof (ApplicationException)), "#4");
1614                 }
1615
1616                 [Test]
1617                 public void WhenAny ()
1618                 {
1619                         var t1 = new Task (delegate { });
1620                         var t2 = new Task (delegate { t1.Start (); });
1621
1622                         var tasks = new Task[] {
1623                                 t1,
1624                                 t2,
1625                         };
1626
1627                         var t = Task.WhenAny (tasks);
1628                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#1");
1629                         t2.Start ();
1630
1631                         Assert.IsTrue (t.Wait (1000), "#2");
1632                         Assert.IsNotNull (t.Result, "#3");
1633                 }
1634
1635                 [Test]
1636                 public void WhenAnyResult_WithNull ()
1637                 {
1638                         var tasks = new [] {
1639                                 Task.FromResult (2),
1640                                 null
1641                         };
1642
1643                         try {
1644                                 Task.WhenAny<int> (tasks);
1645                                 Assert.Fail ("#1");
1646                         } catch (ArgumentException) {
1647                         }
1648
1649                         tasks = null;
1650                         try {
1651                                 Task.WhenAny<int> (tasks);
1652                                 Assert.Fail ("#2");
1653                         } catch (ArgumentException) {
1654                         }
1655
1656                         try {
1657                                 Task.WhenAny<short> (new Task<short>[0]);
1658                                 Assert.Fail ("#3");
1659                         } catch (ArgumentException) {
1660                         }
1661                 }
1662
1663                 [Test]
1664                 public void WhenAnyResult_Start ()
1665                 {
1666                         var tasks = new[] {
1667                                 Task.FromResult (2),
1668                         };
1669
1670                         var t = Task.WhenAny<int> (tasks);
1671                         Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#1");
1672
1673                         try {
1674                                 t.Start ();
1675                                 Assert.Fail ("#2");
1676                         } catch (InvalidOperationException) {
1677                         }
1678
1679                         tasks = new[] {
1680                                 new Task<int> (delegate { return 55; }),
1681                         };
1682
1683                         t = Task.WhenAny<int> (tasks);
1684                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#11");
1685
1686                         try {
1687                                 t.Start ();
1688                                 Assert.Fail ("#12");
1689                         } catch (InvalidOperationException) {
1690                         }
1691                 }
1692
1693                 [Test]
1694                 public void WhenAnyResult_Cancelled ()
1695                 {
1696                         var cancelation = new CancellationTokenSource ();
1697                         var tasks = new [] {
1698                                 new Task<double> (delegate { return 1.1; }),
1699                                 new Task<double> (delegate { return -4.4; }, cancelation.Token)
1700                         };
1701
1702                         cancelation.Cancel ();
1703
1704                         var t = Task.WhenAny<double> (tasks);
1705                         Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#1");
1706                         tasks[0].Start ();
1707
1708                         Assert.IsTrue (t.Wait (1000), "#2");
1709                         Assert.AreEqual (TaskStatus.Canceled, t.Result.Status, "#3");
1710                 }
1711
1712                 [Test]
1713                 public void WhenAnyResult_Faulted ()
1714                 {
1715                         var tcs = new TaskCompletionSource<object> ();
1716                         tcs.SetException (new ApplicationException ());
1717
1718                         var tcs2 = new TaskCompletionSource<object> ();
1719                         tcs2.SetException (new InvalidTimeZoneException ());
1720
1721                         var cancelation = new CancellationTokenSource ();
1722                         var tasks = new Task<object>[] {
1723                                 new Task<object> (delegate { return null; }),
1724                                 tcs.Task,
1725                                 new Task<object> (delegate { return ""; }, cancelation.Token),
1726                                 tcs2.Task
1727                         };
1728
1729                         cancelation.Cancel ();
1730
1731                         var t = Task.WhenAny<object> (tasks);
1732                         Assert.AreEqual (TaskStatus.RanToCompletion, t.Status, "#1");
1733                         tasks[0].Start ();
1734
1735                         Assert.IsTrue (t.Wait (1000), "#2");
1736                         Assert.IsNull (t.Exception, "#3");
1737
1738                         Assert.That (t.Result.Exception.InnerException, Is.TypeOf (typeof (ApplicationException)), "#4");
1739                 }
1740
1741                 [Test]
1742                 public void WhenAnyResult ()
1743                 {
1744                         var t1 = new Task<byte> (delegate { return 3; });
1745                         var t2 = new Task<byte> (delegate { t1.Start (); return 2; });
1746
1747                         var tasks = new [] {
1748                                 t1,
1749                                 t2,
1750                         };
1751
1752                         var t = Task.WhenAny<byte> (tasks);
1753                         Assert.AreEqual (TaskStatus.WaitingForActivation, t.Status, "#1");
1754                         t2.Start ();
1755
1756                         Assert.IsTrue (t.Wait (1000), "#2");
1757                         Assert.IsTrue (t.Result.Result > 1, "#3");
1758                 }
1759
1760                 [Test]
1761                 public void ContinueWith_StateValue ()
1762                 {
1763                         var t = Task.Factory.StartNew (l => {
1764                                 Assert.AreEqual (1, l, "a-1");
1765                         }, 1);
1766
1767                         var c = t.ContinueWith ((a, b) => {
1768                                 Assert.AreEqual (t, a, "c-1");
1769                                 Assert.AreEqual (2, b, "c-2");
1770                         }, 2);
1771
1772                         var d = t.ContinueWith ((a, b) => {
1773                                 Assert.AreEqual (t, a, "d-1");
1774                                 Assert.AreEqual (3, b, "d-2");
1775                                 return 77;
1776                         }, 3);
1777
1778                         Assert.IsTrue (d.Wait (1000), "#1");
1779
1780                         Assert.AreEqual (1, t.AsyncState, "#2");
1781                         Assert.AreEqual (2, c.AsyncState, "#3");
1782                         Assert.AreEqual (3, d.AsyncState, "#4");
1783                 }
1784
1785                 [Test]
1786                 public void ContinueWith_StateValueGeneric ()
1787                 {
1788                         var t = Task<int>.Factory.StartNew (l => {
1789                                 Assert.AreEqual (1, l, "a-1");
1790                                 return 80;
1791                         }, 1);
1792
1793                         var c = t.ContinueWith ((a, b) => {
1794                                 Assert.AreEqual (t, a, "c-1");
1795                                 Assert.AreEqual (2, b, "c-2");
1796                                 return "c";
1797                         }, 2);
1798
1799                         var d = t.ContinueWith ((a, b) => {
1800                                 Assert.AreEqual (t, a, "d-1");
1801                                 Assert.AreEqual (3, b, "d-2");
1802                                 return 'd';
1803                         }, 3);
1804
1805                         Assert.IsTrue (d.Wait (1000), "#1");
1806
1807                         Assert.AreEqual (1, t.AsyncState, "#2");
1808                         Assert.AreEqual (80, t.Result, "#2r");
1809                         Assert.AreEqual (2, c.AsyncState, "#3");
1810                         Assert.AreEqual ("c", c.Result, "#3r");
1811                         Assert.AreEqual (3, d.AsyncState, "#4");
1812                         Assert.AreEqual ('d', d.Result, "#3r");
1813                 }
1814
1815                 [Test]
1816                 public void ContinueWith_CustomScheduleRejected ()
1817                 {
1818                         var scheduler = new NonInlineableScheduler ();
1819                         var t = Task.Factory.StartNew (delegate { }).
1820                                 ContinueWith (r => {}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, scheduler);
1821
1822                         Assert.IsTrue (t.Wait (5000));
1823                 }
1824
1825                 [Test]
1826                 public void FromResult ()
1827                 {
1828                         var t = Task.FromResult<object> (null);
1829                         Assert.IsTrue (t.IsCompleted, "#1");
1830                         Assert.AreEqual (null, t.Result, "#2");
1831                         t.Dispose ();
1832                         t.Dispose ();
1833                 }
1834
1835                 [Test]
1836                 public void LongRunning ()
1837                 {
1838                         bool? is_tp = null;
1839                         bool? is_bg = null;
1840                         var t = new Task (() => { is_tp = Thread.CurrentThread.IsThreadPoolThread; is_bg = Thread.CurrentThread.IsBackground; });
1841                         t.Start ();
1842                         Assert.IsTrue (t.Wait (100));
1843                         Assert.IsTrue ((bool)is_tp, "#1");
1844                         Assert.IsTrue ((bool)is_bg, "#2");
1845
1846                         is_tp = null;
1847                         is_bg = null;
1848                         t = new Task (() => { is_tp = Thread.CurrentThread.IsThreadPoolThread; is_bg = Thread.CurrentThread.IsBackground; }, TaskCreationOptions.LongRunning);
1849                         t.Start ();
1850
1851                         Assert.IsTrue (t.Wait (100));
1852                         Assert.IsFalse ((bool) is_tp, "#11");
1853                         Assert.IsTrue ((bool) is_bg, "#12");
1854                 }
1855
1856                 [Test]
1857                 public void Run_ArgumentCheck ()
1858                 {
1859                         try {
1860                                 Task.Run (null as Action);
1861                                 Assert.Fail ("#1");
1862                         } catch (ArgumentNullException) {
1863                         }
1864                 }
1865
1866                 [Test]
1867                 public void Run ()
1868                 {
1869                         bool ranOnDefaultScheduler = false;
1870                         var t = Task.Run (delegate { ranOnDefaultScheduler = Thread.CurrentThread.IsThreadPoolThread; });
1871                         Assert.AreEqual (TaskCreationOptions.DenyChildAttach, t.CreationOptions, "#1");
1872                         t.Wait ();
1873                         Assert.IsTrue (ranOnDefaultScheduler, "#2");
1874                 }
1875
1876                 [Test]
1877                 public void Run_Cancel ()
1878                 {
1879                         var t = Task.Run (() => 1, new CancellationToken (true));
1880                         try {
1881                                 var r = t.Result;
1882                                 Assert.Fail ("#1");
1883                         } catch (AggregateException) {
1884                         }
1885
1886                         Assert.IsTrue (t.IsCanceled, "#2");
1887                 }
1888
1889                 [Test]
1890                 public void Run_ExistingTaskT ()
1891                 {
1892                         var t = new Task<int> (() => 5);
1893                         var t2 = Task.Run (() => { t.Start (); return t; });
1894
1895                         Assert.IsTrue (t2.Wait (1000), "#1");
1896                         Assert.AreEqual (5, t2.Result, "#2");
1897                 }
1898
1899                 [Test]
1900                 public void Run_ExistingTask ()
1901                 {
1902                         var t = new Task (delegate { throw new Exception ("Foo"); });
1903                         var t2 = Task.Run (() => { t.Start (); return t; });
1904
1905                         try {
1906                                 t2.Wait (1000);
1907                                 Assert.Fail ();
1908                         } catch (Exception) {}
1909
1910                         Assert.AreEqual (TaskStatus.Faulted, t.Status, "#2");
1911                 }
1912
1913                 [Test]
1914                 public void DenyChildAttachTest ()
1915                 {
1916                         var mre = new ManualResetEventSlim ();
1917                         Task nested = null;
1918                         Task parent = Task.Factory.StartNew (() => {
1919                                 nested = Task.Factory.StartNew (() => mre.Wait (2000), TaskCreationOptions.AttachedToParent);
1920                         }, TaskCreationOptions.DenyChildAttach);
1921                         Assert.IsTrue (parent.Wait (1000), "#1");
1922                         mre.Set ();
1923                         Assert.IsTrue (nested.Wait (2000), "#2");
1924                 }
1925
1926                 class SynchronousScheduler : TaskScheduler
1927                 {
1928                         protected override IEnumerable<Task> GetScheduledTasks ()
1929                         {
1930                                 throw new NotImplementedException ();
1931                         }
1932
1933                         protected override void QueueTask (Task task)
1934                         {
1935                                 TryExecuteTaskInline (task, false);
1936                         }
1937
1938                         protected override bool TryExecuteTaskInline (Task task, bool taskWasPreviouslyQueued)
1939                         {
1940                                 return base.TryExecuteTask (task);
1941                         }
1942                 }
1943
1944                 [Test]
1945                 public void HideSchedulerTest ()
1946                 {
1947                         var mre = new ManualResetEventSlim ();
1948                         var ranOnDefault = false;
1949                         var scheduler = new SynchronousScheduler ();
1950
1951                         Task parent = Task.Factory.StartNew (() => {
1952                                 Task.Factory.StartNew (() => {
1953                                         ranOnDefault = Thread.CurrentThread.IsThreadPoolThread;
1954                                         mre.Set ();
1955                                 });
1956                         }, CancellationToken.None, TaskCreationOptions.HideScheduler, scheduler);
1957
1958                         Assert.IsTrue (mre.Wait (1000), "#1");
1959                         Assert.IsTrue (ranOnDefault, "#2");
1960                 }
1961
1962                 [Test]
1963                 public void LazyCancelationTest ()
1964                 {
1965                         var source = new CancellationTokenSource ();
1966                         source.Cancel ();
1967                         var parent = new Task (delegate {});
1968                         var cont = parent.ContinueWith (delegate {}, source.Token, TaskContinuationOptions.LazyCancellation, TaskScheduler.Default);
1969
1970                         Assert.AreNotEqual (TaskStatus.Canceled, cont.Status, "#1");
1971                         parent.Start ();
1972                         try {
1973                                 Assert.IsTrue (cont.Wait (1000), "#2");
1974                                 Assert.Fail ();
1975                         } catch (AggregateException ex) {
1976                                 Assert.That (ex.InnerException, Is.TypeOf (typeof (TaskCanceledException)), "#3");
1977                         }
1978                 }
1979
1980                 [Test]
1981                 public void ChildTaskWithUnscheduledContinuationAttachedToParent ()
1982                 {
1983                         Task inner = null;
1984                         var child = Task.Factory.StartNew (() => {
1985                                 inner  = Task.Run (() => {
1986                                         throw new ApplicationException ();
1987                                 }).ContinueWith (task => { }, TaskContinuationOptions.AttachedToParent | TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.ExecuteSynchronously);
1988                         });
1989
1990                         int counter = 0;
1991                         var t = child.ContinueWith (t2 => ++counter, TaskContinuationOptions.ExecuteSynchronously);
1992                         Assert.IsTrue (t.Wait (5000), "#1");
1993                         Assert.AreEqual (1, counter, "#2");
1994                         Assert.AreEqual (TaskStatus.RanToCompletion, child.Status, "#3");
1995                         Assert.AreEqual (TaskStatus.Canceled, inner.Status, "#4");
1996                 }
1997
1998                 [Test]
1999                 [Category("NotWorking")]
2000                 public void TaskContinuationChainLeak()
2001                 {
2002                         // Start cranking out tasks, starting each new task upon completion of and from inside the prior task.
2003                         //
2004                         var tester = new TaskContinuationChainLeakTester ();
2005                         tester.Run ();
2006                         tester.TasksPilledUp.WaitOne ();
2007
2008                         // Head task should be out of scope by now.  Manually run the GC and expect that it gets collected.
2009                         //
2010                         GC.Collect ();
2011                         GC.WaitForPendingFinalizers ();
2012
2013                         try {
2014                                 // It's important that we do the asserting while the task recursion is still going, since that is the
2015                                 // crux of the problem scenario.
2016                                 //
2017                                 tester.Verify ();
2018                         } finally {
2019                                 tester.Stop ();
2020                         }
2021                 }
2022
2023                 class TaskContinuationChainLeakTester
2024                 {
2025                         volatile bool m_bStop;
2026                         int counter;
2027                         ManualResetEvent mre = new ManualResetEvent (false);
2028                         WeakReference<Task> headTaskWeakRef;
2029
2030                         public ManualResetEvent TasksPilledUp {
2031                                 get {
2032                                         return mre;
2033                                 }
2034                         }
2035
2036                         public void Run ()
2037                         {
2038                                 headTaskWeakRef = new WeakReference<Task> (StartNewTask ());
2039                         }
2040
2041                         public Task StartNewTask ()
2042                         {
2043                                 if (m_bStop)
2044                                         return null;
2045
2046                                 if (++counter == 50)
2047                                         mre.Set ();
2048
2049                                 return Task.Factory.StartNew (DummyWorker).ContinueWith (task => StartNewTask ());
2050                         }
2051
2052                         public void Stop ()
2053                         {
2054                                 m_bStop = true;
2055                         }
2056
2057                         public void Verify ()
2058                         {
2059                                 Task task;
2060                                 Assert.IsFalse (headTaskWeakRef.TryGetTarget (out task));
2061                         }
2062
2063                         void DummyWorker ()
2064                         {
2065                                 Thread.Sleep (0);
2066                         }
2067                 }
2068
2069 #endif
2070         }
2071 }
2072 #endif