Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5d745396 authored by Rahul Arya's avatar Rahul Arya
Browse files

[Private GATT] Minor cleanup 

Based on code coverage results, removing unreachable code or adding
tests to untested code.

Bug: 255880936
Test: unit
Change-Id: Ib11c078927e3e5902ac58e2c120c3e7d5cc1175f
parent a7c28497

system/rust/src/gatt/server/att_server_bearer.rs

+5 −7
Original line number Diff line number Diff line
@@ -80,10 +80,10 @@ impl<T: AttDatabase + Clone + 'static> AttServerBearer<T> { 
        }

    }



    fn send_packet(&self, packet: impl Into<AttChild>) -> Result<(), SendError> {

    fn send_packet(&self, packet: impl Into<AttChild>) -> Result<(), SerializeError> {

        let child = packet.into();

        let packet = AttBuilder { opcode: HACK_child_to_opcode(&child), _child_: child };

        (self.send_packet)(packet).map_err(SendError::SerializeError)

        (self.send_packet)(packet)

    }

}
@@ -164,13 +164,10 @@ impl<T: AttDatabase + Clone + 'static> WeakBoxRef<'_, AttServerBearer<T>> { 
                                Ok(_) => {

                                    trace!("reply packet sent")

                                }

                                Err(SendError::ConnectionDropped) => {

                                    warn!("callback returned after disconnect");

                                }

                                Err(SendError::SerializeError(err)) => {

                                Err(err) => {

                                    error!("serializer failure {err:?}, dropping packet and sending failed reply");

                                    // if this also fails, we're stuck

                                    if let Err(SendError::SerializeError(err)) = this.send_packet(AttErrorResponseBuilder {

                                    if let Err(err) = this.send_packet(AttErrorResponseBuilder {

                                        opcode_in_error: packet.view().get_opcode(),

                                        handle_in_error: AttHandle(0).into(),

                                        error_code: AttErrorCode::UNLIKELY_ERROR,
@@ -203,6 +200,7 @@ impl<T: AttDatabase + Clone + 'static> WeakBox<AttServerBearer<T>> { 
                SendError::ConnectionDropped

            })?

            .send_packet(packet)

            .map_err(SendError::SerializeError)

        })

    }

}

system/rust/tests/gatt_callbacks_test.rs

+45 −0
Original line number Diff line number Diff line
@@ -250,3 +250,48 @@ fn test_response_timeout() { 
        assert!(time_slept < Duration::from_secs(16));

    });

}



#[test]

fn test_transaction_cleanup_after_timeout() {

    start_test(async {

        // arrange

        let (callback_manager, mut callbacks_rx) = initialize_manager_with_connection();



        // act: start an operation

        let cloned_manager = callback_manager.clone();

        let pending =

            spawn_local(async move { cloned_manager.read(CONN_ID, HANDLE_1, BACKING_TYPE).await });

        let trans_id = pull_trans_id(&mut callbacks_rx).await;

        // let it time out

        assert_eq!(pending.await.unwrap(), Err(AttErrorCode::UNLIKELY_ERROR));

        // try responding to it now

        let resp =

            callback_manager.send_response(CONN_ID, trans_id, Err(AttErrorCode::INVALID_HANDLE));



        // assert: the response failed

        assert_eq!(resp, Err(CallbackResponseError::NonExistentTransaction(trans_id)));

    });

}



#[test]

fn test_listener_hang_up() {

    start_test(async {

        // arrange

        let (callback_manager, mut callbacks_rx) = initialize_manager_with_connection();



        // act: start an operation

        let cloned_manager = callback_manager.clone();

        let pending =

            spawn_local(async move { cloned_manager.read(CONN_ID, HANDLE_1, BACKING_TYPE).await });

        let trans_id = pull_trans_id(&mut callbacks_rx).await;

        // cancel the listener, wait for it to stop

        pending.abort();

        pending.await.unwrap_err();

        // try responding to it now

        let resp =

            callback_manager.send_response(CONN_ID, trans_id, Err(AttErrorCode::INVALID_HANDLE));



        // assert: we get the expected error

        assert_eq!(resp, Err(CallbackResponseError::ListenerHungUp(trans_id)));

    });

}