[891-make-stats-mgr-thread-safe] Added thread safety to stats

diff --git a/src/lib/stats/context.h b/src/lib/stats/context.h
index 9b532e1d36ebf0a9430c0898e3cb22da2af2f0d6..3e69fb9545193abb17d45e0bfc9604840120ce09 100644 (file)
--- a/src/lib/stats/context.h
+++ b/src/lib/stats/context.h
@@ -1,4 +1,4 @@
-// Copyright (C) 2015 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2015-2019 Internet Systems Consortium, Inc. ("ISC")
 //
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -9,6 +9,7 @@
 
 #include <stats/observation.h>
 #include <boost/shared_ptr.hpp>
+#include <mutex>
 #include <string>
 
 namespace isc {
@@ -27,6 +28,9 @@ public:
 /// related to a given context together. Two examples of such contexts are
 /// all statistics related to a given subnet or all statistics related to a
 /// given network interface.
+///
+/// When multi-threading is enabled the mutex must be held for any use of
+/// a method or the stats_ map.
 struct StatContext {
  public:
 
@@ -53,6 +57,11 @@ struct StatContext {
     /// could make it protected and then return a pointer to it, but that
     /// would defeat the purpose of the hermetization in the first place.
     std::map<std::string, ObservationPtr> stats_;
+
+    /// @brief The mutex to protect concurrent access when multi-threading
+    /// is enabled.
+    std::mutex mutex_;
+
 };
 
 /// @brief Pointer to the statistics context

diff --git a/src/lib/stats/stats_mgr.cc b/src/lib/stats/stats_mgr.cc
index 25ad50086f95dd1bde6a54702a8148b7dfdbfaf4..4dc14b45b53578f5e398c67b9dda32cfa315464a 100644 (file)
--- a/src/lib/stats/stats_mgr.cc
+++ b/src/lib/stats/stats_mgr.cc
@@ -11,11 +11,13 @@
 #include <cc/data.h>
 #include <cc/command_interpreter.h>
 #include <util/boost_time_utils.h>
+#include <util/multi_threading_mgr.h>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 using namespace std;
-using namespace isc::data;
 using namespace isc::config;
+using namespace isc::data;
+using namespace isc::util;
 
 namespace isc {
 namespace stats {
@@ -31,34 +33,74 @@ StatsMgr::StatsMgr() :
 }
 
 void StatsMgr::setValue(const std::string& name, const int64_t value) {
-    setValueInternal(name, value);
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        setValueInternal(name, value);
+    } else {
+        setValueInternal(name, value);
+    }
 }
 
 void StatsMgr::setValue(const std::string& name, const double value) {
-    setValueInternal(name, value);
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        setValueInternal(name, value);
+    } else {
+        setValueInternal(name, value);
+    }
 }
 
 void StatsMgr::setValue(const std::string& name, const StatsDuration& value) {
-    setValueInternal(name, value);
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        setValueInternal(name, value);
+    } else {
+        setValueInternal(name, value);
+    }
 }
 void StatsMgr::setValue(const std::string& name, const std::string& value) {
-    setValueInternal(name, value);
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        setValueInternal(name, value);
+    } else {
+        setValueInternal(name, value);
+    }
 }
 
 void StatsMgr::addValue(const std::string& name, const int64_t value) {
-    addValueInternal(name, value);
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        addValueInternal(name, value);
+    } else {
+        addValueInternal(name, value);
+    }
 }
 
 void StatsMgr::addValue(const std::string& name, const double value) {
-    addValueInternal(name, value);
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        addValueInternal(name, value);
+    } else {
+        addValueInternal(name, value);
+    }
 }
 
 void StatsMgr::addValue(const std::string& name, const StatsDuration& value) {
-    addValueInternal(name, value);
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        addValueInternal(name, value);
+    } else {
+        addValueInternal(name, value);
+    }
 }
 
 void StatsMgr::addValue(const std::string& name, const std::string& value) {
-    addValueInternal(name, value);
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        addValueInternal(name, value);
+    } else {
+        addValueInternal(name, value);
+    }
 }
 
 ObservationPtr StatsMgr::getObservation(const std::string& name) const {
@@ -67,6 +109,15 @@ ObservationPtr StatsMgr::getObservation(const std::string& name) const {
     return (global_->get(name));
 }
 
+ObservationPtr StatsMgr::testGetObservation(const std::string& name) const {
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (getObservation(name));
+    } else {
+        return (getObservation(name));
+    }
+}
+
 void StatsMgr::addObservation(const ObservationPtr& stat) {
     /// @todo: Implement contexts.
     // Currently we keep everything in a global context.
@@ -79,8 +130,8 @@ bool StatsMgr::deleteObservation(const std::string& name) {
     return (global_->del(name));
 }
 
-bool StatsMgr::setMaxSampleAge(const std::string& name,
-                               const StatsDuration& duration) {
+bool StatsMgr::setMaxSampleAgeInternal(const std::string& name,
+                                       const StatsDuration& duration) {
     ObservationPtr obs = getObservation(name);
     if (obs) {
         obs->setMaxSampleAge(duration);
@@ -90,8 +141,18 @@ bool StatsMgr::setMaxSampleAge(const std::string& name,
     }
 }
 
-bool StatsMgr::setMaxSampleCount(const std::string& name,
-                                 uint32_t max_samples) {
+bool StatsMgr::setMaxSampleAge(const std::string& name,
+                               const StatsDuration& duration) {
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (setMaxSampleAgeInternal(name, duration));
+    } else {
+        return (setMaxSampleAgeInternal(name, duration));
+    }
+}
+
+bool StatsMgr::setMaxSampleCountInternal(const std::string& name,
+                                         uint32_t max_samples) {
     ObservationPtr obs = getObservation(name);
     if (obs) {
         obs->setMaxSampleCount(max_samples);
@@ -101,7 +162,17 @@ bool StatsMgr::setMaxSampleCount(const std::string& name,
     }
 }
 
-void StatsMgr::setMaxSampleAgeAll(const StatsDuration& duration) {
+bool StatsMgr::setMaxSampleCount(const std::string& name,
+                                 uint32_t max_samples) {
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (setMaxSampleCountInternal(name, max_samples));
+    } else {
+        return (setMaxSampleCountInternal(name, max_samples));
+    }
+}
+
+void StatsMgr::setMaxSampleAgeAllInternal(const StatsDuration& duration) {
     // Let's iterate over all stored statistics...
     for (std::map<std::string, ObservationPtr>::iterator s = global_->stats_.begin();
          s != global_->stats_.end(); ++s) {
@@ -111,7 +182,16 @@ void StatsMgr::setMaxSampleAgeAll(const StatsDuration& duration) {
     }
 }
 
-void StatsMgr::setMaxSampleCountAll(uint32_t max_samples) {
+void StatsMgr::setMaxSampleAgeAll(const StatsDuration& duration) {
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (setMaxSampleAgeAllInternal(duration));
+    } else {
+        return (setMaxSampleAgeAllInternal(duration));
+    }
+}
+
+void StatsMgr::setMaxSampleCountAllInternal(uint32_t max_samples) {
     // Let's iterate over all stored statistics...
     for (std::map<std::string, ObservationPtr>::iterator s = global_->stats_.begin();
          s != global_->stats_.end(); ++s) {
@@ -121,7 +201,16 @@ void StatsMgr::setMaxSampleCountAll(uint32_t max_samples) {
     }
 }
 
-bool StatsMgr::reset(const std::string& name) {
+void StatsMgr::setMaxSampleCountAll(uint32_t max_samples) {
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (setMaxSampleCountAllInternal(max_samples));
+    } else {
+        return (setMaxSampleCountAllInternal(max_samples));
+    }
+}
+
+bool StatsMgr::resetInternal(const std::string& name) {
     ObservationPtr obs = getObservation(name);
     if (obs) {
         obs->reset();
@@ -131,37 +220,74 @@ bool StatsMgr::reset(const std::string& name) {
     }
 }
 
+bool StatsMgr::reset(const std::string& name) {
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (resetInternal(name));
+    } else {
+        return (resetInternal(name));
+    }
+}
+
 bool StatsMgr::del(const std::string& name) {
-    return (global_->del(name));
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (global_->del(name));
+    } else {
+        return (global_->del(name));
+    }
 }
 
 void StatsMgr::removeAll() {
-    global_->stats_.clear();
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        global_->stats_.clear();
+    } else {
+        global_->stats_.clear();
+    }
 }
 
-isc::data::ConstElementPtr StatsMgr::get(const std::string& name) const {
-    isc::data::ElementPtr response = isc::data::Element::createMap(); // a map
+void StatsMgr::getInternal(const std::string& name,
+                           ElementPtr& response) const {
     ObservationPtr obs = getObservation(name);
     if (obs) {
         response->set(name, obs->getJSON()); // that contains observations
     }
-    return (response);
 }
 
-isc::data::ConstElementPtr StatsMgr::getAll() const {
-    isc::data::ElementPtr map = isc::data::Element::createMap(); // a map
+isc::data::ConstElementPtr StatsMgr::get(const std::string& name) const {
+    isc::data::ElementPtr response = isc::data::Element::createMap(); // a map
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        getInternal(name, response);
+    } else {
+        getInternal(name, response);
+    }
+    return (response);
+}
 
+void StatsMgr::getAllInternal(ElementPtr& response) const {
     // Let's iterate over all stored statistics...
     for (std::map<std::string, ObservationPtr>::iterator s = global_->stats_.begin();
          s != global_->stats_.end(); ++s) {
 
         // ... and add each of them to the map.
-        map->set(s->first, s->second->getJSON());
+        response->set(s->first, s->second->getJSON());
     }
-    return (map);
 }
 
-void StatsMgr::resetAll() {
+isc::data::ConstElementPtr StatsMgr::getAll() const {
+    isc::data::ElementPtr response = isc::data::Element::createMap(); // a map
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        getAllInternal(response);
+    } else {
+        getAllInternal(response);
+    }
+    return (response);
+}
+
+void StatsMgr::resetAllInternal() {
     // Let's iterate over all stored statistics...
     for (std::map<std::string, ObservationPtr>::iterator s = global_->stats_.begin();
          s != global_->stats_.end(); ++s) {
@@ -171,7 +297,16 @@ void StatsMgr::resetAll() {
     }
 }
 
-size_t StatsMgr::getSize(const std::string& name) const {
+void StatsMgr::resetAll() {
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        resetAllInternal();
+    } else {
+        resetAllInternal();
+    }
+}
+
+size_t StatsMgr::getSizeInternal(const std::string& name) const {
     ObservationPtr obs = getObservation(name);
     size_t size = 0;
     if (obs) {
@@ -180,8 +315,22 @@ size_t StatsMgr::getSize(const std::string& name) const {
     return (size);
 }
 
+size_t StatsMgr::getSize(const std::string& name) const {
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (getSizeInternal(name));
+    } else {
+        return (getSizeInternal(name));
+    }
+}
+
 size_t StatsMgr::count() const {
-    return (global_->stats_.size());
+    if (MultiThreadingMgr::instance().getMode()) {
+        std::lock_guard<std::mutex> lock(global_->mutex_);
+        return (global_->stats_.size());
+    } else {
+        return (global_->stats_.size());
+    }
 }
 
 isc::data::ConstElementPtr

diff --git a/src/lib/stats/stats_mgr.h b/src/lib/stats/stats_mgr.h
index 450d65a63bc15f2416dfffd84445e0064ea3a44a..d2df9c97fe6bbde31671d63b5c3ed1bc11a80a71 100644 (file)
--- a/src/lib/stats/stats_mgr.h
+++ b/src/lib/stats/stats_mgr.h
@@ -140,7 +140,7 @@ class StatsMgr : public boost::noncopyable {
     /// @return true if successful, false if there's no such statistic
     /// Example:
     /// To set a statistic to keep observations for the last 5 minutes, call:
-    /// setMaxSampleAge("incoming-packets", time_duration(0, 5, 0, 0));
+    /// setMaxSampleAge~("incoming-packets", time_duration(0, 5, 0, 0));
     /// to revert statistic to a single value, call:
     /// setMaxSampleAge("incoming-packets", time_duration(0, 0, 0, 0));
     bool setMaxSampleAge(const std::string& name, const StatsDuration& duration);
@@ -161,9 +161,13 @@ class StatsMgr : public boost::noncopyable {
     bool setMaxSampleCount(const std::string& name, uint32_t max_samples);
 
     /// @brief Set duration limit for all collected statistics.
+    ///
+    /// @param duration determines maximum age of samples
     void setMaxSampleAgeAll(const StatsDuration& duration);
 
     /// @brief Set count limit for all collected statistics.
+    ///
+    /// @param max_samples how many samples of a given statistic should be kept
     void setMaxSampleCountAll(uint32_t max_samples);
 
     /// @}
@@ -217,13 +221,6 @@ class StatsMgr : public boost::noncopyable {
 
     /// @}
 
-    /// @brief Returns an observation.
-    ///
-    /// Used in testing only. Production code should use @ref get() method.
-    /// @param name name of the statistic
-    /// @return Pointer to the Observation object
-    ObservationPtr getObservation(const std::string& name) const;
-
     /// @brief Generates statistic name in a given context
     ///
     /// Example:
@@ -426,6 +423,11 @@ class StatsMgr : public boost::noncopyable {
 
     /// @}
 
+    /// @brief Returns an observation (test only).
+    ///
+    /// Used in testing only. Production code should use @ref get() method.
+    ObservationPtr testGetObservation(const std::string& name) const;
+
 private:
 
     /// @brief Private constructor.
@@ -441,6 +443,8 @@ private:
     /// specified by value. This internal method is used by public @ref setValue
     /// methods.
     ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
     /// @tparam DataType one of int64_t, double, StatsDuration or string
     /// @param name name of the statistic
     /// @param value specified statistic will be set to this value
@@ -466,6 +470,8 @@ private:
     /// by name to a value). This internal method is used by public @ref setValue
     /// methods.
     ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
     /// @tparam DataType one of int64_t, double, StatsDuration or string
     /// @param name name of the statistic
     /// @param value specified statistic will be set to this value
@@ -490,8 +496,20 @@ private:
 
     /// @public
 
+    /// @brief Returns an observation.
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param name name of the statistic
+    /// @return Pointer to the Observation object
+    ObservationPtr getObservation(const std::string& name) const;
+
+    /// @public
+
     /// @brief Adds a new observation.
     ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
     /// That's an utility method used by public @ref setValue() and
     /// @ref addValue() methods.
     /// @param stat observation
@@ -501,6 +519,8 @@ private:
 
     /// @brief Tries to delete an observation.
     ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
     /// @param name of the statistic to be deleted
     /// @return true if deleted, false if not found
     bool deleteObservation(const std::string& name);
@@ -560,6 +580,89 @@ private:
                                   uint32_t& max_samples,
                                   std::string& reason);
 
+    /// @brief Determines maximum age of samples (internal version).
+    ///
+    /// Specifies that statistic name should be stored not as a single value,
+    /// but rather as a set of values. duration determines the timespan.
+    /// Samples older than duration will be discarded. This is time-constrained
+    /// approach. For sample count constrained approach, see @ref
+    /// setMaxSampleCount() below.
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param name name of the observation
+    /// @param duration determines maximum age of samples
+    /// @return true if successful, false if there's no such statistic
+    bool setMaxSampleAgeInternal(const std::string& name,
+                                 const StatsDuration& duration);
+
+    /// @brief Determines how many samples of a given statistic should be kept
+    /// (internal version).
+    ///
+    /// Specifies that statistic name should be stored not as single value, but
+    /// rather as a set of values. In this form, at most max_samples will be kept.
+    /// When adding max_samples + 1 sample, the oldest sample will be discarded.
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param name name of the observation
+    /// @param max_samples how many samples of a given statistic should be kept
+    /// @return true if successful, false if there's no such statistic
+    bool setMaxSampleCountInternal(const std::string& name,
+                                   uint32_t max_samples);
+
+    /// @brief Set duration limit for all collected statistics (internal version).
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param duration determines maximum age of samples
+    void setMaxSampleAgeAllInternal(const StatsDuration& duration);
+
+    /// @brief Set count limit for all collected statistics (internal version).
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param max_samples how many samples of a given statistic should be kept
+    void setMaxSampleCountAllInternal(uint32_t max_samples);
+
+    /// @brief Resets specified statistic (internal version).
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param name name of the statistic to be reset.
+    /// @return true if successful, false if there's no such statistic
+    bool resetInternal(const std::string& name);
+
+    /// @brief Resets all collected statistics back to zero (internal version).
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    void resetAllInternal();
+
+    /// @brief Returns size of specified statistic (internal version).
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param name name of the statistic which size should be return.
+    /// @return size of specified statistic, 0 means lack of given statistic.
+    size_t getSizeInternal(const std::string& name) const;
+
+    /// @brief Returns a single statistic as a JSON structure (internal version).
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param name name of the statistic to get.
+    /// @param response JSON structures representing a single statistic
+    void getInternal(const std::string& name,
+                     isc::data::ElementPtr& response) const;
+
+    /// @brief Returns all statistics as a JSON structure (internal version).
+    ///
+    /// Called with the mutex held when multi-threading is enabled.
+    ///
+    /// @param response JSON structures representing allstatistics
+    void getAllInternal(isc::data::ElementPtr& response) const;
+
     // This is a global context. All statistics will initially be stored here.
     StatContextPtr global_;
 };

diff --git a/src/lib/stats/tests/stats_mgr_unittest.cc b/src/lib/stats/tests/stats_mgr_unittest.cc
index 952b1b8c22ab5c4153e0dc816cf2305f5e07af85..ac09e00c699ab5a86c76ce43abced5acb9e90097 100644 (file)
--- a/src/lib/stats/tests/stats_mgr_unittest.cc
+++ b/src/lib/stats/tests/stats_mgr_unittest.cc
@@ -62,7 +62,7 @@ TEST_F(StatsMgrTest, integerStat) {
                                                   static_cast<int64_t>(1234)));
 
     ObservationPtr alpha;
-    EXPECT_NO_THROW(alpha = StatsMgr::instance().getObservation("alpha"));
+    EXPECT_NO_THROW(alpha = StatsMgr::instance().testGetObservation("alpha"));
     ASSERT_TRUE(alpha);
 
     std::string exp = "{ \"alpha\": [ [ 1234, \"" +
@@ -77,7 +77,7 @@ TEST_F(StatsMgrTest, floatStat) {
     EXPECT_NO_THROW(StatsMgr::instance().setValue("beta", 12.34));
 
     ObservationPtr beta;
-    EXPECT_NO_THROW(beta = StatsMgr::instance().getObservation("beta"));
+    EXPECT_NO_THROW(beta = StatsMgr::instance().testGetObservation("beta"));
     ASSERT_TRUE(beta);
 
     std::string exp = "{ \"beta\": [ [ 12.34, \"" +
@@ -93,7 +93,7 @@ TEST_F(StatsMgrTest, durationStat) {
                                                   microsec::time_duration(1, 2, 3, 4)));
 
     ObservationPtr gamma;
-    EXPECT_NO_THROW(gamma = StatsMgr::instance().getObservation("gamma"));
+    EXPECT_NO_THROW(gamma = StatsMgr::instance().testGetObservation("gamma"));
     ASSERT_TRUE(gamma);
 
     std::string exp = "{ \"gamma\": [ [ \"01:02:03.000004\", \"" +
@@ -109,7 +109,7 @@ TEST_F(StatsMgrTest, stringStat) {
                                                   "Lorem ipsum"));
 
     ObservationPtr delta;
-    EXPECT_NO_THROW(delta = StatsMgr::instance().getObservation("delta"));
+    EXPECT_NO_THROW(delta = StatsMgr::instance().testGetObservation("delta"));
     ASSERT_TRUE(delta);
 
     std::string exp = "{ \"delta\": [ [ \"Lorem ipsum\", \"" +
@@ -174,45 +174,45 @@ TEST_F(StatsMgrTest, setLimitsAll) {
     EXPECT_NO_THROW(StatsMgr::instance().setMaxSampleAgeAll(time_duration(0, 0, 1, 0)));
 
     // check if time limit was set properly and whether count limit is disabled
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().second,
               time_duration(0, 0, 1, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().second,
               time_duration(0, 0, 1, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().second,
               time_duration(0, 0, 1, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().second,
               time_duration(0, 0, 1, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().first, false);
 
     // check the setting of count limit to existing statistics
     EXPECT_NO_THROW(StatsMgr::instance().setMaxSampleCountAll(1200));
 
     // check if count limit was set properly and whether count limit is disabled
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 1200);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().second, 1200);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().second, 1200);
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().second, 1200);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().second, 1200);
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().second, 1200);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().second, 1200);
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().second, 1200);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().first, false);
 }
 
 // This test checks whether a single (get("foo")) and all (getAll())
@@ -226,16 +226,16 @@ TEST_F(StatsMgrTest, getGetAll) {
 
     // The string's representation of firstly added statistics
     std::string alpha_first = ", [ 1234, \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("alpha")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("alpha")
                                    ->getInteger().second) + "\" ] ]";
     std::string beta_first = ", [ 12.34, \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("beta")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("beta")
                                    ->getFloat().second) + "\" ] ]";
     std::string gamma_first = ", [ \"01:02:03.000004\", \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("gamma")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("gamma")
                                    ->getDuration().second) + "\" ] ]";
     std::string delta_first = ", [ \"Lorem\", \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("delta")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("delta")
                                    ->getString().second) + "\" ] ]";
 
     // Now add some values to them
