use crate::{    AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DevicePixels,    DummyKeyboardMapper, ForegroundExecutor, Keymap, NoopTextSystem, Platform, PlatformDisplay,    PlatformHeadlessRenderer, PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem,    PromptButton, ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream, SourceMetadata,    Task, TestDisplay, TestWindow, ThermalState, WindowAppearance, WindowParams, size,};use anyhow::Result;use collections::VecDeque;use futures::channel::oneshot;use parking_lot::Mutex;use std::{    cell::RefCell,    path::{Path, PathBuf},    rc::{Rc, Weak},    sync::Arc,}; /// TestPlatform implements the Platform trait for use in tests.pub(crate) struct TestPlatform {    background_executor: BackgroundExecutor,    foreground_executor: ForegroundExecutor,     pub(crate) active_window: RefCell<Option<TestWindow>>,    active_display: Rc<dyn PlatformDisplay>,    active_cursor: Mutex<CursorStyle>,    current_clipboard_item: Mutex<Option<ClipboardItem>>,    #[cfg(any(target_os = "linux", target_os = "freebsd"))]    current_primary_item: Mutex<Option<ClipboardItem>>,    #[cfg(target_os = "macos")]    current_find_pasteboard_item: Mutex<Option<ClipboardItem>>,    pub(crate) prompts: RefCell<TestPrompts>,    screen_capture_sources: RefCell<Vec<TestScreenCaptureSource>>,    pub opened_url: RefCell<Option<String>>,    pub text_system: Arc<dyn PlatformTextSystem>,    pub expect_restart: RefCell<Option<oneshot::Sender<Option<PathBuf>>>>,    headless_renderer_factory: Option<Box<dyn Fn() -> Option<Box<dyn PlatformHeadlessRenderer>>>>,    weak: Weak<Self>,} #[derive(Clone)]/// A fake screen capture source, used for testing.pub struct TestScreenCaptureSource {} /// A fake screen capture stream, used for testing.pub struct TestScreenCaptureStream {} impl ScreenCaptureSource for TestScreenCaptureSource {    fn metadata(&self) -> Result<SourceMetadata> {        Ok(SourceMetadata {            id: 0,            is_main: None,            label: None,            resolution: size(DevicePixels(1), DevicePixels(1)),        })    }     fn stream(        &self,        _foreground_executor: &ForegroundExecutor,        _frame_callback: Box<dyn Fn(ScreenCaptureFrame) + Send>,    ) -> oneshot::Receiver<Result<Box<dyn ScreenCaptureStream>>> {        let (mut tx, rx) = oneshot::channel();        let stream = TestScreenCaptureStream {};        tx.send(Ok(Box::new(stream) as Box<dyn ScreenCaptureStream>))            .ok();        rx    }} impl ScreenCaptureStream for TestScreenCaptureStream {    fn metadata(&self) -> Result<SourceMetadata> {        TestScreenCaptureSource {}.metadata()    }} struct TestPrompt {    msg: String,    detail: Option<String>,    answers: Vec<String>,    tx: oneshot::Sender<usize>,} #[derive(Default)]pub(crate) struct TestPrompts {    multiple_choice: VecDeque<TestPrompt>,    new_path: VecDeque<(PathBuf, oneshot::Sender<Result<Option<PathBuf>>>)>,} impl TestPlatform {    pub fn new(executor: BackgroundExecutor, foreground_executor: ForegroundExecutor) -> Rc<Self> {        Self::with_platform(            executor,            foreground_executor,            Arc::new(NoopTextSystem),            None,        )    }     pub fn with_text_system(        executor: BackgroundExecutor,        foreground_executor: ForegroundExecutor,        text_system: Arc<dyn PlatformTextSystem>,    ) -> Rc<Self> {        Self::with_platform(executor, foreground_executor, text_system, None)    }     pub fn with_platform(        executor: BackgroundExecutor,        foreground_executor: ForegroundExecutor,        text_system: Arc<dyn PlatformTextSystem>,        headless_renderer_factory: Option<            Box<dyn Fn() -> Option<Box<dyn PlatformHeadlessRenderer>>>,        >,    ) -> Rc<Self> {        Rc::new_cyclic(|weak| TestPlatform {            background_executor: executor,            foreground_executor,            prompts: Default::default(),            screen_capture_sources: Default::default(),            active_cursor: Default::default(),            active_display: Rc::new(TestDisplay::new()),            active_window: Default::default(),            expect_restart: Default::default(),            current_clipboard_item: Mutex::new(None),            #[cfg(any(target_os = "linux", target_os = "freebsd"))]            current_primary_item: Mutex::new(None),            #[cfg(target_os = "macos")]            current_find_pasteboard_item: Mutex::new(None),            weak: weak.clone(),            opened_url: Default::default(),            text_system,            headless_renderer_factory,        })    }     pub(crate) fn simulate_new_path_selection(        &self,        select_path: impl FnOnce(&std::path::Path) -> Option<std::path::PathBuf>,    ) {        let (path, tx) = self            .prompts            .borrow_mut()            .new_path            .pop_front()            .expect("no pending new path prompt");        tx.send(Ok(select_path(&path))).ok();    }     #[track_caller]    pub(crate) fn simulate_prompt_answer(&self, response: &str) {        let prompt = self            .prompts            .borrow_mut()            .multiple_choice            .pop_front()            .expect("no pending multiple choice prompt");        let Some(ix) = prompt.answers.iter().position(|a| a == response) else {            panic!(                "PROMPT: {}\n{:?}\n{:?}\nCannot respond with {}",                prompt.msg, prompt.detail, prompt.answers, response            )        };        prompt.tx.send(ix).ok();    }     pub(crate) fn has_pending_prompt(&self) -> bool {        !self.prompts.borrow().multiple_choice.is_empty()    }     pub(crate) fn pending_prompt(&self) -> Option<(String, String)> {        let prompts = self.prompts.borrow();        let prompt = prompts.multiple_choice.front()?;        Some((            prompt.msg.clone(),            prompt.detail.clone().unwrap_or_default(),        ))    }     pub(crate) fn set_screen_capture_sources(&self, sources: Vec<TestScreenCaptureSource>) {        *self.screen_capture_sources.borrow_mut() = sources;    }     pub(crate) fn prompt(        &self,        msg: &str,        detail: Option<&str>,        answers: &[PromptButton],    ) -> oneshot::Receiver<usize> {        let (tx, rx) = oneshot::channel();        let answers: Vec<String> = answers.iter().map(|s| s.label().to_string()).collect();        self.prompts            .borrow_mut()            .multiple_choice            .push_back(TestPrompt {                msg: msg.to_string(),                detail: detail.map(|s| s.to_string()),                answers,                tx,            });        rx    }     pub(crate) fn set_active_window(&self, window: Option<TestWindow>) {        let executor = self.foreground_executor();        let previous_window = self.active_window.borrow_mut().take();        self.active_window.borrow_mut().clone_from(&window);         executor            .spawn(async move {                if let Some(previous_window) = previous_window {                    if let Some(window) = window.as_ref()                        && Rc::ptr_eq(&previous_window.0, &window.0)                    {                        return;                    }                    previous_window.simulate_active_status_change(false);                }                if let Some(window) = window {                    window.simulate_active_status_change(true);                }            })            .detach();    }     pub(crate) fn did_prompt_for_new_path(&self) -> bool {        !self.prompts.borrow().new_path.is_empty()    }} impl Platform for TestPlatform {    fn background_executor(&self) -> BackgroundExecutor {        self.background_executor.clone()    }     fn foreground_executor(&self) -> ForegroundExecutor {        self.foreground_executor.clone()    }     fn text_system(&self) -> Arc<dyn PlatformTextSystem> {        self.text_system.clone()    }     fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {        Box::new(TestKeyboardLayout)    }     fn keyboard_mapper(&self) -> Rc<dyn PlatformKeyboardMapper> {        Rc::new(DummyKeyboardMapper)    }     fn on_keyboard_layout_change(&self, _: Box<dyn FnMut()>) {}     fn on_thermal_state_change(&self, _: Box<dyn FnMut()>) {}     fn thermal_state(&self) -> ThermalState {        ThermalState::Nominal    }     fn run(&self, _on_finish_launching: Box<dyn FnOnce()>) {        unimplemented!()    }     fn quit(&self) {}     fn restart(&self, path: Option<PathBuf>) {        if let Some(tx) = self.expect_restart.take() {            tx.send(path).unwrap();        }    }     fn activate(&self, _ignoring_other_apps: bool) {        //    }     fn hide(&self) {        unimplemented!()    }     fn hide_other_apps(&self) {        unimplemented!()    }     fn unhide_other_apps(&self) {        unimplemented!()    }     fn displays(&self) -> Vec<std::rc::Rc<dyn crate::PlatformDisplay>> {        vec![self.active_display.clone()]    }     fn primary_display(&self) -> Option<std::rc::Rc<dyn crate::PlatformDisplay>> {        Some(self.active_display.clone())    }     fn is_screen_capture_supported(&self) -> bool {        true    }     fn screen_capture_sources(        &self,    ) -> oneshot::Receiver<Result<Vec<Rc<dyn ScreenCaptureSource>>>> {        let (mut tx, rx) = oneshot::channel();        tx.send(Ok(self            .screen_capture_sources            .borrow()            .iter()            .map(|source| Rc::new(source.clone()) as Rc<dyn ScreenCaptureSource>)            .collect()))            .ok();        rx    }     fn active_window(&self) -> Option<crate::AnyWindowHandle> {        self.active_window            .borrow()            .as_ref()            .map(|window| window.0.lock().handle)    }     fn open_window(        &self,        handle: AnyWindowHandle,        params: WindowParams,    ) -> anyhow::Result<Box<dyn crate::PlatformWindow>> {        let renderer = self.headless_renderer_factory.as_ref().and_then(|f| f());        let window = TestWindow::new(            handle,            params,            self.weak.clone(),            self.active_display.clone(),            renderer,        );        Ok(Box::new(window))    }     fn window_appearance(&self) -> WindowAppearance {        WindowAppearance::Light    }     fn open_url(&self, url: &str) {        *self.opened_url.borrow_mut() = Some(url.to_string())    }     fn on_open_urls(&self, _callback: Box<dyn FnMut(Vec<String>)>) {        unimplemented!()    }     fn prompt_for_paths(        &self,        _options: crate::PathPromptOptions,    ) -> oneshot::Receiver<Result<Option<Vec<std::path::PathBuf>>>> {        unimplemented!()    }     fn prompt_for_new_path(        &self,        directory: &std::path::Path,        _suggested_name: Option<&str>,    ) -> oneshot::Receiver<Result<Option<std::path::PathBuf>>> {        let (tx, rx) = oneshot::channel();        self.prompts            .borrow_mut()            .new_path            .push_back((directory.to_path_buf(), tx));        rx    }     fn can_select_mixed_files_and_dirs(&self) -> bool {        true    }     fn reveal_path(&self, _path: &std::path::Path) {        unimplemented!()    }     fn on_quit(&self, _callback: Box<dyn FnMut()>) {}     fn on_reopen(&self, _callback: Box<dyn FnMut()>) {        unimplemented!()    }     fn set_menus(&self, _menus: Vec<crate::Menu>, _keymap: &Keymap) {}    fn set_dock_menu(&self, _menu: Vec<crate::MenuItem>, _keymap: &Keymap) {}     fn add_recent_document(&self, _paths: &Path) {}     fn on_app_menu_action(&self, _callback: Box<dyn FnMut(&dyn crate::Action)>) {}     fn on_will_open_app_menu(&self, _callback: Box<dyn FnMut()>) {}     fn on_validate_app_menu_command(&self, _callback: Box<dyn FnMut(&dyn crate::Action) -> bool>) {}     fn app_path(&self) -> Result<std::path::PathBuf> {        unimplemented!()    }     fn path_for_auxiliary_executable(&self, _name: &str) -> Result<std::path::PathBuf> {        unimplemented!()    }     fn set_cursor_style(&self, style: crate::CursorStyle) {        *self.active_cursor.lock() = style;    }     fn should_auto_hide_scrollbars(&self) -> bool {        false    }     fn read_from_clipboard(&self) -> Option<ClipboardItem> {        self.current_clipboard_item.lock().clone()    }     fn write_to_clipboard(&self, item: ClipboardItem) {        *self.current_clipboard_item.lock() = Some(item);    }     #[cfg(any(target_os = "linux", target_os = "freebsd"))]    fn read_from_primary(&self) -> Option<ClipboardItem> {        self.current_primary_item.lock().clone()    }     #[cfg(any(target_os = "linux", target_os = "freebsd"))]    fn write_to_primary(&self, item: ClipboardItem) {        *self.current_primary_item.lock() = Some(item);    }     #[cfg(target_os = "macos")]    fn read_from_find_pasteboard(&self) -> Option<ClipboardItem> {        self.current_find_pasteboard_item.lock().clone()    }     #[cfg(target_os = "macos")]    fn write_to_find_pasteboard(&self, item: ClipboardItem) {        *self.current_find_pasteboard_item.lock() = Some(item);    }     fn write_credentials(&self, _url: &str, _username: &str, _password: &[u8]) -> Task<Result<()>> {        Task::ready(Ok(()))    }     fn read_credentials(&self, _url: &str) -> Task<Result<Option<(String, Vec<u8>)>>> {        Task::ready(Ok(None))    }     fn delete_credentials(&self, _url: &str) -> Task<Result<()>> {        Task::ready(Ok(()))    }     fn register_url_scheme(&self, _: &str) -> Task<anyhow::Result<()>> {        unimplemented!()    }     fn open_with_system(&self, _path: &Path) {        unimplemented!()    }} impl TestScreenCaptureSource {    /// Create a fake screen capture source, for testing.    pub fn new() -> Self {        Self {}    }} struct TestKeyboardLayout; impl PlatformKeyboardLayout for TestKeyboardLayout {    fn id(&self) -> &str {        "zed.keyboard.example"    }     fn name(&self) -> &str {        "zed.keyboard.example"    }}