uic: zpc: UIC-3488: Allow to specify manually bitmask's size we want to parse

(cherry picked from commit 839f66f80c11c41663f601361a57f99fc12b0df9)
Forwarded: #11
Signed-off-by: Philippe Coval <philippe.coval@silabs.com>

Author: silabs-borisl

applications/zpc/components/zpc_attribute_store/include/zwave_frame_parser.hpp

@@ -250,12 +250,14 @@ class zwave_frame_parser
    * 
    * @note Calling this function will read the current value in the frame (starting index = 2) and increment it.
    * 
+   * @param bitmask_length The size of the bitmask to read. If 0, the function will read the first byte to determine the size. Accepted values : 0...4 
+   * 
    * @exception std::out_of_range if the current index is out of range
    * @exception std::invalid_argument if bitmask length is greater than 4
    * 
    * @return The bitmask read from the frame
    */
-  zwave_report_bitmask_t read_bitmask();
+  zwave_report_bitmask_t read_bitmask(uint8_t bitmask_length = 0);
 
   /**
    * @brief Read a bitmask (adaptive size) from the frame and store it in the attribute store
@@ -272,14 +274,16 @@ class zwave_frame_parser
    * @note Calling this function will read the current value in the frame (starting index = 2) and increment it (to 1 + bitmask size)
    * 
    * @param node The node in the attribute store where to store the value.
+   * @param bitmask_length The size of the bitmask to read. If 0, the function will read the first byte to determine the size. Accepted values : 0...4 
    * 
    * @exception std::out_of_range if the current index is out of range
    * @exception std::invalid_argument if something goes wrong when storing the value in the attribute store
    * @exception std::invalid_argument if bitmask length is greater than 4
    * 
    * @return The bitmask read from the frame
    */
