add test for io sequence

Signed-off-by: uchouT <i@uchout.moe>

Author: uchouT

crates/ironrdp-testsuite-core/tests/rdpeusb/client.rs

@@ -18,17 +18,7 @@ use ironrdp_rdpeusb::pdu::{
     UrbdrcClientControlPdu, UrbdrcClientDevicePdu, UrbdrcServerControlPdu, UrbdrcServerDevicePdu,
 };
 
-use super::simple_device_info;
-
-const STREAM_ID_PROXY: u32 = 1;
-
-fn proxy_iface_id(iface: InterfaceId) -> u32 {
-    u32::from(iface) | (STREAM_ID_PROXY << 30)
-}
-
-fn encode_pdu<T: ironrdp_core::Encode>(pdu: &T) -> Vec<u8> {
-    encode_vec(pdu).expect("encode should succeed")
-}
+use super::{encode_pdu, proxy_iface_id, simple_device_info};
 
 fn decode_control_msg(message: &DvcMessage) -> UrbdrcClientControlPdu {
     let encoded = encode_vec(message.as_ref()).expect("encode should succeed");
@@ -98,13 +88,11 @@ impl UrbdrcDeviceBackend for TestDeviceBackend {
 
     fn cancel_request(&mut self, _request_id: RequestId, _channel_id: u32) {}
 
-    fn query_device_text(
-        &mut self,
-        _channel_id: u32,
-        _text_type: u32,
-        _locale_id: u32,
-    ) -> PduResult<Option<DeviceText>> {
-        Ok(None)
+    fn query_device_text(&mut self, _channel_id: u32, _text_type: u32, _locale_id: u32) -> PduResult<DeviceText> {
+        Ok(DeviceText {
+            hresult: 0,
+            description: String::new(),
+        })
     }
 
     fn io_control(

crates/ironrdp-testsuite-core/tests/rdpeusb/io/mod.rs

@@ -0,0 +1,342 @@
+use std::sync::mpsc::{self, Receiver, Sender};
+
+use ironrdp_core::encode_vec;
+use ironrdp_dvc::{DvcMessage, DvcProcessor as _};
+use ironrdp_pdu::PduResult;
+use ironrdp_rdpeusb::client::{UrbdrcDeviceBackend, UrbdrcDeviceClient};
+use ironrdp_rdpeusb::io::{
+    DeviceAnnounce, DeviceText, InternalIoControlPacket, IoControlCompletionResult, IoControlPacket, RequestId,
+    TransferInCompletionResult, TransferInPacket, TransferOutCompletionResult, TransferOutPacket,
+};
+use ironrdp_rdpeusb::pdu::header::InterfaceId;
+use ironrdp_rdpeusb::server::{UrbdrcDeviceServer, UrbdrcDeviceServerBackend};
+
+use super::simple_device_info;
+
+const CHANNEL_ID: u32 = 11;
+const DEVICE_TEXT_DESCRIPTION: &str = "Test USB device";
+const DEVICE_TEXT_HRESULT: u32 = 0;
+
+#[derive(Debug)]
+enum ClientEvent {
+    QueryDeviceText {
+        channel_id: u32,
+        text_type: u32,
+        locale_id: u32,
+    },
+    IoControl {
+        channel_id: u32,
+        request_id: RequestId,
+        request: IoControlPacket,
+    },
+    InternalIoControl {
+        channel_id: u32,
+        request_id: RequestId,
+        request: InternalIoControlPacket,
+    },
+    TransferIn {
+        channel_id: u32,
+        request_id: RequestId,
+        request: TransferInPacket,
+    },
+    TransferOut {
+        channel_id: u32,
+        request_id: RequestId,
+        request: TransferOutPacket,
+    },
+    TransferOutNoAck {
+        channel_id: u32,
+        request_id: RequestId,
+        request: TransferOutPacket,
+    },
+    Cancel {
+        channel_id: u32,
+        request_id: RequestId,
+    },
+}
+
+#[derive(Debug)]
+enum ServerEvent {
+    DeviceText(DeviceText),
+    IoControlCompleted {
+        channel_id: u32,
+        request_id: RequestId,
+        completion: IoControlCompletionResult,
+    },
+    InternalIoControlCompleted {
+        channel_id: u32,
+        request_id: RequestId,
+        completion: IoControlCompletionResult,
+    },
+    TransferInCompleted {
+        channel_id: u32,
+        request_id: RequestId,
+        completion: TransferInCompletionResult,
+    },
+    TransferOutCompleted {
+        channel_id: u32,
+        request_id: RequestId,
+        completion: TransferOutCompletionResult,
+    },
+}
+
+struct TestClientBackend {
+    events: Sender<ClientEvent>,
+}
+
+impl TestClientBackend {
+    fn send(&self, event: ClientEvent) {
+        self.events
+            .send(event)
+            .expect("client event receiver should remain connected");
+    }
+}
+
+impl UrbdrcDeviceBackend for TestClientBackend {
+    fn device_info(&mut self, _channel_id: u32) -> PduResult<ironrdp_rdpeusb::io::DeviceInfo> {
+        Ok(simple_device_info())
+    }
+
+    fn cancel_request(&mut self, request_id: RequestId, channel_id: u32) {
+        self.send(ClientEvent::Cancel { channel_id, request_id });
+    }
+
+    fn query_device_text(&mut self, channel_id: u32, text_type: u32, locale_id: u32) -> PduResult<DeviceText> {
+        self.send(ClientEvent::QueryDeviceText {
+            channel_id,
+            text_type,
+            locale_id,
+        });
+        Ok(DeviceText {
+            hresult: DEVICE_TEXT_HRESULT,
+            description: DEVICE_TEXT_DESCRIPTION.to_owned(),
+        })
+    }
+
+    fn io_control(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        request: IoControlPacket,
+    ) -> PduResult<Option<IoControlCompletionResult>> {
+        self.send(ClientEvent::IoControl {
+            channel_id,
+            request_id,
+            request,
+        });
+        Ok(None)
+    }
+
+    fn internal_io_control(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        request: InternalIoControlPacket,
+    ) -> PduResult<Option<IoControlCompletionResult>> {
+        self.send(ClientEvent::InternalIoControl {
+            channel_id,
+            request_id,
+            request,
+        });
+        Ok(None)
+    }
+
+    fn transfer_in(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        request: TransferInPacket,
+    ) -> PduResult<Option<TransferInCompletionResult>> {
+        self.send(ClientEvent::TransferIn {
+            channel_id,
+            request_id,
+            request,
+        });
+        Ok(None)
+    }
+
+    fn transfer_out(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        request: TransferOutPacket,
+    ) -> PduResult<Option<TransferOutCompletionResult>> {
+        self.send(ClientEvent::TransferOut {
+            channel_id,
+            request_id,
+            request,
+        });
+        Ok(None)
+    }
+
+    fn transfer_out_no_ack(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        request: TransferOutPacket,
+    ) -> PduResult<()> {
+        self.send(ClientEvent::TransferOutNoAck {
+            channel_id,
+            request_id,
+            request,
+        });
+        Ok(())
+    }
+
+    fn retract(&mut self, _channel_id: u32) -> PduResult<()> {
+        Ok(())
+    }
+}
+
+struct TestServerBackend {
+    events: Sender<ServerEvent>,
+}
+
+impl TestServerBackend {
+    fn send(&self, event: ServerEvent) {
+        self.events
+            .send(event)
+            .expect("server event receiver should remain connected");
+    }
+}
+
+impl UrbdrcDeviceServerBackend for TestServerBackend {
+    fn add_device(&mut self, _device: DeviceAnnounce) -> PduResult<()> {
+        Ok(())
+    }
+
+    fn device_text(&mut self, device_text: DeviceText) {
+        self.send(ServerEvent::DeviceText(device_text));
+    }
+
+    fn io_control_completed(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        completion: IoControlCompletionResult,
+    ) -> PduResult<()> {
+        self.send(ServerEvent::IoControlCompleted {
+            channel_id,
+            request_id,
+            completion,
+        });
+        Ok(())
+    }
+
+    fn internal_io_control_completed(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        completion: IoControlCompletionResult,
+    ) -> PduResult<()> {
+        self.send(ServerEvent::InternalIoControlCompleted {
+            channel_id,
+            request_id,
+            completion,
+        });
+        Ok(())
+    }
+
+    fn transfer_in_completed(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        completion: TransferInCompletionResult,
+    ) -> PduResult<()> {
+        self.send(ServerEvent::TransferInCompleted {
+            channel_id,
+            request_id,
+            completion,
+        });
+        Ok(())
+    }
+
+    fn transfer_out_completed(
+        &mut self,
+        channel_id: u32,
+        request_id: RequestId,
+        completion: TransferOutCompletionResult,
+    ) -> PduResult<()> {
+        self.send(ServerEvent::TransferOutCompleted {
+            channel_id,
+            request_id,
+            completion,
+        });
+        Ok(())
+    }
+}
+
+struct ConnectedDevice {
+    client: UrbdrcDeviceClient,
+    server: UrbdrcDeviceServer,
+    client_events: Receiver<ClientEvent>,
+    server_events: Receiver<ServerEvent>,
+}
+
+impl ConnectedDevice {
+    fn new() -> Self {
+        let udev_iface = InterfaceId::try_from(4).expect("valid device interface id");
+        let completion_iface = InterfaceId::try_from(5).expect("valid completion interface id");
+        let (client_events_tx, client_events) = mpsc::channel();
+        let (server_events_tx, server_events) = mpsc::channel();
+
+        let client_backend = Box::new(TestClientBackend {
+            events: client_events_tx,
+        });
+        let server_backend = Box::new(TestServerBackend {
+            events: server_events_tx,
+        });
+        let mut client = UrbdrcDeviceClient::new(udev_iface, client_backend).expect("device client should be created");
+        let mut server =
+            UrbdrcDeviceServer::new(server_backend, completion_iface).expect("device server should be created");
+
+        let server_messages = server.start(CHANNEL_ID).expect("server start should succeed");
+        let client_messages = process_message(&mut client, only_message(server_messages));
+        let server_messages = process_message(&mut server, only_message(client_messages));
+        let client_messages = process_message(&mut client, only_message(server_messages));
+        let server_messages = process_message(&mut server, only_message(client_messages));
+        assert_eq!(server_messages.len(), 2);
+        for message in server_messages {
+            assert!(process_message(&mut client, message).is_empty());
+        }
+        assert!(client.ready_for_io());
+
+        Self {
+            client,
+            server,
+            client_events,
+            server_events,
+        }
+    }
+
+    fn send_to_client(&mut self, message: DvcMessage) -> Vec<DvcMessage> {
+        process_message(&mut self.client, message)
+    }
+
+    fn send_to_server(&mut self, message: DvcMessage) -> Vec<DvcMessage> {
+        process_message(&mut self.server, message)
+    }
+
+    fn next_client_event(&self) -> ClientEvent {
+        self.client_events.try_recv().expect("client backend should be called")
+    }
+
+    fn next_server_event(&self) -> ServerEvent {
+        self.server_events.try_recv().expect("server backend should be called")
+    }
+}
+
+fn process_message(processor: &mut dyn ironrdp_dvc::DvcProcessor, message: DvcMessage) -> Vec<DvcMessage> {
+    let payload = encode_vec(message.as_ref()).expect("DVC message should encode");
+    processor
+        .process(CHANNEL_ID, &payload)
+        .expect("DVC message should process")
+}
+
+fn only_message(mut messages: Vec<DvcMessage>) -> DvcMessage {
+    assert_eq!(messages.len(), 1);
+    messages.pop().expect("one message should be present")
+}
+
+mod requests;
+mod transfers;