base/threading/watchdog_unittest.cc

   1 // Copyright (c) 2012 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/threading/watchdog.h"
   6
   7 #include "base/logging.h"
   8 #include "base/synchronization/spin_wait.h"
   9 #include "base/threading/platform_thread.h"
  10 #include "base/time/time.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace base {
  14
  15 namespace {
  16
  17 //------------------------------------------------------------------------------
  18 // Provide a derived class to facilitate testing.
  19
  20 class WatchdogCounter : public Watchdog {
  21  public:
  22   WatchdogCounter(const TimeDelta& duration,
  23                   const std::string& thread_watched_name,
  24                   bool enabled)
  25       : Watchdog(duration, thread_watched_name, enabled),
  26         alarm_counter_(0) {
  27   }
  28
  29   virtual ~WatchdogCounter() {}
  30
  31   virtual void Alarm() OVERRIDE {
  32     alarm_counter_++;
  33     Watchdog::Alarm();
  34   }
  35
  36   int alarm_counter() { return alarm_counter_; }
  37
  38  private:
  39   int alarm_counter_;
  40
  41   DISALLOW_COPY_AND_ASSIGN(WatchdogCounter);
  42 };
  43
  44 class WatchdogTest : public testing::Test {
  45  public:
  46   virtual void SetUp() OVERRIDE {
  47     Watchdog::ResetStaticData();
  48   }
  49 };
  50
  51 }  // namespace
  52
  53 //------------------------------------------------------------------------------
  54 // Actual tests
  55
  56 // Minimal constructor/destructor test.
  57 TEST_F(WatchdogTest, StartupShutdownTest) {
  58   Watchdog watchdog1(TimeDelta::FromMilliseconds(300), "Disabled", false);
  59   Watchdog watchdog2(TimeDelta::FromMilliseconds(300), "Enabled", true);
  60 }
  61
  62 // Test ability to call Arm and Disarm repeatedly.
  63 TEST_F(WatchdogTest, ArmDisarmTest) {
  64   Watchdog watchdog1(TimeDelta::FromMilliseconds(300), "Disabled", false);
  65   watchdog1.Arm();
  66   watchdog1.Disarm();
  67   watchdog1.Arm();
  68   watchdog1.Disarm();
  69
  70   Watchdog watchdog2(TimeDelta::FromMilliseconds(300), "Enabled", true);
  71   watchdog2.Arm();
  72   watchdog2.Disarm();
  73   watchdog2.Arm();
  74   watchdog2.Disarm();
  75 }
  76
  77 // Make sure a basic alarm fires when the time has expired.
  78 TEST_F(WatchdogTest, AlarmTest) {
  79   WatchdogCounter watchdog(TimeDelta::FromMilliseconds(10), "Enabled", true);
  80   watchdog.Arm();
  81   SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(5),
  82                                    watchdog.alarm_counter() > 0);
  83   EXPECT_EQ(1, watchdog.alarm_counter());
  84 }
  85
  86 // Make sure a basic alarm fires when the time has expired.
  87 TEST_F(WatchdogTest, AlarmPriorTimeTest) {
  88   WatchdogCounter watchdog(TimeDelta(), "Enabled2", true);
  89   // Set a time in the past.
  90   watchdog.ArmSomeTimeDeltaAgo(TimeDelta::FromSeconds(2));
  91   // It should instantly go off, but certainly in less than 5 minutes.
  92   SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(5),
  93                                    watchdog.alarm_counter() > 0);
  94
  95   EXPECT_EQ(1, watchdog.alarm_counter());
  96 }
  97
  98 // Make sure a disable alarm does nothing, even if we arm it.
  99 TEST_F(WatchdogTest, ConstructorDisabledTest) {
 100   WatchdogCounter watchdog(TimeDelta::FromMilliseconds(10), "Disabled", false);
 101   watchdog.Arm();
 102   // Alarm should not fire, as it was disabled.
 103   PlatformThread::Sleep(TimeDelta::FromMilliseconds(500));
 104   EXPECT_EQ(0, watchdog.alarm_counter());
 105 }
 106
 107 // Make sure Disarming will prevent firing, even after Arming.
 108 TEST_F(WatchdogTest, DisarmTest) {
 109   WatchdogCounter watchdog(TimeDelta::FromSeconds(1), "Enabled3", true);
 110
 111   TimeTicks start = TimeTicks::Now();
 112   watchdog.Arm();
 113   // Sleep a bit, but not past the alarm point.
 114   PlatformThread::Sleep(TimeDelta::FromMilliseconds(100));
 115   watchdog.Disarm();
 116   TimeTicks end = TimeTicks::Now();
 117
 118   if (end - start > TimeDelta::FromMilliseconds(500)) {
 119     LOG(WARNING) << "100ms sleep took over 500ms, making the results of this "
 120                  << "timing-sensitive test suspicious.  Aborting now.";
 121     return;
 122   }
 123
 124   // Alarm should not have fired before it was disarmed.
 125   EXPECT_EQ(0, watchdog.alarm_counter());
 126
 127   // Sleep past the point where it would have fired if it wasn't disarmed,
 128   // and verify that it didn't fire.
 129   PlatformThread::Sleep(TimeDelta::FromSeconds(1));
 130   EXPECT_EQ(0, watchdog.alarm_counter());
 131
 132   // ...but even after disarming, we can still use the alarm...
 133   // Set a time greater than the timeout into the past.
 134   watchdog.ArmSomeTimeDeltaAgo(TimeDelta::FromSeconds(10));
 135   // It should almost instantly go off, but certainly in less than 5 minutes.
 136   SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(5),
 137                                    watchdog.alarm_counter() > 0);
 138
 139   EXPECT_EQ(1, watchdog.alarm_counter());
 140 }
 141
 142 }  // namespace base