Add a unit test of System::Layer timer order (#12895)

#### Problem

Nothing explicitly tests that `System::Layer` timers fire in
chronological order. Since we can now have a mock system clock,
this is testable.

#### Change overview

- Add a unit test verifying that timer callbacks run in order.
- Add unit test assertions for timer statistics.
- Revise implementation selection in TestSystemTimer to use the
  `Layer` class rather than only '#if', since not every configuration
  with sockets/LwIP necessarily needs to use the provided `Layer`
  implementations.
- Provide a common MockClock implementation.

#### Testing

Res ipsa loquitur.

src/lib/dnssd/minimal_mdns/tests/TestActiveResolveAttempts.cpp

@@ -26,18 +26,6 @@ using namespace chip;
 using namespace chip::System::Clock::Literals;
 using chip::System::Clock::Timeout;
 
-class MockClock : public System::Clock::ClockImpl
-{
-public:
-    System::Clock::Microseconds64 GetMonotonicMicroseconds64() override { return mMsec; }
-    System::Clock::Milliseconds64 GetMonotonicMilliseconds64() override { return mMsec; }
-
-    void Advance(System::Clock::Milliseconds32 ms) { mMsec += ms; }
-
-private:
-    System::Clock::Milliseconds64 mMsec;
-};
-
 PeerId MakePeerId(NodeId nodeId)
 {
     PeerId peerId;
@@ -46,10 +34,10 @@ PeerId MakePeerId(NodeId nodeId)
 
 void TestSinglePeerAddRemove(nlTestSuite * inSuite, void * inContext)
 {
-    MockClock mockClock;
+    System::Clock::Internal::MockClock mockClock;
     mdns::Minimal::ActiveResolveAttempts attempts(&mockClock);
 
-    mockClock.Advance(1234_ms32);
+    mockClock.AdvanceMonotonic(1234_ms32);
 
     // Starting up, no scheduled peers are expected
     NL_TEST_ASSERT(inSuite, !attempts.GetTimeUntilNextExpectedResponse().HasValue());
@@ -65,20 +53,20 @@ void TestSinglePeerAddRemove(nlTestSuite * inSuite, void * inContext)
 
     // one Next schedule is called, expect to have a delay of 1000 ms
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(1000_ms32));
-    mockClock.Advance(500_ms32);
+    mockClock.AdvanceMonotonic(500_ms32);
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(500_ms32));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
 
     // past due date: timeout should be 0
-    mockClock.Advance(800_ms32);
+    mockClock.AdvanceMonotonic(800_ms32);
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(0_ms32));
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(1)));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
 
     // one Next schedule is called, expect to have a delay of 2000 ms
     // sincve the timeout doubles every time
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(2000_ms32));
-    mockClock.Advance(100_ms32);
+    mockClock.AdvanceMonotonic(100_ms32);
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(1900_ms32));
 
     // once complete, nothing to schedule
@@ -89,10 +77,10 @@ void TestSinglePeerAddRemove(nlTestSuite * inSuite, void * inContext)
 
 void TestRescheduleSamePeerId(nlTestSuite * inSuite, void * inContext)
 {
-    MockClock mockClock;
+    System::Clock::Internal::MockClock mockClock;
     mdns::Minimal::ActiveResolveAttempts attempts(&mockClock);
 
-    mockClock.Advance(112233_ms32);
+    mockClock.AdvanceMonotonic(112233_ms32);
 
     attempts.MarkPending(MakePeerId(1));
 
@@ -104,7 +92,7 @@ void TestRescheduleSamePeerId(nlTestSuite * inSuite, void * inContext)
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(1000_ms32));
 
     // 2nd try goes to 2 seconds (once at least 1 second passes)
-    mockClock.Advance(1234_ms32);
+    mockClock.AdvanceMonotonic(1234_ms32);
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(0_ms32));
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(1)));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
@@ -122,21 +110,21 @@ void TestRescheduleSamePeerId(nlTestSuite * inSuite, void * inContext)
 void TestLRU(nlTestSuite * inSuite, void * inContext)
 {
     // validates that the LRU logic is working
-    MockClock mockClock;
+    System::Clock::Internal::MockClock mockClock;
     mdns::Minimal::ActiveResolveAttempts attempts(&mockClock);
 
-    mockClock.Advance(334455_ms32);
+    mockClock.AdvanceMonotonic(334455_ms32);
 
     // add a single very old peer
     attempts.MarkPending(MakePeerId(9999));
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(9999)));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
 