@@ -259,16 +259,16 @@ TEST_F(StatsMgrTest, getGetAll) {
     ASSERT_TRUE(rep_delta);
 
     std::string exp_str_alpha = "[ [ 6912, \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("alpha")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("alpha")
                                    ->getInteger().second) + "\" ]" + alpha_first;
     std::string exp_str_beta = "[ [ 69.12, \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("beta")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("beta")
                                    ->getFloat().second) + "\" ]" + beta_first;
     std::string exp_str_gamma = "[ [ \"06:08:10.000012\", \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("gamma")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("gamma")
                                    ->getDuration().second) + "\" ]" + gamma_first;
     std::string exp_str_delta = "[ [ \"Lorem ipsum\", \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("delta")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("delta")
                                    ->getString().second) + "\" ]" + delta_first;
 
     // Check that individual stats are reported properly
@@ -310,26 +310,26 @@ TEST_F(StatsMgrTest, reset) {
     // This should reset alpha to 0
     EXPECT_NO_THROW(StatsMgr::instance().reset("alpha"));
     EXPECT_EQ(0,
-              StatsMgr::instance().getObservation("alpha")->getInteger().first);
+              StatsMgr::instance().testGetObservation("alpha")->getInteger().first);
 
     // The other stats should remain untouched
     EXPECT_EQ(12.34,
-              StatsMgr::instance().getObservation("beta")->getFloat().first);
+              StatsMgr::instance().testGetObservation("beta")->getFloat().first);
     EXPECT_EQ(time_duration(1, 2, 3, 4),
-              StatsMgr::instance().getObservation("gamma")->getDuration().first);
+              StatsMgr::instance().testGetObservation("gamma")->getDuration().first);
     EXPECT_EQ("Lorem ipsum",
-              StatsMgr::instance().getObservation("delta")->getString().first);
+              StatsMgr::instance().testGetObservation("delta")->getString().first);
 
     // Now let's wipe them, too.
     EXPECT_NO_THROW(StatsMgr::instance().reset("beta"));
     EXPECT_NO_THROW(StatsMgr::instance().reset("gamma"));
     EXPECT_NO_THROW(StatsMgr::instance().reset("delta"));
     EXPECT_EQ(0.0,
-              StatsMgr::instance().getObservation("beta")->getFloat().first);
+              StatsMgr::instance().testGetObservation("beta")->getFloat().first);
     EXPECT_EQ(time_duration(0, 0, 0, 0),
-              StatsMgr::instance().getObservation("gamma")->getDuration().first);
+              StatsMgr::instance().testGetObservation("gamma")->getDuration().first);
     EXPECT_EQ("",
-              StatsMgr::instance().getObservation("delta")->getString().first);
+              StatsMgr::instance().testGetObservation("delta")->getString().first);
 
     // Resetting statistics should not remove them
     EXPECT_EQ(4, StatsMgr::instance().count());
