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
#![warn(clippy::all)]
use {
anyhow::{anyhow, Error},
fidl_fuchsia_space::ErrorCode,
fuchsia_async as fasync,
futures::prelude::*,
std::sync::Arc,
};
type CallHook = Box<dyn Fn() -> Result<(), ErrorCode> + Send + Sync>;
pub struct MockSpaceService {
call_hook: CallHook,
}
impl MockSpaceService {
pub fn new(call_hook: CallHook) -> Self {
Self { call_hook }
}
pub fn spawn_space_service(self: &Arc<Self>) -> fidl_fuchsia_space::ManagerProxy {
let (proxy, stream) =
fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_space::ManagerMarker>()
.unwrap();
fasync::Task::spawn(
Arc::clone(self)
.run_space_service(stream)
.unwrap_or_else(|e| panic!("error running space service: {:#}", anyhow!(e))),
)
.detach();
proxy
}
pub async fn run_space_service(
self: Arc<Self>,
mut stream: fidl_fuchsia_space::ManagerRequestStream,
) -> Result<(), Error> {
while let Some(event) = stream.try_next().await.expect("received request") {
let fidl_fuchsia_space::ManagerRequest::Gc { responder } = event;
responder.send(&mut (self.call_hook)())?;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicU32, Ordering};
#[fasync::run_singlethreaded(test)]
async fn test_mock_space() {
let called = Arc::new(AtomicU32::new(0));
let called_clone = Arc::clone(&called);
let mock = Arc::new(MockSpaceService::new(Box::new(move || {
called_clone.fetch_add(1, Ordering::SeqCst);
Ok(())
})));
let proxy = mock.spawn_space_service();
assert_eq!(called.load(Ordering::SeqCst), 0);
let gc_result = proxy.gc().await.expect("made fidl call");
assert_eq!(gc_result, Ok(()));
assert_eq!(called.load(Ordering::SeqCst), 1);
let gc_result = proxy.gc().await.expect("made fidl call");
assert_eq!(gc_result, Ok(()));
let gc_result = proxy.gc().await.expect("made fidl call");
assert_eq!(gc_result, Ok(()));
assert_eq!(called.load(Ordering::SeqCst), 3);
}
#[fasync::run_singlethreaded(test)]
async fn test_mock_error() {
let called = Arc::new(AtomicU32::new(0));
let called_clone = Arc::clone(&called);
let mock = Arc::new(MockSpaceService::new(Box::new(move || {
called_clone.fetch_add(1, Ordering::SeqCst);
Err(ErrorCode::Internal)
})));
let proxy = mock.spawn_space_service();
let gc_result = proxy.gc().await.expect("made fidl call");
assert_eq!(gc_result, Err(ErrorCode::Internal));
assert_eq!(called.load(Ordering::SeqCst), 1);
}
}