base/barrier_closure_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/barrier_closure.h"
   6
   7 #include "base/bind.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace {
  11
  12 void Increment(int* count) { (*count)++; }
  13
  14 TEST(BarrierClosureTest, RunImmediatelyForZeroClosures) {
  15   int count = 0;
  16   auto done_closure = base::BindOnce(&Increment, base::Unretained(&count));
  17
  18   base::RepeatingClosure barrier_closure =
  19       base::BarrierClosure(0, std::move(done_closure));
  20   EXPECT_EQ(1, count);
  21 }
  22
  23 TEST(BarrierClosureTest, RunAfterNumClosures) {
  24   int count = 0;
  25   auto done_closure = base::BindOnce(&Increment, base::Unretained(&count));
  26
  27   base::RepeatingClosure barrier_closure =
  28       base::BarrierClosure(2, std::move(done_closure));
  29   EXPECT_EQ(0, count);
  30
  31   barrier_closure.Run();
  32   EXPECT_EQ(0, count);
  33
  34   barrier_closure.Run();
  35   EXPECT_EQ(1, count);
  36 }
  37
  38 class DestructionIndicator {
  39  public:
  40   // Sets |*destructed| to true in destructor.
  41   DestructionIndicator(bool* destructed) : destructed_(destructed) {
  42     *destructed_ = false;
  43   }
  44
  45   ~DestructionIndicator() { *destructed_ = true; }
  46
  47   void DoNothing() {}
  48
  49  private:
  50   bool* destructed_;
  51 };
  52
  53 TEST(BarrierClosureTest, ReleasesDoneClosureWhenDone) {
  54   bool done_destructed = false;
  55   base::RepeatingClosure barrier_closure = base::BarrierClosure(
  56       1,
  57       base::BindOnce(&DestructionIndicator::DoNothing,
  58                      base::Owned(new DestructionIndicator(&done_destructed))));
  59   EXPECT_FALSE(done_destructed);
  60   barrier_closure.Run();
  61   EXPECT_TRUE(done_destructed);
  62 }
  63
  64 void ResetBarrierClosure(base::RepeatingClosure* closure) {
  65   *closure = base::RepeatingClosure();
  66 }
  67
  68 // Tests a case when |done_closure| resets a |barrier_closure|.
  69 // |barrier_closure| is a RepeatingClosure holding the |done_closure|.
  70 // |done_closure| holds a pointer back to the |barrier_closure|. When
  71 // |barrier_closure| is Run() it calls ResetBarrierClosure() which erases the
  72 // |barrier_closure| while still inside of its Run(). The Run() implementation
  73 // (in base::BarrierClosure) must not try use itself after executing
  74 // ResetBarrierClosure() or this test would crash inside Run().
  75 TEST(BarrierClosureTest, KeepingClosureAliveUntilDone) {
  76   base::RepeatingClosure barrier_closure;
  77   auto done_closure = base::BindOnce(ResetBarrierClosure, &barrier_closure);
  78   barrier_closure = base::BarrierClosure(1, std::move(done_closure));
  79   barrier_closure.Run();
  80 }
  81
  82 }  // namespace