diff --git a/EasyAssertions/Assertions/TaskAssertions.cs b/EasyAssertions/Assertions/TaskAssertions.cs
index 4f76086..5712972 100644
--- a/EasyAssertions/Assertions/TaskAssertions.cs
+++ b/EasyAssertions/Assertions/TaskAssertions.cs
@@ -78,8 +78,8 @@ public static void ShouldComplete<TTask>(this TTask actualTask, TimeSpan timeout
         /// </summary>
         public static ActualException<Exception> ShouldFail(this Task actualTask, string message = null)
         {
-            actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<Exception>(DefaultTimeout, message));
-            return new ActualException<Exception>(actualTask.Exception.InnerException);
+            Actual<Exception> result = actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<Exception>(DefaultTimeout, message));
+            return new ActualException<Exception>(result.Value);
         }
 
         /// <summary>
@@ -87,8 +87,8 @@ public static ActualException<Exception> ShouldFail(this Task actualTask, string
         /// </summary>
         public static ActualException<Exception> ShouldFail(this Task actualTask, uint millisecondsTimeout, string message = null)
         {
-            actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<Exception>(TimeSpan.FromMilliseconds(millisecondsTimeout), message));
-            return new ActualException<Exception>(actualTask.Exception.InnerException);
+            Actual<Exception> result = actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<Exception>(TimeSpan.FromMilliseconds(millisecondsTimeout), message));
+            return new ActualException<Exception>(result.Value);
         }
 
         /// <summary>
@@ -96,8 +96,8 @@ public static ActualException<Exception> ShouldFail(this Task actualTask, uint m
         /// </summary>
         public static ActualException<Exception> ShouldFail(this Task actualTask, TimeSpan timeout, string message = null)
         {
-            actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<Exception>(timeout, message));
-            return new ActualException<Exception>(actualTask.Exception.InnerException);
+            Actual<Exception> result = actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<Exception>(timeout, message));
+            return new ActualException<Exception>(result.Value);
         }
 
         /// <summary>
@@ -107,8 +107,8 @@ public static ActualException<Exception> ShouldFail(this Task actualTask, TimeSp
         public static ActualException<TException> ShouldFailWith<TException>(this Task actualTask, string message = null) 
             where TException : Exception
         {
-            actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<TException>(DefaultTimeout, message));
-            return new ActualException<TException>((TException)actualTask.Exception.InnerException);
+            Actual<TException> result = actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<TException>(DefaultTimeout, message));
+            return new ActualException<TException>(result.Value);
         }
 
         /// <summary>
@@ -117,8 +117,8 @@ public static ActualException<TException> ShouldFailWith<TException>(this Task a
         public static ActualException<TException> ShouldFailWith<TException>(this Task actualTask, uint millisecondsTimeout, string message = null) 
             where TException : Exception
         {
-            actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<TException>(TimeSpan.FromMilliseconds(millisecondsTimeout), message));
-            return new ActualException<TException>((TException)actualTask.Exception.InnerException);
+            Actual<TException> result = actualTask.RegisterAssertion(c => actualTask.ShouldFailWith<TException>(TimeSpan.FromMilliseconds(millisecondsTimeout), message));
+            return new ActualException<TException>(result.Value);
         }
 
         /// <summary>
@@ -141,8 +141,9 @@ public static ActualException<TException> ShouldFailWith<TException>(this Task a
                     }
                     catch (AggregateException e)
                     {
-                        if (e.InnerException is TException)
-                            return new ActualException<TException>((TException)actualTask.Exception.InnerException);
+                        TException expectedException = e.InnerException as TException;
+                        if (expectedException != null)
+                            return new ActualException<TException>(expectedException);
 
                         throw StandardErrors.Current.WrongException(typeof(TException), e.InnerException, message: message);
                     }
diff --git a/UnitTests/Assertions/TaskAssertionTests.cs b/UnitTests/Assertions/TaskAssertionTests.cs
index 6e01a2d..20ba334 100644
--- a/UnitTests/Assertions/TaskAssertionTests.cs
+++ b/UnitTests/Assertions/TaskAssertionTests.cs
@@ -226,6 +226,12 @@ public void ShouldFailWithType_FailsWithCorrectType_ReturnsException()
             AssertReturnsException(new InvalidOperationException(), TimeSpan.FromSeconds(1), () => task.ShouldFailWith<InvalidOperationException>());
         }
 
