C++/WinRT coroutine locals may return/complete before locals are destroyed

src/test/cpp/CMakeLists.txt

@@ -9,6 +9,8 @@ target_sources(cpp_test PUBLIC
     test/AbiGuard.cpp
     test/AgileRef.cpp
     test/Async.cpp
+    test/AsyncNoSuspend.cpp
+    test/AsyncReturn.cpp
     test/Collections.cpp
     test/Composable.cpp
     test/Edge.cpp
@@ -52,6 +54,14 @@ else()
         main.cpp
         test/Interop.cpp
         test/Capture.cpp
+        test/AsyncAutoCancel.cpp
+        test/AsyncCancelCallback.cpp
+        test/AsyncCheckCancel.cpp
+        test/AsyncLocal.cpp
+        test/AsyncProgress.cpp
+        test/AsyncResult.cpp
+        test/AsyncSuspend.cpp
+        test/AsyncThrow.cpp
     )
 endif()
 

src/test/cpp/test/AsyncAutoCancel.cpp

@@ -0,0 +1,75 @@
+#include "catch.hpp"
+#include <windows.h>
+#include "winrt/Windows.Foundation.h"
+
+using namespace winrt;
+using namespace Windows::Foundation;
+
+namespace
+{
+    //
+    // Checks that the coroutine is automatically canceled when reaching a suspension point.
+    //
+
+    IAsyncAction Action(HANDLE event)
+    {
+        co_await resume_on_signal(event);
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+    }
+
+    IAsyncActionWithProgress<int> ActionWithProgress(HANDLE event)
+    {
+        co_await resume_on_signal(event);
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+    }
+
+    IAsyncOperation<int> Operation(HANDLE event)
+    {
+        co_await resume_on_signal(event);
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+        co_return 1;
+    }
+
+    IAsyncOperationWithProgress<int, int> OperationWithProgress(HANDLE event)
+    {
+        co_await resume_on_signal(event);
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+        co_return 1;
+    }
+
+    template <typename F>
+    void Check(F make)
+    {
+        handle start{ CreateEvent(nullptr, true, false, nullptr) };
+        handle completed{ CreateEvent(nullptr, true, false, nullptr) };
+        auto async = make(start.get());
+        REQUIRE(async.Status() == AsyncStatus::Started);
+
+        async.Completed([&](auto&& sender, AsyncStatus status)
+            {
+                REQUIRE(async == sender);
+                REQUIRE(status == AsyncStatus::Canceled);
+                SetEvent(completed.get());
+            });
+
+        async.Cancel();
+        SetEvent(start.get());
+        REQUIRE(WaitForSingleObject(completed.get(), 1000) == WAIT_OBJECT_0);
+
+        REQUIRE(async.Status() == AsyncStatus::Canceled);
+        REQUIRE(async.ErrorCode() == HRESULT_FROM_WIN32(ERROR_CANCELLED));
+        REQUIRE_THROWS_AS(async.GetResults(), hresult_canceled);
+    }
+}
+
+TEST_CASE("AsyncAutoCancel")
+{
+    Check(Action);
+    Check(ActionWithProgress);
+    Check(Operation);
+    Check(OperationWithProgress);
+}

src/test/cpp/test/AsyncCancelCallback.cpp

@@ -0,0 +1,95 @@
+#include "catch.hpp"
+#include <windows.h>
+#include "winrt/Windows.Foundation.h"
+
+using namespace winrt;
+using namespace Windows::Foundation;
+
+namespace
+{
+    //
+    // Checks that the cancellation callback is invoked.
+    //
+
+    IAsyncAction Action(HANDLE event, bool& canceled)
+    {
+        auto cancel = co_await get_cancellation_token();
+
+        cancel.callback([&]
+            {
+                REQUIRE(!canceled);
+                canceled = true;
+            });
+
+        co_await resume_on_signal(event);
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+    }
+
+    IAsyncActionWithProgress<int> ActionWithProgress(HANDLE event, bool& canceled)
+    {
+        auto cancel = co_await get_cancellation_token();
+
+        cancel.callback([&]
+            {
+                REQUIRE(!canceled);
+                canceled = true;
+            });
+
+        co_await resume_on_signal(event);
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+    }
+
+    IAsyncOperation<int> Operation(HANDLE event, bool& canceled)
+    {
+        auto cancel = co_await get_cancellation_token();
+
+        cancel.callback([&]
+            {
+                REQUIRE(!canceled);
+                canceled = true;
+            });
+
+        co_await resume_on_signal(event);
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+        co_return 1;
+    }
+
+    IAsyncOperationWithProgress<int, int> OperationWithProgress(HANDLE event, bool& canceled)
+    {
+        auto cancel = co_await get_cancellation_token();
+
+        cancel.callback([&]
+            {
+                REQUIRE(!canceled);
+                canceled = true;
+            });
+
+        co_await resume_on_signal(event);
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+        co_return 1;
+    }
+
+    template <typename F>
+    void Check(F make)
+    {
+        handle event{ CreateEvent(nullptr, true, false, nullptr) };
+        bool canceled = false;
+        auto async = make(event.get(), canceled);
+        async.Cancel();
+        REQUIRE(canceled);
+        SetEvent(event.get());
+        REQUIRE_THROWS_AS(async.GetResults(), hresult_canceled);
+    }
+}
+
+TEST_CASE("AsyncCancelCallback")
+{
+    Check(Action);
+    Check(ActionWithProgress);
+    Check(Operation);
+    Check(OperationWithProgress);
+}

