tests: Add tests for timed invoke

Author: kedars

matter/tests/common/commands.rs

@@ -0,0 +1,98 @@
+/*
+ *
+ *    Copyright (c) 2023 Project CHIP Authors
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+
+use matter::{
+    data_model::objects::EncodeValue,
+    interaction_model::{
+        messages::ib::{CmdPath, CmdStatus, InvResp},
+        messages::msg,
+    },
+};
+
+pub enum ExpectedInvResp {
+    Cmd(CmdPath, u8),
+    Status(CmdStatus),
+}
+
+pub fn assert_inv_response(resp: &msg::InvResp, expected: &[ExpectedInvResp]) {
+    let mut index = 0;
+    for inv_response in resp.inv_responses.unwrap().iter() {
+        println!("Validating index {}", index);
+        match expected[index] {
+            ExpectedInvResp::Cmd(e_c, e_d) => match inv_response {
+                InvResp::Cmd(c) => {
+                    assert_eq!(e_c, c.path);
+                    match c.data {
+                        EncodeValue::Tlv(t) => {
+                            assert_eq!(e_d, t.find_tag(0).unwrap().u8().unwrap())
+                        }
+                        _ => panic!("Incorrect CmdDataType"),
+                    }
+                }
+                _ => {
+                    panic!("Invalid response, expected InvResponse::Cmd");
+                }
+            },
+            ExpectedInvResp::Status(e_status) => match inv_response {
+                InvResp::Status(status) => {
+                    assert_eq!(e_status, status);
+                }
+                _ => {
+                    panic!("Invalid response, expected InvResponse::Status");
+                }
+            },
+        }
+        println!("Index {} success", index);
+        index += 1;
+    }
+    assert_eq!(index, expected.len());
+}
+
+#[macro_export]
+macro_rules! cmd_data {
+    ($path:ident, $data:literal) => {
+        CmdData::new($path, EncodeValue::Value(&($data as u32)))
+    };
+}
+
+#[macro_export]
+macro_rules! echo_req {
+    ($endpoint:literal, $data:literal) => {
+        CmdData::new(
+            CmdPath::new(
+                Some($endpoint),
+                Some(echo_cluster::ID),
+                Some(echo_cluster::Commands::EchoReq as u16),
+            ),
+            EncodeValue::Value(&($data as u32)),
+        )
+    };
+}
+
+#[macro_export]
+macro_rules! echo_resp {
+    ($endpoint:literal, $data:literal) => {
+        ExpectedInvResp::Cmd(
+            CmdPath::new(
+                Some($endpoint),
+                Some(echo_cluster::ID),
+                Some(echo_cluster::Commands::EchoResp as u16),
+            ),
+            $data,
+        )
+    };
+}

matter/tests/common/mod.rs

@@ -16,5 +16,6 @@
  */
 
 pub mod attributes;
+pub mod commands;
 pub mod echo_cluster;
 pub mod im_engine;

matter/tests/data_model/commands.rs

@@ -15,26 +15,25 @@
  *    limitations under the License.
  */
 
+use crate::{
+    cmd_data,
+    common::{commands::*, echo_cluster, im_engine::im_engine},
+    echo_req, echo_resp,
+};
+
 use matter::{
     data_model::{cluster_on_off, objects::EncodeValue},
     interaction_model::{
         core::{IMStatusCode, OpCode},
-        messages::msg,
         messages::{
-            ib::{CmdData, CmdPath, CmdStatus, InvResp},
+            ib::{CmdData, CmdPath, CmdStatus},
+            msg,
             msg::InvReq,
         },
     },
     tlv::{self, FromTLV, TLVArray},
 };
 
-use crate::common::{echo_cluster, im_engine::im_engine};
-
-enum ExpectedInvResp {
-    Cmd(CmdPath, u8),
-    Status(CmdStatus),
-}
-
 // Helper for handling Invoke Command sequences
 fn handle_commands(input: &[CmdData], expected: &[ExpectedInvResp]) {
     let mut out_buf = [0u8; 400];
@@ -47,71 +46,8 @@ fn handle_commands(input: &[CmdData], expected: &[ExpectedInvResp]) {
     let (_, _, out_buf) = im_engine(OpCode::InvokeRequest, &req, &mut out_buf);
     tlv::print_tlv_list(out_buf);
     let root = tlv::get_root_node_struct(out_buf).unwrap();
-
     let resp = msg::InvResp::from_tlv(&root).unwrap();
-    let mut index = 0;
-    for inv_response in resp.inv_responses.unwrap().iter() {
-        println!("Validating index {}", index);
-        match expected[index] {
-            ExpectedInvResp::Cmd(e_c, e_d) => match inv_response {
-                InvResp::Cmd(c) => {
-                    assert_eq!(e_c, c.path);
-                    match c.data {
-                        EncodeValue::Tlv(t) => {
-                            assert_eq!(e_d, t.find_tag(0).unwrap().u8().unwrap())
-                        }
-                        _ => panic!("Incorrect CmdDataType"),
-                    }
-                }
-                _ => {
-                    panic!("Invalid response, expected InvResponse::Cmd");
-                }
-            },
-            ExpectedInvResp::Status(e_status) => match inv_response {
-                InvResp::Status(status) => {
-                    assert_eq!(e_status, status);
-                }
-                _ => {
-                    panic!("Invalid response, expected InvResponse::Status");
-                }
-            },
-        }
-        println!("Index {} success", index);
-        index += 1;
-    }
-    assert_eq!(index, expected.len());
-}
-
-macro_rules! cmd_data {
-    ($path:ident, $data:literal) => {
-        CmdData::new($path, EncodeValue::Value(&($data as u32)))
-    };
-}
-
-macro_rules! echo_req {
-    ($endpoint:literal, $data:literal) => {
-        CmdData::new(
-            CmdPath::new(
-                Some($endpoint),
-                Some(echo_cluster::ID),
-                Some(echo_cluster::Commands::EchoReq as u16),
-            ),
-            EncodeValue::Value(&($data as u32)),
-        )
-    };
-}
-
-macro_rules! echo_resp {
-    ($endpoint:literal, $data:literal) => {
-        ExpectedInvResp::Cmd(
-            CmdPath::new(
-                Some($endpoint),
-                Some(echo_cluster::ID),
-                Some(echo_cluster::Commands::EchoResp as u16),
-            ),
-            $data,
-        )
-    };
+    assert_inv_response(&resp, expected)
 }
 
 #[test]