@@ -346,13 +346,13 @@ TEST_F(StatsMgrTest, resetAll) {
     // This should reset alpha to 0
     EXPECT_NO_THROW(StatsMgr::instance().resetAll());
     EXPECT_EQ(0,
-              StatsMgr::instance().getObservation("alpha")->getInteger().first);
+              StatsMgr::instance().testGetObservation("alpha")->getInteger().first);
     EXPECT_EQ(0.0,
-              StatsMgr::instance().getObservation("beta")->getFloat().first);
+              StatsMgr::instance().testGetObservation("beta")->getFloat().first);
     EXPECT_EQ(time_duration(0, 0, 0, 0),
-              StatsMgr::instance().getObservation("gamma")->getDuration().first);
+              StatsMgr::instance().testGetObservation("gamma")->getDuration().first);
     EXPECT_EQ("",
-              StatsMgr::instance().getObservation("delta")->getString().first);
+              StatsMgr::instance().testGetObservation("delta")->getString().first);
 
     // Resetting all statistics should not remove them
     EXPECT_EQ(4, StatsMgr::instance().count());
@@ -379,10 +379,10 @@ TEST_F(StatsMgrTest, removeAll) {
     EXPECT_EQ("{  }", StatsMgr::instance().get("delta")->str());
 
     // There should be no such statistics anymore
-    EXPECT_FALSE(StatsMgr::instance().getObservation("alpha"));
-    EXPECT_FALSE(StatsMgr::instance().getObservation("beta"));
-    EXPECT_FALSE(StatsMgr::instance().getObservation("gamma"));
-    EXPECT_FALSE(StatsMgr::instance().getObservation("delta"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("alpha"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("beta"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("gamma"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("delta"));
 }
 
 // This is a performance benchmark that checks how long does it take
@@ -516,7 +516,7 @@ TEST_F(StatsMgrTest, commandStatisticGet) {
                                                                    params);
 
     ObservationPtr alpha;
-    EXPECT_NO_THROW(alpha = StatsMgr::instance().getObservation("alpha"));
+    EXPECT_NO_THROW(alpha = StatsMgr::instance().testGetObservation("alpha"));
     ASSERT_TRUE(alpha);
 
     std::string exp = "{ \"alpha\": [ [ 1234, \"" +
@@ -570,16 +570,16 @@ TEST_F(StatsMgrTest, commandGetAll) {
     ASSERT_TRUE(rep_delta);
 
     std::string exp_str_alpha = "[ [ 1234, \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("alpha")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("alpha")
                                    ->getInteger().second) + "\" ] ]";
     std::string exp_str_beta = "[ [ 12.34, \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("beta")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("beta")
                                    ->getFloat().second) + "\" ] ]";
     std::string exp_str_gamma = "[ [ \"01:02:03.000004\", \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("gamma")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("gamma")
                                    ->getDuration().second) + "\" ] ]";
     std::string exp_str_delta = "[ [ \"Lorem ipsum\", \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("delta")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("delta")
                                    ->getString().second) + "\" ] ]";
 
     // Check that all of them can be reported at once
@@ -620,7 +620,7 @@ TEST_F(StatsMgrTest, commandStatisticReset) {
     EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code);
 
     ObservationPtr alpha;
-    EXPECT_NO_THROW(alpha = StatsMgr::instance().getObservation("alpha"));
+    EXPECT_NO_THROW(alpha = StatsMgr::instance().testGetObservation("alpha"));
     ASSERT_TRUE(alpha);
 
     // Check that it was indeed reset
@@ -673,16 +673,16 @@ TEST_F(StatsMgrTest, commandResetAll) {
     ASSERT_TRUE(rep_delta);
 
     std::string exp_str_alpha = "[ [ 1234, \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("alpha")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("alpha")
                                    ->getInteger().second) + "\" ] ]";
     std::string exp_str_beta = "[ [ 12.34, \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("beta")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("beta")
                                    ->getFloat().second) + "\" ] ]";
     std::string exp_str_gamma = "[ [ \"01:02:03.000004\", \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("gamma")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("gamma")
                                    ->getDuration().second) + "\" ] ]";
     std::string exp_str_delta = "[ [ \"Lorem ipsum\", \"" +