-    mockClock.Advance(1000_ms32);
+    mockClock.AdvanceMonotonic(1000_ms32);
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(9999)));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
 
-    mockClock.Advance(2000_ms32);
+    mockClock.AdvanceMonotonic(2000_ms32);
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(9999)));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
 
@@ -145,7 +133,7 @@ void TestLRU(nlTestSuite * inSuite, void * inContext)
     for (uint32_t i = 1; i < mdns::Minimal::ActiveResolveAttempts::kRetryQueueSize; i++)
     {
         attempts.MarkPending(MakePeerId(i));
-        mockClock.Advance(1_ms32);
+        mockClock.AdvanceMonotonic(1_ms32);
 
         NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(i)));
         NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
@@ -159,7 +147,7 @@ void TestLRU(nlTestSuite * inSuite, void * inContext)
 
     // add another element - this should overwrite peer 9999
     attempts.MarkPending(MakePeerId(mdns::Minimal::ActiveResolveAttempts::kRetryQueueSize));
-    mockClock.Advance(32_s16);
+    mockClock.AdvanceMonotonic(32_s16);
 
     for (Optional<PeerId> peerId = attempts.NextScheduledPeer(); peerId.HasValue(); peerId = attempts.NextScheduledPeer())
     {
@@ -182,7 +170,7 @@ void TestLRU(nlTestSuite * inSuite, void * inContext)
             break;
         }
 
-        mockClock.Advance(ms.Value());
+        mockClock.AdvanceMonotonic(ms.Value());
 
         Optional<PeerId> peerId = attempts.NextScheduledPeer();
         while (peerId.HasValue())
@@ -196,18 +184,18 @@ void TestLRU(nlTestSuite * inSuite, void * inContext)
 
 void TestNextPeerOrdering(nlTestSuite * inSuite, void * inContext)
 {
-    MockClock mockClock;
+    System::Clock::Internal::MockClock mockClock;
     mdns::Minimal::ActiveResolveAttempts attempts(&mockClock);
 
-    mockClock.Advance(123321_ms32);
+    mockClock.AdvanceMonotonic(123321_ms32);
 
     // add a single peer that will be resolved quickly
     attempts.MarkPending(MakePeerId(1));
 
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(1)));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(1000_ms32));
-    mockClock.Advance(20_ms32);
+    mockClock.AdvanceMonotonic(20_ms32);
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(980_ms32));
 
     // expect peerid to be resolve within 1 second from now
@@ -216,13 +204,13 @@ void TestNextPeerOrdering(nlTestSuite * inSuite, void * inContext)
     // mock that we are querying 2 as well
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(2)));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
-    mockClock.Advance(80_ms32);
+    mockClock.AdvanceMonotonic(80_ms32);
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(900_ms32));
 
     // Peer 1 is done, now peer2 should be pending (in 980ms)
     attempts.Complete(MakePeerId(1));
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(920_ms32));
-    mockClock.Advance(20_ms32);
+    mockClock.AdvanceMonotonic(20_ms32);
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(900_ms32));
 
     // Once peer 3 is added, queue should be
@@ -236,14 +224,14 @@ void TestNextPeerOrdering(nlTestSuite * inSuite, void * inContext)
     // After the clock advance
     //  - 400 ms until peer id 2 is pending
     //  - 500 ms until peer id 3 is pending
-    mockClock.Advance(500_ms32);
+    mockClock.AdvanceMonotonic(500_ms32);
 
     NL_TEST_ASSERT(inSuite, attempts.GetTimeUntilNextExpectedResponse() == Optional<Timeout>(400_ms32));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());
 
     // advancing the clock 'too long' will return both other entries, in  reverse order due to how
     // the internal cache is built
-    mockClock.Advance(500_ms32);
+    mockClock.AdvanceMonotonic(500_ms32);
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(3)));
     NL_TEST_ASSERT(inSuite, attempts.NextScheduledPeer() == Optional<PeerId>::Value(MakePeerId(2)));
     NL_TEST_ASSERT(inSuite, !attempts.NextScheduledPeer().HasValue());

src/system/SystemClock.h

@@ -303,6 +303,36 @@ inline void SetSystemClockForTesting(Clock::ClockBase * clock)
     Clock::Internal::gClockBase = clock;
 }
 
