fake_iasync_operation_win_unittest.cc 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/test/fake_iasync_operation_win.h"
  5. #include <asyncinfo.h>
  6. #include <wrl/event.h>
  7. #include <wrl/implements.h>
  8. #include "base/test/async_results_test_values_win.h"
  9. #include "testing/gtest/include/gtest/gtest-spi.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. using ABI::Windows::Foundation::IAsyncOperation;
  12. using ABI::Windows::Foundation::IAsyncOperationCompletedHandler;
  13. using Microsoft::WRL::Callback;
  14. using Microsoft::WRL::Make;
  15. namespace base {
  16. namespace win {
  17. namespace {
  18. constexpr HRESULT kTestError = 0x87654321;
  19. }
  20. template <typename T>
  21. class FakeIAsyncOperationTest : public ::testing::Test {};
  22. TYPED_TEST_SUITE_P(FakeIAsyncOperationTest);
  23. TYPED_TEST_P(FakeIAsyncOperationTest, MultipleCompletedHandlers) {
  24. auto operation = Make<FakeIAsyncOperation<TypeParam>>();
  25. auto handler = Callback<IAsyncOperationCompletedHandler<TypeParam>>(
  26. [](auto async_operation, AsyncStatus async_status) { return S_OK; });
  27. ASSERT_HRESULT_SUCCEEDED(operation->put_Completed(handler.Get()));
  28. EXPECT_NONFATAL_FAILURE(
  29. ASSERT_HRESULT_SUCCEEDED(operation->put_Completed(handler.Get()));
  30. , "put_Completed");
  31. }
  32. TYPED_TEST_P(FakeIAsyncOperationTest, MultipleCompletions) {
  33. auto operation = Make<FakeIAsyncOperation<TypeParam>>();
  34. base::test::AsyncResultsTestValues<TypeParam> test_values;
  35. ASSERT_NO_FATAL_FAILURE(
  36. operation->CompleteWithResults(test_values.GetTestValue_T()));
  37. // EXPECT_FATAL_FAILURE() can only reference globals and statics.
  38. // https://github.com/google/googletest/blob/main/docs/advanced.md#catching-failures
  39. static auto test_value_t = test_values.GetTestValue_T();
  40. static auto& static_operation = operation;
  41. EXPECT_FATAL_FAILURE(static_operation->CompleteWithResults(test_value_t),
  42. "already completed");
  43. operation = Make<FakeIAsyncOperation<TypeParam>>();
  44. static_operation = operation;
  45. ASSERT_NO_FATAL_FAILURE(operation->CompleteWithError(E_FAIL));
  46. EXPECT_FATAL_FAILURE(static_operation->CompleteWithError(E_FAIL),
  47. "already completed");
  48. operation = Make<FakeIAsyncOperation<TypeParam>>();
  49. static_operation = operation;
  50. ASSERT_NO_FATAL_FAILURE(operation->CompleteWithError(E_FAIL));
  51. EXPECT_FATAL_FAILURE(static_operation->CompleteWithResults(test_value_t),
  52. "already completed");
  53. operation = Make<FakeIAsyncOperation<TypeParam>>();
  54. static_operation = operation;
  55. ASSERT_NO_FATAL_FAILURE(
  56. operation->CompleteWithResults(test_values.GetTestValue_T()));
  57. EXPECT_FATAL_FAILURE(static_operation->CompleteWithError(E_FAIL),
  58. "already completed");
  59. }
  60. TYPED_TEST_P(FakeIAsyncOperationTest, CompleteWithResults_WithHandler) {
  61. auto operation = Make<FakeIAsyncOperation<TypeParam>>();
  62. bool completed_handler_called = false;
  63. ASSERT_HRESULT_SUCCEEDED(operation->put_Completed(
  64. Callback<IAsyncOperationCompletedHandler<TypeParam>>(
  65. [operation, &completed_handler_called](auto async_operation,
  66. AsyncStatus async_status) {
  67. completed_handler_called = true;
  68. EXPECT_EQ(operation.Get(), async_operation);
  69. EXPECT_EQ(async_status, AsyncStatus::Completed);
  70. return S_OK;
  71. })
  72. .Get()));
  73. ASSERT_FALSE(completed_handler_called);
  74. AsyncStatus async_status;
  75. ASSERT_HRESULT_SUCCEEDED(operation->get_Status(&async_status));
  76. ASSERT_EQ(async_status, AsyncStatus::Started);
  77. HRESULT error_code;
  78. ASSERT_HRESULT_SUCCEEDED(operation->get_ErrorCode(&error_code));
  79. ASSERT_EQ(error_code, S_OK);
  80. base::test::AsyncResultsTestValues<TypeParam> test_values;
  81. auto results = test_values.GetDefaultValue_AsyncResultsT();
  82. EXPECT_NONFATAL_FAILURE(
  83. ASSERT_HRESULT_FAILED(operation->GetResults(&results)), "GetResults");
  84. operation->CompleteWithResults(test_values.GetTestValue_AsyncResultsT());
  85. ASSERT_TRUE(completed_handler_called);
  86. ASSERT_HRESULT_SUCCEEDED(operation->get_Status(&async_status));
  87. ASSERT_EQ(async_status, AsyncStatus::Completed);
  88. ASSERT_HRESULT_SUCCEEDED(operation->get_ErrorCode(&error_code));
  89. ASSERT_EQ(error_code, S_OK);
  90. ASSERT_HRESULT_SUCCEEDED(operation->GetResults(&results));
  91. ASSERT_EQ(results, test_values.GetTestValue_AsyncResultsT());
  92. }
  93. TYPED_TEST_P(FakeIAsyncOperationTest, CompleteWithResults_WithoutHandler) {
  94. auto operation = Make<FakeIAsyncOperation<TypeParam>>();
  95. AsyncStatus async_status;
  96. ASSERT_HRESULT_SUCCEEDED(operation->get_Status(&async_status));
  97. ASSERT_EQ(async_status, AsyncStatus::Started);
  98. HRESULT error_code;
  99. ASSERT_HRESULT_SUCCEEDED(operation->get_ErrorCode(&error_code));
  100. ASSERT_EQ(error_code, S_OK);
  101. base::test::AsyncResultsTestValues<TypeParam> test_values;
  102. auto results = test_values.GetDefaultValue_AsyncResultsT();
  103. EXPECT_NONFATAL_FAILURE(
  104. ASSERT_HRESULT_FAILED(operation->GetResults(&results)), "GetResults");
  105. operation->CompleteWithResults(test_values.GetTestValue_AsyncResultsT());
  106. ASSERT_HRESULT_SUCCEEDED(operation->get_Status(&async_status));
  107. ASSERT_EQ(async_status, AsyncStatus::Completed);
  108. ASSERT_HRESULT_SUCCEEDED(operation->get_ErrorCode(&error_code));
  109. ASSERT_EQ(error_code, S_OK);
  110. ASSERT_HRESULT_SUCCEEDED(operation->GetResults(&results));
  111. ASSERT_EQ(results, test_values.GetTestValue_AsyncResultsT());
  112. }
  113. TYPED_TEST_P(FakeIAsyncOperationTest, CompleteWithError_WithHandler) {
  114. auto operation = Make<FakeIAsyncOperation<TypeParam>>();
  115. bool completed_handler_called = false;
  116. ASSERT_HRESULT_SUCCEEDED(operation->put_Completed(
  117. Callback<IAsyncOperationCompletedHandler<TypeParam>>(
  118. [operation, &completed_handler_called](auto async_operation,
  119. AsyncStatus async_status) {
  120. completed_handler_called = true;
  121. EXPECT_EQ(operation.Get(), async_operation);
  122. EXPECT_EQ(async_status, AsyncStatus::Error);
  123. return S_OK;
  124. })
  125. .Get()));
  126. ASSERT_FALSE(completed_handler_called);
  127. AsyncStatus async_status;
  128. ASSERT_HRESULT_SUCCEEDED(operation->get_Status(&async_status));
  129. ASSERT_EQ(async_status, AsyncStatus::Started);
  130. HRESULT error_code;
  131. ASSERT_HRESULT_SUCCEEDED(operation->get_ErrorCode(&error_code));
  132. ASSERT_EQ(error_code, S_OK);
  133. base::test::AsyncResultsTestValues<TypeParam> test_values;
  134. auto results = test_values.GetDefaultValue_AsyncResultsT();
  135. EXPECT_NONFATAL_FAILURE(
  136. ASSERT_HRESULT_FAILED(operation->GetResults(&results)), "GetResults");
  137. operation->CompleteWithError(kTestError);
  138. ASSERT_TRUE(completed_handler_called);
  139. ASSERT_HRESULT_SUCCEEDED(operation->get_Status(&async_status));
  140. ASSERT_EQ(async_status, AsyncStatus::Error);
  141. ASSERT_HRESULT_SUCCEEDED(operation->get_ErrorCode(&error_code));
  142. ASSERT_EQ(error_code, kTestError);
  143. ASSERT_HRESULT_FAILED(operation->GetResults(&results));
  144. }
  145. TYPED_TEST_P(FakeIAsyncOperationTest, CompleteWithError_WithoutHandler) {
  146. auto operation = Make<FakeIAsyncOperation<TypeParam>>();
  147. AsyncStatus async_status;
  148. ASSERT_HRESULT_SUCCEEDED(operation->get_Status(&async_status));
  149. ASSERT_EQ(async_status, AsyncStatus::Started);
  150. HRESULT error_code;
  151. ASSERT_HRESULT_SUCCEEDED(operation->get_ErrorCode(&error_code));
  152. ASSERT_EQ(error_code, S_OK);
  153. base::test::AsyncResultsTestValues<TypeParam> test_values;
  154. auto results = test_values.GetDefaultValue_AsyncResultsT();
  155. EXPECT_NONFATAL_FAILURE(
  156. ASSERT_HRESULT_FAILED(operation->GetResults(&results)), "GetResults");
  157. operation->CompleteWithError(kTestError);
  158. ASSERT_HRESULT_SUCCEEDED(operation->get_Status(&async_status));
  159. ASSERT_EQ(async_status, AsyncStatus::Error);
  160. ASSERT_HRESULT_SUCCEEDED(operation->get_ErrorCode(&error_code));
  161. ASSERT_EQ(error_code, kTestError);
  162. ASSERT_HRESULT_FAILED(operation->GetResults(&results));
  163. }
  164. REGISTER_TYPED_TEST_SUITE_P(FakeIAsyncOperationTest,
  165. MultipleCompletedHandlers,
  166. MultipleCompletions,
  167. CompleteWithResults_WithHandler,
  168. CompleteWithResults_WithoutHandler,
  169. CompleteWithError_WithHandler,
  170. CompleteWithError_WithoutHandler);
  171. INSTANTIATE_TYPED_TEST_SUITE_P(Win,
  172. FakeIAsyncOperationTest,
  173. base::test::AsyncResultsTestValuesTypes);
  174. } // namespace win
  175. } // namespace base