Refactor chip::app::Testing namespace to chip::Testing

docs/testing/unit_testing.md

@@ -279,10 +279,10 @@ own text context class.
 -   If your test requires access to private/protected members of the underlying
     class you're testing, you'll need to create an accessor class that performs
     these operations and is friended to the underlying class. Please name the
-    class `chip::Test::SomethingTestAccess` where `Something` is the name of the
-    underlying class whose private/protected members you're trying to access.
-    Then add `friend class chip::Test::SomethingTestAccess;` to the underlying
-    class. Make sure your test's BUILD.gn file contains
+    class `chip::Testing::SomethingTestAccess` where `Something` is the name of
+    the underlying class whose private/protected members you're trying to
+    access. Then add `friend class chip::Testing::SomethingTestAccess;` to the
+    underlying class. Make sure your test's BUILD.gn file contains
     `sources = [ "SomethingTestAccess.h" ]`. Before creating a new TestAccess
     class, check if one already exists. If it does exist but doesn't expose the
     member you need, you can add a function to that class to do so. Note that

examples/common/server-cluster-shim/tests/TestServerClusterShim.cpp

@@ -36,7 +36,7 @@ using namespace chip::Testing;
 using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::DataModel;
-using namespace chip::app::Testing;
+using namespace chip::Testing;
 using namespace chip::Protocols::InteractionModel;
 using namespace chip::app::Clusters::Globals::Attributes;
 

src/app/clusters/electrical-energy-measurement-server/tests/TestElectricalEnergyMeasurementCluster.cpp

