test_config.rs

use crate::backend::InputDeviceId;
use crate::ifs::wl_seat::SeatId;
use crate::it::test_error::TestError;
use crate::it::test_error::TestResult;
use crate::tree::OutputNode;
use crate::utils::copyhashmap::CopyHashMap;
use crate::utils::stack::Stack;
use bincode::Options;
use isnt::std_1::primitive::IsntConstPtrExt;
use jay_config::_private::ConfigEntry;
use jay_config::_private::VERSION;
use jay_config::_private::bincode_ops;
use jay_config::_private::ipc::ClientMessage;
use jay_config::_private::ipc::Response;
use jay_config::_private::ipc::ServerMessage;
use jay_config::Axis;
use jay_config::Direction;
use jay_config::input::InputDevice;
use jay_config::input::Seat;
use jay_config::keyboard::Keymap;
use jay_config::keyboard::ModifiedKeySym;
use jay_config::theme::BarPosition;
use jay_config::theme::sized::BAR_SEPARATOR_WIDTH;
use jay_config::theme::sized::Resizable;
use jay_config::video::Connector;
use jay_config::video::Transform;
use std::cell::Cell;
use std::ops::Deref;
use std::ptr;
use std::rc::Rc;
use std::time::Duration;

pub static TEST_CONFIG_ENTRY: ConfigEntry = ConfigEntry {
    version: VERSION,
    init,
    unref,
    handle_msg,
};

thread_local! {
    static CONFIG: Cell<*const TestConfig> = const { Cell::new(ptr::null()) };
}

pub fn with_test_config<T, F>(f: F) -> T
where
    F: FnOnce(Rc<TestConfig>) -> T,
{
    let tc = Rc::new(TestConfig {
        srv: Cell::new(None),
        responses: Default::default(),
        invoked_shortcuts: Default::default(),
        graphics_initialized: Cell::new(false),
    });
    let old = CONFIG.get();
    CONFIG.set(tc.deref());
    let res = f(tc.clone());
    CONFIG.set(old);
    res
}

unsafe extern "C" fn init(
    srv_data: *const u8,
    srv_unref: unsafe extern "C" fn(data: *const u8),
    srv_handler: unsafe extern "C" fn(data: *const u8, msg: *const u8, size: usize),
    _msg: *const u8,
    _size: usize,
) -> *const u8 {
    let tc = CONFIG.get();
    assert!(tc.is_not_null());
    unsafe {
        Rc::increment_strong_count(tc);
        {
            let tc = &*tc;
            tc.srv.set(Some(ServerData {
                srv_data,
                srv_unref,
                srv_handler,
            }));
        }
        tc.cast()
    }
}

unsafe extern "C" fn unref(data: *const u8) {
    unsafe {
        Rc::decrement_strong_count(data.cast::<TestConfig>());
    }
}

unsafe extern "C" fn handle_msg(data: *const u8, msg: *const u8, size: usize) {
    let tc = unsafe { &*data.cast::<TestConfig>() };
    let msg = unsafe { std::slice::from_raw_parts(msg, size) };
    let res = bincode_ops().deserialize::<ServerMessage>(msg);
    let msg = match res {
        Ok(msg) => msg,
        Err(e) => {
            log::error!("could not deserialize message: {}", e);
            return;
        }
    };
    match msg {
        ServerMessage::Configure { .. } => {}
        ServerMessage::Response { response } => {
            tc.responses.push(response);
        }
        ServerMessage::InvokeShortcut { seat, mods, sym } => {
            tc.invoked_shortcuts
                .set((SeatId::from_raw(seat.0 as _), mods | sym), ());
        }
        ServerMessage::InvokeShortcut2 {
            seat,
            unmasked_mods,
            effective_mods,
            sym,
        } => {
            let _ = unmasked_mods;
            tc.invoked_shortcuts
                .set((SeatId::from_raw(seat.0 as _), effective_mods | sym), ());
        }
        ServerMessage::NewInputDevice { .. } => {}
        ServerMessage::DelInputDevice { .. } => {}
        ServerMessage::ConnectorConnect { .. } => {}
        ServerMessage::ConnectorDisconnect { .. } => {}
        ServerMessage::NewConnector { .. } => {}
        ServerMessage::DelConnector { .. } => {}
        ServerMessage::TimerExpired { .. } => {}
        ServerMessage::GraphicsInitialized => tc.graphics_initialized.set(true),
        ServerMessage::Clear => tc.clear(),
        ServerMessage::NewDrmDev { .. } => {}
        ServerMessage::DelDrmDev { .. } => {}
        ServerMessage::Idle => {}
        ServerMessage::DevicesEnumerated => {}
        ServerMessage::InterestReady { .. } => {}
        ServerMessage::Features { .. } => {}
        ServerMessage::SwitchEvent { .. } => {}
        ServerMessage::ClientMatcherMatched { .. } => {}
        ServerMessage::ClientMatcherUnmatched { .. } => {}
        ServerMessage::WindowMatcherMatched { .. } => {}
        ServerMessage::WindowMatcherUnmatched { .. } => {}
        ServerMessage::Locked { .. } => {}
    }
}

#[derive(Copy, Clone)]
struct ServerData {
    srv_data: *const u8,
    srv_unref: unsafe extern "C" fn(data: *const u8),
    srv_handler: unsafe extern "C" fn(data: *const u8, msg: *const u8, size: usize),
}

pub struct TestConfig {
    srv: Cell<Option<ServerData>>,
    responses: Stack<Response>,
    pub invoked_shortcuts: CopyHashMap<(SeatId, ModifiedKeySym), ()>,
    pub graphics_initialized: Cell<bool>,
}

macro_rules! get_response {
    ($res:expr, $ty:ident { $($field:ident),+ }) => {
        let ($($field,)+) = match $res {
            Response::$ty { $($field,)+ } => ($($field,)+),
            _ => {
                bail!("Server did not send a response to a {} request", stringify!($ty));
            }
        };
    }
}

impl TestConfig {
    fn send(&self, msg: ClientMessage) -> Result<(), TestError> {
        self.send_(&msg)
    }

    fn send_(&self, msg: &ClientMessage) -> Result<(), TestError> {
        let srv = match self.srv.get() {
            Some(srv) => srv,
            _ => bail!("srv not set"),
        };
        let mut buf = vec![];
        bincode_ops().serialize_into(&mut buf, msg).unwrap();
        unsafe {
            (srv.srv_handler)(srv.srv_data, buf.as_ptr(), buf.len());
        }
        Ok(())
    }

    fn send_with_reply(&self, msg: ClientMessage) -> Result<Response, TestError> {
        self.send_(&msg)?;
        match self.responses.pop() {
            Some(r) => Ok(r),
            _ => bail!("Compositor did not send a response to {:?}", msg),
        }
    }

    pub fn quit(&self) -> Result<(), TestError> {
        self.send(ClientMessage::Quit)
    }

