base/functional/callback_helpers_unittest.cc

   1 // Copyright 2013 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/functional/callback_helpers.h"
   6
   7 #include <functional>
   8 #include <type_traits>
   9
  10 #include "base/functional/bind.h"
  11 #include "base/functional/callback.h"
  12 #include "base/test/gtest_util.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace {
  16
  17 TEST(CallbackHelpersTest, IsBaseCallback) {
  18   // Check that base::{Once,Repeating}Closures and references to them are
  19   // considered base::{Once,Repeating}Callbacks.
  20   static_assert(base::IsBaseCallback<base::OnceClosure>::value, "");
  21   static_assert(base::IsBaseCallback<base::RepeatingClosure>::value, "");
  22   static_assert(base::IsBaseCallback<base::OnceClosure&&>::value, "");
  23   static_assert(base::IsBaseCallback<const base::RepeatingClosure&>::value, "");
  24
  25   // Check that base::{Once, Repeating}Callbacks with a given RunType and
  26   // references to them are considered base::{Once, Repeating}Callbacks.
  27   static_assert(base::IsBaseCallback<base::OnceCallback<int(int)>>::value, "");
  28   static_assert(base::IsBaseCallback<base::RepeatingCallback<int(int)>>::value,
  29                 "");
  30   static_assert(base::IsBaseCallback<base::OnceCallback<int(int)>&&>::value,
  31                 "");
  32   static_assert(
  33       base::IsBaseCallback<const base::RepeatingCallback<int(int)>&>::value,
  34       "");
  35
  36   // Check that POD types are not considered base::{Once, Repeating}Callbacks.
  37   static_assert(!base::IsBaseCallback<bool>::value, "");
  38   static_assert(!base::IsBaseCallback<int>::value, "");
  39   static_assert(!base::IsBaseCallback<double>::value, "");
  40
  41   // Check that the closely related std::function is not considered a
  42   // base::{Once, Repeating}Callback.
  43   static_assert(!base::IsBaseCallback<std::function<void()>>::value, "");
  44   static_assert(!base::IsBaseCallback<const std::function<void()>&>::value, "");
  45   static_assert(!base::IsBaseCallback<std::function<void()>&&>::value, "");
  46 }
  47
  48 TEST(CallbackHelpersTest, IsOnceCallback) {
  49   // Check that base::OnceClosures and references to them are considered
  50   // base::OnceCallbacks, but base::RepeatingClosures are not.
  51   static_assert(base::IsOnceCallback<base::OnceClosure>::value, "");
  52   static_assert(!base::IsOnceCallback<base::RepeatingClosure>::value, "");
  53   static_assert(base::IsOnceCallback<base::OnceClosure&&>::value, "");
  54   static_assert(!base::IsOnceCallback<const base::RepeatingClosure&>::value,
  55                 "");
  56
  57   // Check that base::OnceCallbacks with a given RunType and references to them
  58   // are considered base::OnceCallbacks, but base::RepeatingCallbacks are not.
  59   static_assert(base::IsOnceCallback<base::OnceCallback<int(int)>>::value, "");
  60   static_assert(!base::IsOnceCallback<base::RepeatingCallback<int(int)>>::value,
  61                 "");
  62   static_assert(base::IsOnceCallback<base::OnceCallback<int(int)>&&>::value,
  63                 "");
  64   static_assert(
  65       !base::IsOnceCallback<const base::RepeatingCallback<int(int)>&>::value,
  66       "");
  67
  68   // Check that POD types are not considered base::OnceCallbacks.
  69   static_assert(!base::IsOnceCallback<bool>::value, "");
  70   static_assert(!base::IsOnceCallback<int>::value, "");
  71   static_assert(!base::IsOnceCallback<double>::value, "");
  72
  73   // Check that the closely related std::function is not considered a
  74   // base::OnceCallback.
  75   static_assert(!base::IsOnceCallback<std::function<void()>>::value, "");
  76   static_assert(!base::IsOnceCallback<const std::function<void()>&>::value, "");
  77   static_assert(!base::IsOnceCallback<std::function<void()>&&>::value, "");
  78
  79   // Check that the result of BindOnce is a OnceCallback.
  80   auto cb = base::BindOnce([](int* count) { ++*count; });
  81   static_assert(base::IsOnceCallback<decltype(cb)>::value, "");
  82 }
  83
  84 void Increment(int* value) {
  85   (*value)++;
  86 }
  87
  88 void IncrementWithRef(int& value) {
  89   value++;
  90 }
  91
  92 TEST(CallbackHelpersTest, ScopedClosureRunnerHasClosure) {
  93   base::ScopedClosureRunner runner1;
  94   EXPECT_FALSE(runner1);
  95
  96   base::ScopedClosureRunner runner2{base::DoNothing()};
  97   EXPECT_TRUE(runner2);
  98 }
  99
 100 TEST(CallbackHelpersTest, ScopedClosureRunnerExitScope) {
 101   int run_count = 0;
 102   {
 103     base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count));
 104     EXPECT_EQ(0, run_count);
 105   }
 106   EXPECT_EQ(1, run_count);
 107 }
 108
 109 TEST(CallbackHelpersTest, ScopedClosureRunnerRelease) {
 110   int run_count = 0;
 111   base::OnceClosure c;
 112   {
 113     base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count));
 114     c = runner.Release();
 115     EXPECT_EQ(0, run_count);
 116   }
 117   EXPECT_EQ(0, run_count);
 118   std::move(c).Run();
 119   EXPECT_EQ(1, run_count);
 120 }
 121
 122 TEST(CallbackHelpersTest, ScopedClosureRunnerReplaceClosure) {
 123   int run_count_1 = 0;
 124   int run_count_2 = 0;
 125   {
 126     base::ScopedClosureRunner runner;
 127     runner.ReplaceClosure(base::BindOnce(&Increment, &run_count_1));
 128     runner.ReplaceClosure(base::BindOnce(&Increment, &run_count_2));
 129     EXPECT_EQ(0, run_count_1);
 130     EXPECT_EQ(0, run_count_2);
 131   }
 132   EXPECT_EQ(0, run_count_1);
 133   EXPECT_EQ(1, run_count_2);
 134 }
 135
 136 TEST(CallbackHelpersTest, ScopedClosureRunnerRunAndResetNonNull) {
 137   int run_count_3 = 0;
 138   {
 139     base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count_3));
 140     EXPECT_EQ(0, run_count_3);
 141     runner.RunAndReset();
 142     EXPECT_EQ(1, run_count_3);
 143   }
 144   EXPECT_EQ(1, run_count_3);
 145 }
 146
 147 TEST(CallbackHelpersTest, ScopedClosureRunnerRunAndResetNull) {
 148   base::ScopedClosureRunner runner;
 149   runner.RunAndReset();  // Should not crash.
 150 }
 151
 152 TEST(CallbackHelpersTest, ScopedClosureRunnerMoveConstructor) {
 153   int run_count = 0;
 154   {
 155     std::unique_ptr<base::ScopedClosureRunner> runner(
 156         new base::ScopedClosureRunner(base::BindOnce(&Increment, &run_count)));
 157     base::ScopedClosureRunner runner2(std::move(*runner));
 158     runner.reset();
 159     EXPECT_EQ(0, run_count);
 160   }
 161   EXPECT_EQ(1, run_count);
 162 }
 163
 164 TEST(CallbackHelpersTest, ScopedClosureRunnerMoveAssignment) {
 165   int run_count_1 = 0;
 166   int run_count_2 = 0;
 167   {
 168     base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count_1));
 169     {
 170       base::ScopedClosureRunner runner2(
 171           base::BindOnce(&Increment, &run_count_2));
 172       runner = std::move(runner2);
 173       EXPECT_EQ(1, run_count_1);
 174       EXPECT_EQ(0, run_count_2);
 175     }
 176     EXPECT_EQ(1, run_count_1);
 177     EXPECT_EQ(0, run_count_2);
 178   }
 179   EXPECT_EQ(1, run_count_1);
 180   EXPECT_EQ(1, run_count_2);
 181 }
 182
 183 TEST(CallbackHelpersTest, SplitOnceCallback_EmptyCallback) {
 184   base::OnceCallback<void(int*)> cb = base::NullCallback();
 185   EXPECT_FALSE(cb);
 186
 187   auto split = base::SplitOnceCallback(std::move(cb));
 188
 189   static_assert(std::is_same_v<decltype(split),
 190                                std::pair<base::OnceCallback<void(int*)>,
 191                                          base::OnceCallback<void(int*)>>>,
 192                 "");
 193   EXPECT_FALSE(split.first);
 194   EXPECT_FALSE(split.second);
 195 }
 196
 197 TEST(CallbackHelpersTest, SplitOnceCallback_FirstCallback) {
 198   int count = 0;
 199   base::OnceCallback<void(int*)> cb =
 200       base::BindOnce([](int* count) { ++*count; });
 201
 202   auto split = base::SplitOnceCallback(std::move(cb));
 203
 204   static_assert(std::is_same_v<decltype(split),
 205                                std::pair<base::OnceCallback<void(int*)>,
 206                                          base::OnceCallback<void(int*)>>>,
 207                 "");
 208
 209   EXPECT_EQ(0, count);
 210   std::move(split.first).Run(&count);
 211   EXPECT_EQ(1, count);
 212
 213 #if GTEST_HAS_DEATH_TEST
 214   EXPECT_CHECK_DEATH(std::move(split.second).Run(&count));
 215 #endif  // GTEST_HAS_DEATH_TEST
 216 }
 217
 218 TEST(CallbackHelpersTest, SplitOnceCallback_SecondCallback) {
 219   int count = 0;
 220   base::OnceCallback<void(int*)> cb =
 221       base::BindOnce([](int* count) { ++*count; });
 222
 223   auto split = base::SplitOnceCallback(std::move(cb));
 224
 225   static_assert(std::is_same_v<decltype(split),
 226                                std::pair<base::OnceCallback<void(int*)>,
 227                                          base::OnceCallback<void(int*)>>>,
 228                 "");
 229
 230   EXPECT_EQ(0, count);
 231   std::move(split.second).Run(&count);
 232   EXPECT_EQ(1, count);
 233
 234   EXPECT_CHECK_DEATH(std::move(split.first).Run(&count));
 235 }
 236
 237 TEST(CallbackHelpersTest, SplitSplitOnceCallback_FirstSplit) {
 238   int count = 0;
 239   base::OnceCallback<void(int*)> cb =
 240       base::BindOnce([](int* count) { ++*count; });
 241
 242   auto split = base::SplitOnceCallback(std::move(cb));
 243   base::OnceCallback<void(int*)> cb1 = std::move(split.first);
 244   split = base::SplitOnceCallback(std::move(split.second));
 245   base::OnceCallback<void(int*)> cb2 = std::move(split.first);
 246   base::OnceCallback<void(int*)> cb3 = std::move(split.second);
 247
 248   EXPECT_EQ(0, count);
 249   std::move(cb1).Run(&count);
 250   EXPECT_EQ(1, count);
 251
 252   EXPECT_CHECK_DEATH(std::move(cb3).Run(&count));
 253 }
 254
 255 TEST(CallbackHelpersTest, SplitSplitOnceCallback_SecondSplit) {
 256   int count = 0;
 257   base::OnceCallback<void(int*)> cb =
 258       base::BindOnce([](int* count) { ++*count; });
 259
 260   auto split = base::SplitOnceCallback(std::move(cb));
 261   base::OnceCallback<void(int*)> cb1 = std::move(split.first);
 262   split = base::SplitOnceCallback(std::move(split.second));
 263   base::OnceCallback<void(int*)> cb2 = std::move(split.first);
 264   base::OnceCallback<void(int*)> cb3 = std::move(split.second);
 265
 266   EXPECT_EQ(0, count);
 267   std::move(cb2).Run(&count);
 268   EXPECT_EQ(1, count);
 269
 270   EXPECT_CHECK_DEATH(std::move(cb1).Run(&count));
 271 }
 272
 273 TEST(CallbackHelpersTest, IgnoreArgs) {
 274   int count = 0;
 275   base::RepeatingClosure repeating_closure =
 276       base::BindRepeating(&Increment, &count);
 277   base::OnceClosure once_closure = base::BindOnce(&Increment, &count);
 278
 279   base::RepeatingCallback<void(int)> repeating_int_cb =
 280       base::IgnoreArgs<int>(repeating_closure);
 281   EXPECT_EQ(0, count);
 282   repeating_int_cb.Run(42);
 283   EXPECT_EQ(1, count);
 284   repeating_int_cb.Run(42);
 285   EXPECT_EQ(2, count);
 286
 287   base::OnceCallback<void(int)> once_int_cb =
 288       base::IgnoreArgs<int>(std::move(once_closure));
 289   EXPECT_EQ(2, count);
 290   std::move(once_int_cb).Run(42);
 291   EXPECT_EQ(3, count);
 292
 293   // Ignore only some (one) argument and forward the rest.
 294   auto repeating_callback = base::BindRepeating(&Increment);
 295   auto repeating_cb_with_extra_arg = base::IgnoreArgs<bool>(repeating_callback);
 296   repeating_cb_with_extra_arg.Run(false, &count);
 297   EXPECT_EQ(4, count);
 298
 299   // Ignore two arguments and forward the rest.
 300   auto once_callback = base::BindOnce(&Increment);
 301   auto once_cb_with_extra_arg =
 302       base::IgnoreArgs<char, bool>(repeating_callback);
 303   std::move(once_cb_with_extra_arg).Run('d', false, &count);
 304   EXPECT_EQ(5, count);
 305 }
 306
 307 TEST(CallbackHelpersTest, IgnoreArgs_EmptyCallback) {
 308   base::RepeatingCallback<void(int)> repeating_int_cb =
 309       base::IgnoreArgs<int>(base::RepeatingClosure());
 310   EXPECT_FALSE(repeating_int_cb);
 311
 312   base::OnceCallback<void(int)> once_int_cb =
 313       base::IgnoreArgs<int>(base::OnceClosure());
 314   EXPECT_FALSE(once_int_cb);
 315 }
 316
 317 TEST(CallbackHelpersTest, ForwardRepeatingCallbacks) {
 318   int count = 0;
 319   auto tie_cb =
 320       base::ForwardRepeatingCallbacks({base::BindRepeating(&IncrementWithRef),
 321                                        base::BindRepeating(&IncrementWithRef)});
 322
 323   tie_cb.Run(count);
 324   EXPECT_EQ(count, 2);
 325
 326   tie_cb.Run(count);
 327   EXPECT_EQ(count, 4);
 328 }
 329
 330 TEST(CallbackHelpersTest, ReturnValueOnce) {
 331   // Check that copyable types are supported.
 332   auto string_factory = base::ReturnValueOnce(std::string("test"));
 333   static_assert(std::is_same_v<decltype(string_factory),
 334                                base::OnceCallback<std::string(void)>>);
 335   EXPECT_EQ(std::move(string_factory).Run(), "test");
 336
 337   // Check that move-only types are supported.
 338   auto unique_ptr_factory = base::ReturnValueOnce(std::make_unique<int>(42));
 339   static_assert(std::is_same_v<decltype(unique_ptr_factory),
 340                                base::OnceCallback<std::unique_ptr<int>(void)>>);
 341   EXPECT_EQ(*std::move(unique_ptr_factory).Run(), 42);
 342 }
 343
 344 }  // namespace