src/test/cpp/test/AsyncCheckCancel.cpp

@@ -0,0 +1,109 @@
+#include "catch.hpp"
+#include <windows.h>
+#include "winrt/Windows.Foundation.h"
+
+using namespace winrt;
+using namespace Windows::Foundation;
+
+namespace
+{
+    //
+    // Checks that manual cancellation checks work.
+    //
+
+    IAsyncAction Action(HANDLE event, bool& canceled)
+    {
+        co_await resume_on_signal(event);
+        auto cancel = co_await get_cancellation_token();
+
+        if (cancel())
+        {
+            REQUIRE(!canceled);
+            canceled = true;
+        }
+
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+    }
+
+    IAsyncActionWithProgress<int> ActionWithProgress(HANDLE event, bool& canceled)
+    {
+        co_await resume_on_signal(event);
+        auto cancel = co_await get_cancellation_token();
+
+        if (cancel())
+        {
+            REQUIRE(!canceled);
+            canceled = true;
+        }
+
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+    }
+
+    IAsyncOperation<int> Operation(HANDLE event, bool& canceled)
+    {
+        co_await resume_on_signal(event);
+        auto cancel = co_await get_cancellation_token();
+
+        if (cancel())
+        {
+            REQUIRE(!canceled);
+            canceled = true;
+        }
+
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+        co_return 1;
+    }
+
+    IAsyncOperationWithProgress<int, int> OperationWithProgress(HANDLE event, bool& canceled)
+    {
+        co_await resume_on_signal(event);
+        auto cancel = co_await get_cancellation_token();
+
+        if (cancel())
+        {
+            REQUIRE(!canceled);
+            canceled = true;
+        }
+
+        co_await std::experimental::suspend_never();
+        REQUIRE(false);
+        co_return 1;
+    }
+
+    template <typename F>
+    void Check(F make)
+    {
+        handle start{ CreateEvent(nullptr, true, false, nullptr) };
+        handle completed{ CreateEvent(nullptr, true, false, nullptr) };
+        bool canceled = false;
+        auto async = make(start.get(), canceled);
+        REQUIRE(async.Status() == AsyncStatus::Started);
+
+        async.Completed([&](auto&& sender, AsyncStatus status)
+            {
+                REQUIRE(async == sender);
+                REQUIRE(status == AsyncStatus::Canceled);
+                REQUIRE(canceled);
+                SetEvent(completed.get());
+            });
+
+        async.Cancel();
+        SetEvent(start.get());
+        REQUIRE(WaitForSingleObject(completed.get(), 1000) == WAIT_OBJECT_0);
+
+        REQUIRE(async.Status() == AsyncStatus::Canceled);
+        REQUIRE(async.ErrorCode() == HRESULT_FROM_WIN32(ERROR_CANCELLED));
+        REQUIRE_THROWS_AS(async.GetResults(), hresult_canceled);
+    }
+}
+
+TEST_CASE("AsyncCheckCancel")
+{
+    Check(Action);
+    Check(ActionWithProgress);
+    Check(Operation);
+    Check(OperationWithProgress);
+}

src/test/cpp/test/AsyncLocal.cpp

@@ -0,0 +1,76 @@
+#include "catch.hpp"
+#include <windows.h>
+#include "winrt/Windows.Foundation.h"
+
+using namespace winrt;
+using namespace Windows::Foundation;
+
+namespace
+{
+    //
+    // Checks that coroutine locals are destroyed prior to notifying waiters.
+    //
+
+    struct Local
+    {
+        bool& destroyed;
+
+        ~Local()
+        {
+            REQUIRE(!destroyed);
+            destroyed = true;
+        }
+    };
+
+    IAsyncAction Action(HANDLE event, bool& destroyed)
+    {
+        co_await resume_on_signal(event);
+        Local local{ destroyed };
+    }
+
+    IAsyncActionWithProgress<int> ActionWithProgress(HANDLE event, bool& destroyed)
+    {
+        co_await resume_on_signal(event);
+        Local local{ destroyed };
+    }
+
+    IAsyncOperation<int> Operation(HANDLE event, bool& destroyed)
+    {
+        co_await resume_on_signal(event);
+        Local local{ destroyed };
+        co_return 1;
+    }
+
+    IAsyncOperationWithProgress<int, int> OperationWithProgress(HANDLE event, bool& destroyed)
+    {
+        co_await resume_on_signal(event);
+        Local local{ destroyed };
+        co_return 1;
+    }
+
+    template <typename F>
+    void Check(F make)
+    {
+        handle start{ CreateEvent(nullptr, true, false, nullptr) };
+        handle completed{ CreateEvent(nullptr, true, false, nullptr) };
+        bool destroyed = false;
+        auto async = make(start.get(), destroyed);
+
+        async.Completed([&](auto&&...)
+            {
+                REQUIRE(destroyed);
+                SetEvent(completed.get());
+            });
+
+        SetEvent(start.get());
+        REQUIRE(WaitForSingleObject(completed.get(), 1000) == WAIT_OBJECT_0);
+    }
+}
+
+TEST_CASE("AsyncLocal")
+{
+    Check(Action);
+    Check(ActionWithProgress);
+    Check(Operation);
+    Check(OperationWithProgress);
+}