ui/message_center/message_center_impl_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 "ui/message_center/message_center_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/run_loop.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12 #include "ui/message_center/message_center.h"
  13 #include "ui/message_center/notification_types.h"
  14
  15 namespace message_center {
  16 namespace {
  17
  18 class MessageCenterImplTest : public testing::Test,
  19                               public MessageCenterObserver {
  20  public:
  21   MessageCenterImplTest() {}
  22
  23   virtual void SetUp() OVERRIDE {
  24     MessageCenter::Initialize();
  25     message_center_ = MessageCenter::Get();
  26     loop_.reset(new base::MessageLoop(base::MessageLoop::TYPE_DEFAULT));
  27     run_loop_.reset(new base::RunLoop());
  28     closure_ = run_loop_->QuitClosure();
  29   }
  30
  31   virtual void TearDown() OVERRIDE {
  32     run_loop_.reset();
  33     loop_.reset();
  34     message_center_ = NULL;
  35     MessageCenter::Shutdown();
  36   }
  37
  38   MessageCenter* message_center() const { return message_center_; }
  39   base::RunLoop* run_loop() const { return run_loop_.get(); }
  40   base::Closure closure() const { return closure_; }
  41
  42  private:
  43   MessageCenter* message_center_;
  44   scoped_ptr<base::MessageLoop> loop_;
  45   scoped_ptr<base::RunLoop> run_loop_;
  46   base::Closure closure_;
  47
  48   DISALLOW_COPY_AND_ASSIGN(MessageCenterImplTest);
  49 };
  50
  51 }  // namespace
  52
  53 namespace internal {
  54
  55 class MockPopupTimersController : public PopupTimersController {
  56  public:
  57   MockPopupTimersController(MessageCenter* message_center,
  58                             base::Closure quit_closure)
  59       : PopupTimersController(message_center),
  60         timer_finished_(false),
  61         quit_closure_(quit_closure) {}
  62   virtual ~MockPopupTimersController() {}
  63
  64   virtual void TimerFinished(const std::string& id) OVERRIDE {
  65     LOG(INFO) << "In timer finished for id " << id;
  66     base::MessageLoop::current()->PostTask(FROM_HERE, quit_closure_);
  67     timer_finished_ = true;
  68     last_id_ = id;
  69   }
  70
  71   bool timer_finished() const { return timer_finished_; }
  72   const std::string& last_id() const { return last_id_; }
  73
  74  private:
  75   bool timer_finished_;
  76   std::string last_id_;
  77   base::Closure quit_closure_;
  78 };
  79
  80 TEST_F(MessageCenterImplTest, PopupTimersEmptyController) {
  81   scoped_ptr<PopupTimersController> popup_timers_controller =
  82       make_scoped_ptr(new PopupTimersController(message_center()));
  83
  84   // Test that all functions succed without any timers created.
  85   popup_timers_controller->PauseAll();
  86   popup_timers_controller->StartAll();
  87   popup_timers_controller->CancelAll();
  88   popup_timers_controller->TimerFinished("unknown");
  89   popup_timers_controller->PauseTimer("unknown");
  90   popup_timers_controller->CancelTimer("unknown");
  91 }
  92
  93 TEST_F(MessageCenterImplTest, PopupTimersControllerStartTimer) {
  94   scoped_ptr<MockPopupTimersController> popup_timers_controller =
  95       make_scoped_ptr(
  96           new MockPopupTimersController(message_center(), closure()));
  97   popup_timers_controller->StartTimer("test",
  98                                       base::TimeDelta::FromMilliseconds(1));
  99   run_loop()->Run();
 100   EXPECT_TRUE(popup_timers_controller->timer_finished());
 101 }
 102
 103 TEST_F(MessageCenterImplTest, PopupTimersControllerPauseTimer) {
 104   scoped_ptr<MockPopupTimersController> popup_timers_controller =
 105       make_scoped_ptr(
 106           new MockPopupTimersController(message_center(), closure()));
 107   popup_timers_controller->StartTimer("test",
 108                                       base::TimeDelta::FromMilliseconds(1));
 109   popup_timers_controller->PauseTimer("test");
 110   run_loop()->RunUntilIdle();
 111
 112   EXPECT_FALSE(popup_timers_controller->timer_finished());
 113 }
 114
 115 TEST_F(MessageCenterImplTest, PopupTimersControllerCancelTimer) {
 116   scoped_ptr<MockPopupTimersController> popup_timers_controller =
 117       make_scoped_ptr(
 118           new MockPopupTimersController(message_center(), closure()));
 119   popup_timers_controller->StartTimer("test",
 120                                       base::TimeDelta::FromMilliseconds(1));
 121   popup_timers_controller->CancelTimer("test");
 122   run_loop()->RunUntilIdle();
 123
 124   EXPECT_FALSE(popup_timers_controller->timer_finished());
 125 }
 126
 127 TEST_F(MessageCenterImplTest, PopupTimersControllerPauseAllTimers) {
 128   scoped_ptr<MockPopupTimersController> popup_timers_controller =
 129       make_scoped_ptr(
 130           new MockPopupTimersController(message_center(), closure()));
 131   popup_timers_controller->StartTimer("test",
 132                                       base::TimeDelta::FromMilliseconds(1));
 133   popup_timers_controller->PauseAll();
 134   run_loop()->RunUntilIdle();
 135
 136   EXPECT_FALSE(popup_timers_controller->timer_finished());
 137 }
 138
 139 TEST_F(MessageCenterImplTest, PopupTimersControllerStartAllTimers) {
 140   scoped_ptr<MockPopupTimersController> popup_timers_controller =
 141       make_scoped_ptr(
 142           new MockPopupTimersController(message_center(), closure()));
 143   popup_timers_controller->StartTimer("test",
 144                                       base::TimeDelta::FromMilliseconds(1));
 145   popup_timers_controller->PauseAll();
 146   popup_timers_controller->StartAll();
 147   run_loop()->Run();
 148
 149   EXPECT_TRUE(popup_timers_controller->timer_finished());
 150 }
 151
 152 TEST_F(MessageCenterImplTest, PopupTimersControllerStartMultipleTimers) {
 153   scoped_ptr<MockPopupTimersController> popup_timers_controller =
 154       make_scoped_ptr(
 155           new MockPopupTimersController(message_center(), closure()));
 156   popup_timers_controller->StartTimer("test",
 157                                       base::TimeDelta::FromMilliseconds(5));
 158   popup_timers_controller->StartTimer("test2",
 159                                       base::TimeDelta::FromMilliseconds(1));
 160   popup_timers_controller->StartTimer("test3",
 161                                       base::TimeDelta::FromMilliseconds(3));
 162   popup_timers_controller->PauseAll();
 163   popup_timers_controller->StartAll();
 164   run_loop()->Run();
 165
 166   EXPECT_EQ(popup_timers_controller->last_id(), "test2");
 167   EXPECT_TRUE(popup_timers_controller->timer_finished());
 168 }
 169
 170 TEST_F(MessageCenterImplTest, PopupTimersControllerStartMultipleTimersPause) {
 171   scoped_ptr<MockPopupTimersController> popup_timers_controller =
 172       make_scoped_ptr(
 173           new MockPopupTimersController(message_center(), closure()));
 174   popup_timers_controller->StartTimer("test",
 175                                       base::TimeDelta::FromMilliseconds(5));
 176   popup_timers_controller->StartTimer("test2",
 177                                       base::TimeDelta::FromMilliseconds(1));
 178   popup_timers_controller->StartTimer("test3",
 179                                       base::TimeDelta::FromMilliseconds(3));
 180   popup_timers_controller->PauseTimer("test2");
 181
 182   run_loop()->Run();
 183
 184   EXPECT_EQ(popup_timers_controller->last_id(), "test3");
 185   EXPECT_TRUE(popup_timers_controller->timer_finished());
 186 }
 187
 188 TEST_F(MessageCenterImplTest, PopupTimersControllerResetTimer) {
 189   scoped_ptr<MockPopupTimersController> popup_timers_controller =
 190       make_scoped_ptr(
 191           new MockPopupTimersController(message_center(), closure()));
 192   popup_timers_controller->StartTimer("test",
 193                                       base::TimeDelta::FromMilliseconds(5));
 194   popup_timers_controller->StartTimer("test2",
 195                                       base::TimeDelta::FromMilliseconds(1));
 196   popup_timers_controller->StartTimer("test3",
 197                                       base::TimeDelta::FromMilliseconds(3));
 198   popup_timers_controller->PauseTimer("test2");
 199   popup_timers_controller->ResetTimer("test",
 200                                       base::TimeDelta::FromMilliseconds(2));
 201
 202   run_loop()->Run();
 203
 204   EXPECT_EQ(popup_timers_controller->last_id(), "test");
 205   EXPECT_TRUE(popup_timers_controller->timer_finished());
 206 }
 207
 208 }  // namespace internal
 209
 210 }  // namespace message_center