@@ -222,7 +222,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test CumulativeEnergyImported (requires kCumulativeEnergy + kImportedEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, CumulativeEnergyImported::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());
@@ -231,7 +231,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test CumulativeEnergyExported (requires kCumulativeEnergy + kExportedEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, CumulativeEnergyExported::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());
@@ -240,7 +240,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test PeriodicEnergyImported (requires kPeriodicEnergy + kImportedEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, PeriodicEnergyImported::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());
@@ -249,7 +249,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test PeriodicEnergyExported (requires kPeriodicEnergy + kExportedEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, PeriodicEnergyExported::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());
@@ -258,7 +258,7 @@ TEST_F(TestElectricalEnergyMeasurementCluster, FeatureAttributeTest)
         // Test CumulativeEnergyReset (requires kCumulativeEnergy)
         {
             const ConcreteDataAttributePath path = { paths[0].mEndpointId, paths[0].mClusterId, CumulativeEnergyReset::Id };
-            chip::app::Testing::ReadOperation readOperation(path);
+            chip::Testing::ReadOperation readOperation(path);
             std::unique_ptr<AttributeValueEncoder> encoder = readOperation.StartEncoding();
             auto result                                    = cluster.ReadAttribute(readOperation.GetRequest(), *encoder);
             EXPECT_TRUE(result.IsSuccess());

src/app/clusters/general-diagnostics-server/tests/TestGeneralDiagnosticsCluster.cpp

@@ -39,7 +39,6 @@ using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::GeneralDiagnostics::Attributes;
 using namespace chip::app::DataModel;
-using namespace chip::Test;
 using namespace chip::Testing;
 
 template <class T>

src/app/clusters/groupcast/tests/TestGroupcastCluster.cpp

@@ -115,7 +115,7 @@ TEST_F(TestGroupcastCluster, TestJoinGroupCommand)
     cmdData.gracePeriod     = MakeOptional(0U);
     cmdData.useAuxiliaryACL = MakeOptional(true);
 
-    chip::app::Testing::MockCommandHandler cmdHandler;
+    chip::Testing::MockCommandHandler cmdHandler;
     chip::Testing::ClusterTester tester(cluster);
     auto result = tester.Invoke(Commands::JoinGroup::Id, cmdData);
     ASSERT_TRUE(result.status.has_value());

src/app/clusters/network-commissioning/tests/TestNetworkCommissioningCluster.cpp

@@ -46,8 +46,8 @@ using namespace chip::app::Clusters::NetworkCommissioning::Attributes;
 
 using chip::app::AttributeValueDecoder;
 using chip::app::DataModel::AttributeEntry;
-using chip::app::Testing::kAdminSubjectDescriptor;
-using chip::app::Testing::WriteOperation;
+using chip::Testing::kAdminSubjectDescriptor;
+using chip::Testing::WriteOperation;
 
 class NoopBreadcrumbTracker : public BreadCrumbTracker
 {

src/app/clusters/network-commissioning/tests/TestNetworkCommissioningClusterEthernet.cpp

@@ -48,8 +48,8 @@ using namespace chip::app::Clusters::NetworkCommissioning;
 
 using chip::app::AttributeValueDecoder;
 using chip::app::DataModel::AttributeEntry;
-using chip::app::Testing::kAdminSubjectDescriptor;
-using chip::app::Testing::WriteOperation;
+using chip::Testing::kAdminSubjectDescriptor;
+using chip::Testing::WriteOperation;
 
 class NoopBreadcrumbTracker : public BreadCrumbTracker
 {

src/app/clusters/testing/ClusterTester.h

@@ -92,18 +92,18 @@ class ClusterTester
         // Store the read operation in a vector<std::unique_ptr<...>> to ensure its lifetime
         // using std::unique_ptr because ReadOperation is non-copyable and non-movable
         // vector reallocation is not an issue since we store unique_ptrs
-        std::unique_ptr<app::Testing::ReadOperation> readOperation =
-            std::make_unique<app::Testing::ReadOperation>(path.mEndpointId, path.mClusterId, attr_id);
+        std::unique_ptr<chip::Testing::ReadOperation> readOperation =
+            std::make_unique<chip::Testing::ReadOperation>(path.mEndpointId, path.mClusterId, attr_id);
 
         mReadOperations.push_back(std::move(readOperation));
-        app::Testing::ReadOperation & readOperationRef = *mReadOperations.back().get();
+        chip::Testing::ReadOperation & readOperationRef = *mReadOperations.back().get();
 
         std::unique_ptr<app::AttributeValueEncoder> encoder = readOperationRef.StartEncoding();
         app::DataModel::ActionReturnStatus status           = mCluster.ReadAttribute(readOperationRef.GetRequest(), *encoder);
         VerifyOrReturnError(status.IsSuccess(), status);
         ReturnErrorOnFailure(readOperationRef.FinishEncoding());
 
-        std::vector<app::Testing::DecodedAttributeData> attributeData;
+        std::vector<chip::Testing::DecodedAttributeData> attributeData;
         ReturnErrorOnFailure(readOperationRef.GetEncodedIBs().Decode(attributeData));
         VerifyOrReturnError(attributeData.size() == 1u, CHIP_ERROR_INCORRECT_STATE);
 
@@ -124,7 +124,7 @@ class ClusterTester
         VerifyOrReturnError(paths.size() == 1u, CHIP_ERROR_INCORRECT_STATE);
 
         app::ConcreteAttributePath path(paths[0].mEndpointId, paths[0].mClusterId, attr);
-        app::Testing::WriteOperation writeOp(path);
+        chip::Testing::WriteOperation writeOp(path);
 
         // Create a stable object on the stack
         Access::SubjectDescriptor subjectDescriptor{ mHandler.GetAccessingFabricIndex() };
@@ -293,9 +293,9 @@ class ClusterTester
     // If protocol or test requirements change, this value may need to be increased.
     static constexpr size_t kTlvBufferSize = 256;
 
-    app::Testing::MockCommandHandler mHandler;
+    chip::Testing::MockCommandHandler mHandler;
     uint8_t mTlvBuffer[kTlvBufferSize];
-    std::vector<std::unique_ptr<app::Testing::ReadOperation>> mReadOperations;
+    std::vector<std::unique_ptr<chip::Testing::ReadOperation>> mReadOperations;
 };
 
 } // namespace Testing

src/app/clusters/testing/MockCommandHandler.cpp

@@ -26,33 +26,32 @@
 #include <transport/raw/MessageHeader.h>
 
 namespace chip {
-namespace app {
 namespace Testing {
 
-CHIP_ERROR MockCommandHandler::FallibleAddStatus(const ConcreteCommandPath & aRequestCommandPath,
+CHIP_ERROR MockCommandHandler::FallibleAddStatus(const app::ConcreteCommandPath & aRequestCommandPath,
                                                  const Protocols::InteractionModel::ClusterStatusCode & aStatus,
                                                  const char * context)
 {
     mStatuses.emplace_back(StatusRecord{ aRequestCommandPath, aStatus, context });
     return CHIP_NO_ERROR;
 }
 
-void MockCommandHandler::AddStatus(const ConcreteCommandPath & aRequestCommandPath,
+void MockCommandHandler::AddStatus(const app::ConcreteCommandPath & aRequestCommandPath,
                                    const Protocols::InteractionModel::ClusterStatusCode & aStatus, const char * context)
 {
     CHIP_ERROR err = FallibleAddStatus(aRequestCommandPath, aStatus, context);
     VerifyOrDie(err == CHIP_NO_ERROR);
 }
 
-CHIP_ERROR MockCommandHandler::AddResponseData(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
-                                               const DataModel::EncodableToTLV & aEncodable)
+CHIP_ERROR MockCommandHandler::AddResponseData(const app::ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
+                                               const app::DataModel::EncodableToTLV & aEncodable)
 {
     chip::System::PacketBufferHandle handle = chip::MessagePacketBuffer::New(chip::kMaxAppMessageLen);
     VerifyOrReturnError(!handle.IsNull(), CHIP_ERROR_NO_MEMORY);
 
     TLV::TLVWriter baseWriter;
     baseWriter.Init(handle->Start(), handle->MaxDataLength());
-    DataModel::FabricAwareTLVWriter writer(baseWriter, mFabricIndex);
+    app::DataModel::FabricAwareTLVWriter writer(baseWriter, mFabricIndex);
     TLV::TLVType ct;
 
     ReturnErrorOnFailure(writer.mTLVWriter.StartContainer(TLV::AnonymousTag(), TLV::kTLVType_Structure, ct));
@@ -64,8 +63,8 @@ CHIP_ERROR MockCommandHandler::AddResponseData(const ConcreteCommandPath & aRequ
     return CHIP_NO_ERROR;
 }
 
-void MockCommandHandler::AddResponse(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
-                                     const DataModel::EncodableToTLV & aEncodable)
+void MockCommandHandler::AddResponse(const app::ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
+                                     const app::DataModel::EncodableToTLV & aEncodable)
 {
     CHIP_ERROR err = AddResponseData(aRequestCommandPath, aResponseCommandId, aEncodable);
     VerifyOrDie(err == CHIP_NO_ERROR);
@@ -93,5 +92,4 @@ CHIP_ERROR MockCommandHandler::GetResponseReader(TLV::TLVReader & reader, size_t
 }
 
 } // namespace Testing
-} // namespace app
 } // namespace chip

src/app/clusters/testing/MockCommandHandler.h

@@ -32,48 +32,47 @@
 #include <vector>
 
 namespace chip {
-namespace app {
 namespace Testing {
 
 constexpr FabricIndex kTestFabricIndex = static_cast<FabricIndex>(151);
 
 // Mock class that simulates CommandHandler behavior for unit testing, allowing capture and
 // verification of responses and statuses without real network interactions.
-class MockCommandHandler : public CommandHandler
+class MockCommandHandler : public app::CommandHandler
 {
 public:
     struct ResponseRecord
     {
         CommandId commandId;
         System::PacketBufferHandle encodedData;
-        ConcreteCommandPath path;
+        app::ConcreteCommandPath path;
     };
 
     struct StatusRecord
     {
-        ConcreteCommandPath path;
+        app::ConcreteCommandPath path;
         Protocols::InteractionModel::ClusterStatusCode status;
         const char * context;
     };
 
     ~MockCommandHandler() override = default;
 
-    CHIP_ERROR FallibleAddStatus(const ConcreteCommandPath & aRequestCommandPath,
+    CHIP_ERROR FallibleAddStatus(const app::ConcreteCommandPath & aRequestCommandPath,
                                  const Protocols::InteractionModel::ClusterStatusCode & aStatus,
                                  const char * context = nullptr) override;
 
-    void AddStatus(const ConcreteCommandPath & aRequestCommandPath, const Protocols::InteractionModel::ClusterStatusCode & aStatus,
-                   const char * context = nullptr) override;
+    void AddStatus(const app::ConcreteCommandPath & aRequestCommandPath,
+                   const Protocols::InteractionModel::ClusterStatusCode & aStatus, const char * context = nullptr) override;
 
     FabricIndex GetAccessingFabricIndex() const override { return mFabricIndex; }
 
     // Encodes and stores response data, returning error if encoding fails (fallible version for robust test handling).
-    CHIP_ERROR AddResponseData(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
-                               const DataModel::EncodableToTLV & aEncodable) override;
+    CHIP_ERROR AddResponseData(const app::ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
+                               const app::DataModel::EncodableToTLV & aEncodable) override;
 
     // Encodes and stores response data, without error return (non-fallible version that assumes successful encoding in tests).
-    void AddResponse(const ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
-                     const DataModel::EncodableToTLV & aEncodable) override;
+    void AddResponse(const app::ConcreteCommandPath & aRequestCommandPath, CommandId aResponseCommandId,
+                     const app::DataModel::EncodableToTLV & aEncodable) override;
 
     bool IsTimedInvoke() const override { return false; }
     void FlushAcksRightAwayOnSlowCommand() override {}
@@ -133,5 +132,4 @@ class MockCommandHandler : public CommandHandler
 };
 
 } // namespace Testing
-} // namespace app
 } // namespace chip

src/app/clusters/zone-management-server/tests/TestZonePolygon.cpp

@@ -33,7 +33,7 @@
 #include <lib/support/CodeUtils.h>
 
 using namespace chip;
-using namespace chip::Test;
+using namespace chip::Testing;
 using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::ZoneManagement;

src/app/data-model-provider/tests/ReadTesting.cpp

@@ -19,7 +19,6 @@
 #include <app/MessageDef/ReportDataMessage.h>
 
 namespace chip {
-namespace app {
 namespace Testing {
 namespace {
 
@@ -56,10 +55,10 @@ CHIP_ERROR DecodeAttributeReportIBs(ByteSpan data, std::vector<DecodedAttributeD
     while (CHIP_NO_ERROR == (err = reportIBsReader.Next()))
     {
         TLV::TLVReader attributeReportReader = reportIBsReader;
-        AttributeReportIB::Parser attributeReportParser;
+        app::AttributeReportIB::Parser attributeReportParser;
         ReturnErrorOnFailure(attributeReportParser.Init(attributeReportReader));
 
-        AttributeDataIB::Parser dataParser;
+        app::AttributeDataIB::Parser dataParser;
         // NOTE: to also grab statuses, use GetAttributeStatus and check for CHIP_END_OF_TLV
         ReturnErrorOnFailure(attributeReportParser.GetAttributeData(&dataParser));
 
@@ -93,7 +92,7 @@ CHIP_ERROR DecodeAttributeReportIBs(ByteSpan data, std::vector<DecodedAttributeD
 
 } // namespace
 
-std::unique_ptr<AttributeValueEncoder> ReadOperation::StartEncoding(const EncodingParams & params)
+std::unique_ptr<app::AttributeValueEncoder> ReadOperation::StartEncoding(const EncodingParams & params)
 {
     VerifyOrDie((mState == State::kEncoding) || (mState == State::kInitializing));
     mState = State::kEncoding;
@@ -107,9 +106,9 @@ std::unique_ptr<AttributeValueEncoder> ReadOperation::StartEncoding(const Encodi
 
     // mRequest.subjectDescriptor is known non-null because it is set in the constructor
     // NOLINTNEXTLINE(bugprone-unchecked-optional-access)
-    return std::make_unique<AttributeValueEncoder>(mAttributeReportIBsBuilder, *mRequest.subjectDescriptor, mRequest.path,
-                                                   params.GetDataVersion(), params.GetIsFabricFiltered(),
-                                                   params.GetAttributeEncodeState());
+    return std::make_unique<app::AttributeValueEncoder>(mAttributeReportIBsBuilder, *mRequest.subjectDescriptor, mRequest.path,
+                                                        params.GetDataVersion(), params.GetIsFabricFiltered(),
+                                                        params.GetAttributeEncodeState());
 }
 
 CHIP_ERROR ReadOperation::FinishEncoding()
@@ -119,13 +118,13 @@ CHIP_ERROR ReadOperation::FinishEncoding()
     return mEncodedIBs.FinishEncoding(mAttributeReportIBsBuilder);
 }
 
-CHIP_ERROR DecodedAttributeData::DecodeFrom(const AttributeDataIB::Parser & parser)
+CHIP_ERROR DecodedAttributeData::DecodeFrom(const app::AttributeDataIB::Parser & parser)
 {
     ReturnErrorOnFailure(parser.GetDataVersion(&dataVersion));
 
-    AttributePathIB::Parser pathParser;
+    app::AttributePathIB::Parser pathParser;
     ReturnErrorOnFailure(parser.GetPath(&pathParser));
-    ReturnErrorOnFailure(pathParser.GetConcreteAttributePath(attributePath, AttributePathIB::ValidateIdRanges::kNo));
+    ReturnErrorOnFailure(pathParser.GetConcreteAttributePath(attributePath, app::AttributePathIB::ValidateIdRanges::kNo));
     ReturnErrorOnFailure(parser.GetData(&dataReader));
 
     return CHIP_NO_ERROR;
@@ -135,7 +134,7 @@ CHIP_ERROR EncodedReportIBs::StartEncoding(app::AttributeReportIBs::Builder & bu
 {
     mEncodeWriter.Init(mTlvDataBuffer);
     ReturnErrorOnFailure(mEncodeWriter.StartContainer(TLV::AnonymousTag(), TLV::kTLVType_Structure, mOuterStructureType));
-    return builder.Init(&mEncodeWriter, to_underlying(ReportDataMessage::Tag::kAttributeReportIBs));
+    return builder.Init(&mEncodeWriter, to_underlying(app::ReportDataMessage::Tag::kAttributeReportIBs));
 }
 
 CHIP_ERROR EncodedReportIBs::FinishEncoding(app::AttributeReportIBs::Builder & builder)
@@ -154,5 +153,4 @@ CHIP_ERROR EncodedReportIBs::Decode(std::vector<DecodedAttributeData> & decoded_
 }
 
 } // namespace Testing
-} // namespace app
 } // namespace chip