| /* |
| * |
| * Copyright (c) 2023 Project CHIP Authors |
| * All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <app/InteractionModelEngine.h> |
| #include <app/reporting/ReportSchedulerImpl.h> |
| #include <app/reporting/SynchronizedReportSchedulerImpl.h> |
| #include <app/tests/AppTestContext.h> |
| #include <lib/support/UnitTestContext.h> |
| #include <lib/support/UnitTestRegistration.h> |
| #include <lib/support/logging/CHIPLogging.h> |
| #include <nlunit-test.h> |
| |
| namespace { |
| |
| using TestContext = chip::Test::AppContext; |
| |
| class NullReadHandlerCallback : public chip::app::ReadHandler::ManagementCallback |
| { |
| public: |
| void OnDone(chip::app::ReadHandler & apReadHandlerObj) override {} |
| chip::app::ReadHandler::ApplicationCallback * GetAppCallback() override { return nullptr; } |
| }; |
| |
| } // namespace |
| |
| namespace chip { |
| namespace app { |
| namespace reporting { |
| |
| using ReportScheduler = reporting::ReportScheduler; |
| using ReportSchedulerImpl = reporting::ReportSchedulerImpl; |
| using ReadHandlerNode = reporting::ReportScheduler::ReadHandlerNode; |
| using Milliseconds64 = System::Clock::Milliseconds64; |
| |
| static const size_t kNumMaxReadHandlers = 16; |
| |
| class TestTimerDelegate : public ReportScheduler::TimerDelegate |
| { |
| public: |
| struct NodeTimeoutPair |
| { |
| ReadHandlerNode * node; |
| System::Clock::Timeout timeout; |
| }; |
| |
| NodeTimeoutPair mPairArray[kNumMaxReadHandlers]; |
| size_t mPairArraySize = 0; |
| System::Clock::Timestamp mMockSystemTimestamp = System::Clock::Milliseconds64(0); |
| |
| NodeTimeoutPair * FindPair(ReadHandlerNode * node, size_t & position) |
| { |
| for (size_t i = 0; i < mPairArraySize; i++) |
| { |
| if (mPairArray[i].node == node) |
| { |
| position = i; |
| return &mPairArray[i]; |
| } |
| } |
| return nullptr; |
| } |
| |
| CHIP_ERROR insertPair(ReadHandlerNode * node, System::Clock::Timeout timeout) |
| { |
| VerifyOrReturnError(mPairArraySize < kNumMaxReadHandlers, CHIP_ERROR_NO_MEMORY); |
| mPairArray[mPairArraySize].node = node; |
| mPairArray[mPairArraySize].timeout = timeout; |
| mPairArraySize++; |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| void removePair(ReadHandlerNode * node) |
| { |
| size_t position; |
| NodeTimeoutPair * pair = FindPair(node, position); |
| VerifyOrReturn(pair != nullptr); |
| |
| size_t nextPos = static_cast<size_t>(position + 1); |
| size_t moveNum = static_cast<size_t>(mPairArraySize - nextPos); |
| |
| // Compress array after removal, if the removed position is not the last |
| if (moveNum) |
| { |
| memmove(&mPairArray[position], &mPairArray[nextPos], sizeof(NodeTimeoutPair) * moveNum); |
| } |
| |
| mPairArraySize--; |
| } |
| |
| static void TimerCallbackInterface(System::Layer * aLayer, void * aAppState) |
| { |
| TimerContext * context = static_cast<TimerContext *>(aAppState); |
| context->TimerFired(); |
| ChipLogProgress(DataManagement, "Simluating engine run for Handler: %p", aAppState); |
| } |
| virtual CHIP_ERROR StartTimer(TimerContext * context, System::Clock::Timeout aTimeout) override |
| { |
| return insertPair(static_cast<ReadHandlerNode *>(context), aTimeout + mMockSystemTimestamp); |
| } |
| virtual void CancelTimer(TimerContext * context) override { removePair(static_cast<ReadHandlerNode *>(context)); } |
| virtual bool IsTimerActive(TimerContext * context) override |
| { |
| size_t position; |
| NodeTimeoutPair * pair = FindPair(static_cast<ReadHandlerNode *>(context), position); |
| VerifyOrReturnValue(pair != nullptr, false); |
| |
| return pair->timeout > mMockSystemTimestamp; |
| } |
| |
| virtual System::Clock::Timestamp GetCurrentMonotonicTimestamp() override { return mMockSystemTimestamp; } |
| |
| void SetMockSystemTimestamp(System::Clock::Timestamp aMockTimestamp) { mMockSystemTimestamp = aMockTimestamp; } |
| |
| // Increment the mock timestamp by aTime and call callbacks for timers that have expired. Checks if the timeout expired after |
| // incrementing |
| void IncrementMockTimestamp(System::Clock::Milliseconds64 aTime) |
| { |
| mMockSystemTimestamp = mMockSystemTimestamp + aTime; |
| for (size_t i = 0; i < mPairArraySize; i++) |
| { |
| if (mPairArray[i].timeout <= mMockSystemTimestamp) |
| { |
| TimerCallbackInterface(nullptr, mPairArray[i].node); |
| } |
| } |
| } |
| }; |
| |
| /// @brief TestTimerSynchronizedDelegate is a mock of the TimerDelegate interface that allows to control the time without dependency |
| /// on the system layer. This also simulates the system timer by verifying if the timeout expired when incrementing the mock |
| /// timestamp. only one timer can be active at a time, which is the one has the earliest timeout. |
| /// It is used to test the SynchronizedReportSchedulerImpl. |
| class TestTimerSynchronizedDelegate : public ReportScheduler::TimerDelegate |
| { |
| public: |
| static void TimerCallbackInterface(System::Layer * aLayer, void * aAppState) |
| { |
| TimerContext * context = static_cast<TimerContext *>(aAppState); |
| context->TimerFired(); |
| } |
| virtual CHIP_ERROR StartTimer(TimerContext * context, System::Clock::Timeout aTimeout) override |
| { |
| if (nullptr == context) |
| { |
| return CHIP_ERROR_INCORRECT_STATE; |
| } |
| |
| mTimerContext = context; |
| mTimerTimeout = mMockSystemTimestamp + aTimeout; |
| return CHIP_NO_ERROR; |
| } |
| virtual void CancelTimer(TimerContext * context) override |
| { |
| VerifyOrReturn(nullptr != mTimerContext); |
| mTimerContext = nullptr; |
| mTimerTimeout = System::Clock::Milliseconds64(0x7FFFFFFFFFFFFFFF); |
| } |
| virtual bool IsTimerActive(TimerContext * context) override |
| { |
| return (nullptr != mTimerContext) && (mTimerTimeout > mMockSystemTimestamp); |
| } |
| |
| virtual System::Clock::Timestamp GetCurrentMonotonicTimestamp() override { return mMockSystemTimestamp; } |
| |
| void SetMockSystemTimestamp(System::Clock::Timestamp aMockTimestamp) { mMockSystemTimestamp = aMockTimestamp; } |
| |
| // Increment the mock timestamp one milisecond at a time for a total of aTime miliseconds. Checks if the timeout expired when |
| // incrementing |
| void IncrementMockTimestamp(System::Clock::Milliseconds64 aTime) |
| { |
| for (System::Clock::Milliseconds64 i = System::Clock::Milliseconds64(0); i < aTime; i++) |
| { |
| mMockSystemTimestamp++; |
| if (mMockSystemTimestamp == mTimerTimeout) |
| { |
| TimerCallbackInterface(nullptr, mTimerContext); |
| } |
| } |
| |
| if (aTime == System::Clock::Milliseconds64(0)) |
| { |
| if (mMockSystemTimestamp == mTimerTimeout) |
| { |
| TimerCallbackInterface(nullptr, mTimerContext); |
| } |
| } |
| } |
| |
| TimerContext * mTimerContext = nullptr; |
| System::Clock::Timeout mTimerTimeout = System::Clock::Milliseconds64(0x7FFFFFFFFFFFFFFF); |
| System::Clock::Timestamp mMockSystemTimestamp = System::Clock::Milliseconds64(0); |
| }; |
| |
| TestTimerDelegate sTestTimerDelegate; |
| ReportSchedulerImpl sScheduler(&sTestTimerDelegate); |
| |
| TestTimerSynchronizedDelegate sTestTimerSynchronizedDelegate; |
| SynchronizedReportSchedulerImpl syncScheduler(&sTestTimerSynchronizedDelegate); |
| |
| class TestReportScheduler |
| { |
| public: |
| /// @brief Mimicks the various operations that happen on a subscription transaction after a read handler was created so that |
| /// readhandlers are in the expected state for further tests. |
| /// @param readHandler |
| /// @param scheduler |
| static CHIP_ERROR MockReadHandlerSubscriptionTransaction(ReadHandler * readHandler, ReportScheduler * scheduler, |
| uint8_t min_interval_seconds, uint8_t max_interval_seconds) |
| { |
| ReturnErrorOnFailure(readHandler->SetMaxReportingInterval(max_interval_seconds)); |
| ReturnErrorOnFailure(readHandler->SetMinReportingIntervalForTests(min_interval_seconds)); |
| readHandler->ClearStateFlag(ReadHandler::ReadHandlerFlags::PrimingReports); |
| readHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::ActiveSubscription); |
| scheduler->OnSubscriptionEstablished(readHandler); |
| readHandler->MoveToState(ReadHandler::HandlerState::CanStartReporting); |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| static ReadHandler * GetReadHandlerFromPool(ReportScheduler * scheduler, uint32_t target) |
| { |
| uint32_t i = 0; |
| ReadHandler * ret = nullptr; |
| |
| scheduler->mNodesPool.ForEachActiveObject([target, &i, &ret](ReadHandlerNode * node) { |
| if (i == target) |
| { |
| ret = node->GetReadHandler(); |
| return Loop::Break; |
| } |
| |
| i++; |
| return Loop::Continue; |
| }); |
| |
| return ret; |
| } |
| |
| static void TestReadHandlerList(nlTestSuite * aSuite, void * aContext) |
| { |
| TestContext & ctx = *static_cast<TestContext *>(aContext); |
| NullReadHandlerCallback nullCallback; |
| // exchange context |
| Messaging::ExchangeContext * exchangeCtx = ctx.NewExchangeToAlice(nullptr, false); |
| |
| // Read handler pool |
| ObjectPool<ReadHandler, kNumMaxReadHandlers> readHandlerPool; |
| |
| // Initialize mock timestamp |
| sTestTimerDelegate.SetMockSystemTimestamp(Milliseconds64(0)); |
| |
| for (size_t i = 0; i < kNumMaxReadHandlers; i++) |
| { |
| ReadHandler * readHandler = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &sScheduler); |
| sScheduler.OnSubscriptionEstablished(readHandler); |
| NL_TEST_ASSERT(aSuite, nullptr != readHandler); |
| VerifyOrReturn(nullptr != readHandler); |
| NL_TEST_ASSERT(aSuite, nullptr != sScheduler.FindReadHandlerNode(readHandler)); |
| } |
| |
| NL_TEST_ASSERT(aSuite, readHandlerPool.Allocated() == kNumMaxReadHandlers); |
| NL_TEST_ASSERT(aSuite, sScheduler.GetNumReadHandlers() == kNumMaxReadHandlers); |
| NL_TEST_ASSERT(aSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 1); |
| |
| // Test unregister first ReadHandler |
| uint32_t target = 0; |
| ReadHandler * firstReadHandler = GetReadHandlerFromPool(&sScheduler, target); |
| |
| NL_TEST_ASSERT(aSuite, nullptr != firstReadHandler); |
| sScheduler.OnReadHandlerDestroyed(firstReadHandler); |
| NL_TEST_ASSERT(aSuite, sScheduler.GetNumReadHandlers() == kNumMaxReadHandlers - 1); |
| NL_TEST_ASSERT(aSuite, nullptr == sScheduler.FindReadHandlerNode(firstReadHandler)); |
| |
| // Test unregister middle ReadHandler |
| target = static_cast<uint32_t>(sScheduler.GetNumReadHandlers() / 2); |
| ReadHandler * middleReadHandler = GetReadHandlerFromPool(&sScheduler, target); |
| |
| NL_TEST_ASSERT(aSuite, nullptr != middleReadHandler); |
| sScheduler.OnReadHandlerDestroyed(middleReadHandler); |
| NL_TEST_ASSERT(aSuite, sScheduler.GetNumReadHandlers() == kNumMaxReadHandlers - 2); |
| NL_TEST_ASSERT(aSuite, nullptr == sScheduler.FindReadHandlerNode(middleReadHandler)); |
| |
| // Test unregister last ReadHandler |
| target = static_cast<uint32_t>(sScheduler.GetNumReadHandlers() - 1); |
| ReadHandler * lastReadHandler = GetReadHandlerFromPool(&sScheduler, target); |
| sScheduler.OnReadHandlerDestroyed(lastReadHandler); |
| NL_TEST_ASSERT(aSuite, sScheduler.GetNumReadHandlers() == kNumMaxReadHandlers - 3); |
| NL_TEST_ASSERT(aSuite, nullptr == sScheduler.FindReadHandlerNode(lastReadHandler)); |
| |
| sScheduler.UnregisterAllHandlers(); |
| // Confirm all ReadHandlers are unregistered from the scheduler |
| NL_TEST_ASSERT(aSuite, sScheduler.GetNumReadHandlers() == 0); |
| readHandlerPool.ForEachActiveObject([&](ReadHandler * handler) { |
| NL_TEST_ASSERT(aSuite, nullptr == sScheduler.FindReadHandlerNode(handler)); |
| return Loop::Continue; |
| }); |
| |
| readHandlerPool.ReleaseAll(); |
| exchangeCtx->Close(); |
| NL_TEST_ASSERT(aSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0); |
| } |
| |
| static void TestReportTiming(nlTestSuite * aSuite, void * aContext) |
| { |
| TestContext & ctx = *static_cast<TestContext *>(aContext); |
| NullReadHandlerCallback nullCallback; |
| // exchange context |
| Messaging::ExchangeContext * exchangeCtx = ctx.NewExchangeToAlice(nullptr, false); |
| |
| // Read handler pool |
| ObjectPool<ReadHandler, kNumMaxReadHandlers> readHandlerPool; |
| |
| // Initialize mock timestamp |
| sTestTimerDelegate.SetMockSystemTimestamp(Milliseconds64(0)); |
| |
| // Dirty read handler, will be triggered at min interval |
| // Test OnReadHandler created |
| ReadHandler * readHandler1 = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &sScheduler); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler1, &sScheduler, 1, 2)); |
| readHandler1->ForceDirtyState(); |
| |
| // Clean read handler, will be triggered at max interval |
| ReadHandler * readHandler2 = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &sScheduler); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler2, &sScheduler, 0, 3)); |
| |
| // Clean read handler, will be triggered at max interval, but will be cancelled before |
| ReadHandler * readHandler3 = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &sScheduler); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler3, &sScheduler, 0, 3)); |
| |
| // Confirms that none of the ReadHandlers are currently reportable |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportableNow(readHandler3)); |
| |
| // Simulate system clock increment |
| sTestTimerDelegate.IncrementMockTimestamp(Milliseconds64(1100)); |
| |
| // Checks that the first ReadHandler is reportable after 1 second since it is dirty and min interval has expired |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportableNow(readHandler3)); |
| |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportScheduled(readHandler3)); |
| sScheduler.CancelReport(readHandler3); |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportScheduled(readHandler3)); |
| |
| // Simulate system clock increment |
| sTestTimerDelegate.IncrementMockTimestamp(Milliseconds64(2000)); |
| |
| // Checks that all ReadHandlers are reportable |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportableNow(readHandler2)); |
| // Even if its timer got cancelled, readHandler3 should still be considered reportable as the max interval has expired |
| // and it is in generating report state |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportableNow(readHandler3)); |
| |
| // Clear dirty flag on readHandler1 and confirm it is still reportable by time |
| readHandler1->ClearForceDirtyFlag(); |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportableNow(readHandler1)); |
| |
| sScheduler.UnregisterAllHandlers(); |
| readHandlerPool.ReleaseAll(); |
| exchangeCtx->Close(); |
| NL_TEST_ASSERT(aSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0); |
| } |
| |
| static void TestObserverCallbacks(nlTestSuite * aSuite, void * aContext) |
| { |
| TestContext & ctx = *static_cast<TestContext *>(aContext); |
| NullReadHandlerCallback nullCallback; |
| // exchange context |
| Messaging::ExchangeContext * exchangeCtx = ctx.NewExchangeToAlice(nullptr, false); |
| |
| // Read handler pool |
| ObjectPool<ReadHandler, kNumMaxReadHandlers> readHandlerPool; |
| |
| // Initialize mock timestamp |
| sTestTimerDelegate.SetMockSystemTimestamp(Milliseconds64(0)); |
| |
| ReadHandler * readHandler = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &sScheduler); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler, &sScheduler, 1, 2)); |
| |
| // Verifies OnSubscriptionEstablished registered the ReadHandler in the scheduler |
| NL_TEST_ASSERT(aSuite, nullptr != sScheduler.FindReadHandlerNode(readHandler)); |
| |
| // Should have registered the read handler in the scheduler and scheduled a report |
| NL_TEST_ASSERT(aSuite, sScheduler.GetNumReadHandlers() == 1); |
| |
| ReadHandlerNode * node = sScheduler.FindReadHandlerNode(readHandler); |
| |
| // Test OnReportingIntervalsChanged modified the intervals and re-scheduled a report |
| NL_TEST_ASSERT(aSuite, node->GetMinTimestamp().count() == 1000); |
| NL_TEST_ASSERT(aSuite, node->GetMaxTimestamp().count() == 2000); |
| |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportScheduled(readHandler)); |
| |
| NL_TEST_ASSERT(aSuite, nullptr != node); |
| VerifyOrReturn(nullptr != node); |
| NL_TEST_ASSERT(aSuite, node->GetReadHandler() == readHandler); |
| |
| // Test OnBecameReportable |
| readHandler->ForceDirtyState(); |
| // Should have changed the scheduled timeout to the handler's min interval, to check, we wait for the min interval to |
| // expire |
| // Simulate system clock increment |
| sTestTimerDelegate.IncrementMockTimestamp(Milliseconds64(1100)); |
| |
| // Check that no report is scheduled since the min interval has expired, the timer should now be stopped |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportScheduled(readHandler)); |
| |
| // Test OnSubscriptionReportSent |
| readHandler->ClearForceDirtyFlag(); |
| readHandler->mObserver->OnSubscriptionReportSent(readHandler); |
| // Should have changed the scheduled timeout to the handlers max interval, to check, we wait for the min interval to |
| // confirm it is not expired yet so the report should still be scheduled |
| |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportScheduled(readHandler)); |
| // Simulate system clock increment |
| sTestTimerDelegate.IncrementMockTimestamp(Milliseconds64(1100)); |
| |
| // Check that the report is still scheduled as the max interval has not expired yet and the dirty flag was cleared |
| NL_TEST_ASSERT(aSuite, sScheduler.IsReportScheduled(readHandler)); |
| // Simulate system clock increment |
| sTestTimerDelegate.IncrementMockTimestamp(Milliseconds64(2100)); |
| |
| // Check that no report is scheduled since the max interval should have expired, the timer should now be stopped |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportScheduled(readHandler)); |
| |
| // Test OnReadHandlerDestroyed |
| readHandler->mObserver->OnReadHandlerDestroyed(readHandler); |
| // Should have unregistered the read handler in the scheduler and cancelled the report |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportScheduled(readHandler)); |
| NL_TEST_ASSERT(aSuite, sScheduler.GetNumReadHandlers() == 0); |
| NL_TEST_ASSERT(aSuite, nullptr == sScheduler.FindReadHandlerNode(readHandler)); |
| |
| readHandlerPool.ReleaseAll(); |
| exchangeCtx->Close(); |
| NL_TEST_ASSERT(aSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0); |
| } |
| |
| static void TestSynchronizedScheduler(nlTestSuite * aSuite, void * aContext) |
| { |
| TestContext & ctx = *static_cast<TestContext *>(aContext); |
| NullReadHandlerCallback nullCallback; |
| // exchange context |
| Messaging::ExchangeContext * exchangeCtx = ctx.NewExchangeToAlice(nullptr, false); |
| |
| // First test: ReadHandler 2 merge on ReadHandler 1 max interval |
| // Read handler pool |
| ObjectPool<ReadHandler, kNumMaxReadHandlers> readHandlerPool; |
| |
| // Initialize the mock system time |
| sTestTimerSynchronizedDelegate.SetMockSystemTimestamp(System::Clock::Milliseconds64(0)); |
| |
| ReadHandler * readHandler1 = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &syncScheduler); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler1, &syncScheduler, 0, 2)); |
| ReadHandlerNode * node1 = syncScheduler.FindReadHandlerNode(readHandler1); |
| |
| ReadHandler * readHandler2 = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &syncScheduler); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler2, &syncScheduler, 1, 3)); |
| ReadHandlerNode * node2 = syncScheduler.FindReadHandlerNode(readHandler2); |
| |
| // Confirm all handler are currently registered in the scheduler |
| NL_TEST_ASSERT(aSuite, syncScheduler.GetNumReadHandlers() == 2); |
| |
| // Confirm that a report emission is scheduled |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportScheduled(readHandler1)); |
| |
| // Validates that the lowest max is selected as the common max timestamp |
| NL_TEST_ASSERT(aSuite, syncScheduler.mNextMaxTimestamp == node1->GetMaxTimestamp()); |
| // Validates that the highest reportable min is selected as the common min interval (0 here) |
| NL_TEST_ASSERT(aSuite, syncScheduler.mNextMinTimestamp == node1->GetMinTimestamp()); |
| // Validates that the next report emission is scheduled on the common max timestamp |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == syncScheduler.mNextMaxTimestamp); |
| |
| // Simulate waiting for the max interval to expire (2s) |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(2000)); |
| |
| // Confirm that both handlers are now reportable since the timer has expired (readHandler1 from its max and readHandler2 |
| // from its sync) |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| // Confirm timeout has expired and no report is scheduled, an engine run would typically happen here |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportScheduled(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !sScheduler.IsReportScheduled(readHandler2)); |
| |
| // Simulate a report emission for readHandler1 |
| readHandler1->mObserver->OnSubscriptionReportSent(readHandler1); |
| // Simulate a report emission for readHandler2 |
| readHandler2->mObserver->OnSubscriptionReportSent(readHandler2); |
| |
| // Validate that the max timestamp for both readhandlers got updated and that the next report emission is scheduled on |
| // the new max timestamp for readhandler1 |
| NL_TEST_ASSERT(aSuite, node1->GetMaxTimestamp() > sTestTimerSynchronizedDelegate.GetCurrentMonotonicTimestamp()); |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node1->GetMaxTimestamp()); |
| |
| // Confirm behavior when a read handler becomes dirty |
| readHandler2->ForceDirtyState(); |
| // OnBecomeReportable should have been called on ForceDirtyState because readHandler callbacks are now integrated |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| // Simulate wait enough for min timestamp of readHandler2 to be reached (1s) |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(1000)); |
| |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| |
| // Confirm that the next report emission is scheduled on the min timestamp of readHandler2 (now) as it is the highest |
| // reportable |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node2->GetMinTimestamp()); |
| NL_TEST_ASSERT(aSuite, node1->CanBeSynced() == true); |
| |
| // Simulate a report emission for readHandler1 |
| readHandler1->mObserver->OnSubscriptionReportSent(readHandler1); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| |
| // ReadHandler 2 should still be reportable since it hasn't emitted a report yet |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| readHandler2->ClearForceDirtyFlag(); |
| readHandler2->mObserver->OnSubscriptionReportSent(readHandler2); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| |
| // Simulate ReadHandler 1 becoming dirty after ReadHandler 2 past min will trigger a report emission for both |
| |
| // Wait past ReadHandler 2 min |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(1100)); |
| // No handler should be reportable yet |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| readHandler1->ForceDirtyState(); |
| |
| // Both read handlers should now be reportable since the ForceDirty should immediately trigger the timer expiration callback |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| |
| // Simulate a report emission for readHandler1 |
| readHandler1->ClearForceDirtyFlag(); |
| readHandler1->mObserver->OnSubscriptionReportSent(readHandler1); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| |
| readHandler2->mObserver->OnSubscriptionReportSent(readHandler2); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| |
| // Confirm both handlers are not reportable anymore |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| |
| // Validate next report scheduled on the max timestamp of readHandler1 |
| NL_TEST_ASSERT(aSuite, node1->GetMaxTimestamp() > sTestTimerSynchronizedDelegate.GetCurrentMonotonicTimestamp()); |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node1->GetMaxTimestamp()); |
| |
| // Simulate readHandler1 becoming dirty after less than 1 seconds, since it is reportable now, this will Schedule an Engine |
| // run immediately |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(900)); |
| readHandler1->ForceDirtyState(); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| |
| // Simulate a report emission for readHandler1 |
| readHandler1->ClearForceDirtyFlag(); |
| readHandler1->mObserver->OnSubscriptionReportSent(readHandler1); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| |
| // The next report should be scheduler on the max timestamp of readHandler1 |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node1->GetMaxTimestamp()); |
| |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(2000)); |
| // Confirm node 2 can now be synced since the scheduler timer has fired on the max timestamp of readHandler1 |
| NL_TEST_ASSERT(aSuite, node2->CanBeSynced() == true); |
| |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| readHandler1->mObserver->OnSubscriptionReportSent(readHandler1); |
| readHandler2->mObserver->OnSubscriptionReportSent(readHandler2); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node1->GetMaxTimestamp()); |
| |
| // Simulate a new ReadHandler being added with a min timestamp that will force a conflict |
| |
| // Wait for 1 second, nothing should happen here |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(1000)); |
| |
| ReadHandler * readHandler3 = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &syncScheduler); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler3, &syncScheduler, 2, 3)); |
| ReadHandlerNode * node3 = syncScheduler.FindReadHandlerNode(readHandler3); |
| |
| // Confirm all handler are currently registered in the scheduler |
| NL_TEST_ASSERT(aSuite, syncScheduler.GetNumReadHandlers() == 3); |
| |
| // Since the min interval on readHandler3 is 2, it should be above the current max timestamp, therefore the next report |
| // should still happen on the max timestamp of readHandler1 and the sync should be done on future reports |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node1->GetMaxTimestamp()); |
| // The min timestamp should also not have changed since the min of readhandler3 is higher than the current max |
| NL_TEST_ASSERT(aSuite, syncScheduler.mNextMinTimestamp == node2->GetMinTimestamp()); |
| |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(1000)); |
| |
| // Confirm that readHandler1 and readHandler 2 are now reportable, whilst readHandler3 is not |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler3)); |
| readHandler1->mObserver->OnBecameReportable(readHandler1); |
| readHandler2->mObserver->OnBecameReportable(readHandler2); |
| |
| // Simulate a report emission for readHandler1 and readHandler2 |
| readHandler1->mObserver->OnSubscriptionReportSent(readHandler1); |
| readHandler1->mObserver->OnSubscriptionReportSent(readHandler2); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| |
| // Confirm that next report is scheduled on the max timestamp of readHandler3 and other 2 readHandlers are synced |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node3->GetMaxTimestamp()); |
| |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(2000)); |
| // Confirm nodes 1 and 2 can now be synced since the scheduler timer has fired on the max timestamp of readHandler1 |
| NL_TEST_ASSERT(aSuite, node1->CanBeSynced() == true); |
| NL_TEST_ASSERT(aSuite, node2->CanBeSynced() == true); |
| |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler3)); |
| readHandler1->mObserver->OnBecameReportable(readHandler1); |
| readHandler2->mObserver->OnBecameReportable(readHandler2); |
| readHandler3->mObserver->OnBecameReportable(readHandler3); |
| // Engine run should happen here and send all reports |
| readHandler1->mObserver->OnSubscriptionReportSent(readHandler1); |
| readHandler2->mObserver->OnSubscriptionReportSent(readHandler2); |
| readHandler3->mObserver->OnSubscriptionReportSent(readHandler3); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler3)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node1->GetMaxTimestamp()); |
| |
| // Now simulate a new readHandler being added with a max forcing a conflict |
| ReadHandler * readHandler4 = |
| readHandlerPool.CreateObject(nullCallback, exchangeCtx, ReadHandler::InteractionType::Subscribe, &syncScheduler); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler4, &syncScheduler, 0, 1)); |
| ReadHandlerNode * node4 = syncScheduler.FindReadHandlerNode(readHandler4); |
| |
| // Confirm all handler are currently registered in the scheduler |
| NL_TEST_ASSERT(aSuite, syncScheduler.GetNumReadHandlers() == 4); |
| |
| // Confirm next report is scheduled on the max timestamp of readHandler4 |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node4->GetMaxTimestamp()); |
| |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(1100)); |
| // Confirm node 1 and 2 can now be synced since the scheduler timer has fired on the max timestamp of readHandler4 |
| NL_TEST_ASSERT(aSuite, node1->CanBeSynced() == true); |
| NL_TEST_ASSERT(aSuite, node2->CanBeSynced() == true); |
| // Confirm handler 3 cannot be synched on a later timestamp since its min is higher than the max of readHandler4 |
| NL_TEST_ASSERT(aSuite, node3->CanBeSynced() == false); |
| |
| // Confirm readHandler1, 2 and 4 are reportable |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler4)); |
| |
| // Confirm readHandler3 is not reportable |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler3)); |
| readHandler4->mObserver->OnBecameReportable(readHandler1); |
| readHandler4->mObserver->OnBecameReportable(readHandler2); |
| readHandler4->mObserver->OnBecameReportable(readHandler4); |
| readHandler4->mObserver->OnSubscriptionReportSent(readHandler1); |
| readHandler4->mObserver->OnSubscriptionReportSent(readHandler2); |
| readHandler4->mObserver->OnSubscriptionReportSent(readHandler4); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler4)); |
| |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(1000)); |
| |
| // Confirm readHandler3 is reportable and other handlers are synced |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler3)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler4)); |
| syncScheduler.OnBecameReportable(readHandler1); |
| syncScheduler.OnBecameReportable(readHandler2); |
| syncScheduler.OnBecameReportable(readHandler3); |
| syncScheduler.OnBecameReportable(readHandler4); |
| syncScheduler.OnSubscriptionReportSent(readHandler1); |
| syncScheduler.OnSubscriptionReportSent(readHandler2); |
| syncScheduler.OnSubscriptionReportSent(readHandler3); |
| syncScheduler.OnSubscriptionReportSent(readHandler4); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler3)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler4)); |
| |
| // Next emission should be scheduled on the max timestamp of readHandler4 as it is the most restrictive |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node4->GetMaxTimestamp()); |
| |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(1000)); |
| // Confirm node 1 and 2 can now be synced since the scheduler timer has fired on the max timestamp of readHandler4 |
| NL_TEST_ASSERT(aSuite, node1->CanBeSynced() == true); |
| NL_TEST_ASSERT(aSuite, node2->CanBeSynced() == true); |
| // Confirm node 3 still cannot sync |
| NL_TEST_ASSERT(aSuite, node3->CanBeSynced() == false); |
| |
| // Confirm readHandler 1-2-4 are reportable |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler4)); |
| |
| // Confirm readHandler3 is not reportable because of its min interval |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler3)); |
| |
| syncScheduler.OnReadHandlerDestroyed(readHandler1); |
| syncScheduler.OnReadHandlerDestroyed(readHandler2); |
| syncScheduler.OnReadHandlerDestroyed(readHandler3); |
| syncScheduler.OnReadHandlerDestroyed(readHandler4); |
| |
| // Reset all handlers |
| // Test case: Scheduler 1 and 2 are reportable but min2 > max1, they should sync only when possible (min2 = 3, max1 = 2) |
| NL_TEST_ASSERT(aSuite, syncScheduler.GetNumReadHandlers() == 0); |
| |
| readHandler1->MoveToState(ReadHandler::HandlerState::Idle); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler1, &syncScheduler, 0, 2)); |
| |
| // Forcing the dirty flag to make the scheduler call Engine::ScheduleRun() immediately |
| readHandler1->ForceDirtyState(); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| |
| readHandler2->MoveToState(ReadHandler::HandlerState::Idle); |
| NL_TEST_ASSERT(aSuite, CHIP_NO_ERROR == MockReadHandlerSubscriptionTransaction(readHandler2, &syncScheduler, 3, 4)); |
| readHandler2->ForceDirtyState(); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| |
| node1 = syncScheduler.FindReadHandlerNode(readHandler1); |
| node2 = syncScheduler.FindReadHandlerNode(readHandler2); |
| |
| readHandler1->ClearForceDirtyFlag(); // report got emited so clear dirty flag |
| syncScheduler.OnSubscriptionReportSent(readHandler1); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| |
| // Confirm next report is scheduled on the max timestamp of readHandler1 and readhandler2 is not synced |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node1->GetMaxTimestamp()); |
| // Node 2's sync timestamp should have remained unaffected since its min is higher |
| NL_TEST_ASSERT(aSuite, node2->CanBeSynced() == false); |
| |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(2000)); |
| // Verify handler 1 became reportable |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| syncScheduler.OnBecameReportable(readHandler1); |
| |
| // simulate run with only readhandler1 reportable |
| syncScheduler.OnSubscriptionReportSent(readHandler1); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, !syncScheduler.IsReportableNow(readHandler2)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node2->GetMinTimestamp()); |
| |
| sTestTimerSynchronizedDelegate.IncrementMockTimestamp(System::Clock::Milliseconds64(1000)); |
| NL_TEST_ASSERT(aSuite, node1->CanBeSynced() == true); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler1)); |
| NL_TEST_ASSERT(aSuite, syncScheduler.IsReportableNow(readHandler2)); |
| |
| readHandler2->ClearForceDirtyFlag(); |
| syncScheduler.OnSubscriptionReportSent(readHandler1); |
| syncScheduler.OnSubscriptionReportSent(readHandler2); |
| |
| NL_TEST_ASSERT(aSuite, syncScheduler.mTestNextReportTimestamp == node1->GetMaxTimestamp()); |
| NL_TEST_ASSERT(aSuite, node2->CanBeSynced() == false); |
| |
| syncScheduler.UnregisterAllHandlers(); |
| readHandlerPool.ReleaseAll(); |
| exchangeCtx->Close(); |
| NL_TEST_ASSERT(aSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0); |
| } |
| }; |
| |
| } // namespace reporting |
| } // namespace app |
| } // namespace chip |
| |
| namespace { |
| |
| /** |
| * Test Suite. It lists all the test functions. |
| */ |
| |
| static nlTest sTests[] = { |
| NL_TEST_DEF("TestReadHandlerList", chip::app::reporting::TestReportScheduler::TestReadHandlerList), |
| NL_TEST_DEF("TestReportTiming", chip::app::reporting::TestReportScheduler::TestReportTiming), |
| NL_TEST_DEF("TestObserverCallbacks", chip::app::reporting::TestReportScheduler::TestObserverCallbacks), |
| NL_TEST_DEF("TestSynchronizedScheduler", chip::app::reporting::TestReportScheduler::TestSynchronizedScheduler), |
| NL_TEST_SENTINEL(), |
| }; |
| |
| nlTestSuite sSuite = { |
| "TestReportScheduler", |
| &sTests[0], |
| TestContext::nlTestSetUpTestSuite, |
| TestContext::nlTestTearDownTestSuite, |
| TestContext::nlTestSetUp, |
| TestContext::nlTestTearDown, |
| }; |
| |
| } // namespace |
| |
| int TestReportScheduler() |
| { |
| return chip::ExecuteTestsWithContext<TestContext>(&sSuite); |
| } |
| |
| CHIP_REGISTER_TEST_SUITE(TestReportScheduler); |
