use crate::{    AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DevicePixels,    DummyKeyboardMapper, ForegroundExecutor, Keymap, NoopTextSystem, PathPromptOptions, Platform,    PlatformDisplay, PlatformHeadlessRenderer, PlatformKeyboardLayout, PlatformKeyboardMapper,    PlatformTextSystem, PromptButton, ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream,    SharedString, SourceMetadata, SystemNotification, SystemNotificationResponse, 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(crate) system_notifications: RefCell<TestSystemNotifications>,    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 TestSystemNotifications {    pub(crate) app_identity: Option<(SharedString, SharedString)>,    pub(crate) shown: Vec<SystemNotification>,    pub(crate) delivered: Vec<SystemNotification>,    pub(crate) dismissed: Vec<SharedString>,    response_callback: Option<Box<dyn FnMut(SystemNotificationResponse)>>,} #[derive(Default)]pub(crate) struct TestPrompts {    multiple_choice: VecDeque<TestPrompt>,    new_path: VecDeque<(PathBuf, oneshot::Sender<Result<Option<PathBuf>>>)>,    paths: VecDeque<(        PathPromptOptions,        oneshot::Sender<Result<Option<Vec<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(),            system_notifications: 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();    }     pub(crate) fn simulate_path_prompt_response(        &self,        select_paths: impl FnOnce(&PathPromptOptions) -> Option<Vec<std::path::PathBuf>>,    ) {        let (options, tx) = self            .prompts            .borrow_mut()            .paths            .pop_front()            .expect("no pending paths prompt");        let selection = select_paths(&options);        if let Some(paths) = &selection            && !options.multiple            && paths.len() > 1        {            panic!(                "selected {} paths for a prompt that does not allow multiple selection",                paths.len()            );        }        tx.send(Ok(selection)).ok();    }     pub(crate) fn did_prompt_for_paths(&self) -> bool {        !self.prompts.borrow().paths.is_empty()    }     #[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()    }     pub(crate) fn app_identity(&self) -> Option<(SharedString, SharedString)> {        self.system_notifications.borrow().app_identity.clone()    }     pub(crate) fn shown_system_notifications(&self) -> Vec<SystemNotification> {        self.system_notifications.borrow().shown.clone()    }     pub(crate) fn delivered_system_notifications(&self) -> Vec<SystemNotification> {        self.system_notifications.borrow().delivered.clone()    }     pub(crate) fn dismissed_system_notifications(&self) -> Vec<SharedString> {        self.system_notifications.borrow().dismissed.clone()    }     pub(crate) fn simulate_system_notification_response(        &self,        response: SystemNotificationResponse,    ) {        let callback = self            .system_notifications            .borrow_mut()            .response_callback            .take();        if let Some(mut callback) = callback {            callback(response);            self.system_notifications                .borrow_mut()                .response_callback                .get_or_insert(callback);        }    }} 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>>>> {        let (tx, rx) = oneshot::channel();        self.prompts.borrow_mut().paths.push_back((options, tx));        rx    }     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 on_system_wake(&self, _callback: Box<dyn FnMut()>) {}     fn set_app_identity(&self, identifier: &str, name: &str) {        self.system_notifications.borrow_mut().app_identity =            Some((identifier.to_string().into(), name.to_string().into()));    }     fn show_system_notification(&self, notification: SystemNotification) {        let mut system_notifications = self.system_notifications.borrow_mut();        if system_notifications.app_identity.is_none() {            return;        }         let delivered = system_notifications            .delivered            .iter_mut()            .find(|delivered| delivered.tag == notification.tag);        if let Some(delivered) = delivered {            *delivered = notification.clone();        } else {            system_notifications.delivered.push(notification.clone());        }        system_notifications.shown.push(notification);    }     fn dismiss_system_notification(&self, tag: &str) {        let mut system_notifications = self.system_notifications.borrow_mut();        system_notifications            .delivered            .retain(|notification| notification.tag != tag);        system_notifications            .dismissed            .push(SharedString::from(tag.to_string()));    }     fn on_system_notification_response(        &self,        callback: Box<dyn FnMut(SystemNotificationResponse)>,    ) {

Lines 1–500 of 603. Load more