MB-43238: Fix intermittent failure of expiry pager settings test

The test checks that the expected run time of the expiry pager task is
within an upper and lower bound based on the time before/after setting
the config param, plus the sleep time.

This ensures the test is resilient to time passing between computing an
expected time and the config actually being applied.

However, the test relies on system_clock, whereas the expiry pager
config derives the current time using ep_current_time(), which is
subject to memcached_uptime ticks.

The time computed by the expiry pager can then appear to be (at most)
one second behind system_clock, dependent on exactly when the time was
determined relative to when the tick occurs.

Fix by relaxing the test checks by one second.

A better fix might be to settle on one time source for the test and
pager for consistency, but relaxing the test is a less invasive path to
resolving the intermittent failure.

Change-Id: I53efc937f07a48ce1d3b2157ec3aea31efe93b38
Reviewed-on: http://review.couchbase.org/c/kv_engine/+/163884
Tested-by: Build Bot <[email protected]>
Reviewed-by: Richard de Mellow <[email protected]>
Reviewed-by: Dave Rigby <[email protected]>

Author: jameseh96

engines/ep/tests/ep_testsuite.cc

@@ -643,7 +643,9 @@ static enum test_result test_expiry_pager_settings(EngineIface* h) {
             get_int_stat(h, "ep_exp_pager_stime"),
             "Expiry pager sleep time not updated");
     cb_assert(!get_bool_stat(h, "ep_exp_pager_enabled"));
-    std::this_thread::sleep_for(std::chrono::seconds(1));
+    using namespace std::chrono;
+    using namespace std::chrono_literals;
+    std::this_thread::sleep_for(1s);
     checkeq(0,
             get_int_stat(h, "ep_num_expiry_pager_runs"),
             "Expiry pager run count is not zero");
@@ -687,23 +689,27 @@ static enum test_result test_expiry_pager_settings(EngineIface* h) {
     checkeq(0, str.substr(11, 5).compare(expected_time), err_msg.c_str());
 
     // Update exp_pager_stime by 30 minutes and ensure that the update is successful
-    const std::chrono::minutes update_by{30};
-    std::string targetTaskTime1{make_time_string(std::chrono::system_clock::now() +
-                                                 update_by)};
+    const auto update_by = 30min;
+    // the calculated task time depends on memcached_uptime ticks, so can be
+    // at most 1 second behind based on exactly when it is checked;
+    // reduce the lower bound to allow this.
+    std::string targetTaskTime1{
+            make_time_string(system_clock::now() + update_by - 1s)};
 
     // clear the initial task time, and test setting stime results in an exact
     // result of
     //   task_time = now + stime
     set_param(
             h, EngineParamCategory::Flush, "exp_pager_initial_run_time", "-1");
-    set_param(h,
-              EngineParamCategory::Flush,
-              "exp_pager_stime",
-              std::to_string(update_by.count() * 60).c_str());
+    set_param(
+            h,
+            EngineParamCategory::Flush,
+            "exp_pager_stime",
+            std::to_string(duration_cast<seconds>(update_by).count()).c_str());
     str = get_str_stat(h, "ep_expiry_pager_task_time");
 
-    std::string targetTaskTime2{make_time_string(std::chrono::system_clock::now() +
-                                                 update_by)};
+    std::string targetTaskTime2{
+            make_time_string(system_clock::now() + update_by)};
 
     // ep_expiry_pager_task_time should fall within the range of
     // targetTaskTime1 and targetTaskTime2