uwb(uci-rust): Wait for CLOSE_CPLT HAL event for deinitializing am: c957526570 am: 6eac479397

Original change: https://googleplex-android-review.googlesource.com/c/platform/external/uwb/+/17751459

Change-Id: Ide886b565a877410e8a7529fb91641a4069dacce
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

2 files changed, 353 insertions, 358 deletions

diff --git a/src/fuzz/fuzzer.rs b/src/fuzz/fuzzer.rs
index 24accc3..a34b560 100644
--- a/src/fuzz/fuzzer.rs
+++ b/src/fuzz/fuzzer.rs
@@ -226,7 +226,6 @@ fn consume_command(msgs: Vec<JNICommand>) -> Result<(), UwbErr> {
             }
         }
     }
-    mock_dispatcher.exit();
     Ok(())
 }
 
diff --git a/src/rust/uci/mod.rs b/src/rust/uci/mod.rs
index 15c28dc..120459d 100644
--- a/src/rust/uci/mod.rs
+++ b/src/rust/uci/mod.rs
@@ -92,7 +92,6 @@ pub enum JNICommand {
     // Non blocking commands
     Enable,
     Disable(bool),
-    Exit,
 }
 
 // Responses from the HAL.
@@ -298,14 +297,6 @@ impl<T: EventManager> Driver<T> {
             JNICommand::UciDeviceReset { reset_config } => {
                 uci_hmsgs::build_device_reset_cmd(reset_config)?.build().into()
             }
-            JNICommand::Disable(_graceful) => {
-                self.adaptation.hal_close().await?;
-                self.set_state(UwbState::W4HalClose);
-                tx.send(UciResponse::DisableRsp).unwrap_or_else(|_| {
-                    error!("Unable to send response, receiver gone");
-                });
-                return Ok(());
-            }
             _ => {
                 error!("Unexpected blocking cmd received {:?}", cmd);
                 return Ok(());
@@ -329,8 +320,9 @@ impl<T: EventManager> Driver<T> {
                 self.adaptation.core_initialization().await?;
                 self.set_state(UwbState::W4HalOpen);
             }
-            JNICommand::Exit => {
-                return Err(UwbErr::Exit);
+            JNICommand::Disable(_graceful) => {
+                self.adaptation.hal_close().await?;
+                self.set_state(UwbState::W4HalClose);
             }
             _ => {
                 error!("Unexpected non blocking cmd received {:?}", cmd);
@@ -406,6 +398,7 @@ impl<T: EventManager> Driver<T> {
                             }
                             UwbEvent::CLOSE_CPLT => {
                                 self.set_state(UwbState::None);
+                                return Err(UwbErr::Exit);
                             }
                             UwbEvent::ERROR => {
                                 // Send device status notification with error state.
@@ -465,7 +458,7 @@ impl<T: EventManager> Driver<T> {
 pub trait Dispatcher {
     fn send_jni_command(&self, cmd: JNICommand) -> Result<()>;
     fn block_on_jni_command(&self, cmd: JNICommand) -> Result<UciResponse>;
-    fn exit(&mut self) -> Result<()>;
+    fn wait_for_exit(&mut self) -> Result<()>;
     fn get_device_info(&self) -> &Option<GetDeviceInfoRspPacket>;
     fn set_device_info(&mut self, device_info: Option<GetDeviceInfoRspPacket>);
 }
@@ -535,8 +528,7 @@ impl Dispatcher for DispatcherImpl {
         Ok(ret)
     }
 
-    fn exit(&mut self) -> Result<()> {
-        self.send_jni_command(JNICommand::Exit)?;
+    fn wait_for_exit(&mut self) -> Result<()> {
         match self.runtime.block_on(&mut self.join_handle) {
             Err(err) if err.is_panic() => {
                 error!("Driver thread is panic!");
@@ -568,32 +560,9 @@ mod tests {
     use num_traits::ToPrimitive;
     use uwb_uci_packets::*;
 
-    fn setup_dispatcher(
-        config_fn: fn(&mut Arc<MockUwbAdaptation>, &mut MockEventManager),
-    ) -> Result<DispatcherImpl> {
-        // TODO: Remove this once we call it somewhere real.
-        logger::init(
-            logger::Config::default()
-                .with_tag_on_device("uwb_test")
-                .with_min_level(log::Level::Debug),
-        );
-
-        let (rsp_sender, rsp_receiver) = mpsc::unbounded_channel::<HalCallback>();
-        let mut mock_adaptation = Arc::new(MockUwbAdaptation::new(rsp_sender));
-        let mut mock_event_manager = MockEventManager::new();
-
-        config_fn(&mut mock_adaptation, &mut mock_event_manager);
-
-        DispatcherImpl::new_for_testing(
-            mock_event_manager,
-            mock_adaptation as SyncUwbAdaptation,
-            rsp_receiver,
-        )
-    }
-
     fn setup_dispatcher_and_return_hal_cb_sender(
         config_fn: fn(&mut Arc<MockUwbAdaptation>, &mut MockEventManager),
-    ) -> Result<(DispatcherImpl, mpsc::UnboundedSender<HalCallback>)> {
+    ) -> (DispatcherImpl, mpsc::UnboundedSender<HalCallback>) {
         // TODO: Remove this once we call it somewhere real.
         logger::init(
             logger::Config::default().with_tag_on_device("uwb").with_min_level(log::Level::Debug),
@@ -608,8 +577,9 @@ mod tests {
             mock_event_manager,
             mock_adaptation as SyncUwbAdaptation,
             rsp_receiver,
-        )?;
-        Ok((dispatcher, rsp_sender))
+        )
+        .unwrap();
+        (dispatcher, rsp_sender)
     }
 
     fn generate_fake_get_device_cmd_rsp() -> (GetDeviceInfoCmdPacket, GetDeviceInfoRspPacket) {
@@ -631,400 +601,426 @@ mod tests {
     }
 
     #[test]
-    fn test_initialize() -> Result<()> {
-        let mut dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            mock_adaptation.expect_hal_open(Ok(()));
-            mock_adaptation.expect_core_initialization(Ok(()));
-        })?;
-
-        dispatcher.send_jni_command(JNICommand::Enable)?;
-        dispatcher.exit()
+    fn test_initialize() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                mock_adaptation.expect_hal_open(Ok(()));
+                mock_adaptation.expect_core_initialization(Ok(()));
+            });
+
+        dispatcher.send_jni_command(JNICommand::Enable).unwrap();
     }
 
     #[test]
-    fn test_hal_error_event() -> Result<()> {
-        let (mut dispatcher, hal_sender) =
+    fn test_hal_error_event() {
+        let (dispatcher, hal_sender) =
             setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, mock_event_manager| {
                 mock_adaptation.expect_hal_open(Ok(()));
                 mock_adaptation.expect_core_initialization(Ok(()));
                 mock_event_manager.expect_device_status_notification_received(Ok(()));
-            })?;
+            });
 
-        dispatcher.send_jni_command(JNICommand::Enable)?;
+        dispatcher.send_jni_command(JNICommand::Enable).unwrap();
         hal_sender
             .send(HalCallback::Event { event: UwbEvent::ERROR, event_status: UwbStatus::FAILED })
             .unwrap();
-        dispatcher.exit()
     }
 
     #[test]
-    fn test_deinitialize() -> Result<()> {
-        let mut dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            mock_adaptation.expect_hal_close(Ok(()));
-        })?;
+    fn test_deinitialize() {
+        let (mut dispatcher, hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                mock_adaptation.expect_hal_close(Ok(()));
+            });
 
-        dispatcher.block_on_jni_command(JNICommand::Disable(true))?;
-        dispatcher.exit()
+        dispatcher.send_jni_command(JNICommand::Disable(true)).unwrap();
+        hal_sender
+            .send(HalCallback::Event { event: UwbEvent::CLOSE_CPLT, event_status: UwbStatus::OK })
+            .unwrap();
+        dispatcher.wait_for_exit().unwrap();
     }
 
     #[test]
-    fn test_get_device_info() -> Result<()> {
-        let mut dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let (cmd, rsp) = generate_fake_get_device_cmd_rsp();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::GetDeviceInfoRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciGetDeviceInfo)?;
-        dispatcher.exit()
+    fn test_get_device_info() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let (cmd, rsp) = generate_fake_get_device_cmd_rsp();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::GetDeviceInfoRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciGetDeviceInfo).unwrap();
     }
 
     #[test]
-    fn test_get_device_info_with_uci_retry() -> Result<()> {
-        let mut dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let (cmd, rsp) = generate_fake_get_device_cmd_rsp();
-
-            // Let the first 2 tries not response data, then the 3rd tries response successfully.
-            mock_adaptation.expect_send_uci_message(cmd.clone().into(), None, None, Ok(()));
-            mock_adaptation.expect_send_uci_message(cmd.clone().into(), None, None, Ok(()));
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::GetDeviceInfoRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciGetDeviceInfo)?;
-        dispatcher.exit()
+    fn test_get_device_info_with_uci_retry() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let (cmd, rsp) = generate_fake_get_device_cmd_rsp();
+
+                // Let the first 2 tries not response data, then the 3rd tries response successfully.
+                mock_adaptation.expect_send_uci_message(cmd.clone().into(), None, None, Ok(()));
+                mock_adaptation.expect_send_uci_message(cmd.clone().into(), None, None, Ok(()));
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::GetDeviceInfoRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciGetDeviceInfo).unwrap();
     }
 
     #[test]
