chore: setup rustfmt.toml for repo

Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "wayland-test"
 version = "0.0.1"
+edition = "2018"
 publish = false
 autotests = false
 

fuzz/fuzz_targets/message_parser.rs

@@ -1,17 +1,15 @@
 #![no_main]
-#[macro_use] extern crate libfuzzer_sys;
+#[macro_use]
+extern crate libfuzzer_sys;
 extern crate wayland_commons;
 
-use std::{mem, slice};
 use std::os::unix::io::RawFd;
-use wayland_commons::wire::{Message, ArgumentType};
+use std::{mem, slice};
+use wayland_commons::wire::{ArgumentType, Message};
 
 unsafe fn convert_slice<T: Sized>(data: &[u8]) -> &[T] {
     let n = mem::size_of::<T>();
-    slice::from_raw_parts(
-        data.as_ptr() as *const T,
-        data.len()/n,
-    )
+    slice::from_raw_parts(data.as_ptr() as *const T, data.len() / n)
 }
 
 fn get_arg_types(data: &[u8]) -> [ArgumentType; 16] {
@@ -36,7 +34,9 @@ fn get_arg_types(data: &[u8]) -> [ArgumentType; 16] {
 }
 
 fuzz_target!(|data: &[u8]| {
-    if data.len() < 32 { return; }
+    if data.len() < 32 {
+        return;
+    }
     // 4 `RawFd`s
     let fds: &[RawFd] = unsafe { convert_slice(&data[..16]) };
     // 16 `ArgumentType`s

rustfmt.toml

@@ -0,0 +1,4 @@
+use_small_heuristics = "Max"
+use_field_init_shorthand = true
+newline_style = "Unix"
+edition = "2018"

tests/attach_to_surface.rs

@@ -26,15 +26,11 @@ fn insert_compositor(server: &mut TestServer) -> Arc<Mutex<Option<Option<ServerB
 
     let filter = ways::Filter::new(move |req, filter, _| match req {
         Reqs::Compositor {
-            request: wl_compositor::Request::CreateSurface { id: surface },
-            ..
+            request: wl_compositor::Request::CreateSurface { id: surface }, ..
         } => {
             surface.assign(filter.clone());
         }
-        Reqs::Surface {
-            request: wl_surface::Request::Attach { buffer, x, y },
-            ..
-        } => {
+        Reqs::Surface { request: wl_surface::Request::Attach { buffer, x, y }, .. } => {
             assert!(x == 0);
             assert!(y == 0);
             assert!(buffer_found.lock().unwrap().is_none());
@@ -55,7 +51,9 @@ fn insert_compositor(server: &mut TestServer) -> Arc<Mutex<Option<Option<ServerB
     buffer_found2
 }
 
-fn insert_shm(server: &mut TestServer) -> Arc<Mutex<Option<(RawFd, Option<ways::Main<ServerBuffer>>)>>> {
+fn insert_shm(
+    server: &mut TestServer,
+) -> Arc<Mutex<Option<(RawFd, Option<ways::Main<ServerBuffer>>)>>> {
     use ways::protocol::{wl_shm, wl_shm_pool};
 
     let buffer = Arc::new(Mutex::new(None));
@@ -67,19 +65,13 @@ fn insert_shm(server: &mut TestServer) -> Arc<Mutex<Option<(RawFd, Option<ways::
     );
 
     let filter = ways::Filter::new(move |req, filter, _| match req {
-        Reqs::Shm {
-            request: wl_shm::Request::CreatePool { id, fd, size },
-            ..
-        } => {
+        Reqs::Shm { request: wl_shm::Request::CreatePool { id, fd, size }, .. } => {
             assert!(size == 42);
             assert!(buffer.lock().unwrap().is_none());
             *buffer.lock().unwrap() = Some((fd, None));
             id.assign(filter.clone());
         }
-        Reqs::Pool {
-            request: wl_shm_pool::Request::CreateBuffer { id, .. },
-            ..
-        } => {
+        Reqs::Pool { request: wl_shm_pool::Request::CreateBuffer { id, .. }, .. } => {
             let mut guard = buffer.lock().unwrap();
             let buf = guard.as_mut().unwrap();
             assert!(buf.1.is_none());
@@ -118,9 +110,8 @@ fn attach_null() {
     // Initial sync
     roundtrip(&mut client, &mut server).unwrap();
 
-    let compositor = manager
-        .instantiate_exact::<wayc::protocol::wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor =
+        manager.instantiate_exact::<wayc::protocol::wl_compositor::WlCompositor>(1).unwrap();
     let surface = compositor.create_surface();
     surface.attach(None, 0, 0);
 
@@ -145,19 +136,16 @@ fn attach_buffer() {
     // Initial sync
     roundtrip(&mut client, &mut server).unwrap();
 
-    let shm = manager
-        .instantiate_exact::<wayc::protocol::wl_shm::WlShm>(1)
-        .unwrap();
+    let shm = manager.instantiate_exact::<wayc::protocol::wl_shm::WlShm>(1).unwrap();
 
     let mut file = tempfile::tempfile().unwrap();
     write!(file, "I like trains!").unwrap();
     file.flush().unwrap();
     let pool = shm.create_pool(file.as_raw_fd(), 42);
     let buffer = pool.create_buffer(0, 0, 0, 0, Format::Argb8888);
 
-    let compositor = manager
-        .instantiate_exact::<wayc::protocol::wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor =
+        manager.instantiate_exact::<wayc::protocol::wl_compositor::WlCompositor>(1).unwrap();
     let surface = compositor.create_surface();
     surface.attach(Some(&buffer), 0, 0);
 

tests/client_bad_requests.rs

@@ -9,9 +9,7 @@ use wayc::protocol::{wl_keyboard, wl_seat};
 #[test]
 fn constructor_dead() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerSeat, _>(5, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerSeat, _>(5, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
     let manager = wayc::GlobalManager::new(&client.display_proxy);
@@ -28,9 +26,7 @@ fn constructor_dead() {
 #[should_panic]
 fn send_constructor_wrong_type() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerSeat, _>(5, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerSeat, _>(5, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
     let manager = wayc::GlobalManager::new(&client.display_proxy);
@@ -39,7 +35,5 @@ fn send_constructor_wrong_type() {
 
     let seat = manager.instantiate_exact::<wl_seat::WlSeat>(5).unwrap();
 
-    let _ = seat
-        .as_ref()
-        .send::<wl_keyboard::WlKeyboard>(wl_seat::Request::GetPointer {}, None);
+    let _ = seat.as_ref().send::<wl_keyboard::WlKeyboard>(wl_seat::Request::GetPointer {}, None);
 }

tests/client_connect_to_env.rs

@@ -6,9 +6,7 @@ use ways::protocol::wl_output::WlOutput as ServerOutput;
 
 fn main() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerOutput, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerOutput, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
 
     ::std::env::remove_var("WAYLAND_DISPLAY");
 

tests/client_connect_to_socket.rs

@@ -8,9 +8,7 @@ use std::os::unix::io::IntoRawFd;
 
 fn main() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerOutput, _>(2, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerOutput, _>(2, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let (s1, s2) = ::std::os::unix::net::UnixStream::pair().unwrap();
 

tests/client_dispatch.rs

@@ -33,10 +33,7 @@ fn client_sync_roundtrip() {
 
     let mut client = TestClient::new(OsStr::new(socket_name));
 
-    client
-        .event_queue
-        .sync_roundtrip(&mut (), |_, _, _| unreachable!())
-        .unwrap();
+    client.event_queue.sync_roundtrip(&mut (), |_, _, _| unreachable!()).unwrap();
 
     *(kill_switch.lock().unwrap()) = true;
 
@@ -71,15 +68,9 @@ fn client_dispatch() {
     // do a manual roundtrip
     let done = Rc::new(Cell::new(false));
     let done2 = done.clone();
-    client
-        .display_proxy
-        .sync()
-        .quick_assign(move |_, _, _| done2.set(true));
+    client.display_proxy.sync().quick_assign(move |_, _, _| done2.set(true));
     while !done.get() {
-        client
-            .event_queue
-            .dispatch(&mut (), |_, _, _| unreachable!())
-            .unwrap();
+        client.event_queue.dispatch(&mut (), |_, _, _| unreachable!()).unwrap();
     }
 
     *(kill_switch.lock().unwrap()) = true;

tests/client_multithread.rs

@@ -89,10 +89,7 @@ fn display_from_external_on_new_thread() {
         let attached = (*display).clone().attach(evq.token());
         let manager = wayc::GlobalManager::new(&attached);
         evq.sync_roundtrip(&mut (), |_, _, _| {}).unwrap();
-        manager
-            .instantiate_exact::<wl_seat::WlSeat>(5)
-            .unwrap()
-            .quick_assign(|_, _, _| {});
+        manager.instantiate_exact::<wl_seat::WlSeat>(5).unwrap().quick_assign(|_, _, _| {});
     })
     .join()
     .unwrap();

tests/client_proxies.rs

@@ -12,22 +12,16 @@ use wayc::Proxy;
 #[test]
 fn proxy_equals() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
     let manager = wayc::GlobalManager::new(&client.display_proxy);
 
     roundtrip(&mut client, &mut server).unwrap();
 
-    let compositor1 = manager
-        .instantiate_exact::<wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor1 = manager.instantiate_exact::<wl_compositor::WlCompositor>(1).unwrap();
 
-    let compositor2 = manager
-        .instantiate_exact::<wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor2 = manager.instantiate_exact::<wl_compositor::WlCompositor>(1).unwrap();
 
     let compositor3 = compositor1.clone();
 
@@ -39,24 +33,18 @@ fn proxy_equals() {
 #[test]
 fn proxy_user_data() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
     let manager = wayc::GlobalManager::new(&client.display_proxy);
 
     roundtrip(&mut client, &mut server).unwrap();
 
-    let compositor1 = manager
-        .instantiate_exact::<wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor1 = manager.instantiate_exact::<wl_compositor::WlCompositor>(1).unwrap();
     let compositor1 = compositor1.as_ref();
     compositor1.user_data().set(|| 0xDEADBEEFusize);
 
-    let compositor2 = manager
-        .instantiate_exact::<wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor2 = manager.instantiate_exact::<wl_compositor::WlCompositor>(1).unwrap();
     let compositor2 = compositor2.as_ref();
     compositor2.user_data().set(|| 0xBADC0FFEusize);
 
@@ -71,18 +59,14 @@ fn proxy_user_data() {
 #[test]
 fn proxy_user_data_wrong_thread() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
     let manager = wayc::GlobalManager::new(&client.display_proxy);
 
     roundtrip(&mut client, &mut server).unwrap();
 
-    let compositor = manager
-        .instantiate_exact::<wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor = manager.instantiate_exact::<wl_compositor::WlCompositor>(1).unwrap();
     let compositor: Proxy<_> = (**compositor).clone().into();
     compositor.user_data().set(|| 0xDEADBEEFusize);
 
@@ -100,43 +84,36 @@ fn proxy_user_data_wrong_thread() {
 #[test]
 fn proxy_wrapper() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
 
     let mut event_queue_2 = client.display.create_event_queue();
-    let manager = wayc::GlobalManager::new(&(**client.display).clone().attach(event_queue_2.token()));
+    let manager =
+        wayc::GlobalManager::new(&(**client.display).clone().attach(event_queue_2.token()));
 
     roundtrip(&mut client, &mut server).unwrap();
 
     // event_queue_2 has not been dispatched
     assert!(manager.list().len() == 0);
 
-    event_queue_2
-        .dispatch_pending(&mut (), |_, _, _| unreachable!())
-        .unwrap();
+    event_queue_2.dispatch_pending(&mut (), |_, _, _| unreachable!()).unwrap();
 
     assert!(manager.list().len() == 1);
 }
 
 #[test]
 fn proxy_create_unattached() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
 
     let manager = wayc::GlobalManager::new(&client.display_proxy);
 
     roundtrip(&mut client, &mut server).unwrap();
 
-    let compositor = manager
-        .instantiate_exact::<wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor = manager.instantiate_exact::<wl_compositor::WlCompositor>(1).unwrap();
     let compositor = (**compositor).clone();
 
     let ret = ::std::thread::spawn(move || {
@@ -151,19 +128,15 @@ fn proxy_create_unattached() {
 #[test]
 fn proxy_create_attached() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerCompositor, _>(1, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
 
     let manager = wayc::GlobalManager::new(&client.display_proxy);
 
     roundtrip(&mut client, &mut server).unwrap();
 
-    let compositor = manager
-        .instantiate_exact::<wl_compositor::WlCompositor>(1)
-        .unwrap();
+    let compositor = manager.instantiate_exact::<wl_compositor::WlCompositor>(1).unwrap();
     let compositor = (**compositor).clone();
 
     let display2 = client.display.clone();
@@ -180,9 +153,7 @@ fn proxy_create_attached() {
 #[test]
 fn dead_proxies() {
     let mut server = TestServer::new();
-    server
-        .display
-        .create_global::<ServerOutput, _>(3, ways::Filter::new(|_: (_, _), _, _| {}));
+    server.display.create_global::<ServerOutput, _>(3, ways::Filter::new(|_: (_, _), _, _| {}));
 
     let mut client = TestClient::new(&server.socket_name);
     let manager = wayc::GlobalManager::new(&client.display_proxy);
@@ -212,9 +183,7 @@ fn dead_proxies() {
 fn dead_connection() {
     fn get_output() -> wl_output::WlOutput {
         let mut server = TestServer::new();
-        server
-            .display
-            .create_global::<ServerOutput, _>(3, ways::Filter::new(|_: (_, _), _, _| {}));
+        server.display.create_global::<ServerOutput, _>(3, ways::Filter::new(|_: (_, _), _, _| {}));
 
         let mut client = TestClient::new(&server.socket_name);
         let manager = wayc::GlobalManager::new(&client.display_proxy);