1 files changed, 73 insertions, 22 deletions
diff --git a/staging_vespalib/src/tests/metrics/mock_tick.h b/staging_vespalib/src/tests/metrics/mock_tick.h
index e0336260880..3f244ea6c9f 100644
--- a/staging_vespalib/src/tests/metrics/mock_tick.h
+++ b/staging_vespalib/src/tests/metrics/mock_tick.h
@@ -5,36 +5,87 @@
 #include <condition_variable>
 #include <mutex>
 #include <vespa/vespalib/metrics/clock.h>
+#include <vespa/vespalib/testkit/test_kit.h>
 
 namespace vespalib::metrics {
 
-// share the MockTick between the tested and the tester.
+// used to test clients of the Tick interface
+// values shared between threads are bounded queues with max size 1
 class MockTick : public Tick {
 private:
-    std::mutex _lock;
-    bool _runFlag;
-    bool _provided;
-    bool _blocked;
-    std::condition_variable _providedCond;
-    std::condition_variable _blockedCond;
-    TimeStamp _nextValue;
-    TimeStamp _prevValue;
-public:
-    MockTick();
-    TimeStamp next(TimeStamp prev) override;
-    void kill() override;
-    bool alive() override;
+    using Guard = std::unique_lock<std::mutex>;
+    struct Value {
+        TimeStamp value{0.0};
+        bool    valid{false};
+    };
+
+    TimeStamp               _first_value;
+    std::mutex              _lock;
+    std::condition_variable _cond;
+    bool                    _alive;
+    Value                   _prev;
+    Value                   _next;
+
+    void push(Value &dst, TimeStamp value) {
+        Guard guard(_lock);
+        while (_alive && dst.valid) {
+            _cond.wait(guard);
+        }
+        dst.value = value;
+        dst.valid = true;
+        _cond.notify_one();
+    }
+
+    TimeStamp pop(Value &src) {
+        Guard guard(_lock);
+        while (_alive && !src.valid) {
+            _cond.wait(guard);
+        }
+        src.valid = false;
+        _cond.notify_one();
+        return src.value;
+    }
 
-    void provide(TimeStamp value);
-    TimeStamp waitUntilBlocked();
+    TimeStamp peek(const Value &src) {
+        Guard guard(_lock);
+        while (_alive && !src.valid) {
+            _cond.wait(guard);
+        }
+        return src.value;
+    }
+
+public:
+    MockTick(TimeStamp first_value)
+        : _first_value(first_value), _lock(), _cond(), _alive(true), _prev(), _next() {}
+    TimeStamp first() override { return _first_value; }
+    TimeStamp next(TimeStamp prev) override {
+        push(_prev, prev);
+        return pop(_next);
+    }
+    TimeStamp give(TimeStamp next_value) {
+        TimeStamp prev_value = pop(_prev);
+        push(_next, next_value);
+        EXPECT_EQUAL(peek(_prev).count(), next_value.count());
+        return prev_value;
+    }
+    bool alive() const override { return _alive; }
+    void kill() override {
+        Guard guard(_lock);
+        _alive = false;
+        _cond.notify_all();
+    }
 };
 
-struct TickProxy : Tick {
-    std::shared_ptr<Tick> tick;
-    TickProxy(std::shared_ptr<Tick> tick_in) : tick(std::move(tick_in)) {}
-    TimeStamp next(TimeStamp prev) override { return tick->next(prev); }
-    void kill() override { tick->kill(); }
-    bool alive() override { return tick->alive(); }
+// share the MockTick between the tested and the tester.
+class TickProxy : public Tick {
+private:
+    std::shared_ptr<Tick> _tick;
+public:
+    TickProxy(std::shared_ptr<Tick> tick) : _tick(std::move(tick)) {}
+    TimeStamp first() override { return _tick->first(); }
+    TimeStamp next(TimeStamp prev) override { return _tick->next(prev); }
+    bool alive() const override { return _tick->alive(); }
+    void kill() override { _tick->kill(); }
 };
 
 } // namespace vespalib::metrics