+// Provide a mock implementation for use by unit tests.
+class MockClock : public ClockImpl
+{
+public:
+    Microseconds64 GetMonotonicMicroseconds64() override { return mSystemTime; }
+    Milliseconds64 GetMonotonicMilliseconds64() override { return std::chrono::duration_cast<Milliseconds64>(mSystemTime); }
+    CHIP_ERROR GetClock_RealTime(Microseconds64 & aCurTime) override
+    {
+        aCurTime = mRealTime;
+        return CHIP_NO_ERROR;
+    }
+    CHIP_ERROR GetClock_RealTimeMS(Milliseconds64 & aCurTime) override
+    {
+        aCurTime = std::chrono::duration_cast<Milliseconds64>(mRealTime);
+        return CHIP_NO_ERROR;
+    }
+    CHIP_ERROR SetClock_RealTime(Microseconds64 aNewCurTime) override
+    {
+        mRealTime = aNewCurTime;
+        return CHIP_NO_ERROR;
+    }
+
+    void SetMonotonic(Milliseconds64 timestamp) { mSystemTime = timestamp; }
+    void AdvanceMonotonic(Milliseconds64 increment) { mSystemTime += increment; }
+    void AdvanceRealTime(Milliseconds64 increment) { mRealTime += increment; }
+
+    Microseconds64 mSystemTime = Clock::kZero;
+    Microseconds64 mRealTime   = Clock::kZero;
+};
+
 } // namespace Internal
 
 #if CHIP_SYSTEM_CONFIG_USE_POSIX_TIME_FUNCTS || CHIP_SYSTEM_CONFIG_USE_SOCKETS

src/system/SystemStats.h

@@ -156,6 +156,11 @@ const Label * GetStrings();
 // Additional macros for testing.
 #define SYSTEM_STATS_TEST_IN_USE(entry, expected) (chip::System::Stats::GetResourcesInUse()[entry] == (expected))
 #define SYSTEM_STATS_TEST_HIGH_WATER_MARK(entry, expected) (chip::System::Stats::GetHighWatermarks()[entry] == (expected))
+#define SYSTEM_STATS_RESET_HIGH_WATER_MARK_FOR_TESTING(entry)                                                                      \
+    do                                                                                                                             \
+    {                                                                                                                              \
+        chip::System::Stats::GetHighWatermarks()[entry] = 0;                                                                       \
+    } while (0)
 
 #else // CHIP_SYSTEM_CONFIG_PROVIDE_STATISTICS
 
@@ -171,5 +176,6 @@ const Label * GetStrings();
 
 #define SYSTEM_STATS_TEST_IN_USE(entry, expected) (true)
 #define SYSTEM_STATS_TEST_HIGH_WATER_MARK(entry, expected) (true)
+#define SYSTEM_STATS_RESET_HIGH_WATER_MARK_FOR_TESTING(entry)
 
 #endif // CHIP_SYSTEM_CONFIG_PROVIDE_STATISTICS

src/system/tests/TestSystemClock.cpp

@@ -85,14 +85,7 @@ void TestRealClock(nlTestSuite * inSuite, void * inContext)
 
 void TestMockClock(nlTestSuite * inSuite, void * inContext)
 {
-    class MockClock : public Clock::ClockImpl
-    {
-    public:
-        Clock::Microseconds64 GetMonotonicMicroseconds64() override { return mTime; }
-        Clock::Milliseconds64 GetMonotonicMilliseconds64() override { return mTime; }
-        Clock::Milliseconds64 mTime = Clock::kZero;
-    };
-    MockClock clock;
+    Clock::Internal::MockClock clock;
 
     Clock::ClockBase * savedRealClock = &SystemClock();
     Clock::Internal::SetSystemClockForTesting(&clock);
@@ -101,7 +94,7 @@ void TestMockClock(nlTestSuite * inSuite, void * inContext)
     NL_TEST_ASSERT(inSuite, SystemClock().GetMonotonicMicroseconds64() == Clock::kZero);
 
     constexpr Clock::Milliseconds64 k1234 = Clock::Milliseconds64(1234);
-    clock.mTime                           = k1234;
+    clock.SetMonotonic(k1234);
     NL_TEST_ASSERT(inSuite, SystemClock().GetMonotonicMilliseconds64() == k1234);
     NL_TEST_ASSERT(inSuite, SystemClock().GetMonotonicMicroseconds64() == k1234);