libkea_dhcpsrv_la_SOURCES += callout_handle_store.h
libkea_dhcpsrv_la_SOURCES += cfg_hosts.cc cfg_hosts.h
libkea_dhcpsrv_la_SOURCES += cfg_iface.cc cfg_iface.h
+libkea_dhcpsrv_la_SOURCES += cfg_expiration.cc cfg_expiration.h
libkea_dhcpsrv_la_SOURCES += cfg_option.cc cfg_option.h
libkea_dhcpsrv_la_SOURCES += cfg_option_def.cc cfg_option_def.h
libkea_dhcpsrv_la_SOURCES += cfg_rsoo.cc cfg_rsoo.h
--- /dev/null
+// Copyright (C) 2015 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <dhcpsrv/cfg_expiration.h>
+#include <exceptions/exceptions.h>
+#include <limits.h>
+
+namespace isc {
+namespace dhcp {
+
+// Default values
+const uint16_t CfgExpiration::DEFAULT_RECLAIM_TIMER_WAIT_TIME = 10;
+const uint16_t CfgExpiration::DEFAULT_FLUSH_RECLAIMED_TIMER_WAIT_TIME = 25;
+const uint32_t CfgExpiration::DEFAULT_HOLD_RECLAIMED_TIME = 3600;
+const uint32_t CfgExpiration::DEFAULT_MAX_RECLAIM_LEASES = 100;
+const uint16_t CfgExpiration::DEFAULT_MAX_RECLAIM_TIME = 250;
+const uint16_t CfgExpiration::DEFAULT_UNWARNED_RECLAIM_CYCLES = 5;
+
+// Maximum values.
+const uint16_t CfgExpiration::LIMIT_RECLAIM_TIMER_WAIT_TIME =
+ std::numeric_limits<uint16_t>::max();
+const uint16_t CfgExpiration::LIMIT_FLUSH_RECLAIMED_TIMER_WAIT_TIME =
+ std::numeric_limits<uint16_t>::max();
+const uint32_t CfgExpiration::LIMIT_HOLD_RECLAIMED_TIME =
+ std::numeric_limits<uint32_t>::max();
+const uint32_t CfgExpiration::LIMIT_MAX_RECLAIM_LEASES =
+ std::numeric_limits<uint32_t>::max();
+const uint16_t CfgExpiration::LIMIT_MAX_RECLAIM_TIME = 10000;
+const uint16_t CfgExpiration::LIMIT_UNWARNED_RECLAIM_CYCLES =
+ std::numeric_limits<uint16_t>::max();
+
+CfgExpiration::CfgExpiration()
+ : reclaim_timer_wait_time_(DEFAULT_RECLAIM_TIMER_WAIT_TIME),
+ flush_reclaimed_timer_wait_time_(DEFAULT_FLUSH_RECLAIMED_TIMER_WAIT_TIME),
+ hold_reclaimed_time_(DEFAULT_HOLD_RECLAIMED_TIME),
+ max_reclaim_leases_(DEFAULT_MAX_RECLAIM_LEASES),
+ max_reclaim_time_(DEFAULT_MAX_RECLAIM_TIME),
+ unwarned_reclaim_cycles_(DEFAULT_UNWARNED_RECLAIM_CYCLES) {
+}
+
+void
+CfgExpiration::setReclaimTimerWaitTime(const int64_t reclaim_timer_wait_time) {
+ rangeCheck(reclaim_timer_wait_time, LIMIT_RECLAIM_TIMER_WAIT_TIME,
+ "reclaim-timer-wait-time");
+ reclaim_timer_wait_time_ = reclaim_timer_wait_time;
+}
+
+void
+CfgExpiration::setFlushReclaimedTimerWaitTime(const int64_t flush_reclaimed_wait_time) {
+ rangeCheck(flush_reclaimed_wait_time, LIMIT_FLUSH_RECLAIMED_TIMER_WAIT_TIME,
+ "flush-reclaimed-timer-wait-time");
+ flush_reclaimed_timer_wait_time_ = flush_reclaimed_wait_time;
+}
+
+void
+CfgExpiration::setHoldReclaimedTime(const int64_t hold_reclaimed_time) {
+ rangeCheck(hold_reclaimed_time, LIMIT_HOLD_RECLAIMED_TIME, "hold-reclaimed-time");
+ hold_reclaimed_time_ = hold_reclaimed_time;
+}
+
+void
+CfgExpiration::setMaxReclaimLeases(const int64_t max_reclaim_leases) {
+ rangeCheck(max_reclaim_leases, LIMIT_MAX_RECLAIM_LEASES, "max-reclaim-leases");
+ max_reclaim_leases_ = max_reclaim_leases;
+}
+
+void
+CfgExpiration::setMaxReclaimTime(const int64_t max_reclaim_time) {
+ rangeCheck(max_reclaim_time, LIMIT_MAX_RECLAIM_TIME, "max-reclaim-time");
+ max_reclaim_time_ = max_reclaim_time;
+}
+
+void
+CfgExpiration::setUnwarnedReclaimCycles(const int64_t unwarned_reclaim_cycles) {
+ rangeCheck(unwarned_reclaim_cycles, LIMIT_UNWARNED_RECLAIM_CYCLES,
+ "unwarned-reclaim-cycles");
+ unwarned_reclaim_cycles_ = unwarned_reclaim_cycles;
+}
+
+void
+CfgExpiration::rangeCheck(const int64_t value, const uint64_t max_value,
+ const std::string& config_parameter_name) const {
+ if (value < 0) {
+ isc_throw(OutOfRange, "value for configuration parameter '"
+ << config_parameter_name << "' must not be negtive");
+
+ } else if (value > max_value) {
+ isc_throw(OutOfRange, "out range value '" << value << "' for configuration"
+ " parameter '" << config_parameter_name << "', expected maximum"
+ " value of '" << max_value << "'");
+ }
+}
+
+
+
+}
+}
--- /dev/null
+// Copyright (C) 2015 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#ifndef CFG_EXPIRATION_H
+#define CFG_EXPIRATION_H
+
+#include <boost/shared_ptr.hpp>
+#include <stdint.h>
+#include <string>
+
+namespace isc {
+namespace dhcp {
+
+/// @brief Holds configuration parameters pertaining to lease expiration
+/// and lease affinity.
+///
+/// This class holds the values of the following configuration parameters:
+///
+/// - reclaim-timer-wait-time - is the time between two cycles of processing
+/// expired leases, expressed in seconds, i.e. the time between the end of
+/// one cycle and the beginning of the next cycle. If this value is 0, the
+/// expired leases are not processed.
+///
+/// - flush-reclaimed-timer-wait-time - is the time between two cycles of
+/// recycling "expired-reclaimed" leases, expressed in seconds. If this
+/// value is 0, the expired leases are removed by the leases reclamation
+/// routine rather than recycling function. The recycling function is not
+/// executed and the value of the "hold-reclaimed-time" is ignored.
+///
+/// - hold-reclaimed-time -is the time for which "expired-reclaimed" leases
+/// are held in the lease database in the "expired-reclaimed" state after
+/// they expire. If this time is set to 0, the recycling function is not
+/// executed and the value of the "recycle-timer-wait-time" is ignored.
+/// This value is expressed in seconds.
+///
+/// - max-reclaim-leases - is the maximum number of leases to be processed
+/// in a single cycle. If this value is 0, all expired leases are
+/// processed in a single cycle, unless the maximum processing time
+/// (configured with the "max-time") parameter elapses first.
+///
+/// - max-reclaim-time - the maximum time that a single processing cycle
+/// may last, expressed in milliseconds. If this value is 0, there is no
+/// limitation for the maximum processing time. This value is expressed
+/// in milliseconds.
+///
+/// - unwarned-reclaim-cycles - is the number of consecutive processing
+/// cycles of expired leases, after which the system issues a warning if
+/// there are still expired leases in the database. If this value is 0,
+/// the warning is never issued.
+///
+/// The @c CfgExpiration class provides a collection of accessors and
+/// modifiers to manage the data. Each accessor checks if the given value
+/// is in range allowed for this value.
+class CfgExpiration {
+public:
+
+ /// @name Default values.
+ //@{
+ ///
+ /// @brief Default value for reclaim-timer-wait-time.
+ static const uint16_t DEFAULT_RECLAIM_TIMER_WAIT_TIME;
+
+ /// @brief Default value for flush-reclaimed-timer-wait-time.
+ static const uint16_t DEFAULT_FLUSH_RECLAIMED_TIMER_WAIT_TIME;
+
+ /// @brief Default value for hold-reclaimed-time.
+ static const uint32_t DEFAULT_HOLD_RECLAIMED_TIME;
+
+ /// @brief Default value for max-reclaim-leases.
+ static const uint32_t DEFAULT_MAX_RECLAIM_LEASES;
+
+ /// @brief Default value for max-reclaim-time.
+ static const uint16_t DEFAULT_MAX_RECLAIM_TIME;
+
+ /// @brief Default value for unwarned-reclaim-cycles.
+ static const uint16_t DEFAULT_UNWARNED_RECLAIM_CYCLES;
+
+ //@}
+
+ /// @name Upper limits for the parameters
+ //@{
+ ///
+ /// @brief Maximum value for reclaim-timer-wait-time.
+ static const uint16_t LIMIT_RECLAIM_TIMER_WAIT_TIME;
+
+ /// @brief Maximum value for flush-reclaimed-timer-wait-time.
+ static const uint16_t LIMIT_FLUSH_RECLAIMED_TIMER_WAIT_TIME;
+
+ /// @brief Maximum value for hold-reclaimed-time.
+ static const uint32_t LIMIT_HOLD_RECLAIMED_TIME;
+
+ /// @brief Maximum value for max-reclaim-leases.
+ static const uint32_t LIMIT_MAX_RECLAIM_LEASES;
+
+ /// @brief Defalt value for max-reclaim-time.
+ static const uint16_t LIMIT_MAX_RECLAIM_TIME;
+
+ /// @brief Maximum value for unwarned-reclaim-cycles.
+ static const uint16_t LIMIT_UNWARNED_RECLAIM_CYCLES;
+
+ //@}
+
+ /// @brief Constructor.
+ ///
+ /// Sets all parameters to their defaults.
+ CfgExpiration();
+
+ /// @brief Returns reclaim-timer-wait-time
+ uint16_t getReclaimTimerWaitTime() const {
+ return (reclaim_timer_wait_time_);
+ }
+
+ /// @brief Sets reclaim-timer-wait-time
+ ///
+ /// @param reclaim_timer_wait_time New value.
+ void setReclaimTimerWaitTime(const int64_t reclaim_timer_wait_time);
+
+ /// @brief Returns flush-reclaimed-timer-wait-time.
+ uint16_t getFlushReclaimedTimerWaitTime() const {
+ return (flush_reclaimed_timer_wait_time_);
+ }
+
+ /// @brief Sets flush-reclaimed-timer-wait-time.
+ ///
+ /// @param flush_reclaimed_wait_time New value.
+ void setFlushReclaimedTimerWaitTime(const int64_t flush_reclaimed_wait_time);
+
+ /// @brief Returns hold-reclaimed-time.
+ uint32_t getHoldReclaimedTime() const {
+ return (hold_reclaimed_time_);
+ }
+
+ /// @brief Sets hold-reclaimed-time
+ ///
+ /// @param hold_reclaimed_time New value.
+ void setHoldReclaimedTime(const int64_t hold_reclaimed_time);
+
+ /// @brief Returns max-reclaim-leases.
+ uint32_t getMaxReclaimLeases() const {
+ return (max_reclaim_leases_);
+ }
+
+ /// @brief Sets max-reclaim-leases.
+ ///
+ /// @param max_reclaim_leases New value.
+ void setMaxReclaimLeases(const int64_t max_reclaim_leases);
+
+ /// @brief Returns max-reclaim-time.
+ uint16_t getMaxReclaimTime() const {
+ return (max_reclaim_time_);
+ }
+
+ /// @brief Sets max-reclaim-time.
+ ///
+ /// @param max_reclaim_time New value.
+ void setMaxReclaimTime(const int64_t max_reclaim_time);
+
+ /// @brief Returns unwarned-reclaim-cycles.
+ uint16_t getUnwarnedReclaimCycles() const {
+ return (unwarned_reclaim_cycles_);
+ }
+
+ /// @brief Sets unwarned-reclaim-cycles.
+ ///
+ /// @param unwarned_reclaim_cycles New value.
+ void setUnwarnedReclaimCycles(const int64_t unwarned_reclaim_cycles);
+
+private:
+
+ /// @brief Checks if the value being set by one of the modifiers is
+ /// within an allowed range.
+ ///
+ /// @param value Value to be checked.
+ /// @param max_value Maximum allowed value.
+ /// @param config_parameter_name A name of the configuration parameter
+ /// (used for logging purposes if value is out of range).
+ ///
+ /// @throw isc::OutOfRange if the value is negative or greater than
+ /// the maximum value.
+ void rangeCheck(const int64_t value, const uint64_t max_value,
+ const std::string& config_parameter_name) const;
+
+ /// @brief reclaim-timer-wait-time
+ uint16_t reclaim_timer_wait_time_;
+
+ /// @brief flush-reclaimed-timer-wait-time
+ uint16_t flush_reclaimed_timer_wait_time_;
+
+ /// @brief hold-reclaimed-time
+ uint32_t hold_reclaimed_time_;
+
+ /// @brief max-reclaim-leases
+ uint32_t max_reclaim_leases_;
+
+ /// @brief max-reclaim-time
+ uint16_t max_reclaim_time_;
+
+ /// @brief unwarned-reclaim-cycles.
+ uint16_t unwarned_reclaim_cycles_;
+
+};
+
+/// @name Pointers to the @c CfgExpiration objects.
+//@{
+/// @brief Pointer to the Non-const object.
+typedef boost::shared_ptr<CfgExpiration> CfgExpirationPtr;
+
+/// @brief Pointer to the const object.
+typedef boost::shared_ptr<const CfgExpiration> ConstCfgExpirationPtr;
+
+//@}
+
+} // end of isc::dhcp namespace
+} // end of isc namespace
+
+#endif // CFG_EXPIRATION_H
cfg_option_def_(new CfgOptionDef()), cfg_option_(new CfgOption()),
cfg_subnets4_(new CfgSubnets4()), cfg_subnets6_(new CfgSubnets6()),
cfg_hosts_(new CfgHosts()), cfg_rsoo_(new CfgRSOO()),
+ cfg_expiration_(new CfgExpiration()),
decline_timer_(0) {
}
cfg_option_def_(new CfgOptionDef()), cfg_option_(new CfgOption()),
cfg_subnets4_(new CfgSubnets4()), cfg_subnets6_(new CfgSubnets6()),
cfg_hosts_(new CfgHosts()), cfg_rsoo_(new CfgRSOO()),
+ cfg_expiration_(new CfgExpiration()),
decline_timer_(0) {
}
#ifndef DHCPSRV_CONFIG_H
#define DHCPSRV_CONFIG_H
+#include <dhcpsrv/cfg_expiration.h>
#include <dhcpsrv/cfg_hosts.h>
#include <dhcpsrv/cfg_iface.h>
#include <dhcpsrv/cfg_option.h>
return (cfg_rsoo_);
}
+ /// @brief Returns pointer to the object holding configuration pertaining
+ /// to processing expired leases.
+ CfgExpirationPtr getCfgExpiration() {
+ return (cfg_expiration_);
+ }
+
+ /// @brief Returns pointer to the const object holding configuration
+ /// pertaining to processing expired leases.
+ ConstCfgExpirationPtr getCfgExpiration() const {
+ return (cfg_expiration_);
+ }
+
//@}
/// @brief Returns non-const reference to an array that stores
/// RFC 6422 for the definition of the RSOO-enabled option.
CfgRSOOPtr cfg_rsoo_;
+ /// @brief Pointer to the configuration pertaining to processing of
+ /// expired leases.
+ CfgExpirationPtr cfg_expiration_;
+
/// @brief Pointer to the control-socket information
isc::data::ConstElementPtr control_socket_;
libdhcpsrv_unittests_SOURCES += alloc_engine4_unittest.cc
libdhcpsrv_unittests_SOURCES += alloc_engine6_unittest.cc
libdhcpsrv_unittests_SOURCES += callout_handle_store_unittest.cc
+libdhcpsrv_unittests_SOURCES += cfg_expiration_unittest.cc
libdhcpsrv_unittests_SOURCES += cfg_hosts_unittest.cc
libdhcpsrv_unittests_SOURCES += cfg_iface_unittest.cc
libdhcpsrv_unittests_SOURCES += cfg_mac_source_unittest.cc
--- /dev/null
+// Copyright (C) 2015 Internet Systems Consortium, Inc. ("ISC")
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <config.h>
+#include <dhcpsrv/cfg_expiration.h>
+#include <exceptions/exceptions.h>
+#include <boost/function.hpp>
+#include <gtest/gtest.h>
+#include <stdint.h>
+
+using namespace isc;
+using namespace isc::dhcp;
+
+namespace {
+
+/// @brief Type definition of the @c CfgExpiration modified function.
+typedef boost::function<void(CfgExpiration*, const int64_t)> ModifierFun;
+/// @brief Type definition of the @c CfgExpiration accessor function
+/// returning uint16_t value.
+typedef boost::function<uint16_t(CfgExpiration*)> AccessorFunUint16;
+/// @brief Type definition of the @c CfgExpiration accessor function
+/// returning uint32_t value.
+typedef boost::function<uint32_t(CfgExpiration*)> AccessorFunUint32;
+
+/// @brief Tests the accessor and modifier function for a particular
+/// configuration parameter held in @c CfgExpiration.
+///
+/// This is a simple test which tries to set the given parameter to
+/// different values:
+/// - value greater than maximum allowed for this parameter - expects
+/// the exception to be thrown,
+/// - value lower than 0 - expects the exception to be thrown,
+/// - value equal to the maximum allowed,
+/// - value equal to maximum allowed minus 1.
+///
+/// @param limit Maximum allowed value for the parameter.
+/// @param modifier Pointer to the modifier function to be tested.
+/// @param accessor Pointer to the accessor function to be tested.
+/// @tparam ReturnType Type of the value returned by the accessor,
+/// i.e. uint16_t or uint32_t.
+template<typename ReturnType>
+void
+testAccessModify(const int64_t limit, const ModifierFun& modifier,
+ const boost::function<ReturnType(CfgExpiration*)>& accessor) {
+ CfgExpiration cfg;
+
+ // Setting the value to maximum allowed + 1 should result in
+ // an exception.
+ ASSERT_THROW(modifier(&cfg, limit + 1), OutOfRange);
+
+ // Setting to the negative value should result in an exception.
+ ASSERT_THROW(modifier(&cfg, -1), OutOfRange);
+
+ // Setting the value to the maximum allowed should pass.
+ ASSERT_NO_THROW(modifier(&cfg, limit));
+ EXPECT_EQ(limit, accessor(&cfg));
+
+ // Setting the value to the maximum allowed - 1 should pass.
+ ASSERT_NO_THROW(modifier(&cfg, limit - 1));
+ EXPECT_EQ(limit - 1, accessor(&cfg));
+}
+
+/// @brief Tests that modifier and the accessor returning uint16_t value
+/// work as expected.
+///
+/// @param limit Maximum allowed value for the parameter.
+/// @param modifier Pointer to the modifier function to be tested.
+/// @param accessor Pointer to the accessor function to be tested.
+void
+testAccessModifyUint16(const int64_t limit, const ModifierFun& modifier,
+ const AccessorFunUint16& accessor) {
+ testAccessModify<uint16_t>(limit, modifier, accessor);
+}
+
+/// @brief Tests that modifier and the accessor returning uint32_t value
+/// work as expected.
+///
+/// @param limit Maximum allowed value for the parameter.
+/// @param modifier Pointer to the modifier function to be tested.
+/// @param accessor Pointer to the accessor function to be tested.
+void
+testAccessModifyUint32(const int64_t limit, const ModifierFun& modifier,
+ const AccessorFunUint32& accessor) {
+ testAccessModify<uint32_t>(limit, modifier, accessor);
+}
+
+/// Test the default values of CfgExpiration object.
+TEST(CfgExpirationTest, defaults) {
+ CfgExpiration cfg;
+ EXPECT_EQ(CfgExpiration::DEFAULT_RECLAIM_TIMER_WAIT_TIME,
+ cfg.getReclaimTimerWaitTime());
+ EXPECT_EQ(CfgExpiration::DEFAULT_FLUSH_RECLAIMED_TIMER_WAIT_TIME,
+ cfg.getFlushReclaimedTimerWaitTime());
+ EXPECT_EQ(CfgExpiration::DEFAULT_HOLD_RECLAIMED_TIME,
+ cfg.getHoldReclaimedTime());
+ EXPECT_EQ(CfgExpiration::DEFAULT_MAX_RECLAIM_LEASES,
+ cfg.getMaxReclaimLeases());
+ EXPECT_EQ(CfgExpiration::DEFAULT_MAX_RECLAIM_TIME,
+ cfg.getMaxReclaimTime());
+ EXPECT_EQ(CfgExpiration::DEFAULT_UNWARNED_RECLAIM_CYCLES,
+ cfg.getUnwarnedReclaimCycles());
+}
+
+// Test the {get,set}ReclaimTimerWaitTime.
+TEST(CfgExpirationTest, getReclaimTimerWaitTime) {
+ testAccessModify<uint16_t>(CfgExpiration::LIMIT_RECLAIM_TIMER_WAIT_TIME,
+ &CfgExpiration::setReclaimTimerWaitTime,
+ &CfgExpiration::getReclaimTimerWaitTime);
+}
+
+// Test the {get,set}FlushReclaimedTimerWaitTime.
+TEST(CfgExpirationTest, getFlushReclaimedTimerWaitTime) {
+ testAccessModifyUint16(CfgExpiration::LIMIT_FLUSH_RECLAIMED_TIMER_WAIT_TIME,
+ &CfgExpiration::setFlushReclaimedTimerWaitTime,
+ &CfgExpiration::getFlushReclaimedTimerWaitTime);
+}
+
+// Test the {get,set}HoldReclaimedTime.
+TEST(CfgExpirationTest, getHoldReclaimedTime) {
+ testAccessModifyUint32(CfgExpiration::LIMIT_HOLD_RECLAIMED_TIME,
+ &CfgExpiration::setHoldReclaimedTime,
+ &CfgExpiration::getHoldReclaimedTime);
+}
+
+// Test the {get,set}MaxReclaimLeases.
+TEST(CfgExpirationTest, getMaxReclaimLeases) {
+ testAccessModifyUint32(CfgExpiration::LIMIT_MAX_RECLAIM_LEASES,
+ &CfgExpiration::setMaxReclaimLeases,
+ &CfgExpiration::getMaxReclaimLeases);
+}
+
+// Test the {get,set}MaxReclaimTime.
+TEST(CfgExpirationTest, getMaxReclaimTime) {
+ testAccessModifyUint16(CfgExpiration::LIMIT_MAX_RECLAIM_TIME,
+ &CfgExpiration::setMaxReclaimTime,
+ &CfgExpiration::getMaxReclaimTime);
+}
+
+// Test the {get,set}UnwarnedReclaimCycles.
+TEST(CfgExpirationTest, getUnwarnedReclaimCycles) {
+ testAccessModifyUint16(CfgExpiration::LIMIT_UNWARNED_RECLAIM_CYCLES,
+ &CfgExpiration::setUnwarnedReclaimCycles,
+ &CfgExpiration::getUnwarnedReclaimCycles);
+}
+
+} // end of anonymous namespace
projects / thirdparty / kea.git / commitdiff
