1use std::cell::RefCell;
15use std::future::Future;
16use std::pin::Pin;
17use std::rc::Rc;
18
19use day_spec::Cap;
20
21use crate::AnyPiece;
22
23#[derive(Clone, Debug, PartialEq, Eq)]
25pub struct Fail(pub String);
26
27impl std::fmt::Display for Fail {
28 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29 f.write_str(&self.0)
30 }
31}
32
33impl From<String> for Fail {
34 fn from(s: String) -> Self {
35 Fail(s)
36 }
37}
38
39impl From<&str> for Fail {
40 fn from(s: &str) -> Self {
41 Fail(s.to_owned())
42 }
43}
44
45pub type TestResult = Result<(), Fail>;
47
48#[derive(Clone, Debug, PartialEq)]
51pub enum DriveOp {
52 Tap(String),
53 Input(String, String),
54 Toggle(String, bool),
55 SetValue(String, f64),
56 Select(String, usize),
57 Focus(String),
58 Submit(String),
59 Navigate(String),
60 WaitIdle,
61 Pause(f64),
62 Shot(String),
64 AssertText(String, String),
65 AssertVisible(String),
66 AssertMissing(String),
67 AssertHidden(String),
69 Hover(String, Option<(f64, f64)>),
71 HoverLeave(String),
73 Pan(String, f64, f64),
75 Pinch(String, f64),
77 Rotate(String, f64),
79 Drag(String, (f64, f64), (f64, f64)),
81 TapAt(String, f64, f64),
83 Key(Option<String>, String),
85 KeyPhase(Option<String>, String, String),
87 Press(String, bool),
89 LongPress(String),
91 DoubleTap(String),
93 Touches(String, Vec<(f64, f64)>, String),
96 Fling(String, (f64, f64), (f64, f64), (f64, f64)),
98 Pointer(String),
100 DropText(String, String, String),
103 DropFiles(String, Vec<String>),
105 AssertAnnounced(String),
107 AssertValue(String, f64),
108 AssertOn(String, bool),
110 AssertFocused(String, bool),
111 AssertRoute(String),
112 A11yAudit(Option<String>),
113 AssertNative(String, NativeExpect),
115 AssertFrame(String, FrameExpect),
117 AssertDisplayed(String, DisplayedExpect),
119 SamplePixel(String, f64, f64, String),
121 AssertOpenedUrl(String),
123 Activate(String, usize),
125 Reorder(String, usize, usize),
127 DeleteRow(String, usize),
129 SwipeRow(String, usize, bool, usize),
132 ScrollTo(String, String),
134 Expand(String, String, bool),
136 NavBack,
138 TreeMove(String, String, Option<String>, Option<usize>),
140 ContextMenu(String, String),
142 Menu(String),
144 ToolbarPress(String),
146 ToolbarToggle(String, bool),
148 DialogScripted(bool),
150 AssertPresented(Option<String>),
152 Respond(Option<usize>),
154 RespondText(String),
156}
157
158#[derive(Clone, Debug, Default, PartialEq)]
161pub struct FrameExpect {
162 pub width: Option<f64>,
163 pub height: Option<f64>,
164 pub x: Option<f64>,
165 pub y: Option<f64>,
166 pub relative_to: Option<String>,
168 pub tolerance: Option<f64>,
170}
171
172#[derive(Clone, Debug, Default, PartialEq)]
175pub struct NativeExpect {
176 pub text: Option<String>,
178 pub number: Option<f64>,
180 pub checked: Option<bool>,
182 pub enabled: Option<bool>,
184 pub visible: Option<bool>,
186}
187
188#[derive(Clone, Debug, Default, PartialEq)]
192pub struct DisplayedExpect {
193 pub opacity: Option<f64>,
195 pub translation: Option<day_spec::Point>,
197 pub width: Option<f64>,
199 pub height: Option<f64>,
201 pub background: Option<day_spec::Color>,
203 pub tolerance: Option<f64>,
206}
207
208pub type OpFuture = Pin<Box<dyn Future<Output = TestResult>>>;
210
211pub trait DriveBackend {
215 fn run(&self, op: DriveOp) -> OpFuture;
216}
217
218#[derive(Clone)]
221pub struct Drive {
222 backend: Rc<dyn DriveBackend>,
223}
224
225impl Drive {
226 pub fn new(backend: Rc<dyn DriveBackend>) -> Self {
228 Drive { backend }
229 }
230
231 fn op(&self, op: DriveOp) -> OpFuture {
232 self.backend.run(op)
233 }
234
235 pub fn tap(&self, id: &str) -> OpFuture {
236 self.op(DriveOp::Tap(id.into()))
237 }
238 pub fn input(&self, id: &str, text: &str) -> OpFuture {
240 self.op(DriveOp::Input(id.into(), text.into()))
241 }
242 pub fn toggle(&self, id: &str, on: bool) -> OpFuture {
243 self.op(DriveOp::Toggle(id.into(), on))
244 }
245 pub fn set_value(&self, id: &str, value: f64) -> OpFuture {
246 self.op(DriveOp::SetValue(id.into(), value))
247 }
248 pub fn select(&self, id: &str, index: usize) -> OpFuture {
249 self.op(DriveOp::Select(id.into(), index))
250 }
251 pub fn focus(&self, id: &str) -> OpFuture {
252 self.op(DriveOp::Focus(id.into()))
253 }
254 pub fn submit(&self, id: &str) -> OpFuture {
255 self.op(DriveOp::Submit(id.into()))
256 }
257 pub fn navigate(&self, route: &str) -> OpFuture {
258 self.op(DriveOp::Navigate(route.into()))
259 }
260 pub fn wait_idle(&self) -> OpFuture {
262 self.op(DriveOp::WaitIdle)
263 }
264 pub fn pause(&self, secs: f64) -> OpFuture {
265 self.op(DriveOp::Pause(secs))
266 }
267 pub fn shot(&self, name: &str) -> OpFuture {
269 self.op(DriveOp::Shot(name.into()))
270 }
271 pub fn assert_text(&self, id: &str, text: &str) -> OpFuture {
272 self.op(DriveOp::AssertText(id.into(), text.into()))
273 }
274 pub fn assert_visible(&self, id: &str) -> OpFuture {
275 self.op(DriveOp::AssertVisible(id.into()))
276 }
277 pub fn assert_missing(&self, id: &str) -> OpFuture {
278 self.op(DriveOp::AssertMissing(id.into()))
279 }
280 pub fn hover(&self, id: &str, at: Option<(f64, f64)>) -> OpFuture {
282 self.op(DriveOp::Hover(id.into(), at))
283 }
284 pub fn hover_leave(&self, id: &str) -> OpFuture {
286 self.op(DriveOp::HoverLeave(id.into()))
287 }
288 pub fn pan(&self, id: &str, dx: f64, dy: f64) -> OpFuture {
290 self.op(DriveOp::Pan(id.into(), dx, dy))
291 }
292 pub fn pinch(&self, id: &str, scale: f64) -> OpFuture {
294 self.op(DriveOp::Pinch(id.into(), scale))
295 }
296 pub fn rotate(&self, id: &str, rotation: f64) -> OpFuture {
298 self.op(DriveOp::Rotate(id.into(), rotation))
299 }
300 pub fn drag(&self, id: &str, from: (f64, f64), to: (f64, f64)) -> OpFuture {
302 self.op(DriveOp::Drag(id.into(), from, to))
303 }
304 pub fn tap_at(&self, id: &str, x: f64, y: f64) -> OpFuture {
306 self.op(DriveOp::TapAt(id.into(), x, y))
307 }
308 pub fn key(&self, id: Option<&str>, key: &str) -> OpFuture {
311 self.op(DriveOp::Key(id.map(str::to_owned), key.into()))
312 }
313 pub fn key_phase(&self, id: Option<&str>, key: &str, phase: day_spec::KeyPhase) -> OpFuture {
316 let phase = match phase {
317 day_spec::KeyPhase::Down => "down",
318 day_spec::KeyPhase::Repeat => "repeat",
319 day_spec::KeyPhase::Up => "up",
320 };
321 self.op(DriveOp::KeyPhase(
322 id.map(str::to_owned),
323 key.into(),
324 phase.into(),
325 ))
326 }
327 pub fn press(&self, id: &str, pressed: bool) -> OpFuture {
329 self.op(DriveOp::Press(id.into(), pressed))
330 }
331 pub fn long_press(&self, id: &str) -> OpFuture {
333 self.op(DriveOp::LongPress(id.into()))
334 }
335 pub fn double_tap(&self, id: &str) -> OpFuture {
337 self.op(DriveOp::DoubleTap(id.into()))
338 }
339 pub fn touches(
341 &self,
342 id: &str,
343 points: &[(f64, f64)],
344 phase: day_spec::TouchPhase,
345 ) -> OpFuture {
346 let phase = match phase {
347 day_spec::TouchPhase::Began => "began",
348 day_spec::TouchPhase::Moved | day_spec::TouchPhase::Stationary => "moved",
349 day_spec::TouchPhase::Ended => "ended",
350 day_spec::TouchPhase::Cancelled => "cancelled",
351 };
352 self.op(DriveOp::Touches(id.into(), points.to_vec(), phase.into()))
353 }
354 pub fn fling(
357 &self,
358 id: &str,
359 from: (f64, f64),
360 to: (f64, f64),
361 velocity: (f64, f64),
362 ) -> OpFuture {
363 self.op(DriveOp::Fling(id.into(), from, to, velocity))
364 }
365 pub fn pointer(&self, kind: day_spec::PointerKind) -> OpFuture {
367 self.op(DriveOp::Pointer(kind.name().into()))
368 }
369 pub fn drag_enter(&self, id: &str, text: &str) -> OpFuture {
371 self.op(DriveOp::DropText(id.into(), text.into(), "enter".into()))
372 }
373 pub fn drag_leave(&self, id: &str) -> OpFuture {
375 self.op(DriveOp::DropText(id.into(), String::new(), "leave".into()))
376 }
377 pub fn drop_text(&self, id: &str, text: &str) -> OpFuture {
379 self.op(DriveOp::DropText(id.into(), text.into(), "drop".into()))
380 }
381 pub fn drop_files(&self, id: &str, paths: &[&str]) -> OpFuture {
383 self.op(DriveOp::DropFiles(
384 id.into(),
385 paths.iter().map(|p| (*p).to_owned()).collect(),
386 ))
387 }
388 pub fn assert_announced(&self, text: &str) -> OpFuture {
390 self.op(DriveOp::AssertAnnounced(text.into()))
391 }
392 pub fn assert_hidden(&self, id: &str) -> OpFuture {
395 self.op(DriveOp::AssertHidden(id.into()))
396 }
397 pub fn assert_value(&self, id: &str, value: f64) -> OpFuture {
398 self.op(DriveOp::AssertValue(id.into(), value))
399 }
400 pub fn assert_on(&self, id: &str, on: bool) -> OpFuture {
402 self.op(DriveOp::AssertOn(id.into(), on))
403 }
404 pub fn assert_focused(&self, id: &str, focused: bool) -> OpFuture {
405 self.op(DriveOp::AssertFocused(id.into(), focused))
406 }
407 pub fn assert_route(&self, route: &str) -> OpFuture {
408 self.op(DriveOp::AssertRoute(route.into()))
409 }
410 pub fn a11y_audit(&self, id: Option<&str>) -> OpFuture {
413 self.op(DriveOp::A11yAudit(id.map(str::to_owned)))
414 }
415
416 pub fn assert_native(&self, id: &str, expect: NativeExpect) -> OpFuture {
421 self.op(DriveOp::AssertNative(id.into(), expect))
422 }
423 pub fn assert_frame(&self, id: &str, expect: FrameExpect) -> OpFuture {
425 self.op(DriveOp::AssertFrame(id.into(), expect))
426 }
427 pub fn assert_displayed(&self, id: &str, expect: DisplayedExpect) -> OpFuture {
432 self.op(DriveOp::AssertDisplayed(id.into(), expect))
433 }
434 pub fn assert_size(&self, id: &str, width: f64, height: f64) -> OpFuture {
436 self.assert_frame(
437 id,
438 FrameExpect {
439 width: Some(width),
440 height: Some(height),
441 ..Default::default()
442 },
443 )
444 }
445 pub fn sample_pixel(&self, id: &str, x: f64, y: f64, color: &str) -> OpFuture {
448 self.op(DriveOp::SamplePixel(id.into(), x, y, color.into()))
449 }
450 pub fn assert_opened_url(&self, url: &str) -> OpFuture {
453 self.op(DriveOp::AssertOpenedUrl(url.into()))
454 }
455 pub fn assert_enabled(&self, id: &str, enabled: bool) -> OpFuture {
457 self.assert_native(
458 id,
459 NativeExpect {
460 enabled: Some(enabled),
461 ..Default::default()
462 },
463 )
464 }
465
466 pub fn activate(&self, id: &str, index: usize) -> OpFuture {
468 self.op(DriveOp::Activate(id.into(), index))
469 }
470 pub fn reorder(&self, id: &str, from: usize, to: usize) -> OpFuture {
472 self.op(DriveOp::Reorder(id.into(), from, to))
473 }
474 pub fn delete_row(&self, id: &str, row: usize) -> OpFuture {
476 self.op(DriveOp::DeleteRow(id.into(), row))
477 }
478 pub fn swipe_row(&self, id: &str, row: usize, leading: bool, action: usize) -> OpFuture {
480 self.op(DriveOp::SwipeRow(id.into(), row, leading, action))
481 }
482 pub fn scroll_to(&self, id: &str, edge: &str) -> OpFuture {
484 self.op(DriveOp::ScrollTo(id.into(), edge.into()))
485 }
486 pub fn reveal(&self, id: &str) -> OpFuture {
489 self.op(DriveOp::ScrollTo(id.into(), String::new()))
490 }
491 pub fn expand(&self, id: &str, row: &str, expanded: bool) -> OpFuture {
493 self.op(DriveOp::Expand(id.into(), row.into(), expanded))
494 }
495 pub fn nav_back(&self) -> OpFuture {
497 self.op(DriveOp::NavBack)
498 }
499 pub fn tree_move(
502 &self,
503 id: &str,
504 row: &str,
505 parent: Option<&str>,
506 index: Option<usize>,
507 ) -> OpFuture {
508 self.op(DriveOp::TreeMove(
509 id.into(),
510 row.into(),
511 parent.map(str::to_owned),
512 index,
513 ))
514 }
515
516 pub fn context_menu(&self, id: &str, item: &str) -> OpFuture {
519 self.op(DriveOp::ContextMenu(id.into(), item.into()))
520 }
521 pub fn menu(&self, item_id: &str) -> OpFuture {
523 self.op(DriveOp::Menu(item_id.into()))
524 }
525 pub fn toolbar_press(&self, item: &str) -> OpFuture {
527 self.op(DriveOp::ToolbarPress(item.into()))
528 }
529 pub fn toolbar_toggle(&self, item: &str, on: bool) -> OpFuture {
531 self.op(DriveOp::ToolbarToggle(item.into(), on))
532 }
533 pub fn dialogs_scripted(&self, scripted: bool) -> OpFuture {
537 self.op(DriveOp::DialogScripted(scripted))
538 }
539 pub fn assert_presented(&self, title: Option<&str>) -> OpFuture {
541 self.op(DriveOp::AssertPresented(title.map(str::to_owned)))
542 }
543 pub fn respond(&self, button: Option<usize>) -> OpFuture {
546 self.op(DriveOp::Respond(button))
547 }
548
549 pub fn respond_text(&self, text: &str) -> OpFuture {
551 self.op(DriveOp::RespondText(text.into()))
552 }
553
554 pub fn check(&self, ok: bool, what: &str) -> TestResult {
560 if ok { Ok(()) } else { Err(Fail(what.into())) }
561 }
562 #[expect(
568 clippy::needless_pass_by_value,
569 reason = "public test-helper signature; callers pass temporaries by value"
570 )]
571 pub fn check_eq<T: PartialEq + std::fmt::Debug>(&self, got: T, want: T) -> TestResult {
572 if got == want {
573 Ok(())
574 } else {
575 Err(Fail(format!("{got:?} ≠ expected {want:?}")))
576 }
577 }
578}
579
580#[derive(Clone, Copy, Debug, PartialEq, Eq)]
582pub enum TestKind {
583 Gui,
584 Headless,
585}
586
587type Body = Rc<dyn Fn(Drive) -> Pin<Box<dyn Future<Output = TestResult>>>>;
588
589#[derive(Clone)]
593pub struct Case {
594 name: String,
595 kind: TestKind,
596 proves: Vec<String>,
597 requires: Vec<Cap>,
598 requires_support: Vec<(String, fn() -> day_spec::Support)>,
600 page: Option<Rc<dyn Fn() -> AnyPiece>>,
601 shots: Vec<String>,
602 body: Option<Body>,
603 timeout_secs: Option<f64>,
604}
605
606impl Default for Case {
607 fn default() -> Self {
608 Case::new()
609 }
610}
611
612impl Case {
613 pub fn new() -> Self {
615 Case {
616 name: String::new(),
617 kind: TestKind::Gui,
618 proves: Vec::new(),
619 requires: Vec::new(),
620 requires_support: Vec::new(),
621 page: None,
622 shots: Vec::new(),
623 body: None,
624 timeout_secs: None,
625 }
626 }
627 pub fn headless() -> Self {
629 Case {
630 kind: TestKind::Headless,
631 ..Case::new()
632 }
633 }
634 #[must_use]
637 pub fn timeout(mut self, secs: f64) -> Self {
638 self.timeout_secs = Some(secs);
639 self
640 }
641 #[must_use]
644 pub fn proves(mut self, kind: &str) -> Self {
645 self.proves.push(format!("kind:{kind}"));
646 self
647 }
648 #[must_use]
650 pub fn proves_cap(mut self, cap: Cap) -> Self {
651 self.proves.push(format!("cap:{cap:?}"));
652 self
653 }
654 #[must_use]
656 pub fn proves_modifier(mut self, modifier: &str) -> Self {
657 self.proves.push(format!("modifier:{modifier}"));
658 self
659 }
660 #[must_use]
662 pub fn proves_duty(mut self, duty: &str) -> Self {
663 self.proves.push(format!("duty:{duty}"));
664 self
665 }
666 #[must_use]
669 pub fn requires(mut self, cap: Cap) -> Self {
670 self.requires.push(cap);
671 self
672 }
673 #[must_use]
677 pub fn requires_support(mut self, what: &str, support: fn() -> day_spec::Support) -> Self {
678 self.requires_support.push((what.to_owned(), support));
679 self
680 }
681 #[must_use]
683 pub fn missing_support(&self) -> Option<String> {
684 self.requires_support
685 .iter()
686 .find(|(_, f)| f() == day_spec::Support::Unsupported)
687 .map(|(what, _)| what.clone())
688 }
689 #[must_use]
691 pub fn page<P: crate::Piece>(mut self, page: impl Fn() -> P + 'static) -> Self {
692 self.page = Some(Rc::new(move || AnyPiece::new(page())));
693 self
694 }
695 #[must_use]
697 pub fn shot(mut self, name: &str) -> Self {
698 self.shots.push(name.into());
699 self
700 }
701 #[must_use]
705 pub fn drive<F>(mut self, body: impl Fn(Drive) -> F + 'static) -> Self
706 where
707 F: Future<Output = TestResult> + 'static,
708 {
709 self.body = Some(Rc::new(move |d| Box::pin(body(d))));
710 self
711 }
712 #[must_use]
714 pub fn run<F>(self, body: impl Fn(Drive) -> F + 'static) -> Self
715 where
716 F: Future<Output = TestResult> + 'static,
717 {
718 self.drive(body)
719 }
720
721 #[must_use]
724 pub fn name(&self) -> &str {
725 &self.name
726 }
727 #[must_use]
729 pub fn timeout_secs(&self) -> Option<f64> {
730 self.timeout_secs
731 }
732 #[must_use]
733 pub fn kind(&self) -> TestKind {
734 self.kind
735 }
736 #[must_use]
738 pub fn proves_keys(&self) -> &[String] {
739 &self.proves
740 }
741 #[must_use]
742 pub fn requirements(&self) -> &[Cap] {
743 &self.requires
744 }
745 #[must_use]
747 pub fn shots(&self) -> &[String] {
748 &self.shots
749 }
750 #[must_use]
752 pub fn build_page(&self) -> Option<AnyPiece> {
753 self.page.as_ref().map(|p| p())
754 }
755 pub fn run_body(&self, drive: Drive) -> Pin<Box<dyn Future<Output = TestResult>>> {
757 match &self.body {
758 Some(body) => body(drive),
759 None => Box::pin(async { Ok(()) }),
760 }
761 }
762}
763
764#[derive(Clone, Copy)]
767pub struct TestFn {
768 ident: &'static str,
769 build: fn() -> Case,
770}
771
772impl TestFn {
773 pub const fn new(ident: &'static str, build: fn() -> Case) -> Self {
775 TestFn { ident, build }
776 }
777 #[must_use]
779 pub fn name(&self) -> String {
780 let last = self.ident.rsplit("::").next().unwrap_or(self.ident);
781 last.trim().replace('_', "-")
782 }
783 pub fn case(&self) -> Case {
785 let mut case = (self.build)();
786 case.name = self.name();
787 case
788 }
789}
790
791mod registry;
792pub use registry::validate_registry;
793#[cfg(target_arch = "wasm32")]
794pub use registry::{Registration, install_web_registry};
795
796#[cfg(not(target_arch = "wasm32"))]
798#[linkme::distributed_slice]
799pub static TESTS: [TestFn];
800
801type HostNotify = Rc<dyn Fn()>;
803
804day_reactive::tls_slots! {
805 conformance;
806 static RUNTIME: RefCell<Vec<TestFn>> = const { RefCell::new(Vec::new()) };
807 static ACTIVE: RefCell<Option<Case>> = const { RefCell::new(None) };
810 static HOST: RefCell<Option<HostNotify>> = const { RefCell::new(None) };
812 static PAGE_PANIC: RefCell<Option<String>> = const { RefCell::new(None) };
814 static OPENED: RefCell<Option<Vec<String>>> = const { RefCell::new(None) };
816 static ANNOUNCED: RefCell<Option<Vec<String>>> = const { RefCell::new(None) };
818}
819
820pub fn set_intercepting_urls(on: bool) {
824 OPENED.with(|o| *o.borrow_mut() = on.then(Vec::new));
825 ANNOUNCED.with(|a| *a.borrow_mut() = on.then(Vec::new));
826}
827
828pub fn note_announcement(text: &str) {
832 ANNOUNCED.with(|a| {
833 if let Some(list) = a.borrow_mut().as_mut() {
834 list.push(text.to_owned());
835 }
836 });
837}
838
839#[must_use]
841pub fn announcements() -> Vec<String> {
842 ANNOUNCED.with(|a| a.borrow().clone().unwrap_or_default())
843}
844
845#[must_use]
847pub fn intercept_open_url(url: &str) -> bool {
848 OPENED.with(|o| match o.borrow_mut().as_mut() {
849 Some(list) => {
850 list.push(url.to_owned());
851 true
852 }
853 None => false,
854 })
855}
856
857#[must_use]
859pub fn opened_urls() -> Vec<String> {
860 OPENED.with(|o| o.borrow().clone().unwrap_or_default())
861}
862
863pub fn register(test: TestFn) {
865 RUNTIME.with(|r| {
866 let mut r = r.borrow_mut();
867 if !r.iter().any(|t| std::ptr::fn_addr_eq(t.build, test.build)) {
868 r.push(test);
869 }
870 });
871}
872
873#[must_use]
875pub fn tests() -> Vec<TestFn> {
876 let mut all: Vec<TestFn> = Vec::new();
877 all.extend(registry::compiled_tests());
878 RUNTIME.with(|r| {
879 for t in r.borrow().iter() {
880 if !all.iter().any(|a| std::ptr::fn_addr_eq(a.build, t.build)) {
881 all.push(*t);
882 }
883 }
884 });
885 all
886}
887
888pub fn cases() -> Vec<Case> {
890 let mut cases: Vec<Case> = tests().iter().map(TestFn::case).collect();
891 cases.sort_by(|a, b| a.name.cmp(&b.name));
892 cases
893}
894
895#[must_use]
898pub fn set_active(case: Case) -> bool {
899 ACTIVE.with(|a| *a.borrow_mut() = Some(case));
900 PAGE_PANIC.with(|p| *p.borrow_mut() = None);
901 notify_host()
902}
903
904pub fn clear_active() {
906 ACTIVE.with(|a| *a.borrow_mut() = None);
907 notify_host();
908}
909
910fn notify_host() -> bool {
911 let host = HOST.with(|h| h.borrow().clone());
912 match host {
913 Some(rebuild) => {
914 rebuild();
915 true
916 }
917 None => false,
918 }
919}
920
921#[must_use]
923pub fn active() -> Option<Case> {
924 ACTIVE.with(|a| a.borrow().clone())
925}
926
927pub fn set_host(rebuild: Option<Rc<dyn Fn()>>) {
930 HOST.with(|h| *h.borrow_mut() = rebuild);
931}
932
933pub fn note_page_panic(message: String) {
935 PAGE_PANIC.with(|p| *p.borrow_mut() = Some(message));
936}
937
938#[must_use]
940pub fn take_page_panic() -> Option<String> {
941 PAGE_PANIC.with(|p| p.borrow_mut().take())
942}
943
944pub fn panic_message(payload: &(dyn std::any::Any + Send)) -> String {
946 if let Some(s) = payload.downcast_ref::<&str>() {
947 (*s).to_owned()
948 } else if let Some(s) = payload.downcast_ref::<String>() {
949 s.clone()
950 } else {
951 "a panic with no message".to_owned()
952 }
953}
954
955#[must_use]
958pub fn case_named(name: &str) -> Option<Case> {
959 tests()
960 .into_iter()
961 .find(|t| t.name() == name)
962 .map(|t| t.case())
963}