-        isc::util::ptimeToText(StatsMgr::instance().getObservation("delta")
+        isc::util::ptimeToText(StatsMgr::instance().testGetObservation("delta")
                                    ->getString().second) + "\" ] ]";
 
     // Check that all of them can be reset at once
@@ -696,13 +696,13 @@ TEST_F(StatsMgrTest, commandResetAll) {
 
     // Check that they're indeed reset
     EXPECT_EQ(0,
-              StatsMgr::instance().getObservation("alpha")->getInteger().first);
+              StatsMgr::instance().testGetObservation("alpha")->getInteger().first);
     EXPECT_EQ(0.0f,
-              StatsMgr::instance().getObservation("beta")->getFloat().first);
+              StatsMgr::instance().testGetObservation("beta")->getFloat().first);
     EXPECT_EQ(time_duration(0, 0, 0, 0),
-              StatsMgr::instance().getObservation("gamma")->getDuration().first);
+              StatsMgr::instance().testGetObservation("gamma")->getDuration().first);
     EXPECT_EQ("",
-              StatsMgr::instance().getObservation("delta")->getString().first);
+              StatsMgr::instance().testGetObservation("delta")->getString().first);
 }
 
 // Test checks if statistic-remove handler is able to remove a statistic.
@@ -719,7 +719,7 @@ TEST_F(StatsMgrTest, commandStatisticRemove) {
     EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code);
 
     // It should be gone.