-    fn test_get_device_info_send_uci_message_failed() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let (cmd, _rsp) = generate_fake_get_device_cmd_rsp();
-            mock_adaptation.expect_send_uci_message(cmd.into(), None, None, Err(UwbErr::failed()));
-        })?;
+    fn test_get_device_info_send_uci_message_failed() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let (cmd, _rsp) = generate_fake_get_device_cmd_rsp();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    None,
+                    None,
+                    Err(UwbErr::failed()),
+                );
+            });
 
         dispatcher
             .block_on_jni_command(JNICommand::UciGetDeviceInfo)
             .expect_err("This method should fail.");
-        Ok(())
     }
 
     #[test]
-    fn test_device_status_notification() -> Result<()> {
-        let mut dispatcher = setup_dispatcher(|mock_adaptation, mock_event_manager| {
-            let (cmd, rsp) = generate_fake_get_device_cmd_rsp();
-            let ntf = generate_fake_device_status_ntf();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::GetDeviceInfoRsp(rsp)),
-                Some(UciNotification::DeviceStatusNtf(ntf)),
-                Ok(()),
-            );
-            mock_event_manager.expect_device_status_notification_received(Ok(()));
-        })?;
+    fn test_device_status_notification() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, mock_event_manager| {
+                let (cmd, rsp) = generate_fake_get_device_cmd_rsp();
+                let ntf = generate_fake_device_status_ntf();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::GetDeviceInfoRsp(rsp)),
+                    Some(UciNotification::DeviceStatusNtf(ntf)),
+                    Ok(()),
+                );
+                mock_event_manager.expect_device_status_notification_received(Ok(()));
+            });
 
