ferroui-headless 0.3.0

The headless platform of FerroUI: windows without a screen, driven by simulated input, for tests
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

//! The upstream unit tests of the headless platform
//! (`tests/<the headless unit test project>` upstream), one module per
//! upstream file, and the upstream tests of the controls that run on the
//! headless platform (`headless_probe_tests`).
//!
//! The tests of the platform run as upstream's do: on the dispatcher thread
//! of the [`HeadlessUnitTestSession`](crate::HeadlessUnitTestSession) of
//! their test assembly, with the application of `test_application`, which
//! has the Simple theme and renders with the Skia backend.

use ferroui_base::threading::{DispatcherPriority, DispatcherTimer};
use std::future::Future;
use std::pin::{pin, Pin};
use std::sync::{Arc, Mutex};
use std::task::{Context, Poll, Wake, Waker};
use std::thread::Thread;
use std::time::Duration;

mod test_application;

mod async_setup_tests;
mod headless_probe_tests;
mod headless_unit_test_application;
mod headless_unit_test_session_tests;
mod input_tests;
mod isolation_tests;
mod leak_tests;
mod mouse_device_tests;
mod popup_tests;
mod render_scaling_tests;
mod rendering_tests;
mod second_window_tests;
mod services_tests;
mod setup_tests;
mod shared_session_tests;
mod threading_tests;

/// A future that is completed by hand: the stand-in for a task completion
/// source.
struct Oneshot<T> {
    shared: Arc<Mutex<(Option<T>, Option<Waker>)>>,
}

struct OneshotSender<T> {
    shared: Arc<Mutex<(Option<T>, Option<Waker>)>>,
}

fn oneshot<T>() -> (OneshotSender<T>, Oneshot<T>) {
    let shared = Arc::new(Mutex::new((None, None)));
    (OneshotSender { shared: shared.clone() }, Oneshot { shared })
}

impl<T> OneshotSender<T> {
    fn send(&self, value: T) {
        let waker = {
            let mut shared = self.shared.lock().unwrap();
            shared.0 = Some(value);
            shared.1.take()
        };
        if let Some(waker) = waker {
            waker.wake();
        }
    }
}

impl<T> Future for Oneshot<T> {
    type Output = T;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
        let mut shared = self.shared.lock().unwrap();
        match shared.0.take() {
            Some(value) => Poll::Ready(value),
            None => {
                shared.1 = Some(cx.waker().clone());
                Poll::Pending
            }
        }
    }
}

/// Completes after `duration` of dispatcher time: the stand-in for a timer
/// task (`Task.Delay`).
fn delay(duration: Duration) -> Oneshot<()> {
    let (sender, receiver) = oneshot();
    DispatcherTimer::run_once(move || sender.send(()), duration, DispatcherPriority::NORMAL);
    receiver
}

struct ThreadWaker(Thread);

impl Wake for ThreadWaker {
    fn wake(self: Arc<Self>) {
        self.0.unpark();
    }
}

/// Waits for a future on the calling thread, which is not a dispatcher
/// thread: what awaiting does in a test of the original that does not run
/// on the session.
fn block_on<F: Future>(future: F) -> F::Output {
    let mut future = pin!(future);
    let waker = Waker::from(Arc::new(ThreadWaker(std::thread::current())));
    let mut context = Context::from_waker(&waker);
    loop {
        match future.as_mut().poll(&mut context) {
            Poll::Ready(output) => return output,
            Poll::Pending => std::thread::park(),
        }
    }
}