callback_helpers_unittest.cc 9.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269
  1. // Copyright 2013 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/callback_helpers.h"
  5. #include <functional>
  6. #include <type_traits>
  7. #include "base/bind.h"
  8. #include "base/callback.h"
  9. #include "base/test/gtest_util.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. namespace {
  12. TEST(CallbackHelpersTest, IsBaseCallback) {
  13. // Check that base::{Once,Repeating}Closures and references to them are
  14. // considered base::{Once,Repeating}Callbacks.
  15. static_assert(base::IsBaseCallback<base::OnceClosure>::value, "");
  16. static_assert(base::IsBaseCallback<base::RepeatingClosure>::value, "");
  17. static_assert(base::IsBaseCallback<base::OnceClosure&&>::value, "");
  18. static_assert(base::IsBaseCallback<const base::RepeatingClosure&>::value, "");
  19. // Check that base::{Once, Repeating}Callbacks with a given RunType and
  20. // references to them are considered base::{Once, Repeating}Callbacks.
  21. static_assert(base::IsBaseCallback<base::OnceCallback<int(int)>>::value, "");
  22. static_assert(base::IsBaseCallback<base::RepeatingCallback<int(int)>>::value,
  23. "");
  24. static_assert(base::IsBaseCallback<base::OnceCallback<int(int)>&&>::value,
  25. "");
  26. static_assert(
  27. base::IsBaseCallback<const base::RepeatingCallback<int(int)>&>::value,
  28. "");
  29. // Check that POD types are not considered base::{Once, Repeating}Callbacks.
  30. static_assert(!base::IsBaseCallback<bool>::value, "");
  31. static_assert(!base::IsBaseCallback<int>::value, "");
  32. static_assert(!base::IsBaseCallback<double>::value, "");
  33. // Check that the closely related std::function is not considered a
  34. // base::{Once, Repeating}Callback.
  35. static_assert(!base::IsBaseCallback<std::function<void()>>::value, "");
  36. static_assert(!base::IsBaseCallback<const std::function<void()>&>::value, "");
  37. static_assert(!base::IsBaseCallback<std::function<void()>&&>::value, "");
  38. }
  39. TEST(CallbackHelpersTest, IsOnceCallback) {
  40. // Check that base::OnceClosures and references to them are considered
  41. // base::OnceCallbacks, but base::RepeatingClosures are not.
  42. static_assert(base::IsOnceCallback<base::OnceClosure>::value, "");
  43. static_assert(!base::IsOnceCallback<base::RepeatingClosure>::value, "");
  44. static_assert(base::IsOnceCallback<base::OnceClosure&&>::value, "");
  45. static_assert(!base::IsOnceCallback<const base::RepeatingClosure&>::value,
  46. "");
  47. // Check that base::OnceCallbacks with a given RunType and references to them
  48. // are considered base::OnceCallbacks, but base::RepeatingCallbacks are not.
  49. static_assert(base::IsOnceCallback<base::OnceCallback<int(int)>>::value, "");
  50. static_assert(!base::IsOnceCallback<base::RepeatingCallback<int(int)>>::value,
  51. "");
  52. static_assert(base::IsOnceCallback<base::OnceCallback<int(int)>&&>::value,
  53. "");
  54. static_assert(
  55. !base::IsOnceCallback<const base::RepeatingCallback<int(int)>&>::value,
  56. "");
  57. // Check that POD types are not considered base::OnceCallbacks.
  58. static_assert(!base::IsOnceCallback<bool>::value, "");
  59. static_assert(!base::IsOnceCallback<int>::value, "");
  60. static_assert(!base::IsOnceCallback<double>::value, "");
  61. // Check that the closely related std::function is not considered a
  62. // base::OnceCallback.
  63. static_assert(!base::IsOnceCallback<std::function<void()>>::value, "");
  64. static_assert(!base::IsOnceCallback<const std::function<void()>&>::value, "");
  65. static_assert(!base::IsOnceCallback<std::function<void()>&&>::value, "");
  66. // Check that the result of BindOnce is a OnceCallback.
  67. auto cb = base::BindOnce([](int* count) { ++*count; });
  68. static_assert(base::IsOnceCallback<decltype(cb)>::value, "");
  69. }
  70. void Increment(int* value) {
  71. (*value)++;
  72. }
  73. TEST(CallbackHelpersTest, ScopedClosureRunnerHasClosure) {
  74. base::ScopedClosureRunner runner1;
  75. EXPECT_FALSE(runner1);
  76. base::ScopedClosureRunner runner2{base::DoNothing()};
  77. EXPECT_TRUE(runner2);
  78. }
  79. TEST(CallbackHelpersTest, ScopedClosureRunnerExitScope) {
  80. int run_count = 0;
  81. {
  82. base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count));
  83. EXPECT_EQ(0, run_count);
  84. }
  85. EXPECT_EQ(1, run_count);
  86. }
  87. TEST(CallbackHelpersTest, ScopedClosureRunnerRelease) {
  88. int run_count = 0;
  89. base::OnceClosure c;
  90. {
  91. base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count));
  92. c = runner.Release();
  93. EXPECT_EQ(0, run_count);
  94. }
  95. EXPECT_EQ(0, run_count);
  96. std::move(c).Run();
  97. EXPECT_EQ(1, run_count);
  98. }
  99. TEST(CallbackHelpersTest, ScopedClosureRunnerReplaceClosure) {
  100. int run_count_1 = 0;
  101. int run_count_2 = 0;
  102. {
  103. base::ScopedClosureRunner runner;
  104. runner.ReplaceClosure(base::BindOnce(&Increment, &run_count_1));
  105. runner.ReplaceClosure(base::BindOnce(&Increment, &run_count_2));
  106. EXPECT_EQ(0, run_count_1);
  107. EXPECT_EQ(0, run_count_2);
  108. }
  109. EXPECT_EQ(0, run_count_1);
  110. EXPECT_EQ(1, run_count_2);
  111. }
  112. TEST(CallbackHelpersTest, ScopedClosureRunnerRunAndResetNonNull) {
  113. int run_count_3 = 0;
  114. {
  115. base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count_3));
  116. EXPECT_EQ(0, run_count_3);
  117. runner.RunAndReset();
  118. EXPECT_EQ(1, run_count_3);
  119. }
  120. EXPECT_EQ(1, run_count_3);
  121. }
  122. TEST(CallbackHelpersTest, ScopedClosureRunnerRunAndResetNull) {
  123. base::ScopedClosureRunner runner;
  124. runner.RunAndReset(); // Should not crash.
  125. }
  126. TEST(CallbackHelpersTest, ScopedClosureRunnerMoveConstructor) {
  127. int run_count = 0;
  128. {
  129. std::unique_ptr<base::ScopedClosureRunner> runner(
  130. new base::ScopedClosureRunner(base::BindOnce(&Increment, &run_count)));
  131. base::ScopedClosureRunner runner2(std::move(*runner));
  132. runner.reset();
  133. EXPECT_EQ(0, run_count);
  134. }
  135. EXPECT_EQ(1, run_count);
  136. }
  137. TEST(CallbackHelpersTest, ScopedClosureRunnerMoveAssignment) {
  138. int run_count_1 = 0;
  139. int run_count_2 = 0;
  140. {
  141. base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count_1));
  142. {
  143. base::ScopedClosureRunner runner2(
  144. base::BindOnce(&Increment, &run_count_2));
  145. runner = std::move(runner2);
  146. EXPECT_EQ(1, run_count_1);
  147. EXPECT_EQ(0, run_count_2);
  148. }
  149. EXPECT_EQ(1, run_count_1);
  150. EXPECT_EQ(0, run_count_2);
  151. }
  152. EXPECT_EQ(1, run_count_1);
  153. EXPECT_EQ(1, run_count_2);
  154. }
  155. TEST(CallbackHelpersTest, SplitOnceCallback_EmptyCallback) {
  156. base::OnceCallback<void(int*)> cb = base::NullCallback();
  157. EXPECT_FALSE(cb);
  158. auto split = base::SplitOnceCallback(std::move(cb));
  159. static_assert(std::is_same<decltype(split),
  160. std::pair<base::OnceCallback<void(int*)>,
  161. base::OnceCallback<void(int*)>>>::value,
  162. "");
  163. EXPECT_FALSE(split.first);
  164. EXPECT_FALSE(split.second);
  165. }
  166. TEST(CallbackHelpersTest, SplitOnceCallback_FirstCallback) {
  167. int count = 0;
  168. base::OnceCallback<void(int*)> cb =
  169. base::BindOnce([](int* count) { ++*count; });
  170. auto split = base::SplitOnceCallback(std::move(cb));
  171. static_assert(std::is_same<decltype(split),
  172. std::pair<base::OnceCallback<void(int*)>,
  173. base::OnceCallback<void(int*)>>>::value,
  174. "");
  175. EXPECT_EQ(0, count);
  176. std::move(split.first).Run(&count);
  177. EXPECT_EQ(1, count);
  178. #if GTEST_HAS_DEATH_TEST
  179. EXPECT_CHECK_DEATH(std::move(split.second).Run(&count));
  180. #endif // GTEST_HAS_DEATH_TEST
  181. }
  182. TEST(CallbackHelpersTest, SplitOnceCallback_SecondCallback) {
  183. int count = 0;
  184. base::OnceCallback<void(int*)> cb =
  185. base::BindOnce([](int* count) { ++*count; });
  186. auto split = base::SplitOnceCallback(std::move(cb));
  187. static_assert(std::is_same<decltype(split),
  188. std::pair<base::OnceCallback<void(int*)>,
  189. base::OnceCallback<void(int*)>>>::value,
  190. "");
  191. EXPECT_EQ(0, count);
  192. std::move(split.second).Run(&count);
  193. EXPECT_EQ(1, count);
  194. EXPECT_CHECK_DEATH(std::move(split.first).Run(&count));
  195. }
  196. TEST(CallbackHelpersTest, SplitSplitOnceCallback_FirstSplit) {
  197. int count = 0;
  198. base::OnceCallback<void(int*)> cb =
  199. base::BindOnce([](int* count) { ++*count; });
  200. auto split = base::SplitOnceCallback(std::move(cb));
  201. base::OnceCallback<void(int*)> cb1 = std::move(split.first);
  202. split = base::SplitOnceCallback(std::move(split.second));
  203. base::OnceCallback<void(int*)> cb2 = std::move(split.first);
  204. base::OnceCallback<void(int*)> cb3 = std::move(split.second);
  205. EXPECT_EQ(0, count);
  206. std::move(cb1).Run(&count);
  207. EXPECT_EQ(1, count);
  208. EXPECT_CHECK_DEATH(std::move(cb3).Run(&count));
  209. }
  210. TEST(CallbackHelpersTest, SplitSplitOnceCallback_SecondSplit) {
  211. int count = 0;
  212. base::OnceCallback<void(int*)> cb =
  213. base::BindOnce([](int* count) { ++*count; });
  214. auto split = base::SplitOnceCallback(std::move(cb));
  215. base::OnceCallback<void(int*)> cb1 = std::move(split.first);
  216. split = base::SplitOnceCallback(std::move(split.second));
  217. base::OnceCallback<void(int*)> cb2 = std::move(split.first);
  218. base::OnceCallback<void(int*)> cb3 = std::move(split.second);
  219. EXPECT_EQ(0, count);
  220. std::move(cb2).Run(&count);
  221. EXPECT_EQ(1, count);
  222. EXPECT_CHECK_DEATH(std::move(cb1).Run(&count));
  223. }
  224. } // namespace