-        dispatcher.block_on_jni_command(JNICommand::UciGetDeviceInfo)?;
-        dispatcher.exit()
+        dispatcher.block_on_jni_command(JNICommand::UciGetDeviceInfo).unwrap();
     }
 
     #[test]
-    fn test_get_caps_info() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = GetCapsInfoCmdBuilder {}.build();
-            let rsp =
-                GetCapsInfoRspBuilder { status: StatusCode::UciStatusOk, tlvs: Vec::new() }.build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::GetCapsInfoRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciGetCapsInfo)?;
-        Ok(())
+    fn test_get_caps_info() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = GetCapsInfoCmdBuilder {}.build();
+                let rsp =
+                    GetCapsInfoRspBuilder { status: StatusCode::UciStatusOk, tlvs: Vec::new() }
+                        .build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::GetCapsInfoRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciGetCapsInfo).unwrap();
     }
 
     #[test]
-    fn test_session_init() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = SessionInitCmdBuilder {
-                session_id: 1,
-                session_type: SessionType::FiraRangingSession,
-            }
-            .build();
-            let rsp = SessionInitRspBuilder { status: StatusCode::UciStatusOk }.build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::SessionInitRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
+    fn test_session_init() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = SessionInitCmdBuilder {
+                    session_id: 1,
+                    session_type: SessionType::FiraRangingSession,
+                }
+                .build();
+                let rsp = SessionInitRspBuilder { status: StatusCode::UciStatusOk }.build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::SessionInitRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
 
