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