Helper changes for PowerSource codedriven implementation (project-chip#72119) (project-chip#72250)

* Pull helper changes from project-chip#72119

* Compile fix

Author: Hayk10002

examples/evse-app/evse-common/src/EVSEManufacturerImpl.cpp

@@ -130,8 +130,6 @@ CHIP_ERROR FindNextTarget(const BitMask<EnergyEvse::TargetDayOfWeekBitmap> dayOf
                           uint16_t & targetTimeMinutesPastMidnight_m, DataModel::Nullable<Percent> & targetSoC,
                           DataModel::Nullable<int64_t> & targetAddedEnergy_mWh, bool bAllowTargetsInPast)
 {
-    EnergyEvse::Structs::ChargingTargetScheduleStruct::Type entry;
-
     uint16_t minTimeToTarget_m = 24 * 60; // 24 hours
     bool bFound                = false;
 

src/app/server-cluster/OptionalAttributeSet.h

@@ -57,13 +57,13 @@ struct IsOneOf<T>
 class AttributeSet
 {
 public:
-    explicit AttributeSet(uint32_t initialValue) : mSetBits(initialValue) {}
+    constexpr explicit AttributeSet(uint32_t initialValue) : mSetBits(initialValue) {}
 
-    AttributeSet()                                       = default;
-    AttributeSet(const AttributeSet & other)             = default;
-    AttributeSet(AttributeSet && other)                  = default;
-    AttributeSet & operator=(const AttributeSet & other) = default;
-    AttributeSet & operator=(AttributeSet && other)      = default;
+    constexpr AttributeSet()                                       = default;
+    constexpr AttributeSet(const AttributeSet & other)             = default;
+    constexpr AttributeSet(AttributeSet && other)                  = default;
+    constexpr AttributeSet & operator=(const AttributeSet & other) = default;
+    constexpr AttributeSet & operator=(AttributeSet && other)      = default;
 
     // Checks if an attribute ID is set.
     //
@@ -85,6 +85,8 @@ class AttributeSet
         return Set(id, true);
     }
 
+    constexpr uint32_t Raw() const { return mSetBits; }
+
 protected:
     constexpr AttributeSet & Set(AttributeId id, bool value = true)
     {
@@ -140,9 +142,9 @@ template <AttributeId... OptionalAttributeIds>
 class OptionalAttributeSet : public AttributeSet
 {
 public:
-    explicit OptionalAttributeSet(uint32_t initialValue) : AttributeSet(initialValue & All()) {}
-    OptionalAttributeSet(const AttributeSet & initialValue) : AttributeSet(initialValue) {}
-    OptionalAttributeSet() = default;
+    constexpr explicit OptionalAttributeSet(uint32_t initialValue) : AttributeSet(initialValue & All()) {}
+    constexpr OptionalAttributeSet(const AttributeSet & initialValue) : AttributeSet(initialValue) {}
+    constexpr OptionalAttributeSet() = default;
 
     template <uint32_t ATTRIBUTE_ID>
     constexpr OptionalAttributeSet & Set(bool value = true)

src/app/server-cluster/testing/BUILD.gn

@@ -29,7 +29,6 @@ source_set("testing") {
     "TestAttributeChangeListener.h",
     "TestEventGenerator.h",
     "TestServerClusterContext.h",
-    "ValidateGlobalAttributes.cpp",
     "ValidateGlobalAttributes.h",
   ]
 

src/app/server-cluster/testing/ValidateGlobalAttributes.cpp

@@ -34,7 +34,8 @@ namespace Testing {
 ///
 /// Parameters:
 ///     cluster - The cluster interface to test.
-///     expected - An initializer list of expected attribute entries (may be empty for only globals)
+///     expected - initializer_list or any other iterable of expected attribute entries supporting `std::size(container)` syntax.
+///     May be empty for global attributes only.
 ///
 /// @note This function will assert (die) if `cluster.GetPaths()` does not return exactly one path.
 ///
@@ -43,16 +44,39 @@ namespace Testing {
 /// ClusterImpl cluster(kTestEndpointId, ....);
 /// ASSERT_TRUE(IsAttributesListEqualTo(cluster, { Attributes::SomeAttribute::kMetadataEntry }));
 /// ```
-bool IsAttributesListEqualTo(app::ServerClusterInterface & cluster,
-                             std::initializer_list<const app::DataModel::AttributeEntry> expected);
 
-/// Overload of IsAttributesListEqualTo that accepts a standard vector of attribute entries.
-///
-/// Parameters:
-///     cluster - The cluster interface to test.
-///     expected - A vector containing the expected attribute entries (must include all
-///                non-global, non-optional attributes).
-bool IsAttributesListEqualTo(app::ServerClusterInterface & cluster, const std::vector<app::DataModel::AttributeEntry> & expected);
+template <class T>
+bool IsAttributesListEqualTo(app::ServerClusterInterface & cluster, const T & expected)
+{
+    VerifyOrDie(cluster.GetPaths().size() == 1);
+    auto path = cluster.GetPaths()[0];
+    ReadOnlyBufferBuilder<app::DataModel::AttributeEntry> attributesBuilder;
+    if (CHIP_ERROR err = cluster.Attributes(path, attributesBuilder); err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Test, "Failed to get attributes list from cluster. Error: %" CHIP_ERROR_FORMAT, err.Format());
+        return false;
+    }
+
+    ReadOnlyBufferBuilder<app::DataModel::AttributeEntry> expectedBuilder;
+
+    SuccessOrDie(expectedBuilder.EnsureAppendCapacity(std::size(expected)));
+    for (const auto & entry : expected)
+    {
+        SuccessOrDie(expectedBuilder.Append(entry));
+    }
+
+    SuccessOrDie(expectedBuilder.AppendElements(app::DefaultServerCluster::GlobalAttributes()));
+
+    return EqualAttributeSets(attributesBuilder.TakeBuffer(), expectedBuilder.TakeBuffer());
+}
+
+// Overload for std::initializer_list to not get "template argument deduction failed" when calling `IsAttributesListEqualTo(cluster,
+// {...})`
+template <typename T = const app::DataModel::AttributeEntry>
+bool IsAttributesListEqualTo(app::ServerClusterInterface & cluster, std::initializer_list<T> expected)
+{
+    return IsAttributesListEqualTo<std::initializer_list<T>>(cluster, expected);
+}
 
 /// Compares the accepted commands of a cluster against an expected set.
 ///
@@ -61,7 +85,8 @@ bool IsAttributesListEqualTo(app::ServerClusterInterface & cluster, const std::v
 ///
 /// Parameters:
 ///     cluster - The cluster interface to test.
-///     expected - An initializer list of expected accepted command entries. May be empty.
+///     expected - initializer_list or any other iterable of expected accepted command entries supporting `std::size(container)`
+///     syntax. May be empty.
 ///
 /// @note This function will assert (die) if `cluster.GetPaths()` does not return exactly one path.
 ///
@@ -71,8 +96,36 @@ bool IsAttributesListEqualTo(app::ServerClusterInterface & cluster, const std::v
 /// ClusterImpl cluster(kTestEndpointId, ...);
 /// ASSERT_TRUE(IsAcceptedCommandsListEqualTo(cluster, { Commands::SomeCommand::kMetadataEntry }));
 /// ```
-bool IsAcceptedCommandsListEqualTo(app::ServerClusterInterface & cluster,
-                                   std::initializer_list<const app::DataModel::AcceptedCommandEntry> expected);
+template <class T>
+bool IsAcceptedCommandsListEqualTo(app::ServerClusterInterface & cluster, const T & expected)
+{
+    VerifyOrDie(cluster.GetPaths().size() == 1);
+    auto path = cluster.GetPaths()[0];
+    ReadOnlyBufferBuilder<app::DataModel::AcceptedCommandEntry> commandsBuilder;
+    if (CHIP_ERROR err = cluster.AcceptedCommands(path, commandsBuilder); err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Test, "Failed to get accepted commands list from cluster. Error: %" CHIP_ERROR_FORMAT, err.Format());
+        return false;
+    }
+
+    ReadOnlyBufferBuilder<app::DataModel::AcceptedCommandEntry> expectedBuilder;
+
+    SuccessOrDie(expectedBuilder.EnsureAppendCapacity(std::size(expected)));
+    for (const auto & entry : expected)
+    {
+        SuccessOrDie(expectedBuilder.Append(entry));
+    }
+
+    return EqualAcceptedCommandSets(commandsBuilder.TakeBuffer(), expectedBuilder.TakeBuffer());
+}
+
+// Overload for std::initializer_list to not get "template argument deduction failed" when calling
+// `IsAcceptedCommandsListEqualTo(cluster, {...})`
+template <typename T = const app::DataModel::AcceptedCommandEntry>
+bool IsAcceptedCommandsListEqualTo(app::ServerClusterInterface & cluster, std::initializer_list<T> expected)
+{
+    return IsAcceptedCommandsListEqualTo<std::initializer_list<T>>(cluster, expected);
+}
 
 /// Compares the generated commands of a cluster against an expected set.
 ///
@@ -81,7 +134,8 @@ bool IsAcceptedCommandsListEqualTo(app::ServerClusterInterface & cluster,
 ///
 /// Parameters:
 ///     cluster - The cluster interface to test.
-///     expected - An initializer list of expected generated command entries. May be empty.
+///     expected - initializer_list or any other iterable of expected generated command entries supporting `std::size(container)`
+///     syntax. May be empty.
 ///
 /// @note This function will assert (die) if `cluster.GetPaths()` does not return exactly one path.
 ///
@@ -90,7 +144,36 @@ bool IsAcceptedCommandsListEqualTo(app::ServerClusterInterface & cluster,
 /// ClusterImpl cluster(kTestEndpointId, ...);
 /// ASSERT_TRUE(IsGeneratedCommandsListEqualTo(cluster, { Commands::SomeCommandResponse::kMetadataEntry }));
 /// ```
-bool IsGeneratedCommandsListEqualTo(app::ServerClusterInterface & cluster, std::initializer_list<const CommandId> expected);
+template <class T>
+bool IsGeneratedCommandsListEqualTo(app::ServerClusterInterface & cluster, const T & expected)
+{
+    VerifyOrDie(cluster.GetPaths().size() == 1);
+    auto path = cluster.GetPaths()[0];
+    ReadOnlyBufferBuilder<CommandId> commandsBuilder;
+    if (CHIP_ERROR err = cluster.GeneratedCommands(path, commandsBuilder); err != CHIP_NO_ERROR)
+    {
+        ChipLogError(Test, "Failed to get generated commands list from cluster. Error: %" CHIP_ERROR_FORMAT, err.Format());
+        return false;
+    }
+
+    ReadOnlyBufferBuilder<CommandId> expectedBuilder;
+
+    SuccessOrDie(expectedBuilder.EnsureAppendCapacity(std::size(expected)));
+    for (const auto & entry : expected)
+    {
+        SuccessOrDie(expectedBuilder.Append(entry));
+    }
+
+    return EqualGeneratedCommandSets(commandsBuilder.TakeBuffer(), expectedBuilder.TakeBuffer());
+}
+
+// Overload for std::initializer_list to not get "template argument deduction failed" when calling
+// `IsGeneratedCommandsListEqualTo(cluster, {...})`
+template <typename T = const CommandId>
+bool IsGeneratedCommandsListEqualTo(app::ServerClusterInterface & cluster, std::initializer_list<T> expected)
+{
+    return IsGeneratedCommandsListEqualTo<std::initializer_list<T>>(cluster, expected);
+}
 
 } // namespace Testing
 } // namespace chip

src/app/server-cluster/testing/ValidateGlobalAttributes.h

@@ -43,6 +43,9 @@ inline constexpr NullOptionalType NullOptional{};
 /**
  * Pairs an object with a boolean value to determine if the object value
  * is actually valid or not.
+ *
+ * @note Despite the `constexpr` keywords throughout the class, this class is not a literal type and thus cannot be used in
+ * compile-time contexts. This is mainly because of the use of placement new.
  */
 template <class T>
 class Optional

src/lib/core/Optional.h

@@ -70,7 +70,7 @@ class BitFlags
      *
      * @param other     Flag(s) to set. Any flags not set in @a other are unaffected.
      */
-    BitFlags & Set(const BitFlags & other)
+    constexpr BitFlags & Set(const BitFlags & other)
     {
         mValue |= other.mValue;
         return *this;
@@ -144,7 +144,7 @@ class BitFlags
      * @note            Flags passed need not be set; this test only requires that no *other* flags be set.
      */
     template <typename... Args>
-    bool HasOnly(Args &&... args) const
+    constexpr bool HasOnly(Args &&... args) const
     {
         return (mValue & Or(std::forward<Args>(args)...)) == mValue;
     }
@@ -157,7 +157,7 @@ class BitFlags
      *                  False if any given flag is not set.
      */
     template <typename... Args>
-    bool HasAll(Args &&... args) const
+    constexpr bool HasAll(Args &&... args) const
     {
         const IntegerType all = Or(std::forward<Args>(args)...);
         return (mValue & all) == all;
@@ -171,7 +171,7 @@ class BitFlags
      *                  False if all given flags are not set.
      */
     template <typename... Args>
-    bool HasAny(Args &&... args) const
+    constexpr bool HasAny(Args &&... args) const
     {
         return (mValue & Or(std::forward<Args>(args)...)) != 0;
     }

src/lib/support/BitFlags.h

@@ -38,8 +38,8 @@ class BitMask : public BitFlags<FlagsEnum, StorageType>
     constexpr BitMask(BitFlags<FlagsEnum, StorageType> && other) : BitFlags<FlagsEnum, StorageType>(std::move(other)) {}
     BitMask(const BitMask &) = default;
 
-    explicit BitMask(FlagsEnum value) : BitFlags<FlagsEnum, StorageType>(value) {}
-    explicit BitMask(IntegerType value) : BitFlags<FlagsEnum, StorageType>(value) {}
+    constexpr explicit BitMask(FlagsEnum value) : BitFlags<FlagsEnum, StorageType>(value) {}
+    constexpr explicit BitMask(IntegerType value) : BitFlags<FlagsEnum, StorageType>(value) {}
 
     template <typename... Args>
     constexpr BitMask(FlagsEnum flag, Args &&... args) : BitFlags<FlagsEnum, StorageType>(flag, std::forward<Args>(args)...)