+        [Test]
+        public void ShouldFailWithType_ExpectedTaskCanceledException_TaskCancelled_ReturnsException()
+        {
+            AssertReturnsTaskCanceledException(TimeSpan.FromSeconds(1), () => task.ShouldFailWith<TaskCanceledException>());
+        }
+
         [Test]
         public void ShouldFailWithType_FailsWithWrongType_FailsWithWrongExceptionMessage()
         {
@@ -267,6 +273,12 @@ public void ShouldFailWithinMillisecondsWithType_FailsWithCorrectType_ReturnsExc
             AssertReturnsException(new InvalidOperationException(), TimeSpan.FromMilliseconds(1), () => task.ShouldFailWith<InvalidOperationException>(1));
         }
 
+        [Test]
+        public void ShouldFailWithinMillisecondsWithType_ExpectedTaskCanceledExcepton_TaskCancelled_ReturnsException()
+        {
+            AssertReturnsTaskCanceledException(TimeSpan.FromMilliseconds(1), () => task.ShouldFailWith<TaskCanceledException>(1));
+        }
+
         [Test]
         public void ShouldFailWithinMillisecondsWithType_FailsWithWrongType_FailsWithWrongExceptionMessage()
         {
@@ -307,6 +319,12 @@ public void ShouldFailWithinTimeSpanWithType_FailsWithCorrectType_ReturnsExcepti
             AssertReturnsException(new InvalidOperationException(), TimeSpan.FromMilliseconds(1), () => task.ShouldFailWith<InvalidOperationException>(TimeSpan.FromMilliseconds(1)));
         }
 
+        [Test]
+        public void ShouldFailWithinTimeSpanWithType_ExpectedTaskCanceledException_TaskCancelled_ReturnsException()
+        {
+            AssertReturnsTaskCanceledException(TimeSpan.FromMilliseconds(1), () => task.ShouldFailWith<TaskCanceledException>(TimeSpan.FromMilliseconds(1)));
+        }
+
         [Test]
         public void ShouldFailWithinTimeSpanWithType_NegativeTimeSpan_ThrowsArgumentOutOfRangeException()
         {
@@ -355,6 +373,12 @@ public void ShouldFail_Fails_ReturnsException()
             AssertReturnsException(new Exception(), TimeSpan.FromSeconds(1), () => task.ShouldFail());
         }
 
+        [Test]
+        public void ShouldFail_TaskCancelled_ReturnsException()
+        {
+            AssertReturnsTaskCanceledException(TimeSpan.FromSeconds(1), () => task.ShouldFail());
+        }
+
         [Test]
         public void ShouldFail_TimesOut_FailsWithTimeoutMessage()
         {
@@ -390,6 +414,12 @@ public void ShouldFailWithinMilliseconds_Fails_ReturnsException()
             AssertReturnsException(new Exception(), TimeSpan.FromMilliseconds(1), () => task.ShouldFail(1));
         }
 
+        [Test]
+        public void ShouldFailWithinMilliseconds_TaskCancelled_ReturnsException()
+        {
+            AssertReturnsTaskCanceledException(TimeSpan.FromMilliseconds(1), () => task.ShouldFail(1));
+        }
+
         [Test]
         public void ShouldFailWithinMilliseconds_TimesOut_FailsWithTimeoutMessage()
         {
@@ -424,6 +454,12 @@ public void ShouldFailWithinTimeSpan_Fails_ReturnsException()
             AssertReturnsException(new Exception(), TimeSpan.FromMilliseconds(1), () => task.ShouldFail(TimeSpan.FromMilliseconds(1)));
         }
 
+        [Test]
+        public void ShouldFailWithinTimeSpan_TaskCancelled_ReturnsException()
+        {
+            AssertReturnsTaskCanceledException(TimeSpan.FromMilliseconds(1), () => task.ShouldFail(TimeSpan.FromMilliseconds(1)));
+        }
+
         [Test]
         public void ShouldFailWithinTimeSpan_NegativeTimeSpan_ThrowsArgumentOutOfRangeException()
         {
@@ -478,6 +514,17 @@ private void AssertReturnsResult(int expectedResult, TimeSpan timeout, Func<Actu
             Assert.AreSame(expectedException, result.And);
         }
 
+        private void AssertReturnsTaskCanceledException<TException>(TimeSpan timeout, Func<ActualException<TException>> callAssertion)
+            where TException : Exception
+        {
+            wait(task, timeout).Returns(c => task.Wait(timeout));
+            taskSource.SetCanceled();
+
+            ActualException<TException> result = callAssertion();
+
+            Assert.IsInstanceOf<TaskCanceledException>(result.And);
+        }
+
         private void AssertTimesOut(TimeSpan timeout, Action<string> callAssertion)
         {
             Error.TaskTimedOut(timeout, "foo").Returns(ExpectedException);