adding *TestAccess.h sources to build.gn

Author: Alami-Amine

src/app/tests/BUILD.gn

@@ -175,6 +175,19 @@ chip_test_suite("tests") {
 
   cflags = [ "-Wconversion" ]
 
+  sources = [
+    "CommandHandlerTestAccess.h",
+    "CommandSenderTestAccess.h",
+    "EngineTestAccess.h",
+    "InteractionModelEngineTestAccess.h",
+    "ReadClientTestAccess.h",
+    "ReadHandlerTestAccess.h",
+    "ReportSchedulerImplTestAccess.h",
+    "SynchronizedReportSchedulerImplTestAccess.h",
+    "WriteClientTestAccess.h",
+    "WriteHandlerTestAccess.h",
+  ]
+
   public_deps = [
     ":app-test-stubs",
     ":binding-test-srcs",

src/app/tests/CommandHandlerTestAccess.h

@@ -22,8 +22,6 @@
 namespace chip {
 namespace Test {
 
-using namespace app;
-
 /**
  * @brief Class acts as an accessor to private methods of the CommandHandler class without needing to give friend access to
  *        each individual test.
@@ -33,9 +31,9 @@ class CommandHandlerTestAccess
 {
 
 public:
-    CommandHandlerTestAccess(CommandHandler * apCommandHandler) : mpCommandHandler(apCommandHandler) {}
-    InvokeResponseMessage::Builder & GetInvokeResponseBuilder() { return mpCommandHandler->mInvokeResponseBuilder; }
-    CommandHandlerExchangeInterface * GetmpResponder() { return mpCommandHandler->mpResponder; }
+    CommandHandlerTestAccess(app::CommandHandler * apCommandHandler) : mpCommandHandler(apCommandHandler) {}
+    app::InvokeResponseMessage::Builder & GetInvokeResponseBuilder() { return mpCommandHandler->mInvokeResponseBuilder; }
+    app::CommandHandlerExchangeInterface * GetmpResponder() { return mpCommandHandler->mpResponder; }
 
     void SetReserveSpaceForMoreChunkMessages(bool aReserveSpaceForMoreChunkMessages)
     {
@@ -50,7 +48,7 @@ class CommandHandlerTestAccess
     }
 
 private:
-    CommandHandler * mpCommandHandler = nullptr;
+    app::CommandHandler * mpCommandHandler = nullptr;
 };
 
 } // namespace Test

src/app/tests/CommandSenderTestAccess.h

@@ -22,8 +22,6 @@
 namespace chip {
 namespace Test {
 
-using namespace app;
-
 /**
  * @brief Class acts as an accessor to private methods of the CommandSender class without needing to give friend access to
  *        each individual test.
@@ -33,13 +31,13 @@ class CommandSenderTestAccess
 {
 
 public:
-    CommandSenderTestAccess(CommandSender * aCommandSender) : mpCommandSender(aCommandSender) {}
+    CommandSenderTestAccess(app::CommandSender * aCommandSender) : mpCommandSender(aCommandSender) {}
 
     Messaging::ExchangeHolder & GetExchangeCtx() { return mpCommandSender->mExchangeCtx; }
 
     void FlushNoCommandResponse() { mpCommandSender->FlushNoCommandResponse(); }
     void SetFinishedCommandCount(uint16_t aFinishedCommandCount) { mpCommandSender->mFinishedCommandCount = aFinishedCommandCount; }
-    void MoveToStateAddedCommand() { mpCommandSender->MoveToState(CommandSender::State::AddedCommand); }
+    void MoveToStateAddedCommand() { mpCommandSender->MoveToState(app::CommandSender::State::AddedCommand); }
 
     CHIP_ERROR Finalize(System::PacketBufferHandle & commandPacket) { return mpCommandSender->Finalize(commandPacket); }
     CHIP_ERROR ProcessInvokeResponse(System::PacketBufferHandle && payload, bool & moreChunkedMessages)
@@ -54,7 +52,7 @@ class CommandSenderTestAccess
     }
 
 private:
-    CommandSender * mpCommandSender = nullptr;
+    app::CommandSender * mpCommandSender = nullptr;
 };
 
 } // namespace Test

src/app/tests/EngineTestAccess.h

@@ -22,8 +22,6 @@
 namespace chip {
 namespace Test {
 
-using namespace app;
-
 /**
  * @brief Class acts as an accessor to private methods of the Engine class without needing to give friend access to
  *        each individual test.
@@ -33,35 +31,36 @@ class EngineTestAccess
 {
 
 public:
-    EngineTestAccess(reporting::Engine * apEngine) : mpEngine(apEngine) {}
+    EngineTestAccess(app::reporting::Engine * apEngine) : mpEngine(apEngine) {}
 
-    reporting::Engine * GetEngine() { return mpEngine; }
+    app::reporting::Engine * GetEngine() { return mpEngine; }
     inline void BumpDirtySetGeneration() { mpEngine->BumpDirtySetGeneration(); }
     bool IsRunScheduled() const { return mpEngine->IsRunScheduled(); }
 
-    CHIP_ERROR BuildAndSendSingleReportData(ReadHandler * apReadHandler)
+    CHIP_ERROR BuildAndSendSingleReportData(app::ReadHandler * apReadHandler)
     {
         return mpEngine->BuildAndSendSingleReportData(apReadHandler);
     }
 
-    bool MergeOverlappedAttributePath(const AttributePathParams & aAttributePath)
+    bool MergeOverlappedAttributePath(const app::AttributePathParams & aAttributePath)
     {
         return mpEngine->MergeOverlappedAttributePath(aAttributePath);
     }
 
-    CHIP_ERROR InsertPathIntoDirtySet(const AttributePathParams & aAttributePath)
+    CHIP_ERROR InsertPathIntoDirtySet(const app::AttributePathParams & aAttributePath)
     {
         return mpEngine->InsertPathIntoDirtySet(aAttributePath);
     }
 
-    ObjectPool<reporting::Engine::AttributePathParamsWithGeneration, CHIP_IM_SERVER_MAX_NUM_DIRTY_SET, ObjectPoolMem::kInline> &
+    ObjectPool<app::reporting::Engine::AttributePathParamsWithGeneration, CHIP_IM_SERVER_MAX_NUM_DIRTY_SET,
+               ObjectPoolMem::kInline> &
     GetGlobalDirtySet()
     {
         return mpEngine->mGlobalDirtySet;
     }
 
 private:
-    reporting::Engine * mpEngine = nullptr;
+    app::reporting::Engine * mpEngine = nullptr;
 };
 
 } // namespace Test

src/app/tests/InteractionModelEngineTestAccess.h

@@ -17,12 +17,13 @@
 
 #pragma once
 
+#if CHIP_CONFIG_PERSIST_SUBSCRIPTIONS
+
 #include <app/InteractionModelEngine.h>
 
 namespace chip {
 namespace Test {
 
-using namespace app;
 /**
  * @brief Class acts as an accessor to private methods of the InteractionModelEngine class without needing to give friend access to
  *        each individual test.
@@ -32,31 +33,36 @@ class InteractionModelEngineTestAccess
 {
 
 public:
-    InteractionModelEngineTestAccess(InteractionModelEngine * apInteractionModelEngine) :
+    InteractionModelEngineTestAccess(app::InteractionModelEngine * apInteractionModelEngine) :
         mpInteractionModelEngine(apInteractionModelEngine)
     {}
-    uint32_t GetNumOfSubscriptionsToResume() { return mpInteractionModelEngine->mNumOfSubscriptionsToResume; }
-    uint32_t GetNumSubscriptionResumptionRetries() { return mpInteractionModelEngine->mNumSubscriptionResumptionRetries; }
-    InteractionModelEngine * GetInstance() { return InteractionModelEngine::GetInstance(); }
 
-    void SetNumSubscriptionResumptionRetries(uint32_t aNumSubscriptionResumptionRetries)
+    int8_t GetNumOfSubscriptionsToResume() { return mpInteractionModelEngine->mNumOfSubscriptionsToResume; }
+    void SetNumOfSubscriptionsToResume(int8_t aNumOfSubscriptionsToResume)
     {
-        mpInteractionModelEngine->mNumSubscriptionResumptionRetries = aNumSubscriptionResumptionRetries;
+        mpInteractionModelEngine->mNumOfSubscriptionsToResume = aNumOfSubscriptionsToResume;
     }
 
-    void SetNumOfSubscriptionsToResume(int8_t aNumOfSubscriptionsToResume)
+#if CHIP_CONFIG_SUBSCRIPTION_TIMEOUT_RESUMPTION
+
+    uint32_t GetNumSubscriptionResumptionRetries() { return mpInteractionModelEngine->mNumSubscriptionResumptionRetries; }
+    void SetNumSubscriptionResumptionRetries(uint32_t aNumSubscriptionResumptionRetries)
     {
-        mpInteractionModelEngine->mNumOfSubscriptionsToResume = aNumOfSubscriptionsToResume;
+        mpInteractionModelEngine->mNumSubscriptionResumptionRetries = aNumSubscriptionResumptionRetries;
     }
 
     uint32_t ComputeTimeSecondsTillNextSubscriptionResumption()
     {
         return mpInteractionModelEngine->ComputeTimeSecondsTillNextSubscriptionResumption();
     }
 
+#endif // CHIP_CONFIG_SUBSCRIPTION_TIMEOUT_RESUMPTION
+
 private:
-    InteractionModelEngine * mpInteractionModelEngine = nullptr;
+    app::InteractionModelEngine * mpInteractionModelEngine = nullptr;
 };
 
 } // namespace Test
 } // namespace chip
+
+#endif // CHIP_CONFIG_PERSIST_SUBSCRIPTIONS

src/app/tests/ReadClientTestAccess.h

@@ -28,19 +28,17 @@ namespace Test {
  *        This is not a Global API and should only be used for (Unit) Testing.
  */
 
-using namespace app;
-
 class ReadClientTestAccess
 {
 
 public:
-    ReadClientTestAccess(ReadClient * aReadClient) : mpReadClient(aReadClient) {}
+    ReadClientTestAccess(app::ReadClient * aReadClient) : mpReadClient(aReadClient) {}
 
     Messaging::ExchangeHolder & GetExchange() { return mpReadClient->mExchange; }
     Messaging::ExchangeManager * GetExchangeMgr() { return mpReadClient->mpExchangeMgr; }
     SubscriptionId GetSubscriptionId() { return mpReadClient->mSubscriptionId; }
 
-    void MoveToState(const ReadClient::ClientState aTargetState) { mpReadClient->MoveToState(aTargetState); }
+    void MoveToState(const app::ReadClient::ClientState aTargetState) { mpReadClient->MoveToState(aTargetState); }
     bool IsIdle() const { return mpReadClient->IsIdle(); }
 
     CHIP_ERROR OnMessageReceived(Messaging::ExchangeContext * apExchangeContext, const PayloadHeader & aPayloadHeader,
@@ -49,29 +47,29 @@ class ReadClientTestAccess
         return mpReadClient->OnMessageReceived(apExchangeContext, aPayloadHeader, std::move(aPayload));
     }
 
-    CHIP_ERROR ProcessReportData(System::PacketBufferHandle && aPayload, ReadClient::ReportType aReportType)
+    CHIP_ERROR ProcessReportData(System::PacketBufferHandle && aPayload, app::ReadClient::ReportType aReportType)
     {
         return mpReadClient->ProcessReportData(std::move(aPayload), aReportType);
     }
 
-    CHIP_ERROR GenerateAttributePaths(AttributePathIBs::Builder & aAttributePathIBsBuilder,
-                                      const Span<AttributePathParams> & aAttributePaths)
+    CHIP_ERROR GenerateAttributePaths(app::AttributePathIBs::Builder & aAttributePathIBsBuilder,
+                                      const Span<app::AttributePathParams> & aAttributePaths)
     {
         return mpReadClient->GenerateAttributePaths(aAttributePathIBsBuilder, aAttributePaths);
     }
 
-    CHIP_ERROR GenerateEventPaths(EventPathIBs::Builder & aEventPathsBuilder, const Span<EventPathParams> & aEventPaths)
+    CHIP_ERROR GenerateEventPaths(app::EventPathIBs::Builder & aEventPathsBuilder, const Span<app::EventPathParams> & aEventPaths)
     {
         return mpReadClient->GenerateEventPaths(aEventPathsBuilder, aEventPaths);
     }
 
-    CHIP_ERROR SendSubscribeRequest(const ReadPrepareParams & aSubscribePrepareParams)
+    CHIP_ERROR SendSubscribeRequest(const app::ReadPrepareParams & aSubscribePrepareParams)
     {
         return mpReadClient->SendSubscribeRequest(aSubscribePrepareParams);
     }
 
 private:
-    ReadClient * mpReadClient = nullptr;
+    app::ReadClient * mpReadClient = nullptr;
 };
 
 } // namespace Test

src/app/tests/ReadHandlerTestAccess.h

@@ -22,7 +22,6 @@
 namespace chip {
 namespace Test {
 
-using namespace app;
 /**
  * @brief Class acts as an accessor to private methods of the ReadHandler class without needing to give friend access to
  *        each individual test.
@@ -32,24 +31,28 @@ class ReadHandlerTestAccess
 {
 
 public:
-    ReadHandlerTestAccess(ReadHandler * apReadHandler) : mpReadHandler(apReadHandler) {}
+    ReadHandlerTestAccess(app::ReadHandler * apReadHandler) : mpReadHandler(apReadHandler) {}
 
     Messaging::ExchangeHolder & GetExchangeCtx() { return mpReadHandler->mExchangeCtx; }
-    ReadHandler * GetReadHandler() { return mpReadHandler; }
+    app::ReadHandler * GetReadHandler() { return mpReadHandler; }
     SessionHolder & GetSessionHandle() { return mpReadHandler->mSessionHandle; }
     Transport::SecureSession * GetSession() { return mpReadHandler->GetSession(); }
-    ReadHandler::Observer * GetObserver() { return mpReadHandler->mObserver; }
+    app::ReadHandler::Observer * GetObserver() { return mpReadHandler->mObserver; }
+
+#if CHIP_CONFIG_ENABLE_ICD_SERVER
+    uint16_t GetPublisherSelectedIntervalLimit() { return mpReadHandler->GetPublisherSelectedIntervalLimit(); }
+#endif
 
     bool IsDirty() const { return mpReadHandler->IsDirty(); }
     bool ShouldStartReporting() const { return mpReadHandler->ShouldStartReporting(); }
 
     void ForceDirtyState() { mpReadHandler->ForceDirtyState(); }
     void ClearForceDirtyFlag() { mpReadHandler->ClearForceDirtyFlag(); }
-    void MoveHandlerToIdleState() { mpReadHandler->MoveToState(ReadHandler::HandlerState::Idle); }
+    void MoveHandlerToIdleState() { mpReadHandler->MoveToState(app::ReadHandler::HandlerState::Idle); }
 
     void SetStateFlagToActiveSubscription(bool aValue)
     {
-        mpReadHandler->SetStateFlag(ReadHandler::ReadHandlerFlags::ActiveSubscription, aValue);
+        mpReadHandler->SetStateFlag(app::ReadHandler::ReadHandlerFlags::ActiveSubscription, aValue);
     }
 
     void OnInitialRequest(System::PacketBufferHandle && aPayload)
@@ -76,7 +79,7 @@ class ReadHandlerTestAccess
     }
 
 private:
-    ReadHandler * mpReadHandler = nullptr;
+    app::ReadHandler * mpReadHandler = nullptr;
 };
 
 } // namespace Test

src/app/tests/ReportSchedulerImplTestAccess.h

@@ -22,29 +22,29 @@
 namespace chip {
 namespace Test {
 
-using namespace app::reporting;
-using namespace app;
-
 /**
  * @brief Class acts as an accessor to private methods of the ReportSchedulerImpl class without needing to give friend access to
  *        each individual test.
  *        This is not a Global API and should only be used for (Unit) Testing.
  */
 class ReportSchedulerImplTestAccess
 {
+
 public:
-    ReportSchedulerImplTestAccess(ReportSchedulerImpl * apReportSchedulerImpl) : mpReportSchedulerImpl(apReportSchedulerImpl) {}
+    ReportSchedulerImplTestAccess(app::reporting::ReportSchedulerImpl * apReportSchedulerImpl) :
+        mpReportSchedulerImpl(apReportSchedulerImpl)
+    {}
 
-    void CancelReport(ReadHandler * aReadHandler) { mpReportSchedulerImpl->CancelReport(aReadHandler); }
+    void CancelReport(app::ReadHandler * aReadHandler) { mpReportSchedulerImpl->CancelReport(aReadHandler); }
     void UnregisterAllHandlers() { mpReportSchedulerImpl->UnregisterAllHandlers(); }
 
-    ReadHandlerNode * FindReadHandlerNode(const ReadHandler * aReadHandler)
+    app::reporting::ReadHandlerNode * FindReadHandlerNode(const app::ReadHandler * aReadHandler)
     {
         return mpReportSchedulerImpl->FindReadHandlerNode(aReadHandler);
     }
 
 private:
-    ReportSchedulerImpl * mpReportSchedulerImpl = nullptr;
+    app::reporting::ReportSchedulerImpl * mpReportSchedulerImpl = nullptr;
 };
 
 } // namespace Test

src/app/tests/SynchronizedReportSchedulerImplTestAccess.h

@@ -22,8 +22,6 @@
 namespace chip {
 namespace Test {
 
-using namespace app::reporting;
-using Timestamp = System::Clock::Timestamp;
 /**
  * @brief Class acts as an accessor to private methods of the SynchronizedReportSchedulerImpl class without needing to give
  * friend access to each individual test. This is not a Global API and should only be used for (Unit) Testing.
@@ -32,23 +30,23 @@ class SynchronizedReportSchedulerImplTestAccess
 {
 
 public:
-    SynchronizedReportSchedulerImplTestAccess(SynchronizedReportSchedulerImpl * apSynchronizedReportSchedulerImpl) :
+    SynchronizedReportSchedulerImplTestAccess(app::reporting::SynchronizedReportSchedulerImpl * apSynchronizedReportSchedulerImpl) :
         mpSynchronizedReportSchedulerImpl(apSynchronizedReportSchedulerImpl)
     {}
 
-    Timestamp & GetNextMinTimestamp() { return mpSynchronizedReportSchedulerImpl->mNextMinTimestamp; }
-    Timestamp & GetNextMaxTimestamp() { return mpSynchronizedReportSchedulerImpl->mNextMaxTimestamp; }
-    Timestamp & GetNextReportTimestamp() { return mpSynchronizedReportSchedulerImpl->mNextReportTimestamp; }
+    System::Clock::Timestamp & GetNextMinTimestamp() { return mpSynchronizedReportSchedulerImpl->mNextMinTimestamp; }
+    System::Clock::Timestamp & GetNextMaxTimestamp() { return mpSynchronizedReportSchedulerImpl->mNextMaxTimestamp; }
+    System::Clock::Timestamp & GetNextReportTimestamp() { return mpSynchronizedReportSchedulerImpl->mNextReportTimestamp; }
 
     void UnregisterAllHandlers() { mpSynchronizedReportSchedulerImpl->UnregisterAllHandlers(); }
 
-    ReadHandlerNode * FindReadHandlerNode(const ReadHandler * aReadHandler)
+    app::reporting::ReadHandlerNode * FindReadHandlerNode(const app::ReadHandler * aReadHandler)
     {
         return mpSynchronizedReportSchedulerImpl->FindReadHandlerNode(aReadHandler);
     }
 
 private:
-    SynchronizedReportSchedulerImpl * mpSynchronizedReportSchedulerImpl = nullptr;
+    app::reporting::SynchronizedReportSchedulerImpl * mpSynchronizedReportSchedulerImpl = nullptr;
 };
 
 } // namespace Test