it: test subsurface positioning

src/it.rs

@@ -1,5 +1,6 @@
 use {
     crate::{
+        async_engine::Phase,
         it::{
             test_backend::TestBackend,
             test_config::{with_test_config, TestConfig},
@@ -132,12 +133,14 @@ fn run_test(it_run: &ItRun, test: &'static dyn TestCase, cfg: Rc<TestConfig>) {
             backend,
             errors: Default::default(),
             server_addr,
-            dir: dir.clone(),
+            out_dir: dir.clone(),
+            in_dir: format!("{}/{}", env!("CARGO_MANIFEST_DIR"), test.dir()),
             cfg: cfg.clone(),
         });
         let errors = errors2.clone();
         Box::new(async move {
             let future: Pin<_> = test.run(testrun.clone()).into();
+            let future = state.eng.spawn2(Phase::Present, future);
             let timeout = state.eng.timeout(5000).unwrap();
             match future::select(future, timeout).await {
                 Either::Left((Ok(..), _)) => {}

src/it/test_client.rs

@@ -7,7 +7,8 @@ use {
             test_error::TestError,
             test_ifs::{
                 test_compositor::TestCompositor, test_jay_compositor::TestJayCompositor,
-                test_registry::TestRegistry, test_shm::TestShm, test_xdg_base::TestXdgWmBase,
+                test_registry::TestRegistry, test_shm::TestShm,
+                test_subcompositor::TestSubcompositor, test_xdg_base::TestXdgWmBase,
             },
             test_transport::TestTransport,
             test_utils::test_window::TestWindow,
@@ -26,6 +27,7 @@ pub struct TestClient {
     pub registry: Rc<TestRegistry>,
     pub jc: Rc<TestJayCompositor>,
     pub comp: Rc<TestCompositor>,
+    pub sub: Rc<TestSubcompositor>,
     pub shm: Rc<TestShm>,
     pub xdg: Rc<TestXdgWmBase>,
 }
@@ -40,13 +42,35 @@ impl TestClient {
         self.tran.sync().await
     }
 
-    #[allow(dead_code)]
     pub async fn take_screenshot(&self) -> Result<Vec<u8>, TestError> {
         let dmabuf = self.jc.take_screenshot().await?;
         let qoi = buf_to_qoi(&dmabuf);
         Ok(qoi)
     }
 
+    #[allow(dead_code)]
+    pub async fn save_screenshot(&self, name: &str) -> Result<(), TestError> {
+        let qoi = self.take_screenshot().await?;
+        let path = format!("{}/screenshot_{}.qoi", self.run.out_dir, name);
+        std::fs::write(path, qoi)?;
+        Ok(())
+    }
+
+    pub async fn compare_screenshot(&self, name: &str) -> Result<(), TestError> {
+        let actual = self.take_screenshot().await?;
+        let expected_path = format!("{}/screenshot_{}.qoi", self.run.in_dir, name);
+        let expected = std::fs::read(expected_path)?;
+        if actual != expected {
+            let actual_out_path = format!("{}/screenshot_{}_actual.qoi", self.run.out_dir, name);
+            let expected_out_path =
+                format!("{}/screenshot_{}_expected.qoi", self.run.out_dir, name);
+            let _ = std::fs::write(actual_out_path, actual);
+            let _ = std::fs::write(expected_out_path, expected);
+            bail!("Screenshots differ");
+        }
+        Ok(())
+    }
+
     pub async fn create_window(&self) -> Result<Rc<TestWindow>, TestError> {
         let surface = self.comp.create_surface().await?;
         let shm = self.shm.create_pool(0)?;

src/it/test_config.rs

@@ -1,10 +1,13 @@
 use {
     crate::{ifs::wl_seat::SeatId, it::test_error::TestError, utils::stack::Stack},
     isnt::std_1::primitive::IsntConstPtrExt,
-    jay_config::_private::{
+    jay_config::{
-        bincode_ops,
+        _private::{
-        ipc::{ClientMessage, Response, ServerMessage},
+            bincode_ops,
-        ConfigEntry, VERSION,
+            ipc::{ClientMessage, Response, ServerMessage},
+            ConfigEntry, VERSION,
+        },
+        input::Seat,
     },
     std::{cell::Cell, ops::Deref, ptr, rc::Rc},
 };
@@ -149,6 +152,15 @@ impl TestConfig {
         Ok(SeatId::from_raw(seat.0 as _))
     }
 
+    pub fn show_workspace(&self, seat: SeatId, name: &str) -> Result<(), TestError> {
+        let reply = self.send_with_reply(ClientMessage::GetWorkspace { name })?;
+        get_response!(reply, GetWorkspace { workspace });
+        self.send(ClientMessage::ShowWorkspace {
+            seat: Seat(seat.raw() as _),
+            workspace,
+        })
+    }
+
     fn clear(&self) {
         unsafe {
             if let Some(srv) = self.srv.take() {

src/it/test_ifs.rs

@@ -8,6 +8,8 @@ pub mod test_screenshot;
 pub mod test_shm;
 pub mod test_shm_buffer;
 pub mod test_shm_pool;
+pub mod test_subcompositor;
+pub mod test_subsurface;
 pub mod test_surface;
 pub mod test_xdg_base;
 pub mod test_xdg_surface;

src/it/test_ifs/test_registry.rs

@@ -6,7 +6,8 @@ use {
             test_error::TestError,
             test_ifs::{
                 test_compositor::TestCompositor, test_jay_compositor::TestJayCompositor,
-                test_shm::TestShm, test_xdg_base::TestXdgWmBase,
+                test_shm::TestShm, test_subcompositor::TestSubcompositor,
+                test_xdg_base::TestXdgWmBase,
             },
             test_object::TestObject,
             test_transport::TestTransport,
@@ -27,6 +28,7 @@ pub struct TestGlobal {
 pub struct TestRegistrySingletons {
     pub jay_compositor: u32,
     pub wl_compositor: u32,
+    pub wl_subcompositor: u32,
     pub wl_shm: u32,
     pub xdg_wm_base: u32,
 }
@@ -38,6 +40,7 @@ pub struct TestRegistry {
     pub singletons: CloneCell<Option<Rc<TestRegistrySingletons>>>,
     pub jay_compositor: CloneCell<Option<Rc<TestJayCompositor>>>,
     pub compositor: CloneCell<Option<Rc<TestCompositor>>>,
+    pub subcompositor: CloneCell<Option<Rc<TestSubcompositor>>>,
     pub shm: CloneCell<Option<Rc<TestShm>>>,
     pub xdg: CloneCell<Option<Rc<TestXdgWmBase>>>,
     pub seats: CopyHashMap<GlobalName, Rc<WlSeatGlobal>>,
@@ -84,6 +87,7 @@ impl TestRegistry {
         let singletons = singleton! {
             jay_compositor,
             wl_compositor,
+            wl_subcompositor,
             wl_shm,
             xdg_wm_base,
         };
@@ -118,6 +122,20 @@ impl TestRegistry {
         Ok(jc)
     }
 
+    pub async fn get_subcompositor(&self) -> Result<Rc<TestSubcompositor>, TestError> {
+        singleton!(self.subcompositor);
+        let singletons = self.get_singletons().await?;
+        singleton!(self.subcompositor);
+        let jc = Rc::new(TestSubcompositor {
+            id: self.tran.id(),
+            tran: self.tran.clone(),
+            destroyed: Cell::new(false),
+        });
+        self.bind(&jc, singletons.wl_subcompositor, 1)?;
+        self.subcompositor.set(Some(jc.clone()));
+        Ok(jc)
+    }
+
     pub async fn get_shm(&self) -> Result<Rc<TestShm>, TestError> {
         singleton!(self.shm);
         let singletons = self.get_singletons().await?;

src/it/test_ifs/test_subcompositor.rs

@@ -0,0 +1,60 @@
+use {
+    crate::{
+        it::{
+            test_error::TestError, test_ifs::test_subsurface::TestSubsurface,
+            test_object::TestObject, test_transport::TestTransport,
+        },
+        wire::{wl_subcompositor::*, WlSubcompositorId, WlSurfaceId},
+    },
+    std::{cell::Cell, rc::Rc},
+};
+
+pub struct TestSubcompositor {
+    pub id: WlSubcompositorId,
+    pub tran: Rc<TestTransport>,
+    pub destroyed: Cell<bool>,
+}
+
+impl TestSubcompositor {
+    pub fn destroy(&self) -> Result<(), TestError> {
+        if !self.destroyed.replace(true) {
+            self.tran.send(Destroy { self_id: self.id })?;
+        }
+        Ok(())
+    }
+
+    pub async fn get_subsurface(
+        &self,
+        surface: WlSurfaceId,
+        parent: WlSurfaceId,
+    ) -> Result<Rc<TestSubsurface>, TestError> {
+        let id = self.tran.id();
+        self.tran.send(GetSubsurface {
+            self_id: self.id,
+            id,
+            surface,
+            parent,
+        })?;
+        self.tran.sync().await;
+        let ss = Rc::new(TestSubsurface {
+            id,
+            tran: self.tran.clone(),
+            destroyed: Cell::new(false),
+            server: self.tran.get_object(id)?,
+        });
+        self.tran.add_obj(ss.clone())?;
+        Ok(ss)
+    }
+}
+
+impl Drop for TestSubcompositor {
+    fn drop(&mut self) {
+        let _ = self.destroy();
+    }
+}
+
+test_object! {
+    TestSubcompositor, WlSubcompositor;
+}
+
+impl TestObject for TestSubcompositor {}

src/it/test_ifs/test_subsurface.rs

@@ -0,0 +1,68 @@
+use {
+    crate::{
+        ifs::wl_surface::wl_subsurface::WlSubsurface,
+        it::{test_error::TestError, test_object::TestObject, test_transport::TestTransport},
+        wire::{wl_subsurface::*, WlSubsurfaceId, WlSurfaceId},
+    },
+    std::{cell::Cell, rc::Rc},
+};
+
+pub struct TestSubsurface {
+    pub id: WlSubsurfaceId,
+    pub tran: Rc<TestTransport>,
+    pub destroyed: Cell<bool>,
+    pub server: Rc<WlSubsurface>,
+}
+
+impl TestSubsurface {
+    pub fn destroy(&self) -> Result<(), TestError> {
+        if !self.destroyed.replace(true) {
+            self.tran.send(Destroy { self_id: self.id })?;
+        }
+        Ok(())
+    }
+
+    pub fn set_position(&self, x: i32, y: i32) -> Result<(), TestError> {
+        self.tran.send(SetPosition {
+            self_id: self.id,
+            x,
+            y,
+        })
+    }
+
+    pub fn place_above(&self, surface: WlSurfaceId) -> Result<(), TestError> {
+        self.tran.send(PlaceAbove {
+            self_id: self.id,
+            sibling: surface,
+        })
+    }
+
+    pub fn place_below(&self, surface: WlSurfaceId) -> Result<(), TestError> {
+        self.tran.send(PlaceBelow {
+            self_id: self.id,
+            sibling: surface,
+        })
+    }
+
+    #[allow(dead_code)]
+    pub fn set_sync(&self) -> Result<(), TestError> {
+        self.tran.send(SetSync { self_id: self.id })
+    }
+
+    #[allow(dead_code)]
+    pub fn set_desync(&self) -> Result<(), TestError> {
+        self.tran.send(SetDesync { self_id: self.id })
+    }
+}
+
+impl Drop for TestSubsurface {
+    fn drop(&mut self) {
+        let _ = self.destroy();
+    }
+}
+
+test_object! {
+    TestSubsurface, WlSubsurface;
+}
+
+impl TestObject for TestSubsurface {}

src/it/test_transport.rs

@@ -6,6 +6,7 @@ use {
             test_error::{StdError, TestError},
             test_ifs::{test_callback::TestCallback, test_registry::TestRegistry},
             test_object::TestObject,
+            test_utils::test_object_ext::TestObjectExt,
             testrun::TestRun,
         },
         object::{ObjectId, WL_DISPLAY_ID},
@@ -52,6 +53,7 @@ impl TestTransport {
             singletons: Default::default(),
             jay_compositor: Default::default(),
             compositor: Default::default(),
+            subcompositor: Default::default(),
             shm: Default::default(),
             xdg: Default::default(),
             seats: Default::default(),
@@ -169,6 +171,11 @@ impl TestTransport {
         self.flush_request.trigger();
         Ok(())
     }
+
+    pub fn get_object<I: Into<ObjectId>, T: 'static>(&self, id: I) -> Result<Rc<T>, TestError> {
+        let client = self.get_client()?;
+        client.objects.get_obj(id.into())?.downcast()
+    }
 }
 
 struct Outgoing {

src/it/test_utils.rs

@@ -1 +1,2 @@
+pub mod test_object_ext;
 pub mod test_window;

src/it/test_utils/test_object_ext.rs

@@ -0,0 +1,17 @@
+use {
+    crate::{it::test_error::TestError, object::Object},
+    std::rc::Rc,
+};
+
+pub trait TestObjectExt {
+    fn downcast<T: 'static>(self: Rc<Self>) -> Result<Rc<T>, TestError>;
+}
+
+impl TestObjectExt for dyn Object {
+    fn downcast<T: 'static>(self: Rc<Self>) -> Result<Rc<T>, TestError> {
+        match self.into_any().downcast() {
+            Ok(t) => Ok(t),
+            _ => bail!("Object has an incompatible type id"),
+        }
+    }
+}

src/it/testrun.rs

@@ -26,7 +26,8 @@ pub struct TestRun {
     pub backend: Rc<TestBackend>,
     pub errors: Stack<String>,
     pub server_addr: c::sockaddr_un,
-    pub dir: String,
+    pub out_dir: String,
+    pub in_dir: String,
     pub cfg: Rc<TestConfig>,
 }
 
@@ -85,6 +86,7 @@ impl TestRun {
             tran,
             jc,
             comp: registry.get_compositor().await?,
+            sub: registry.get_subcompositor().await?,
             shm: registry.get_shm().await?,
             xdg: registry.get_xdg().await?,
             registry,

src/it/tests.rs

@@ -12,6 +12,10 @@ macro_rules! testcase {
                 module_path!().strip_prefix("jay::it::tests::").unwrap()
             }
 
+            fn dir(&self) -> &'static str {
+                file!().strip_suffix(".rs").unwrap()
+            }
+
             fn run(
                 &self,
                 testrun: std::rc::Rc<crate::it::testrun::TestRun>,
@@ -28,9 +32,11 @@ mod t0003_multi_window;
 mod t0004_quit;
 mod t0005_create_seat;
 mod t0006_region;
+mod t0007_subsurface;
 
 pub trait TestCase: Sync {
     fn name(&self) -> &'static str;
+    fn dir(&self) -> &'static str;
     fn run(&self, testrun: Rc<TestRun>) -> Box<dyn Future<Output = Result<(), TestError>>>;
 }
 
@@ -51,5 +57,6 @@ pub fn tests() -> Vec<&'static dyn TestCase> {
         t0004_quit,
         t0005_create_seat,
         t0006_region,
+        t0007_subsurface,
     }
 }

src/it/tests/t0007_subsurface.rs

@@ -0,0 +1,55 @@
+use {
+    crate::{
+        format::ARGB8888,
+        it::{test_error::TestError, testrun::TestRun},
+        theme::Color,
+    },
+    std::rc::Rc,
+};
+
+testcase!();
+
+async fn test(run: Rc<TestRun>) -> Result<(), TestError> {
+    run.backend.install_default();
+
+    let seat = run.get_seat("default")?;
+
+    run.state.eng.yield_now().await;
+
+    run.cfg.show_workspace(seat.id(), "")?;
+
+    let client = run.create_client().await?;
+
+    let parent = client.create_window().await?;
+    parent.map().await?;
+    parent.set_color(0, 0, 0, 255);
+
+    let child = client.comp.create_surface().await?;
+    let sub = client
+        .sub
+        .get_subsurface(child.id, parent.surface.id)
+        .await?;
+    sub.set_position(100, 100)?;
+
+    let pool = client.shm.create_pool(100 * 100 * 4)?;
+    let buffer = pool.create_buffer(0, 100, 100, 100 * 4, ARGB8888)?;
+    buffer.fill(Color::from_rgba_straight(255, 255, 255, 255));
+
+    child.attach(buffer.id)?;
+
+    parent.map().await?;
+
+    seat.set_app_cursor(None);
+
+    client.compare_screenshot("1").await?;
+
+    sub.place_below(parent.surface.id)?;
+    parent.map().await?;
+    client.compare_screenshot("2").await?;
+
+    sub.place_above(parent.surface.id)?;
+    parent.map().await?;
+    client.compare_screenshot("1").await?;
+
+    Ok(())
+}

src/macros.rs

@@ -18,6 +18,10 @@ macro_rules! object_base {
                 self.id.into()
             }
 
+            fn into_any(self: std::rc::Rc<Self>) -> std::rc::Rc<dyn std::any::Any> {
+                self
+            }
+
             #[allow(unused_variables, unreachable_code)]
             fn handle_request(
                 self: std::rc::Rc<Self>,

src/object.rs

@@ -1,6 +1,7 @@
 use {
     crate::{client::ClientError, utils::buffd::MsgParser, wire::WlDisplayId},
     std::{
+        any::Any,
         fmt::{Display, Formatter},
         rc::Rc,
     },
@@ -31,6 +32,7 @@ impl Display for ObjectId {
 
 pub trait ObjectBase {
     fn id(&self) -> ObjectId;
+    fn into_any(self: Rc<Self>) -> Rc<dyn Any>;
     fn handle_request(
         self: Rc<Self>,
         request: u32,