tests: Add test for error when server ring buffer is full

.github/workflows/ci.yml

@@ -218,6 +218,12 @@ jobs:
           command: update
           args: -p libloading --precise 0.8.8
 
+      - name: Downgrade quote
+        uses: actions-rs/cargo@v1
+        with:
+          command: update
+          args: -p quote --precise 1.0.41
+
       - name: Check
         uses: actions-rs/cargo@v1
         with:

wayland-tests/Cargo.toml

@@ -74,3 +74,6 @@ name = "server_resources"
 
 [[test]]
 name = "xdg_shell_ping"
+
+[[test]]
+name = "buffer_size"

wayland-tests/tests/buffer_size.rs

@@ -0,0 +1,110 @@
+use std::io::ErrorKind;
+
+#[macro_use]
+mod helpers;
+
+use helpers::*;
+
+#[test]
+fn buffer_size() {
+    let mut server = TestServer::new();
+    server
+        .display
+        .handle()
+        .create_global::<ServerHandler, ways::protocol::wl_seat::WlSeat, _>(1, ());
+
+    let (_, mut client) = server.add_client();
+    let mut client_ddata = ClientHandler { globals: globals::GlobalList::new() };
+
+    let registry = client.display.get_registry(&client.event_queue.handle(), ());
+
+    let mut server_handler = ServerHandler::default();
+
+    roundtrip(&mut client, &mut server, &mut client_ddata, &mut server_handler).unwrap();
+
+    let seat = client_ddata
+        .globals
+        .bind::<wayc::protocol::wl_seat::WlSeat, _, _>(
+            &client.event_queue.handle(),
+            &registry,
+            1..2,
+            (),
+        )
+        .unwrap();
+
+    let _pointer = seat.get_pointer(&client.event_queue.handle(), ());
+
+    roundtrip(&mut client, &mut server, &mut client_ddata, &mut server_handler).unwrap();
+
+    // Send too many Wayland events to buffer
+    let server_pointer = server_handler.pointer.as_ref().unwrap().clone();
+    for _ in 0..10_000 {
+        server_pointer.motion(0, 0., 0.);
+    }
+
+    // Verify we get `ConnectionReset` or `BrokenPipe` error
+    // TODO: Why do we get one with one backend, and the other with the other backend?
+    let res = roundtrip(&mut client, &mut server, &mut client_ddata, &mut server_handler);
+    assert!(res.is_err());
+    let err = res.unwrap_err();
+    assert!(matches!(err, wayc::backend::WaylandError::Io(_)));
+    if let wayc::backend::WaylandError::Io(err) = err {
+        assert!(matches!(err.kind(), ErrorKind::ConnectionReset | ErrorKind::BrokenPipe));
+    }
+}
+
+/*
+ * Client handler
+ */
+
+struct ClientHandler {
+    globals: globals::GlobalList,
+}
+
+impl AsMut<globals::GlobalList> for ClientHandler {
+    fn as_mut(&mut self) -> &mut globals::GlobalList {
+        &mut self.globals
+    }
+}
+
+wayc::delegate_dispatch!(ClientHandler:
+    [wayc::protocol::wl_registry::WlRegistry: ()] => globals::GlobalList
+);
+
+client_ignore_impl!(ClientHandler => [
+    wayc::protocol::wl_seat::WlSeat,
+    wayc::protocol::wl_pointer::WlPointer,
+    wayc::protocol::wl_keyboard::WlKeyboard
+]);
+
+/*
+ * Server handler
+ */
+
+#[derive(Default)]
+struct ServerHandler {
+    pointer: Option<ways::protocol::wl_pointer::WlPointer>,
+}
+
+server_ignore_impl!(ServerHandler => [ways::protocol::wl_pointer::WlPointer]);
+
+server_ignore_global_impl!(ServerHandler => [ways::protocol::wl_seat::WlSeat]);
+
+impl ways::Dispatch<ways::protocol::wl_seat::WlSeat, ()> for ServerHandler {
+    fn request(
+        server_handler: &mut ServerHandler,
+        _: &ways::Client,
+        _: &ways::protocol::wl_seat::WlSeat,
+        request: ways::protocol::wl_seat::Request,
+        _: &(),
+        _: &ways::DisplayHandle,
+        data_init: &mut ways::DataInit<'_, ServerHandler>,
+    ) {
+        match request {
+            ways::protocol::wl_seat::Request::GetPointer { id } => {
+                server_handler.pointer = Some(data_init.init(id, ()));
+            }
+            _ => unreachable!(),
+        }
+    }
+}