-  zwave_report_bitmask_t read_bitmask(attribute_store_node_t node);
+  zwave_report_bitmask_t read_bitmask(attribute_store_node_t node,
+                                      uint8_t bitmask_length = 0);
 
   /**
    * @brief Convenience function to read a string (ASCII) from the frame

applications/zpc/components/zpc_attribute_store/src/zwave_frame_parser.cpp

@@ -71,12 +71,23 @@ uint8_t zwave_frame_parser::read_byte(attribute_store_node_t node)
   return value;
 }
 
-zwave_report_bitmask_t zwave_frame_parser::read_bitmask()
+zwave_report_bitmask_t zwave_frame_parser::read_bitmask(uint8_t bitmask_length)
 {
   constexpr uint8_t SUPPORT_BITMASK_SIZE = sizeof(zwave_report_bitmask_t);
   constexpr uint8_t BITMASK_SIZE         = SUPPORT_BITMASK_SIZE * 8;
 
-  uint8_t bitmask_length                    = this->read_byte();
+  if (bitmask_length > BITMASK_SIZE) {
+    sl_log_critical(LOG_TAG,
+                    "Invalid bitmask size in read_bitmask, must be less than or equal to %d",
+                    SUPPORT_BITMASK_SIZE);
+    throw std::runtime_error("Critical error in read_bitmask. This should not happen.");
+  }
+
+  // Read the first byte if the length is not provided
+  if (bitmask_length == 0) {
+    bitmask_length = read_byte();
+  }
+
   std::bitset<BITMASK_SIZE> support_bitmask = 0;
 
   if (bitmask_length > SUPPORT_BITMASK_SIZE) {
@@ -100,9 +111,10 @@ zwave_report_bitmask_t zwave_frame_parser::read_bitmask()
 }
 
 zwave_report_bitmask_t
-  zwave_frame_parser::read_bitmask(attribute_store_node_t node)
+  zwave_frame_parser::read_bitmask(attribute_store_node_t node,
+                                   uint8_t bitmask_length)
 {
-  zwave_report_bitmask_t value = read_bitmask();
+  zwave_report_bitmask_t value = read_bitmask(bitmask_length);
 
   // Store value if applicable
   helper_store_value(node, value);
@@ -118,7 +130,7 @@ zwave_frame_parser::zwave_parser_bitmask_result
 
   if (!bitmask_data.empty()) {
     uint8_t value_from_frame = read_byte();
-    
+
     for (const auto &current_bitmask: bitmask_data) {
       // Extract value
       uint8_t current_value = current_bitmask.bitmask & value_from_frame;

applications/zpc/components/zpc_attribute_store/test/zwave_frame_parser_test.cpp

@@ -548,6 +548,23 @@ void test_read_bitmask_no_attribute_happy_case()
                             "Should be able to read support bitmask value");
 }
 
+void test_read_bitmask_no_attribute_with_size_happy_case()
+{
+  const uint8_t tested_frame[] = {0x01, 0x02, 0xFF, 0x02, 0x12};
+  uint8_t expected_frame_size  = sizeof(tested_frame);
+
+  zwave_frame_parser parser(tested_frame, expected_frame_size);
+
+  // Read first value
+  zwave_report_bitmask_t reported_value
+    = parser.read_bitmask(static_cast<uint8_t>(3));
+  zwave_report_bitmask_t tested_value = 0x1202FF;
+
+  TEST_ASSERT_EQUAL_MESSAGE(tested_value,
+                            reported_value,
+                            "Should be able to read support bitmask value");
+}
+
 void test_read_bitmask_attribute_happy_case()
 {
   const uint8_t tested_frame[] = {0x01, 0x02, 3, 0x12, 0xFF, 0x02};
@@ -574,6 +591,33 @@ void test_read_bitmask_attribute_happy_case()
     "Value on node should match the returned value");
 }
 
+void test_read_bitmask_attribute_given_size_happy_case()
+{
+  const uint8_t tested_frame[] = {0x01, 0x02, 0x12, 0xFF, 0x02, 0x15};
+  uint8_t expected_frame_size  = sizeof(tested_frame);
+
+  zwave_frame_parser parser(tested_frame, expected_frame_size);
+
+  // Any nodes that have the right type (zwave_report_bitmask_t) and under endpoint_id will do the trick here
+  attribute_store::attribute endpoint_id_node_cpp(endpoint_id_node);
+  auto bitmask_node = endpoint_id_node_cpp.add_node(
+    ATTRIBUTE_COMMAND_CLASS_THERMOSTAT_SUPPORTED_MODES);
+
+  // Read first value
+  zwave_report_bitmask_t reported_value
+    = parser.read_bitmask(bitmask_node, static_cast<uint8_t>(4));
+  zwave_report_bitmask_t tested_value = 0x1502FF12;
+
+  TEST_ASSERT_EQUAL_MESSAGE(tested_value,
+                            reported_value,
+                            "Should be able to read support bitmask value");
+
+  TEST_ASSERT_EQUAL_MESSAGE(
+    tested_value,
+    bitmask_node.get<zwave_report_bitmask_t>(REPORTED_ATTRIBUTE),
+    "Value on node should match the returned value");
+}
+
 void test_read_bitmask_value_too_big()
 {
   const uint8_t tested_frame[] = {0x01, 0x02, 5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
@@ -586,6 +630,18 @@ void test_read_bitmask_value_too_big()
                                 "a support bitmask value that is too big");
 }
 
+void test_read_bitmask_specified_value_too_big()
+{
+  const uint8_t tested_frame[] = {0x01, 0x02, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+
+  uint8_t expected_frame_size = sizeof(tested_frame);
+  zwave_frame_parser parser(tested_frame, expected_frame_size);
+
+  TEST_ASSERT_EXCEPTION_MESSAGE(parser.read_bitmask(static_cast<uint8_t>(5)),
+                                "Should throw an exception when trying to read "
+                                "a support bitmask value that is too big");
+}
+
 void test_read_string_no_attribute_happy_case()
 {
   const uint8_t tested_frame[] = {0x01, 0x02, 5, 'D', 'o', 'U', 'z', 'E'};