Commit 878bae10 authored by Marcin Siodelski's avatar Marcin Siodelski

[3974] Added class holding configuration for lease expiation.

parent 76f0f610
......@@ -80,6 +80,7 @@ libkea_dhcpsrv_la_SOURCES += base_host_data_source.h
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
......
// 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 << "'");
}
}
}
}
// 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
......@@ -31,6 +31,7 @@ SrvConfig::SrvConfig()
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) {
}
......@@ -39,6 +40,7 @@ SrvConfig::SrvConfig(const uint32_t sequence)
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) {
}
......
......@@ -15,6 +15,7 @@
#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>
......@@ -259,6 +260,18 @@ public:
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
......@@ -441,6 +454,10 @@ private:
/// 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_;
......
......@@ -65,6 +65,7 @@ libdhcpsrv_unittests_SOURCES += alloc_engine_hooks_unittest.cc
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
......
// 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
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment