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