Update soil measurement, boolean state, fixed label and user label cluster unit tests (#41508)

* Update soil measurement unit tests

* Code update

* Code update

* Code update

* Code update

* Code update

* Implement ClusterTester class with member functions instead

* Addressing review comments

* Address comment

Author: arielsz71

src/app/clusters/boolean-state-server/tests/TestBooleanStateCluster.cpp

@@ -18,7 +18,7 @@
 #include <pw_unit_test/framework.h>
 
 #include <app/clusters/testing/AttributeTesting.h>
-#include <app/clusters/testing/TestReadWriteAttribute.h>
+#include <app/clusters/testing/ClusterTester.h>
 #include <app/server-cluster/AttributeListBuilder.h>
 #include <app/server-cluster/testing/TestEventGenerator.h>
 #include <app/server-cluster/testing/TestServerClusterContext.h>
@@ -44,7 +44,7 @@ struct TestBooleanStateCluster : public ::testing::Test
 
     void TearDown() override { booleanState.Shutdown(); }
 
-    TestBooleanStateCluster() : testContext(), context(testContext.Create()), booleanState(kRootEndpointId) {}
+    TestBooleanStateCluster() : context(testContext.Create()), booleanState(kRootEndpointId) {}
 
     chip::Test::TestServerClusterContext testContext;
     ServerClusterContext context;
@@ -66,14 +66,16 @@ TEST_F(TestBooleanStateCluster, AttributeTest)
 
 TEST_F(TestBooleanStateCluster, ReadAttributeTest)
 {
+    ClusterTester tester(booleanState);
+
     uint16_t revision{};
-    ASSERT_EQ(ReadClusterAttribute(booleanState, Globals::Attributes::ClusterRevision::Id, revision), CHIP_NO_ERROR);
+    ASSERT_EQ(tester.ReadAttribute(Globals::Attributes::ClusterRevision::Id, revision), CHIP_NO_ERROR);
 
     uint32_t features{};
-    ASSERT_EQ(ReadClusterAttribute(booleanState, FeatureMap::Id, features), CHIP_NO_ERROR);
+    ASSERT_EQ(tester.ReadAttribute(FeatureMap::Id, features), CHIP_NO_ERROR);
 
     bool stateValue{};
-    ASSERT_EQ(ReadClusterAttribute(booleanState, StateValue::Id, stateValue), CHIP_NO_ERROR);
+    ASSERT_EQ(tester.ReadAttribute(StateValue::Id, stateValue), CHIP_NO_ERROR);
 }
 
 TEST_F(TestBooleanStateCluster, StateValue)

src/app/clusters/fixed-label-server/tests/BUILD.gn

@@ -30,6 +30,7 @@ chip_test_suite("tests") {
   public_deps = [
     "${chip_root}/src/app/clusters/fixed-label-server",
     "${chip_root}/src/app/clusters/testing",
+    "${chip_root}/src/app/server-cluster/testing:testing",
     "${chip_root}/src/lib/support",
   ]
 }

src/app/clusters/fixed-label-server/tests/TestFixedLabelCluster.cpp

@@ -17,10 +17,11 @@
 #include <pw_unit_test/framework.h>
 
 #include <app/clusters/fixed-label-server/fixed-label-cluster.h>
-
 #include <app/clusters/testing/AttributeTesting.h>
+#include <app/clusters/testing/ClusterTester.h>
 #include <app/server-cluster/AttributeListBuilder.h>
 #include <app/server-cluster/DefaultServerCluster.h>
+#include <app/server-cluster/testing/TestServerClusterContext.h>
 #include <clusters/FixedLabel/Attributes.h>
 #include <clusters/FixedLabel/Metadata.h>
 
@@ -29,102 +30,55 @@ using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::FixedLabel;
 using namespace chip::app::Clusters::FixedLabel::Attributes;
+using namespace chip::Test;
 
 namespace {
 
 struct TestFixedLabelCluster : public ::testing::Test
 {
-    static void SetUpTestSuite() { ASSERT_EQ(Platform::MemoryInit(), CHIP_NO_ERROR); }
-    static void TearDownTestSuite() { Platform::MemoryShutdown(); }
-};
-
-constexpr size_t kFixedLabelFixedClusterCount = 2;
-
-class FixedLabelClusterTest
-{
-    FixedLabelCluster fixedLabel;
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
 
-public:
-    template <typename... Args>
-    FixedLabelClusterTest(Args &&... args) : fixedLabel(std::forward<Args>(args)...)
-    {}
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
 
-    template <typename F>
-    void Check(F check)
-    {
-        check(fixedLabel);
-    }
-};
+    void SetUp() override { ASSERT_EQ(fixedLabel.Startup(context), CHIP_NO_ERROR); }
 
-class ReadAttribute
-{
-    FixedLabelCluster & mCluster;
-    DataModel::ActionReturnStatus mStatus;
-
-public:
-    ReadAttribute(FixedLabelCluster & cluster) : mCluster(cluster), mStatus(CHIP_NO_ERROR) {}
+    void TearDown() override { fixedLabel.Shutdown(); }
 
-    DataModel::ActionReturnStatus GetStatus() const { return mStatus; }
+    TestFixedLabelCluster() : context(testContext.Create()), fixedLabel(kRootEndpointId) {}
 
-    void operator()(DataModel::ReadAttributeRequest & request)
-    {
-        Platform::ScopedMemoryBufferWithSize<uint8_t> buffer;
-        ASSERT_NE(buffer.Alloc(1024).Get(), nullptr);
-
-        AttributeReportIBs::Builder attributeReportIBsBuilder;
-        TLV::TLVWriter reportWriter;
-        reportWriter.Init(buffer.Get(), buffer.AllocatedSize());
-        ASSERT_EQ(attributeReportIBsBuilder.Init(&reportWriter), CHIP_NO_ERROR);
-
-        AttributeValueEncoder encoder(attributeReportIBsBuilder, Access::SubjectDescriptor{}, request.path, 0 /* dataVersion */);
-
-        mStatus = mCluster.ReadAttribute(request, encoder);
-    }
+    chip::Test::TestServerClusterContext testContext;
+    ServerClusterContext context;
+    FixedLabelCluster fixedLabel;
 };
 
 } // namespace
 
 TEST_F(TestFixedLabelCluster, AttributeTest)
 {
-    for (EndpointId endpoint = 0; endpoint < kFixedLabelFixedClusterCount; ++endpoint)
-    {
-        FixedLabelClusterTest(endpoint).Check([&](FixedLabelCluster & fixedLabel) {
-            ReadOnlyBufferBuilder<DataModel::AttributeEntry> attributes;
-            ASSERT_EQ(fixedLabel.Attributes(ConcreteClusterPath(endpoint, FixedLabel::Id), attributes), CHIP_NO_ERROR);
-
-            ReadOnlyBufferBuilder<DataModel::AttributeEntry> expected;
-            AttributeListBuilder listBuilder(expected);
-            ASSERT_EQ(listBuilder.Append(Span(FixedLabel::Attributes::kMandatoryMetadata), {}), CHIP_NO_ERROR);
-            ASSERT_TRUE(Testing::EqualAttributeSets(attributes.TakeBuffer(), expected.TakeBuffer()));
-        });
-    }
+    ReadOnlyBufferBuilder<DataModel::AttributeEntry> attributes;
+    ASSERT_EQ(fixedLabel.Attributes(ConcreteClusterPath(kRootEndpointId, FixedLabel::Id), attributes), CHIP_NO_ERROR);
+
+    ReadOnlyBufferBuilder<DataModel::AttributeEntry> expected;
+    AttributeListBuilder listBuilder(expected);
+    ASSERT_EQ(listBuilder.Append(Span(FixedLabel::Attributes::kMandatoryMetadata), {}), CHIP_NO_ERROR);
+    ASSERT_TRUE(chip::Testing::EqualAttributeSets(attributes.TakeBuffer(), expected.TakeBuffer()));
 }
 
 TEST_F(TestFixedLabelCluster, ReadAttributeTest)
 {
-    for (EndpointId endpoint = 0; endpoint < kFixedLabelFixedClusterCount; ++endpoint)
+    ClusterTester tester(fixedLabel);
+
+    uint16_t revision{};
+    ASSERT_EQ(tester.ReadAttribute(Globals::Attributes::ClusterRevision::Id, revision), CHIP_NO_ERROR);
+
+    uint32_t features{};
+    ASSERT_EQ(tester.ReadAttribute(FeatureMap::Id, features), CHIP_NO_ERROR);
+
+    DataModel::DecodableList<Structs::LabelStruct::DecodableType> labelList;
+    ASSERT_EQ(tester.ReadAttribute(LabelList::Id, labelList), CHIP_NO_ERROR);
+    auto it = labelList.begin();
+    while (it.Next())
     {
-        FixedLabelClusterTest(endpoint).Check([&](FixedLabelCluster & fixedLabel) {
-            DataModel::ReadAttributeRequest request;
-            request.path.mEndpointId  = endpoint;
-            request.path.mClusterId   = FixedLabel::Id;
-            request.path.mAttributeId = Globals::Attributes::ClusterRevision::Id;
-
-            ReadAttribute readAttribute(fixedLabel);
-            readAttribute(request);
-            EXPECT_TRUE(readAttribute.GetStatus().IsSuccess());
-
-            request.path.mAttributeId = FeatureMap::Id;
-            readAttribute(request);
-            EXPECT_TRUE(readAttribute.GetStatus().IsSuccess());
-
-            request.path.mAttributeId = LabelList::Id;
-            readAttribute(request);
-            EXPECT_TRUE(readAttribute.GetStatus().IsSuccess());
-
-            request.path.mAttributeId = 0xFFFF;
-            readAttribute(request);
-            EXPECT_TRUE(readAttribute.GetStatus().IsError());
-        });
+        ASSERT_GT(it.GetValue().label.size(), 0u);
     }
 }

src/app/clusters/soil-measurement-server/tests/BUILD.gn

@@ -30,6 +30,7 @@ chip_test_suite("tests") {
   public_deps = [
     "${chip_root}/src/app/clusters/soil-measurement-server",
     "${chip_root}/src/app/clusters/testing",
+    "${chip_root}/src/app/server-cluster/testing:testing",
     "${chip_root}/src/lib/support",
   ]
 }

src/app/clusters/soil-measurement-server/tests/TestSoilMeasurementCluster.cpp

@@ -17,10 +17,10 @@
 #include <pw_unit_test/framework.h>
 
 #include <app/clusters/soil-measurement-server/soil-measurement-cluster.h>
-
 #include <app/clusters/testing/AttributeTesting.h>
+#include <app/clusters/testing/ClusterTester.h>
 #include <app/server-cluster/AttributeListBuilder.h>
-#include <app/server-cluster/DefaultServerCluster.h>
+#include <app/server-cluster/testing/TestServerClusterContext.h>
 #include <clusters/SoilMeasurement/Attributes.h>
 #include <clusters/SoilMeasurement/Metadata.h>
 
@@ -29,15 +29,10 @@ using namespace chip::app;
 using namespace chip::app::Clusters;
 using namespace chip::app::Clusters::SoilMeasurement;
 using namespace chip::app::Clusters::SoilMeasurement::Attributes;
+using namespace chip::Test;
 
 namespace {
 
-struct TestSoilMeasurementCluster : public ::testing::Test
-{
-    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
-    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
-};
-
 const Globals::Structs::MeasurementAccuracyRangeStruct::Type kDefaultSoilMoistureMeasurementLimitsAccuracyRange[] = {
     { .rangeMin = 0, .rangeMax = 100, .percentMax = MakeOptional(static_cast<chip::Percent100ths>(10)) }
 };
@@ -66,83 +61,93 @@ class SoilMeasurementClusterLocal : public SoilMeasurementCluster
     SoilMoistureMeasuredValue::TypeInfo::Type GetSoilMoistureMeasuredValue() const { return mSoilMoistureMeasuredValue; }
 };
 
-class SoilMeasurementClusterTest
+struct TestSoilMeasurementCluster : public ::testing::Test
 {
-    SoilMeasurementClusterLocal soilMeasurement;
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
 
-public:
-    template <typename... Args>
-    SoilMeasurementClusterTest(Args &&... args) : soilMeasurement(std::forward<Args>(args)...)
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+
+    void SetUp() override { ASSERT_EQ(soilMeasurement.Startup(context), CHIP_NO_ERROR); }
+
+    void TearDown() override { soilMeasurement.Shutdown(); }
+
+    TestSoilMeasurementCluster() :
+        context(testContext.Create()), soilMeasurement(kEndpointWithSoilMeasurement, kDefaultSoilMoistureMeasurementLimits)
     {}
 
-    template <typename F>
-    void Check(F check)
-    {
-        check(soilMeasurement);
-    }
+    chip::Test::TestServerClusterContext testContext;
+    ServerClusterContext context;
+    SoilMeasurementClusterLocal soilMeasurement;
 };
 
 } // namespace
 
 TEST_F(TestSoilMeasurementCluster, AttributeTest)
 {
-    SoilMeasurementClusterTest(kEndpointWithSoilMeasurement, kDefaultSoilMoistureMeasurementLimits)
-        .Check([](SoilMeasurementClusterLocal & soilMeasurement) {
-            ReadOnlyBufferBuilder<DataModel::AttributeEntry> attributes;
-            ASSERT_EQ(
-                soilMeasurement.Attributes(ConcreteClusterPath(kEndpointWithSoilMeasurement, SoilMeasurement::Id), attributes),
-                CHIP_NO_ERROR);
-
-            ReadOnlyBufferBuilder<DataModel::AttributeEntry> expected;
-            AttributeListBuilder listBuilder(expected);
-            ASSERT_EQ(listBuilder.Append(Span(SoilMeasurement::Attributes::kMandatoryMetadata), {}), CHIP_NO_ERROR);
-            ASSERT_TRUE(Testing::EqualAttributeSets(attributes.TakeBuffer(), expected.TakeBuffer()));
-        });
+    ReadOnlyBufferBuilder<DataModel::AttributeEntry> attributes;
+    ASSERT_EQ(soilMeasurement.Attributes(ConcreteClusterPath(kEndpointWithSoilMeasurement, SoilMeasurement::Id), attributes),
+              CHIP_NO_ERROR);
+
+    ReadOnlyBufferBuilder<DataModel::AttributeEntry> expected;
+    AttributeListBuilder listBuilder(expected);
+    ASSERT_EQ(listBuilder.Append(Span(SoilMeasurement::Attributes::kMandatoryMetadata), {}), CHIP_NO_ERROR);
+    ASSERT_TRUE(chip::Testing::EqualAttributeSets(attributes.TakeBuffer(), expected.TakeBuffer()));
+}
+
+TEST_F(TestSoilMeasurementCluster, ReadAttributeTest)
+{
+    ClusterTester tester(soilMeasurement);
+
+    uint16_t revision{};
+    ASSERT_EQ(tester.ReadAttribute(Globals::Attributes::ClusterRevision::Id, revision), CHIP_NO_ERROR);
+
+    uint32_t features{};
+    ASSERT_EQ(tester.ReadAttribute(FeatureMap::Id, features), CHIP_NO_ERROR);
+
+    SoilMoistureMeasuredValue::TypeInfo::DecodableType soilMoistureMeasuredValue;
+    ASSERT_EQ(tester.ReadAttribute(SoilMoistureMeasuredValue::Id, soilMoistureMeasuredValue), CHIP_NO_ERROR);
+
+    SoilMoistureMeasurementLimits::TypeInfo::DecodableType soilMoistureMeasurementLimits;
+    ASSERT_EQ(tester.ReadAttribute(SoilMoistureMeasurementLimits::Id, soilMoistureMeasurementLimits), CHIP_NO_ERROR);
 }
 
 TEST_F(TestSoilMeasurementCluster, SoilMoistureMeasuredValue)
 {
-    SoilMeasurementClusterTest(kEndpointWithSoilMeasurement, kDefaultSoilMoistureMeasurementLimits)
-        .Check([](SoilMeasurementClusterLocal & soilMeasurement) {
-            SoilMoistureMeasuredValue::TypeInfo::Type measuredValue;
-            measuredValue.SetNull();
-            ASSERT_EQ(soilMeasurement.GetSoilMoistureMeasuredValue(), measuredValue);
-
-            measuredValue = 50;
-            ASSERT_EQ(soilMeasurement.SetSoilMoistureMeasuredValue(measuredValue), CHIP_NO_ERROR);
-            ASSERT_EQ(soilMeasurement.GetSoilMoistureMeasuredValue(), measuredValue);
-
-            measuredValue = 101;
-            ASSERT_EQ(soilMeasurement.SetSoilMoistureMeasuredValue(measuredValue), CHIP_ERROR_INVALID_ARGUMENT);
-
-            measuredValue = -1;
-            ASSERT_EQ(soilMeasurement.SetSoilMoistureMeasuredValue(measuredValue), CHIP_ERROR_INVALID_ARGUMENT);
-
-            measuredValue.SetNull();
-            ASSERT_EQ(soilMeasurement.SetSoilMoistureMeasuredValue(measuredValue), CHIP_NO_ERROR);
-            ASSERT_EQ(soilMeasurement.GetSoilMoistureMeasuredValue(), measuredValue);
-        });
+    SoilMoistureMeasuredValue::TypeInfo::Type measuredValue;
+    measuredValue.SetNull();
+    ASSERT_EQ(soilMeasurement.GetSoilMoistureMeasuredValue(), measuredValue);
+
+    measuredValue = 50;
+    ASSERT_EQ(soilMeasurement.SetSoilMoistureMeasuredValue(measuredValue), CHIP_NO_ERROR);
+    ASSERT_EQ(soilMeasurement.GetSoilMoistureMeasuredValue(), measuredValue);
+
+    measuredValue = 101;
+    ASSERT_EQ(soilMeasurement.SetSoilMoistureMeasuredValue(measuredValue), CHIP_ERROR_INVALID_ARGUMENT);
+
+    measuredValue = -1;
+    ASSERT_EQ(soilMeasurement.SetSoilMoistureMeasuredValue(measuredValue), CHIP_ERROR_INVALID_ARGUMENT);
+
+    measuredValue.SetNull();
+    ASSERT_EQ(soilMeasurement.SetSoilMoistureMeasuredValue(measuredValue), CHIP_NO_ERROR);
+    ASSERT_EQ(soilMeasurement.GetSoilMoistureMeasuredValue(), measuredValue);
 }
 
 TEST_F(TestSoilMeasurementCluster, SoilMoistureMeasurementLimits)
 {
-    SoilMeasurementClusterTest(kEndpointWithSoilMeasurement, kDefaultSoilMoistureMeasurementLimits)
-        .Check([](SoilMeasurementClusterLocal & soilMeasurement) {
-            const auto & measurementLimits = soilMeasurement.GetSoilMoistureMeasurementLimits();
-            ASSERT_EQ(measurementLimits.measurementType, kDefaultSoilMoistureMeasurementLimits.measurementType);
-            ASSERT_EQ(measurementLimits.measured, kDefaultSoilMoistureMeasurementLimits.measured);
-            ASSERT_EQ(measurementLimits.minMeasuredValue, kDefaultSoilMoistureMeasurementLimits.minMeasuredValue);
-            ASSERT_EQ(measurementLimits.maxMeasuredValue, kDefaultSoilMoistureMeasurementLimits.maxMeasuredValue);
-
-            const auto & accuracyRange = measurementLimits.accuracyRanges[0];
-            const auto & defaultRange  = kDefaultSoilMoistureMeasurementLimits.accuracyRanges[0];
-            ASSERT_EQ(accuracyRange.rangeMin, defaultRange.rangeMin);
-            ASSERT_EQ(accuracyRange.rangeMax, defaultRange.rangeMax);
-            ASSERT_EQ(accuracyRange.percentMax.Value(), defaultRange.percentMax.Value());
-            ASSERT_FALSE(accuracyRange.percentMin.HasValue());
-            ASSERT_FALSE(accuracyRange.percentTypical.HasValue());
-            ASSERT_FALSE(accuracyRange.fixedMax.HasValue());
-            ASSERT_FALSE(accuracyRange.fixedMin.HasValue());
-            ASSERT_FALSE(accuracyRange.fixedTypical.HasValue());
-        });
+    const auto & measurementLimits = soilMeasurement.GetSoilMoistureMeasurementLimits();
+    ASSERT_EQ(measurementLimits.measurementType, kDefaultSoilMoistureMeasurementLimits.measurementType);
+    ASSERT_EQ(measurementLimits.measured, kDefaultSoilMoistureMeasurementLimits.measured);
+    ASSERT_EQ(measurementLimits.minMeasuredValue, kDefaultSoilMoistureMeasurementLimits.minMeasuredValue);
+    ASSERT_EQ(measurementLimits.maxMeasuredValue, kDefaultSoilMoistureMeasurementLimits.maxMeasuredValue);
+
+    const auto & accuracyRange = measurementLimits.accuracyRanges[0];
+    const auto & defaultRange  = kDefaultSoilMoistureMeasurementLimits.accuracyRanges[0];
+    ASSERT_EQ(accuracyRange.rangeMin, defaultRange.rangeMin);
+    ASSERT_EQ(accuracyRange.rangeMax, defaultRange.rangeMax);
+    ASSERT_EQ(accuracyRange.percentMax.Value(), defaultRange.percentMax.Value());
+    ASSERT_FALSE(accuracyRange.percentMin.HasValue());
+    ASSERT_FALSE(accuracyRange.percentTypical.HasValue());
+    ASSERT_FALSE(accuracyRange.fixedMax.HasValue());
+    ASSERT_FALSE(accuracyRange.fixedMin.HasValue());
+    ASSERT_FALSE(accuracyRange.fixedTypical.HasValue());
 }

src/app/clusters/testing/BUILD.gn

@@ -20,7 +20,7 @@ source_set("testing") {
   sources = [
     "AttributeTesting.cpp",
     "AttributeTesting.h",
-    "TestReadWriteAttribute.h",
+    "ClusterTester.h",
   ]
 
   public_deps = [