-        dispatcher.block_on_jni_command(JNICommand::UciSessionInit(
-            1,
-            SessionType::FiraRangingSession.to_u8().unwrap(),
-        ))?;
-        Ok(())
+        dispatcher
+            .block_on_jni_command(JNICommand::UciSessionInit(
+                1,
+                SessionType::FiraRangingSession.to_u8().unwrap(),
+            ))
+            .unwrap();
     }
 
     #[test]
-    fn test_session_deinit() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = SessionDeinitCmdBuilder { session_id: 1 }.build();
-            let rsp = SessionDeinitRspBuilder { status: StatusCode::UciStatusOk }.build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::SessionDeinitRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciSessionDeinit(1))?;
-        Ok(())
+    fn test_session_deinit() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = SessionDeinitCmdBuilder { session_id: 1 }.build();
+                let rsp = SessionDeinitRspBuilder { status: StatusCode::UciStatusOk }.build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::SessionDeinitRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciSessionDeinit(1)).unwrap();
     }
 
     #[test]
-    fn test_session_get_count() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = SessionGetCountCmdBuilder {}.build();
-            let rsp =
-                SessionGetCountRspBuilder { status: StatusCode::UciStatusOk, session_count: 5 }
-                    .build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::SessionGetCountRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciSessionGetCount)?;
-        Ok(())
+    fn test_session_get_count() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = SessionGetCountCmdBuilder {}.build();
+                let rsp =
+                    SessionGetCountRspBuilder { status: StatusCode::UciStatusOk, session_count: 5 }
+                        .build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::SessionGetCountRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciSessionGetCount).unwrap();
     }
 
     #[test]
-    fn test_start_range() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = RangeStartCmdBuilder { session_id: 5 }.build();
-            let rsp = RangeStartRspBuilder { status: StatusCode::UciStatusOk }.build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::RangeStartRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciStartRange(5))?;
-        Ok(())
+    fn test_start_range() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = RangeStartCmdBuilder { session_id: 5 }.build();
+                let rsp = RangeStartRspBuilder { status: StatusCode::UciStatusOk }.build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::RangeStartRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciStartRange(5)).unwrap();
     }
 
     #[test]
-    fn test_stop_range() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = RangeStopCmdBuilder { session_id: 5 }.build();
-            let rsp = RangeStopRspBuilder { status: StatusCode::UciStatusOk }.build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::RangeStopRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciStopRange(5))?;
-        Ok(())
+    fn test_stop_range() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = RangeStopCmdBuilder { session_id: 5 }.build();
+                let rsp = RangeStopRspBuilder { status: StatusCode::UciStatusOk }.build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::RangeStopRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciStopRange(5)).unwrap();
     }
 
     #[test]
-    fn test_get_session_state() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = SessionGetStateCmdBuilder { session_id: 5 }.build();
-            let rsp = SessionGetStateRspBuilder {
-                status: StatusCode::UciStatusOk,
-                session_state: SessionState::SessionStateActive,
-            }
-            .build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::SessionGetStateRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciGetSessionState(5))?;
-        Ok(())
+    fn test_get_session_state() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = SessionGetStateCmdBuilder { session_id: 5 }.build();
+                let rsp = SessionGetStateRspBuilder {
+                    status: StatusCode::UciStatusOk,
+                    session_state: SessionState::SessionStateActive,
+                }
+                .build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::SessionGetStateRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciGetSessionState(5)).unwrap();
     }
 
     #[test]
