anchor.diff:              | :? TaskCanceledException as t -> ()
               | _ -> reraise()
           Assert.IsTrue (t.IsCompleted, "Task is not completed")
  +
  +    [<Test>]
  +    member this.``AwaitTask ignores Async cancellation`` () =
  +        let cts = new CancellationTokenSource()
  +        let tcs = new TaskCompletionSource<unit>()
  +        let innerTcs = new TaskCompletionSource<unit>()
  +        let a = innerTcs.Task |> Async.AwaitTask
  +
  +        Async.StartWithContinuations(a, tcs.SetResult, tcs.SetException, ignore >> tcs.SetCanceled, cts.Token)
  +
  +        cts.CancelAfter(100)
  +        try
  +            let result = tcs.Task.Wait(300)
  +            Assert.IsFalse (result)
  +        with :? AggregateException -> Assert.Fail "Should not finish, yet"
  +
  +        innerTcs.SetResult ()
  +
  +        try
  +            this.WaitASec tcs.Task
  +        with :? AggregateException as a ->
  +            match a.InnerException with
  +            | :? TaskCanceledException -> ()
  +            | _ -> reraise()
  +        Assert.IsTrue (tcs.Task.IsCompleted, "Task is not completed")
   
       [<Test>]
       member this.StartTask () =
  
positive.code:     [<Test>]
      member this.StartAsTaskCancellation () =
          let cts = new CancellationTokenSource()
          let tcs = TaskCompletionSource<unit>()
          let a = async {
              cts.CancelAfter (100)
              do! tcs.Task |> Async.AwaitTask }
  #if !NET46
          let t : Task<unit> =
  #else
  
negative.code: #endif
              Async.StartAsTask(a, cancellationToken = cts.Token)
  
          // Should not finish, we don't eagerly mark the task done just because it's been signaled to cancel.
          try
              let result = t.Wait(300)
              Assert.IsFalse (result)
          with :? AggregateException -> Assert.Fail "Task should not finish, yet"
  
          spinloop <- false
          
          try
              this.WaitASec t
  