Made some helper functions into class methods.

Author: feasel0

src/controller/tests/TestReadChunking.cpp

@@ -70,8 +70,6 @@ constexpr AttributeId kTestBadAttribute =
 
 constexpr int kListAttributeItems = 5;
 
-using TestReadChunking = chip::Test::AppContext;
-
 //clang-format off
 DECLARE_DYNAMIC_ATTRIBUTE_LIST_BEGIN(testClusterAttrs)
 DECLARE_DYNAMIC_ATTRIBUTE(0x00000001, INT8U, 1, 0), DECLARE_DYNAMIC_ATTRIBUTE(0x00000002, INT8U, 1, 0),
@@ -456,6 +454,15 @@ void TestMutableReadCallback::OnAttributeData(const app::ConcreteDataAttributePa
     // Ignore all other attributes, we don't care above the global attributes.
 }
 
+class TestReadChunking : public chip::Test::AppContext
+{
+protected:
+    struct Instruction;
+    void DoTest(TestMutableReadCallback * callback, Instruction instruction);
+    void DriveIOUntilSubscriptionEstablished(TestMutableReadCallback * callback);
+    void DriveIOUntilEndOfReport(TestMutableReadCallback * callback);
+};
+
 /*
  * This validates all the various corner cases encountered during chunking by
  * artificially reducing the size of a packet buffer used to encode attribute data
@@ -809,57 +816,59 @@ enum AttrIds
 using AttributeWithValue = std::pair<AttributeIdWithEndpointId, uint8_t>;
 using AttributesList     = std::vector<AttributeIdWithEndpointId>;
 
-struct Instruction
+void CheckValues(TestMutableReadCallback * callback, std::vector<AttributeWithValue> expectedValues = {})
+{
+    for (const auto & vals : expectedValues)
+    {
+        EXPECT_EQ(callback->mValues[vals.first], vals.second);
+    }
+}
+
+void ExpectSameDataVersions(TestMutableReadCallback * callback, AttributesList attrList)
+{
+    if (attrList.size() == 0)
+    {
+        return;
+    }
+    DataVersion expectedVersion = callback->mDataVersions[attrList[0]];
+    for (const auto & attr : attrList)
+    {
+        EXPECT_EQ(callback->mDataVersions[attr], expectedVersion);
+    }
+}
+
+}; // namespace TestSetDirtyBetweenChunksUtil
+
+struct TestReadChunking::Instruction
 {
     // The maximum number of attributes should be iterated in a single report chunk.
     uint32_t chunksize;
     // A list of functions that will be executed before driving the main loop.
     std::vector<std::function<void()>> preworks;
     // A list of pair for attributes and their expected values in the report.
-    std::vector<AttributeWithValue> expectedValues;
+    std::vector<TestSetDirtyBetweenChunksUtil::AttributeWithValue> expectedValues;
     // A list of list of various attributes which should have the same data version in the report.
-    std::vector<AttributesList> attributesWithSameDataVersion;
+    std::vector<TestSetDirtyBetweenChunksUtil::AttributesList> attributesWithSameDataVersion;
 };
 
-void DriveIOUntilSubscriptionEstablished(TestReadChunking * pContext, TestMutableReadCallback * callback)
+void TestReadChunking::DriveIOUntilSubscriptionEstablished(TestMutableReadCallback * callback)
 {
     callback->mOnReportEnd = false;
-    pContext->GetIOContext().DriveIOUntil(System::Clock::Seconds16(5), [&]() { return callback->mOnSubscriptionEstablished; });
+    GetIOContext().DriveIOUntil(System::Clock::Seconds16(5), [&]() { return callback->mOnSubscriptionEstablished; });
     EXPECT_TRUE(callback->mOnReportEnd);
     EXPECT_TRUE(callback->mOnSubscriptionEstablished);
     callback->mActionOn.clear();
 }
 
-void DriveIOUntilEndOfReport(TestReadChunking * pContext, TestMutableReadCallback * callback)
+void TestReadChunking::DriveIOUntilEndOfReport(TestMutableReadCallback * callback)
 {
     callback->mOnReportEnd = false;
-    pContext->GetIOContext().DriveIOUntil(System::Clock::Seconds16(5), [&]() { return callback->mOnReportEnd; });
+    GetIOContext().DriveIOUntil(System::Clock::Seconds16(5), [&]() { return callback->mOnReportEnd; });
     EXPECT_TRUE(callback->mOnReportEnd);
     callback->mActionOn.clear();
 }
 
-void CheckValues(TestMutableReadCallback * callback, std::vector<AttributeWithValue> expectedValues = {})
-{
-    for (const auto & vals : expectedValues)
-    {
-        EXPECT_EQ(callback->mValues[vals.first], vals.second);
-    }
-}
-
-void ExpectSameDataVersions(TestMutableReadCallback * callback, AttributesList attrList)
-{
-    if (attrList.size() == 0)
-    {
-        return;
-    }
-    DataVersion expectedVersion = callback->mDataVersions[attrList[0]];
-    for (const auto & attr : attrList)
-    {
-        EXPECT_EQ(callback->mDataVersions[attr], expectedVersion);
-    }
-}
-
-void DoTest(TestReadChunking * pContext, TestMutableReadCallback * callback, Instruction instruction)
+void TestReadChunking::DoTest(TestMutableReadCallback * callback, Instruction instruction)
 {
     app::InteractionModelEngine::GetInstance()->GetReportingEngine().SetMaxAttributesPerChunk(instruction.chunksize);
 
@@ -868,18 +877,16 @@ void DoTest(TestReadChunking * pContext, TestMutableReadCallback * callback, Ins
         act();
     }
 
-    DriveIOUntilEndOfReport(pContext, callback);
+    DriveIOUntilEndOfReport(callback);
 
-    CheckValues(callback, instruction.expectedValues);
+    TestSetDirtyBetweenChunksUtil::CheckValues(callback, instruction.expectedValues);
 
     for (const auto & attrList : instruction.attributesWithSameDataVersion)
     {
-        ExpectSameDataVersions(callback, attrList);
+        TestSetDirtyBetweenChunksUtil::ExpectSameDataVersions(callback, attrList);
     }
 }
 
-}; // namespace TestSetDirtyBetweenChunksUtil
-
 TEST_F(TestReadChunking, TestSetDirtyBetweenChunks)
 {
     using namespace TestSetDirtyBetweenChunksUtil;
@@ -929,19 +936,19 @@ TEST_F(TestReadChunking, TestSetDirtyBetweenChunks)
                 // We are expected to miss attributes on kTestEndpointId during initial reports.
                 ChipLogProgress(DataManagement, "Case 1-1: Set dirty during priming report.");
                 readCallback.mActionOn[AttrOnEp5<Attr1>] = TouchAttrOp(AttrOnEp1<Attr1>);
-                DriveIOUntilSubscriptionEstablished(this, &readCallback);
+                DriveIOUntilSubscriptionEstablished(&readCallback);
                 CheckValues(&readCallback, { { AttrOnEp1<Attr1>, 1 } });
 
                 ChipLogProgress(DataManagement, "Case 1-2: Check for attributes missed last report.");
-                DoTest(this, &readCallback, Instruction{ .chunksize = 2, .expectedValues = { { AttrOnEp1<Attr1>, 2 } } });
+                DoTest(&readCallback, Instruction{ .chunksize = 2, .expectedValues = { { AttrOnEp1<Attr1>, 2 } } });
             }
 
             // CASE 2 -- Set dirty during chunked report, the attribute is already dirty.
             {
                 ChipLogProgress(DataManagement, "Case 2: Set dirty during chunked report by wildcard path.");
                 readCallback.mActionOn[AttrOnEp5<Attr2>] = WriteAttrOp(AttrOnEp5<Attr3>, 3);
                 DoTest(
-                    this, &readCallback,
+                    &readCallback,
                     Instruction{ .chunksize      = 2,
                                  .preworks       = { WriteAttrOp(AttrOnEp5<Attr1>, 2), WriteAttrOp(AttrOnEp5<Attr2>, 2),
                                                      WriteAttrOp(AttrOnEp5<Attr3>, 2) },
@@ -955,7 +962,7 @@ TEST_F(TestReadChunking, TestSetDirtyBetweenChunks)
                                 "Case 3-1: Set dirty during chunked report by wildcard path -- new dirty attribute.");
                 readCallback.mActionOn[AttrOnEp5<Attr2>] = WriteAttrOp(AttrOnEp5<Attr3>, 4);
                 DoTest(
-                    this, &readCallback,
+                    &readCallback,
                     Instruction{ .chunksize      = 1,
                                  .preworks       = { WriteAttrOp(AttrOnEp5<Attr1>, 4), WriteAttrOp(AttrOnEp5<Attr2>, 4) },
                                  .expectedValues = { { AttrOnEp5<Attr1>, 4 }, { AttrOnEp5<Attr2>, 4 }, { AttrOnEp5<Attr3>, 4 } },
@@ -966,7 +973,7 @@ TEST_F(TestReadChunking, TestSetDirtyBetweenChunks)
                 app::InteractionModelEngine::GetInstance()->GetReportingEngine().SetMaxAttributesPerChunk(1);
                 readCallback.mActionOn[AttrOnEp5<Attr2>] = WriteAttrOp(AttrOnEp5<Attr1>, 5);
                 DoTest(
-                    this, &readCallback,
+                    &readCallback,
                     Instruction{ .chunksize      = 1,
                                  .preworks       = { WriteAttrOp(AttrOnEp5<Attr2>, 5), WriteAttrOp(AttrOnEp5<Attr3>, 5) },
                                  .expectedValues = { { AttrOnEp5<Attr1>, 5 }, { AttrOnEp5<Attr2>, 5 }, { AttrOnEp5<Attr3>, 5 } },
@@ -1001,21 +1008,21 @@ TEST_F(TestReadChunking, TestSetDirtyBetweenChunks)
 
             EXPECT_EQ(readClient.SendRequest(readParams), CHIP_NO_ERROR);
 
-            DriveIOUntilSubscriptionEstablished(this, &readCallback);
+            DriveIOUntilSubscriptionEstablished(&readCallback);
 
             // Note, although the two attributes comes from the same cluster, they are generated by different interested paths.
             // In this case, we won't reset the path iterator.
             ChipLogProgress(DataManagement, "Case 1-1: Test set dirty during reports generated by concrete paths.");
             readCallback.mActionOn[AttrOnEp5<Attr2>] = WriteAttrOp(AttrOnEp5<Attr3>, 4);
-            DoTest(this, &readCallback,
+            DoTest(&readCallback,
                    Instruction{ .chunksize      = 1,
                                 .preworks       = { WriteAttrOp(AttrOnEp5<Attr1>, 3), WriteAttrOp(AttrOnEp5<Attr2>, 3),
                                                     WriteAttrOp(AttrOnEp5<Attr3>, 3) },
                                 .expectedValues = { { AttrOnEp5<Attr1>, 3 }, { AttrOnEp5<Attr2>, 3 }, { AttrOnEp5<Attr3>, 3 } } });
 
             // The attribute failed to catch last report will be picked by this report.
             ChipLogProgress(DataManagement, "Case 1-2: Check for attributes missed last report.");
-            DoTest(this, &readCallback, { .chunksize = 1, .expectedValues = { { AttrOnEp5<Attr3>, 4 } } });
+            DoTest(&readCallback, { .chunksize = 1, .expectedValues = { { AttrOnEp5<Attr3>, 4 } } });
         }
     }
 

src/controller/tests/data_model/TestRead.cpp

@@ -294,6 +294,11 @@ class TestRead : public chip::Test::AppContext, public app::ReadHandler::Applica
     bool mEmitSubscriptionError      = false;
     int32_t mNumActiveSubscriptions  = 0;
     bool mAlterSubscriptionIntervals = false;
+
+protected:
+    struct TestReadHandler_ParallelReads_TestCase_Parameters;
+    void TestReadHandler_ParallelReads_TestCase(const TestReadHandler_ParallelReads_TestCase_Parameters & params,
+                                                std::function<void()> body);
 };
 
 uint16_t TestRead::mMaxInterval = 66;
@@ -3629,16 +3634,15 @@ TEST_F(TestRead, TestReadHandler_KillOldestSubscriptions)
     app::InteractionModelEngine::GetInstance()->SetPathPoolCapacityForSubscriptions(-1);
 }
 
-struct TestReadHandler_ParallelReads_TestCase_Parameters
+struct TestRead::TestReadHandler_ParallelReads_TestCase_Parameters
 {
     int ReadHandlerCapacity = -1;
     int PathPoolCapacity    = -1;
     int MaxFabrics          = -1;
 };
 
-static void TestReadHandler_ParallelReads_TestCase(TestRead * apContext,
-                                                   const TestReadHandler_ParallelReads_TestCase_Parameters & params,
-                                                   std::function<void()> body)
+void TestRead::TestReadHandler_ParallelReads_TestCase(const TestReadHandler_ParallelReads_TestCase_Parameters & params,
+                                                      std::function<void()> body)
 {
     app::InteractionModelEngine::GetInstance()->SetForceHandlerQuota(true);
     app::InteractionModelEngine::GetInstance()->SetHandlerCapacityForReads(params.ReadHandlerCapacity);
@@ -3649,10 +3653,10 @@ static void TestReadHandler_ParallelReads_TestCase(TestRead * apContext,
 
     // Clean up
     app::InteractionModelEngine::GetInstance()->ShutdownActiveReads();
-    apContext->DrainAndServiceIO();
+    DrainAndServiceIO();
 
     // Sanity check
-    EXPECT_EQ(apContext->GetExchangeManager().GetNumActiveExchanges(), 0u);
+    EXPECT_EQ(GetExchangeManager().GetNumActiveExchanges(), 0u);
 
     app::InteractionModelEngine::GetInstance()->SetForceHandlerQuota(false);
     app::InteractionModelEngine::GetInstance()->SetHandlerCapacityForReads(-1);
@@ -3673,7 +3677,7 @@ TEST_F(TestRead, TestReadHandler_ParallelReads)
     app::InteractionModelEngine::GetInstance()->RegisterReadHandlerAppCallback(this);
 
     auto TestCase = [&](const TestReadHandler_ParallelReads_TestCase_Parameters & params, std::function<void()> body) {
-        TestReadHandler_ParallelReads_TestCase(this, params, body);
+        TestReadHandler_ParallelReads_TestCase(params, body);
     };
 
     // Case 1.1: 2 reads used up the path pool (but not the ReadHandler pool), and one incoming oversized read request =>