-    fn test_session_update_multicast_list() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = SessionUpdateControllerMulticastListCmdBuilder {
+    fn test_session_update_multicast_list() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = SessionUpdateControllerMulticastListCmdBuilder {
+                    session_id: 5,
+                    action: UpdateMulticastListAction::AddControlee,
+                    controlees: Vec::new(),
+                }
+                .build();
+                let rsp = SessionUpdateControllerMulticastListRspBuilder {
+                    status: StatusCode::UciStatusOk,
+                }
+                .build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::SessionUpdateControllerMulticastListRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher
+            .block_on_jni_command(JNICommand::UciSessionUpdateMulticastList {
                 session_id: 5,
-                action: UpdateMulticastListAction::AddControlee,
-                controlees: Vec::new(),
-            }
-            .build();
-            let rsp =
-                SessionUpdateControllerMulticastListRspBuilder { status: StatusCode::UciStatusOk }
-                    .build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::SessionUpdateControllerMulticastListRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciSessionUpdateMulticastList {
-            session_id: 5,
-            action: UpdateMulticastListAction::AddControlee.to_u8().unwrap(),
-            no_of_controlee: 0,
-            address_list: Vec::new(),
-            sub_session_id_list: Vec::new(),
-        })?;
-        Ok(())
+                action: UpdateMulticastListAction::AddControlee.to_u8().unwrap(),
+                no_of_controlee: 0,
+                address_list: Vec::new(),
+                sub_session_id_list: Vec::new(),
+            })
+            .unwrap();
     }
 
     #[test]
-    fn test_set_country_code() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = AndroidSetCountryCodeCmdBuilder { country_code: [45, 34] }.build();
-            let rsp = AndroidSetCountryCodeRspBuilder { status: StatusCode::UciStatusOk }.build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::AndroidSetCountryCodeRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
+    fn test_set_country_code() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = AndroidSetCountryCodeCmdBuilder { country_code: [45, 34] }.build();
+                let rsp =
+                    AndroidSetCountryCodeRspBuilder { status: StatusCode::UciStatusOk }.build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::AndroidSetCountryCodeRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
 
-        dispatcher.block_on_jni_command(JNICommand::UciSetCountryCode { code: vec![45, 34] })?;
-        Ok(())
+        dispatcher
+            .block_on_jni_command(JNICommand::UciSetCountryCode { code: vec![45, 34] })
+            .unwrap();
     }
 
     #[test]
-    fn test_set_app_config() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = SessionSetAppConfigCmdBuilder { session_id: 5, tlvs: Vec::new() }.build();
-            let rsp = SessionSetAppConfigRspBuilder {
-                status: StatusCode::UciStatusOk,
-                cfg_status: Vec::new(),
-            }
-            .build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::SessionSetAppConfigRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciSetAppConfig {
-            session_id: 5,
-            no_of_params: 0,
-            app_config_param_len: 0,
-            app_configs: Vec::new(),
-        })?;
-        Ok(())
-    }
+    fn test_set_app_config() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = SessionSetAppConfigCmdBuilder { session_id: 5, tlvs: Vec::new() }.build();
+                let rsp = SessionSetAppConfigRspBuilder {
+                    status: StatusCode::UciStatusOk,
+                    cfg_status: Vec::new(),
+                }
+                .build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::SessionSetAppConfigRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
 
-    #[test]
-    fn test_get_app_config() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = SessionGetAppConfigCmdBuilder { session_id: 5, app_cfg: Vec::new() }.build();
-            let rsp =
-                SessionGetAppConfigRspBuilder { status: StatusCode::UciStatusOk, tlvs: Vec::new() }
-                    .build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::SessionGetAppConfigRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
-
-        dispatcher.block_on_jni_command(JNICommand::UciGetAppConfig {
-            session_id: 5,
-            no_of_params: 0,
-            app_config_param_len: 0,
-            app_configs: Vec::new(),
-        })?;
-        Ok(())
+        dispatcher
+            .block_on_jni_command(JNICommand::UciSetAppConfig {
+                session_id: 5,
+                no_of_params: 0,
+                app_config_param_len: 0,
+                app_configs: Vec::new(),
+            })
+            .unwrap();
     }
 
     #[test]
