Skip to main content

sui_platform/
lib.rs

1#![deny(unsafe_code)]
2
3mod accessibility;
4#[cfg(target_os = "android")]
5#[allow(unsafe_code)]
6mod android_clipboard;
7mod desktop;
8mod display_capabilities;
9mod file_dialog;
10mod headless;
11#[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
12mod os_clipboard;
13#[cfg(any(target_arch = "wasm32", test))]
14mod web_interop;
15#[cfg(target_os = "windows")]
16mod windows_accessibility;
17
18use web_time::Instant;
19
20use sui_core::WindowId;
21use sui_render_wgpu::{
22    ColorManagementMode, RendererFrameStats, RequestedColorManagementMode,
23    RequestedDynamicRangeMode, RequestedOutputColorPrimaries, RequestedToneMappingMode,
24    StemDarkening, TextCoveragePolicy, TextHinting, TextSubpixelOrder, WgpuRenderer,
25};
26use sui_runtime::{
27    CacheMetrics, FramePhase, FramePhaseSample, PresentationLatencyDiagnostics, RenderOutput,
28    RendererSubmissionDiagnostics, RetainedPacketHotspotDiagnostics,
29    RetainedPacketRebuildDiagnostics, SceneStatistics, TextCacheDiagnostics,
30    WindowColorManagementMode, WindowDynamicRangeMode, WindowOutputColorPrimaries,
31    WindowPerformanceSnapshot, WindowStemDarkening, WindowTextCoveragePolicy, WindowTextHinting,
32    WindowTextSubpixelOrder, WindowToneMappingMode, clear_window_performance_snapshot,
33    clear_window_performance_snapshots, publish_window_performance_snapshot,
34    window_performance_text_caches, window_scene_statistics_detail_mode,
35};
36
37pub(crate) use accessibility::AccessibilityBridge;
38pub use accessibility::{
39    AccessibilityIssue, AccessibilityIssueSeverity, AccessibilityIssueTarget,
40    AccessibilitySnapshot, validate_accessibility_snapshot,
41};
42#[cfg(target_os = "android")]
43pub use desktop::AndroidApp;
44pub use desktop::{
45    DesktopAutomationAction, DesktopAutomationConfig, DesktopExtension, DesktopExtensionContext,
46    DesktopFramePresented, DesktopPlatform, DesktopWindow, WakeSignal, Waker,
47};
48pub use display_capabilities::{
49    WindowOutputDiagnostics, clear_window_output_diagnostics, clear_window_output_diagnostics_all,
50    detect_window_display_capabilities, publish_window_output_diagnostics,
51    resolve_sdr_content_brightness_nits, window_output_diagnostics,
52};
53pub use file_dialog::{
54    FileDialogFilter, FileDialogFuture, FileDialogMode, FileDialogRequest, FileDialogSelection,
55    FileDialogService, NativeFileDialogs, PlatformFile, show_file_dialog,
56};
57pub use headless::{HeadlessPlatform, PlatformWindow};
58#[cfg(any(target_os = "windows", target_os = "macos", target_os = "linux"))]
59pub use os_clipboard::OsClipboardBackend;
60
61pub(crate) fn reset_window_performance_store() {
62    clear_window_performance_snapshots();
63    clear_window_output_diagnostics_all();
64}
65
66pub(crate) fn map_window_text_hinting(hinting: WindowTextHinting) -> TextHinting {
67    match hinting.normalized() {
68        WindowTextHinting::None => TextHinting::None,
69        WindowTextHinting::Slight { max_ppem } => TextHinting::Slight { max_ppem },
70    }
71}
72
73pub(crate) fn map_window_stem_darkening(darkening: WindowStemDarkening) -> StemDarkening {
74    match darkening.normalized() {
75        WindowStemDarkening::None => StemDarkening::None,
76        WindowStemDarkening::Enabled { max_ppem, amount } => {
77            StemDarkening::Enabled { max_ppem, amount }
78        }
79    }
80}
81
82pub(crate) fn map_window_text_coverage_policy(
83    policy: WindowTextCoveragePolicy,
84) -> TextCoveragePolicy {
85    match policy.normalized() {
86        WindowTextCoveragePolicy::Perceptual => TextCoveragePolicy::Perceptual,
87        WindowTextCoveragePolicy::Linear => TextCoveragePolicy::Linear,
88        WindowTextCoveragePolicy::Gamma(gamma) => TextCoveragePolicy::Gamma(gamma),
89        WindowTextCoveragePolicy::CoverageBoost(amount) => {
90            TextCoveragePolicy::CoverageBoost(amount)
91        }
92        WindowTextCoveragePolicy::TwoCoverageMinusCoverageSq => {
93            TextCoveragePolicy::TwoCoverageMinusCoverageSq
94        }
95    }
96}
97
98pub(crate) fn map_window_text_subpixel_order(order: WindowTextSubpixelOrder) -> TextSubpixelOrder {
99    match order {
100        WindowTextSubpixelOrder::None => TextSubpixelOrder::None,
101        WindowTextSubpixelOrder::Rgb => TextSubpixelOrder::Rgb,
102        WindowTextSubpixelOrder::Bgr => TextSubpixelOrder::Bgr,
103    }
104}
105
106pub(crate) fn map_window_color_management(
107    mode: WindowColorManagementMode,
108    primaries: WindowOutputColorPrimaries,
109    dynamic_range: WindowDynamicRangeMode,
110    tone_mapping: WindowToneMappingMode,
111    sdr_content_brightness_nits: f32,
112) -> ColorManagementMode {
113    ColorManagementMode {
114        mode: match mode {
115            WindowColorManagementMode::Automatic => RequestedColorManagementMode::Automatic,
116            WindowColorManagementMode::ForceSdr => RequestedColorManagementMode::ForceSdr,
117            WindowColorManagementMode::PreferWideGamut => {
118                RequestedColorManagementMode::PreferWideGamut
119            }
120            WindowColorManagementMode::PreferHdr => RequestedColorManagementMode::PreferHdr,
121        },
122        output_primaries: match primaries {
123            WindowOutputColorPrimaries::Automatic => RequestedOutputColorPrimaries::Automatic,
124            WindowOutputColorPrimaries::Srgb => RequestedOutputColorPrimaries::Srgb,
125            WindowOutputColorPrimaries::DisplayP3 => RequestedOutputColorPrimaries::DisplayP3,
126        },
127        dynamic_range: match dynamic_range {
128            WindowDynamicRangeMode::Automatic => RequestedDynamicRangeMode::Automatic,
129            WindowDynamicRangeMode::StandardDynamicRange => {
130                RequestedDynamicRangeMode::StandardDynamicRange
131            }
132            WindowDynamicRangeMode::HighDynamicRange => RequestedDynamicRangeMode::HighDynamicRange,
133        },
134        tone_mapping: match tone_mapping {
135            WindowToneMappingMode::Automatic => RequestedToneMappingMode::Automatic,
136            WindowToneMappingMode::Clamp => RequestedToneMappingMode::Clamp,
137            WindowToneMappingMode::Reinhard => RequestedToneMappingMode::Reinhard,
138        },
139        sdr_content_brightness_nits,
140    }
141}
142
143pub(crate) fn clear_window_performance(window_id: WindowId) {
144    clear_window_performance_snapshot(window_id);
145    clear_window_output_diagnostics(window_id);
146}
147
148fn retained_packet_rebuild_diagnostics(
149    rebuilds: sui_render_wgpu::RetainedPacketRebuildStats,
150) -> RetainedPacketRebuildDiagnostics {
151    RetainedPacketRebuildDiagnostics::new(
152        rebuilds.new_count,
153        rebuilds.coordinate_space_count,
154        rebuilds.signature_count,
155        rebuilds.scene_count,
156        rebuilds.state_count,
157    )
158}
159
160fn renderer_submission_diagnostics_from_frame_stats(
161    renderer_stats: &RendererFrameStats,
162) -> RendererSubmissionDiagnostics {
163    RendererSubmissionDiagnostics::new(
164        renderer_stats.pass_count,
165        renderer_stats.draw_count,
166        renderer_stats.uploaded_vertex_bytes,
167        renderer_stats.text_glyph_instance_count,
168        renderer_stats.text_vertex_bytes,
169        renderer_stats.visible_layer_count,
170        renderer_stats.direct_packet_count,
171        renderer_stats.retained_state_update_time_us,
172        renderer_stats.composition_time_us,
173        renderer_stats.retained_scene_traversal_time_us,
174        renderer_stats.retained_packet_build_time_us,
175        renderer_stats.retained_packet_build_count,
176        retained_packet_rebuild_diagnostics(renderer_stats.retained_packet_rebuilds),
177        renderer_stats.text_atlas_miss_count,
178        renderer_stats.text_atlas_miss_time_us,
179        renderer_stats.surface_acquire_time_us,
180        renderer_stats.resource_collection_time_us,
181        renderer_stats.bind_group_prepare_time_us,
182        renderer_stats.image_bind_group_time_us,
183        renderer_stats.analytic_path_bind_group_time_us,
184        renderer_stats.analytic_path_bind_group_miss_count,
185        renderer_stats.analytic_path_bind_group_upload_bytes,
186        renderer_stats.text_atlas_bind_group_time_us,
187        renderer_stats.text_atlas_upload_copy_time_us,
188        renderer_stats.text_atlas_upload_write_time_us,
189        renderer_stats.text_atlas_upload_bytes,
190        renderer_stats.batch_prepare_time_us,
191        renderer_stats.gpu_upload_time_us,
192        renderer_stats.pass_encode_time_us,
193        renderer_stats.queue_submit_time_us,
194        renderer_stats.surface_present_time_us,
195    )
196    .with_retained_packet_breakdown(
197        renderer_stats.retained_packet_normalize_time_us,
198        renderer_stats.retained_packet_signature_time_us,
199        renderer_stats.retained_packet_raster_state_init_time_us,
200        renderer_stats.retained_packet_scene_build_time_us,
201        renderer_stats.retained_packet_command_count,
202        renderer_stats.retained_packet_text_command_count,
203        renderer_stats.retained_packet_path_command_count,
204        renderer_stats.retained_packet_clip_path_command_count,
205        renderer_stats.retained_packet_image_command_count,
206        renderer_stats.retained_packet_rect_command_count,
207        renderer_stats.retained_packet_text_command_time_us,
208        renderer_stats.retained_packet_path_command_time_us,
209        renderer_stats.retained_packet_clip_path_command_time_us,
210        renderer_stats.retained_packet_image_command_time_us,
211        renderer_stats.retained_packet_rect_command_time_us,
212    )
213}
214
215fn retained_packet_hotspot_diagnostics_from_frame_stats(
216    renderer_stats: &RendererFrameStats,
217) -> Option<RetainedPacketHotspotDiagnostics> {
218    renderer_stats
219        .retained_packet_hotspot
220        .clone()
221        .map(|hotspot| RetainedPacketHotspotDiagnostics {
222            container_layer_id: hotspot.container_layer_id,
223            owner_widget_id: hotspot.owner_widget_id,
224            segment_index: hotspot.segment_index,
225            total_time_us: hotspot.total_time_us,
226            scene_build_time_us: hotspot.scene_build_time_us,
227            command_count: hotspot.command_count,
228            text_command_count: hotspot.text_command_count,
229            path_command_count: hotspot.path_command_count,
230            rect_command_count: hotspot.rect_command_count,
231            text_command_time_us: hotspot.text_command_time_us,
232            path_command_time_us: hotspot.path_command_time_us,
233            rect_command_time_us: hotspot.rect_command_time_us,
234            text_sample: hotspot.text_sample,
235        })
236}
237
238fn split_renderer_phase_times_ms(
239    renderer_time_ms: f64,
240    renderer_stats: &RendererFrameStats,
241) -> (f64, f64) {
242    let renderer_time_ms = renderer_time_ms.max(0.0);
243    let surface_wait_time_ms = ((renderer_stats
244        .surface_acquire_time_us
245        .saturating_add(renderer_stats.surface_present_time_us))
246        as f64
247        / 1000.0)
248        .min(renderer_time_ms);
249    let renderer_work_time_ms = (renderer_time_ms - surface_wait_time_ms).max(0.0);
250    (renderer_work_time_ms, surface_wait_time_ms)
251}
252
253#[allow(clippy::too_many_arguments)]
254pub fn publish_frame_performance(
255    window_id: WindowId,
256    frame_index: u64,
257    event_time_ms: f64,
258    redraw_time_ms: f64,
259    runtime_time_ms: f64,
260    presentation_latency: PresentationLatencyDiagnostics,
261    output: &RenderOutput,
262    renderer: &WgpuRenderer,
263    renderer_time_ms: f64,
264) {
265    let detail_mode = window_scene_statistics_detail_mode(window_id);
266    let total_time_ms = event_time_ms + redraw_time_ms + runtime_time_ms + renderer_time_ms;
267
268    if !detail_mode.is_detailed() {
269        let scene =
270            SceneStatistics::minimal(&output.frame, output.diagnostics.widget_count, detail_mode)
271                .with_animation_counters(
272                    output.diagnostics.active_animated_widget_count,
273                    output.diagnostics.animation_frame_wake_count,
274                    output.diagnostics.animation_repaint_frame_count,
275                    output
276                        .diagnostics
277                        .animation_transform_effect_only_frame_count,
278                );
279        publish_window_performance_snapshot(
280            WindowPerformanceSnapshot::with_total_time_ms(
281                window_id,
282                frame_index,
283                total_time_ms,
284                Vec::new(),
285                RendererSubmissionDiagnostics::default(),
286                TextCacheDiagnostics::default(),
287                Default::default(),
288                scene,
289            )
290            .with_presentation_latency(presentation_latency)
291            .with_runtime_text_timing(output.diagnostics.runtime_text_timing)
292            .with_widget_timings(output.diagnostics.widget_timings.clone())
293            .with_event_traces(
294                output.diagnostics.command_dispatches.clone(),
295                output.diagnostics.invalidations.clone(),
296            ),
297        );
298        return;
299    }
300
301    let diagnostics_started = Instant::now();
302    let mut phase_timings = Vec::with_capacity(output.diagnostics.phase_timings.len() + 3);
303    let renderer_text_cache = renderer.text_cache_snapshot(window_id);
304    let text_caches = TextCacheDiagnostics {
305        runtime_layout: output.diagnostics.text_caches.runtime_layout,
306        renderer_layout: CacheMetrics::new(
307            renderer_text_cache.layout.entries,
308            renderer_text_cache.layout.hits,
309            renderer_text_cache.layout.misses,
310        ),
311        renderer_glyph: CacheMetrics::new(
312            renderer_text_cache.glyph.entries,
313            renderer_text_cache.glyph.hits,
314            renderer_text_cache.glyph.misses,
315        ),
316        renderer_path: CacheMetrics::new(
317            renderer_text_cache.path.entries,
318            renderer_text_cache.path.hits,
319            renderer_text_cache.path.misses,
320        ),
321    };
322    let text_cache_deltas = window_performance_text_caches(window_id)
323        .map(|previous| text_caches.delta_from(&previous))
324        .unwrap_or_else(|| text_caches.delta_from(&TextCacheDiagnostics::default()));
325    let renderer_stats = renderer.last_frame_stats(window_id).unwrap_or_default();
326
327    if event_time_ms > 0.0 {
328        phase_timings.push(FramePhaseSample::new(FramePhase::Event, event_time_ms));
329    }
330
331    if redraw_time_ms > 0.0 {
332        phase_timings.push(FramePhaseSample::new(FramePhase::Redraw, redraw_time_ms));
333    }
334
335    phase_timings.extend(output.diagnostics.phase_timings.iter().copied());
336    let (renderer_work_time_ms, surface_wait_time_ms) =
337        split_renderer_phase_times_ms(renderer_time_ms, &renderer_stats);
338    if renderer_work_time_ms > 0.0 {
339        phase_timings.push(FramePhaseSample::new(
340            FramePhase::Renderer,
341            renderer_work_time_ms,
342        ));
343    }
344    if surface_wait_time_ms > 0.0 {
345        phase_timings.push(FramePhaseSample::new(
346            FramePhase::SurfaceWait,
347            surface_wait_time_ms,
348        ));
349    }
350    phase_timings.push(FramePhaseSample::new(
351        FramePhase::Diagnostics,
352        diagnostics_started.elapsed().as_secs_f64() * 1000.0,
353    ));
354    let total_time_ms = event_time_ms
355        + redraw_time_ms
356        + runtime_time_ms
357        + renderer_time_ms
358        + diagnostics_started.elapsed().as_secs_f64() * 1000.0;
359
360    let scene = SceneStatistics::from_frame_with_mode(
361        &output.frame,
362        output.diagnostics.widget_count,
363        detail_mode,
364    )
365    .with_animation_counters(
366        output.diagnostics.active_animated_widget_count,
367        output.diagnostics.animation_frame_wake_count,
368        output.diagnostics.animation_repaint_frame_count,
369        output
370            .diagnostics
371            .animation_transform_effect_only_frame_count,
372    );
373
374    publish_window_performance_snapshot(
375        WindowPerformanceSnapshot::with_total_time_ms(
376            window_id,
377            frame_index,
378            total_time_ms,
379            phase_timings,
380            renderer_submission_diagnostics_from_frame_stats(&renderer_stats),
381            text_caches,
382            text_cache_deltas,
383            scene,
384        )
385        .with_presentation_latency(presentation_latency)
386        .with_runtime_text_timing(output.diagnostics.runtime_text_timing)
387        .with_retained_packet_hotspot(retained_packet_hotspot_diagnostics_from_frame_stats(
388            &renderer_stats,
389        ))
390        .with_widget_timings(output.diagnostics.widget_timings.clone())
391        .with_event_traces(
392            output.diagnostics.command_dispatches.clone(),
393            output.diagnostics.invalidations.clone(),
394        ),
395    );
396}
397
398#[cfg(test)]
399mod tests {
400    use super::{
401        renderer_submission_diagnostics_from_frame_stats,
402        retained_packet_hotspot_diagnostics_from_frame_stats, retained_packet_rebuild_diagnostics,
403        split_renderer_phase_times_ms,
404    };
405    use sui_render_wgpu::{RendererFrameStats, RendererPacketHotspot, RetainedPacketRebuildStats};
406
407    #[test]
408    fn retained_packet_rebuild_diagnostics_bridge_preserves_named_buckets() {
409        let rebuilds = RetainedPacketRebuildStats::new(2, 3, 5, 7, 11);
410
411        let diagnostics = retained_packet_rebuild_diagnostics(rebuilds);
412
413        assert_eq!(diagnostics.new_count, 2);
414        assert_eq!(diagnostics.coordinate_space_count, 3);
415        assert_eq!(diagnostics.signature_count, 5);
416        assert_eq!(diagnostics.scene_count, 7);
417        assert_eq!(diagnostics.state_count, 11);
418    }
419
420    #[test]
421    fn renderer_submission_diagnostics_from_frame_stats_preserves_retained_details() {
422        let renderer_stats = RendererFrameStats {
423            pass_count: 3,
424            draw_count: 9,
425            uploaded_vertex_bytes: 4096,
426            text_glyph_instance_count: 42,
427            text_vertex_bytes: 2048,
428            visible_layer_count: 4,
429            direct_packet_count: 6,
430            retained_state_update_time_us: 31,
431            composition_time_us: 32,
432            retained_scene_traversal_time_us: 33,
433            retained_packet_build_time_us: 34,
434            retained_packet_build_count: 2,
435            retained_packet_rebuilds: RetainedPacketRebuildStats::new(1, 0, 1, 1, 0),
436            retained_packet_normalize_time_us: 41,
437            retained_packet_signature_time_us: 42,
438            retained_packet_raster_state_init_time_us: 43,
439            retained_packet_scene_build_time_us: 44,
440            retained_packet_command_count: 45,
441            retained_packet_text_command_count: 46,
442            retained_packet_path_command_count: 47,
443            retained_packet_clip_path_command_count: 48,
444            retained_packet_image_command_count: 49,
445            retained_packet_rect_command_count: 50,
446            retained_packet_text_command_time_us: 51,
447            retained_packet_path_command_time_us: 52,
448            retained_packet_clip_path_command_time_us: 53,
449            retained_packet_image_command_time_us: 54,
450            retained_packet_rect_command_time_us: 55,
451            text_atlas_miss_count: 7,
452            text_atlas_miss_time_us: 56,
453            surface_acquire_time_us: 57,
454            resource_collection_time_us: 58,
455            bind_group_prepare_time_us: 59,
456            image_bind_group_time_us: 60,
457            analytic_path_bind_group_time_us: 61,
458            analytic_path_bind_group_miss_count: 8,
459            analytic_path_bind_group_upload_bytes: 62,
460            text_atlas_bind_group_time_us: 63,
461            text_atlas_upload_copy_time_us: 64,
462            text_atlas_upload_write_time_us: 65,
463            text_atlas_upload_bytes: 66,
464            batch_prepare_time_us: 67,
465            gpu_upload_time_us: 68,
466            pass_encode_time_us: 69,
467            queue_submit_time_us: 70,
468            surface_present_time_us: 71,
469            retained_packet_hotspot: Some(RendererPacketHotspot {
470                container_layer_id: Some(101),
471                owner_widget_id: Some(202),
472                segment_index: 3,
473                total_time_us: 72,
474                scene_build_time_us: 73,
475                command_count: 74,
476                text_command_count: 75,
477                path_command_count: 76,
478                rect_command_count: 77,
479                text_command_time_us: 78,
480                path_command_time_us: 79,
481                rect_command_time_us: 80,
482                text_sample: Some("packet text".to_string()),
483            }),
484            ..Default::default()
485        };
486
487        let diagnostics = renderer_submission_diagnostics_from_frame_stats(&renderer_stats);
488
489        assert_eq!(diagnostics.pass_count, 3);
490        assert_eq!(diagnostics.retained_packet_build_count, 2);
491        assert_eq!(diagnostics.retained_packet_rebuilds.new_count, 1);
492        assert_eq!(diagnostics.retained_packet_rebuilds.signature_count, 1);
493        assert_eq!(diagnostics.retained_packet_rebuilds.scene_count, 1);
494        assert_eq!(diagnostics.retained_packet_normalize_time_us, 41);
495        assert_eq!(diagnostics.retained_packet_command_count, 45);
496        assert_eq!(diagnostics.text_atlas_miss_count, 7);
497    }
498
499    #[test]
500    fn renderer_phase_split_separates_surface_wait_from_work() {
501        let renderer_stats = RendererFrameStats {
502            surface_acquire_time_us: 4_000,
503            surface_present_time_us: 8_000,
504            ..Default::default()
505        };
506
507        let (renderer_work_time_ms, surface_wait_time_ms) =
508            split_renderer_phase_times_ms(20.0, &renderer_stats);
509
510        assert_eq!(renderer_work_time_ms, 8.0);
511        assert_eq!(surface_wait_time_ms, 12.0);
512    }
513
514    #[test]
515    fn renderer_phase_split_caps_wait_at_renderer_wall_time() {
516        let renderer_stats = RendererFrameStats {
517            surface_acquire_time_us: 9_000,
518            surface_present_time_us: 9_000,
519            ..Default::default()
520        };
521
522        let (renderer_work_time_ms, surface_wait_time_ms) =
523            split_renderer_phase_times_ms(10.0, &renderer_stats);
524
525        assert_eq!(renderer_work_time_ms, 0.0);
526        assert_eq!(surface_wait_time_ms, 10.0);
527    }
528
529    #[test]
530    fn retained_packet_hotspot_diagnostics_bridge_preserves_hotspot_fields() {
531        let renderer_stats = RendererFrameStats {
532            retained_packet_hotspot: Some(RendererPacketHotspot {
533                container_layer_id: Some(11),
534                owner_widget_id: Some(22),
535                segment_index: 3,
536                total_time_us: 44,
537                scene_build_time_us: 55,
538                command_count: 66,
539                text_command_count: 77,
540                path_command_count: 88,
541                rect_command_count: 99,
542                text_command_time_us: 111,
543                path_command_time_us: 222,
544                rect_command_time_us: 333,
545                text_sample: Some("sample".to_string()),
546            }),
547            ..Default::default()
548        };
549
550        let hotspot = retained_packet_hotspot_diagnostics_from_frame_stats(&renderer_stats)
551            .expect("expected hotspot diagnostics");
552
553        assert_eq!(hotspot.container_layer_id, Some(11));
554        assert_eq!(hotspot.owner_widget_id, Some(22));
555        assert_eq!(hotspot.segment_index, 3);
556        assert_eq!(hotspot.total_time_us, 44);
557        assert_eq!(hotspot.scene_build_time_us, 55);
558        assert_eq!(hotspot.command_count, 66);
559        assert_eq!(hotspot.text_command_count, 77);
560        assert_eq!(hotspot.path_command_count, 88);
561        assert_eq!(hotspot.rect_command_count, 99);
562        assert_eq!(hotspot.text_command_time_us, 111);
563        assert_eq!(hotspot.path_command_time_us, 222);
564        assert_eq!(hotspot.rect_command_time_us, 333);
565        assert_eq!(hotspot.text_sample.as_deref(), Some("sample"));
566    }
567}