base/callback_helpers_unittest.cc

   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
   5 #include "base/callback_helpers.h"
   6
   7 #include <functional>
   8 #include <type_traits>
   9
  10 #include "base/bind.h"
  11 #include "base/callback.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace {
  15
  16 TEST(CallbackHelpersTest, IsBaseCallback) {
  17   // Check that base::{Once,Repeating}Closures and references to them are
  18   // considered base::{Once,Repeating}Callbacks.
  19   static_assert(base::IsBaseCallback<base::OnceClosure>::value, "");
  20   static_assert(base::IsBaseCallback<base::RepeatingClosure>::value, "");
  21   static_assert(base::IsBaseCallback<base::OnceClosure&&>::value, "");
  22   static_assert(base::IsBaseCallback<const base::RepeatingClosure&>::value, "");
  23
  24   // Check that base::Callbacks with a given RunType and references to them are
  25   // considered base::Callbacks.
  26   static_assert(base::IsBaseCallback<base::OnceCallback<int(int)>>::value, "");
  27   static_assert(base::IsBaseCallback<base::RepeatingCallback<int(int)>>::value,
  28                 "");
  29   static_assert(base::IsBaseCallback<base::OnceCallback<int(int)>&&>::value,
  30                 "");
  31   static_assert(
  32       base::IsBaseCallback<const base::RepeatingCallback<int(int)>&>::value,
  33       "");
  34
  35   // Check that POD types are not considered base::Callbacks.
  36   static_assert(!base::IsBaseCallback<bool>::value, "");
  37   static_assert(!base::IsBaseCallback<int>::value, "");
  38   static_assert(!base::IsBaseCallback<double>::value, "");
  39
  40   // Check that the closely related std::function is not considered a
  41   // base::Callback.
  42   static_assert(!base::IsBaseCallback<std::function<void()>>::value, "");
  43   static_assert(!base::IsBaseCallback<const std::function<void()>&>::value, "");
  44   static_assert(!base::IsBaseCallback<std::function<void()>&&>::value, "");
  45 }
  46
  47 TEST(CallbackHelpersTest, IsOnceCallback) {
  48   // Check that base::OnceClosures and references to them are considered
  49   // base::OnceCallbacks, but base::RepeatingClosures are not.
  50   static_assert(base::IsOnceCallback<base::OnceClosure>::value, "");
  51   static_assert(!base::IsOnceCallback<base::RepeatingClosure>::value, "");
  52   static_assert(base::IsOnceCallback<base::OnceClosure&&>::value, "");
  53   static_assert(!base::IsOnceCallback<const base::RepeatingClosure&>::value,
  54                 "");
  55
  56   // Check that base::OnceCallbacks with a given RunType and references to them
  57   // are considered base::OnceCallbacks, but base::RepeatingCallbacks are not.
  58   static_assert(base::IsOnceCallback<base::OnceCallback<int(int)>>::value, "");
  59   static_assert(!base::IsOnceCallback<base::RepeatingCallback<int(int)>>::value,
  60                 "");
  61   static_assert(base::IsOnceCallback<base::OnceCallback<int(int)>&&>::value,
  62                 "");
  63   static_assert(
  64       !base::IsOnceCallback<const base::RepeatingCallback<int(int)>&>::value,
  65       "");
  66
  67   // Check that POD types are not considered base::OnceCallbacks.
  68   static_assert(!base::IsOnceCallback<bool>::value, "");
  69   static_assert(!base::IsOnceCallback<int>::value, "");
  70   static_assert(!base::IsOnceCallback<double>::value, "");
  71
  72   // Check that the closely related std::function is not considered a
  73   // base::OnceCallback.
  74   static_assert(!base::IsOnceCallback<std::function<void()>>::value, "");
  75   static_assert(!base::IsOnceCallback<const std::function<void()>&>::value, "");
  76   static_assert(!base::IsOnceCallback<std::function<void()>&&>::value, "");
  77
  78   // Check that the result of BindOnce is a OnceCallback, but not if it's
  79   // wrapped in AdaptCallbackForRepeating.
  80   auto cb = base::BindOnce([](int* count) { ++*count; });
  81   static_assert(base::IsOnceCallback<decltype(cb)>::value, "");
  82   auto wrapped = base::AdaptCallbackForRepeating(std::move(cb));
  83   static_assert(!base::IsOnceCallback<decltype(wrapped)>::value, "");
  84 }
  85
  86 void Increment(int* value) {
  87   (*value)++;
  88 }
  89
  90 TEST(CallbackHelpersTest, TestScopedClosureRunnerExitScope) {
  91   int run_count = 0;
  92   {
  93     base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count));
  94     EXPECT_EQ(0, run_count);
  95   }
  96   EXPECT_EQ(1, run_count);
  97 }
  98
  99 TEST(CallbackHelpersTest, TestScopedClosureRunnerRelease) {
 100   int run_count = 0;
 101   base::OnceClosure c;
 102   {
 103     base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count));
 104     c = runner.Release();
 105     EXPECT_EQ(0, run_count);
 106   }
 107   EXPECT_EQ(0, run_count);
 108   std::move(c).Run();
 109   EXPECT_EQ(1, run_count);
 110 }
 111
 112 TEST(CallbackHelpersTest, TestScopedClosureRunnerReplaceClosure) {
 113   int run_count_1 = 0;
 114   int run_count_2 = 0;
 115   {
 116     base::ScopedClosureRunner runner;
 117     runner.ReplaceClosure(base::BindOnce(&Increment, &run_count_1));
 118     runner.ReplaceClosure(base::BindOnce(&Increment, &run_count_2));
 119     EXPECT_EQ(0, run_count_1);
 120     EXPECT_EQ(0, run_count_2);
 121   }
 122   EXPECT_EQ(0, run_count_1);
 123   EXPECT_EQ(1, run_count_2);
 124 }
 125
 126 TEST(CallbackHelpersTest, TestScopedClosureRunnerRunAndReset) {
 127   int run_count_3 = 0;
 128   {
 129     base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count_3));
 130     EXPECT_EQ(0, run_count_3);
 131     runner.RunAndReset();
 132     EXPECT_EQ(1, run_count_3);
 133   }
 134   EXPECT_EQ(1, run_count_3);
 135 }
 136
 137 TEST(CallbackHelpersTest, TestScopedClosureRunnerMoveConstructor) {
 138   int run_count = 0;
 139   {
 140     std::unique_ptr<base::ScopedClosureRunner> runner(
 141         new base::ScopedClosureRunner(base::BindOnce(&Increment, &run_count)));
 142     base::ScopedClosureRunner runner2(std::move(*runner));
 143     runner.reset();
 144     EXPECT_EQ(0, run_count);
 145   }
 146   EXPECT_EQ(1, run_count);
 147 }
 148
 149 TEST(CallbackHelpersTest, TestScopedClosureRunnerMoveAssignment) {
 150   int run_count_1 = 0;
 151   int run_count_2 = 0;
 152   {
 153     base::ScopedClosureRunner runner(base::BindOnce(&Increment, &run_count_1));
 154     {
 155       base::ScopedClosureRunner runner2(
 156           base::BindOnce(&Increment, &run_count_2));
 157       runner = std::move(runner2);
 158       EXPECT_EQ(0, run_count_1);
 159       EXPECT_EQ(0, run_count_2);
 160     }
 161     EXPECT_EQ(0, run_count_1);
 162     EXPECT_EQ(0, run_count_2);
 163   }
 164   EXPECT_EQ(0, run_count_1);
 165   EXPECT_EQ(1, run_count_2);
 166 }
 167
 168 TEST(CallbackHelpersTest, TestAdaptCallbackForRepeating) {
 169   int count = 0;
 170   base::OnceCallback<void(int*)> cb =
 171       base::BindOnce([](int* count) { ++*count; });
 172
 173   base::RepeatingCallback<void(int*)> wrapped =
 174       base::AdaptCallbackForRepeating(std::move(cb));
 175
 176   EXPECT_EQ(0, count);
 177   wrapped.Run(&count);
 178   EXPECT_EQ(1, count);
 179   wrapped.Run(&count);
 180   EXPECT_EQ(1, count);
 181 }
 182
 183 }  // namespace