-    fn test_raw_vendor_cmd() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = UciVendor_9_CommandBuilder { opcode: 5, payload: None }.build();
-            let rsp = UciVendor_9_ResponseBuilder { opcode: 5, payload: None }.build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::RawVendorRsp(rsp.into())),
-                None,
-                Ok(()),
-            );
-        })?;
+    fn test_get_app_config() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd =
+                    SessionGetAppConfigCmdBuilder { session_id: 5, app_cfg: Vec::new() }.build();
+                let rsp = SessionGetAppConfigRspBuilder {
+                    status: StatusCode::UciStatusOk,
+                    tlvs: Vec::new(),
+                }
+                .build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::SessionGetAppConfigRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
 
-        dispatcher.block_on_jni_command(JNICommand::UciRawVendorCmd {
-            gid: 9,
-            oid: 5,
-            payload: Vec::new(),
-        })?;
-        Ok(())
+        dispatcher
+            .block_on_jni_command(JNICommand::UciGetAppConfig {
+                session_id: 5,
+                no_of_params: 0,
+                app_config_param_len: 0,
+                app_configs: Vec::new(),
+            })
+            .unwrap();
     }
 
     #[test]
-    fn test_device_reset() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = DeviceResetCmdBuilder { reset_config: ResetConfig::UwbsReset }.build();
-            let rsp = DeviceResetRspBuilder { status: StatusCode::UciStatusOk }.build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::DeviceResetRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
+    fn test_raw_vendor_cmd() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = UciVendor_9_CommandBuilder { opcode: 5, payload: None }.build();
+                let rsp = UciVendor_9_ResponseBuilder { opcode: 5, payload: None }.build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::RawVendorRsp(rsp.into())),
+                    None,
+                    Ok(()),
+                );
+            });
 
-        dispatcher.block_on_jni_command(JNICommand::UciDeviceReset { reset_config: 0 })?;
-        Ok(())
+        dispatcher
+            .block_on_jni_command(JNICommand::UciRawVendorCmd {
+                gid: 9,
+                oid: 5,
+                payload: Vec::new(),
+            })
+            .unwrap();
     }
 
     #[test]
-    fn test_get_power_stats() -> Result<()> {
-        let dispatcher = setup_dispatcher(|mock_adaptation, _mock_event_manager| {
-            let cmd = AndroidGetPowerStatsCmdBuilder {}.build();
-            let rsp = AndroidGetPowerStatsRspBuilder {
-                stats: PowerStats {
-                    status: StatusCode::UciStatusOk,
-                    idle_time_ms: 0,
-                    tx_time_ms: 0,
-                    rx_time_ms: 0,
-                    total_wake_count: 0,
-                },
-            }
-            .build();
-            mock_adaptation.expect_send_uci_message(
-                cmd.into(),
-                Some(UciResponse::AndroidGetPowerStatsRsp(rsp)),
-                None,
-                Ok(()),
-            );
-        })?;
+    fn test_device_reset() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = DeviceResetCmdBuilder { reset_config: ResetConfig::UwbsReset }.build();
+                let rsp = DeviceResetRspBuilder { status: StatusCode::UciStatusOk }.build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::DeviceResetRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciDeviceReset { reset_config: 0 }).unwrap();
+    }
 
-        dispatcher.block_on_jni_command(JNICommand::UciGetPowerStats)?;
-        Ok(())
+    #[test]
+    fn test_get_power_stats() {
+        let (dispatcher, _hal_sender) =
+            setup_dispatcher_and_return_hal_cb_sender(|mock_adaptation, _mock_event_manager| {
+                let cmd = AndroidGetPowerStatsCmdBuilder {}.build();
+                let rsp = AndroidGetPowerStatsRspBuilder {
+                    stats: PowerStats {
+                        status: StatusCode::UciStatusOk,
+                        idle_time_ms: 0,
+                        tx_time_ms: 0,
+                        rx_time_ms: 0,
+                        total_wake_count: 0,
+                    },
+                }
+                .build();
+                mock_adaptation.expect_send_uci_message(
+                    cmd.into(),
+                    Some(UciResponse::AndroidGetPowerStatsRsp(rsp)),
+                    None,
+                    Ok(()),
+                );
+            });
+
+        dispatcher.block_on_jni_command(JNICommand::UciGetPowerStats).unwrap();
     }
 }