-    EXPECT_FALSE(StatsMgr::instance().getObservation("alpha"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("alpha"));
     EXPECT_EQ(0, StatsMgr::instance().count());
 }
 
@@ -765,10 +765,10 @@ TEST_F(StatsMgrTest, commandRemoveAll) {
     ConstElementPtr rep_all = parseAnswer(status_code, rsp);
     ASSERT_EQ(0, status_code);
 
-    EXPECT_FALSE(StatsMgr::instance().getObservation("alpha"));
-    EXPECT_FALSE(StatsMgr::instance().getObservation("beta"));
-    EXPECT_FALSE(StatsMgr::instance().getObservation("gamma"));
-    EXPECT_FALSE(StatsMgr::instance().getObservation("delta"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("alpha"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("beta"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("gamma"));
+    EXPECT_FALSE(StatsMgr::instance().testGetObservation("delta"));
     EXPECT_EQ(0, StatsMgr::instance().count());
 }
 
@@ -788,10 +788,10 @@ TEST_F(StatsMgrTest, commandSetMaxSampleAge) {
     EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code);
 
     // check if time limit was set properly and whether count limit is disabled
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().second,
               time_duration(0, 20, 45, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, false);
 }
 
 // Test checks if statistic-sample-age-set is able to handle:
@@ -845,25 +845,25 @@ TEST_F(StatsMgrTest, commandSetMaxSampleAgeAll) {
     EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code);
 
     // check if time limit was set properly and whether count limit is disabled
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().second,
               time_duration(1, 2, 45, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().second,
               time_duration(1, 2, 45, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().second,
               time_duration(1, 2, 45, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().second,
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().second,
               time_duration(1, 2, 45, 0));
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().first, false);
 }
 
 // This test checks whether statistic-sample-count-set command really set
@@ -882,9 +882,9 @@ TEST_F(StatsMgrTest, commandSetMaxSampleCount) {
     EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code);
 
     // check if time limit was set properly and whether duration limit is disabled
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 15);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().second, 15);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, false);
 }
 
 // Test checks if statistic-sample-count-set is able to handle:
@@ -938,21 +938,21 @@ TEST_F(StatsMgrTest, commandSetMaxSampleCountAll) {
     EXPECT_EQ(CONTROL_RESULT_SUCCESS, status_code);
 
     // check if count limit was set properly and whether count limit is disabled
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleCount().second, 200);
-    EXPECT_EQ(StatsMgr::instance().getObservation("alpha")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleCount().second, 200);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("alpha")->getMaxSampleAge().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleCount().second, 200);
-    EXPECT_EQ(StatsMgr::instance().getObservation("beta")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleCount().second, 200);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("beta")->getMaxSampleAge().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleCount().second, 200);
-    EXPECT_EQ(StatsMgr::instance().getObservation("gamma")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleCount().second, 200);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("gamma")->getMaxSampleAge().first, false);
 
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().first, true);
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleCount().second, 200);
-    EXPECT_EQ(StatsMgr::instance().getObservation("delta")->getMaxSampleAge().first, false);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().first, true);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleCount().second, 200);
+    EXPECT_EQ(StatsMgr::instance().testGetObservation("delta")->getMaxSampleAge().first, false);
 }
 
 };