    pub fn get_seat(&self, name: &str) -> Result<SeatId, TestError> {
        let reply = self.send_with_reply(ClientMessage::GetSeat { name })?;
        get_response!(reply, GetSeat { seat });
        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,
        })
    }

    pub fn parse_keymap(&self, keymap: &str) -> Result<Keymap, TestError> {
        let reply = self.send_with_reply(ClientMessage::ParseKeymap { keymap })?;
        get_response!(reply, ParseKeymap { keymap });
        if keymap.is_invalid() {
            bail!("Could not parse the keymap");
        }
        Ok(keymap)
    }

    pub fn set_keymap(&self, seat: SeatId, keymap: Keymap) -> TestResult {
        self.send(ClientMessage::SeatSetKeymap {
            seat: Seat(seat.raw() as _),
            keymap,
        })
    }

    pub fn create_split(&self, seat: SeatId, axis: Axis) -> TestResult {
        self.send(ClientMessage::CreateSeatSplit {
            seat: Seat(seat.raw() as _),
            axis,
        })
    }

    pub fn set_mono(&self, seat: SeatId, mono: bool) -> TestResult {
        self.send(ClientMessage::SetSeatMono {
            seat: Seat(seat.raw() as _),
            mono,
        })
    }

    pub fn add_shortcut<T: Into<ModifiedKeySym>>(
        &self,
        seat: SeatId,
        key: T,
    ) -> Result<(), TestError> {
        let key = key.into();
        self.send(ClientMessage::AddShortcut {
            seat: Seat(seat.raw() as _),
            mods: key.mods,
            sym: key.sym,
        })
    }

    pub fn set_input_device_seat(&self, id: InputDeviceId, seat: SeatId) -> Result<(), TestError> {
        self.send(ClientMessage::SetSeat {
            device: InputDevice(id.raw() as _),
            seat: Seat(seat.raw() as _),
        })
    }

    pub fn focus(&self, seat: SeatId, direction: Direction) -> TestResult {
        self.send(ClientMessage::SeatFocus {
            seat: Seat(seat.raw() as _),
            direction,
        })
    }

    pub fn set_fullscreen(&self, seat: SeatId, fs: bool) -> TestResult {
        self.send(ClientMessage::SetSeatFullscreen {
            seat: Seat(seat.raw() as _),
            fullscreen: fs,
        })
    }

    pub fn set_idle(&self, timeout: Duration) -> TestResult {
        self.send(ClientMessage::SetIdle { timeout })
    }

    pub fn set_idle_grace_period(&self, period: Duration) -> TestResult {
        self.send(ClientMessage::SetIdleGracePeriod { period })
    }

    pub fn set_floating(&self, seat: SeatId, floating: bool) -> TestResult {
        self.send(ClientMessage::SetSeatFloating {
            seat: Seat(seat.raw() as _),
            floating,
        })
    }

    fn clear(&self) {
        unsafe {
            if let Some(srv) = self.srv.take() {
                (srv.srv_unref)(srv.srv_data);
            }
        }
    }

    pub fn set_scale(&self, output: &OutputNode, scale: f64) -> TestResult {
        self.send(ClientMessage::ConnectorSetScale {
            connector: Connector(output.global.connector.connector.id().raw() as _),
            scale,
        })
    }

    pub fn set_output_transform(&self, output: &OutputNode, transform: Transform) -> TestResult {
        self.send(ClientMessage::ConnectorSetTransform {
            connector: Connector(output.global.connector.connector.id().raw() as _),
            transform,
        })
    }

    pub fn set_size(&self, sized: Resizable, size: i32) -> TestResult {
        self.send(ClientMessage::SetSize { sized, size })
    }

    pub fn set_bar_separator_width(&self, width: i32) -> TestResult {
        self.set_size(BAR_SEPARATOR_WIDTH, width)
    }

    pub fn set_bar_position(&self, position: BarPosition) -> TestResult {
        self.send(ClientMessage::SetBarPosition { position })
    }

    pub fn set_split_reuses_container(&self, reuse: bool) -> TestResult {
        self.send(ClientMessage::SetSplitReusesContainer { reuse })
    }

    pub fn get_split_reuses_container(&self) -> Result<bool, TestError> {
        let reply = self.send_with_reply(ClientMessage::GetSplitReusesContainer)?;
        get_response!(reply, GetSplitReusesContainer { reuse });
        Ok(reuse)
    }

    pub fn set_show_bar(&self, show: bool) -> TestResult {
        self.send(ClientMessage::SetShowBar { show })
    }

    pub fn get_show_bar(&self) -> Result<bool, TestError> {
        let reply = self.send_with_reply(ClientMessage::GetShowBar)?;
        get_response!(reply, GetShowBar { show });
        Ok(show)
    }

    pub fn set_show_titles(&self, show: bool) -> TestResult {
        self.send(ClientMessage::SetShowTitles { show })
    }
}

impl Drop for TestConfig {
    fn drop(&mut self) {
        self.clear();
    }
}