856f865cf98d
tests.rs
use super::*;
/// A GPU measurement arrives a frame or two after its refresh, so most GPU refreshes carry
/// none; the last one reported must stand until a newer one lands. A CPU refresh is
/// different: there is no GPU time at all then, and keeping the old number would show it as
/// this refresh's. Runs anywhere — the GPU timing tests need hardware and CI has none.
#[test]
fn a_gpu_measurement_stands_until_replaced_and_a_cpu_refresh_clears_it() {
let timing = |ms, px| photocraft_gpu::GpuTiming { ms, px, spans: 1 };
let refresh = |kind, gpu| Refresh { kind, gpu, ..Default::default() };
let mut perf = Perf::default();
assert_eq!(perf.gpu_ms, None, "nothing is reported before a measurement");
perf.record_refresh(&refresh("gpu-full", Some(timing(83.9, 24_000_000))));
assert_eq!((perf.gpu_ms, perf.gpu_ms_px), (Some(83.9), 24_000_000));
// The common case: a GPU refresh whose own measurement has not come back yet.
perf.record_refresh(&refresh("gpu-rect", None));
assert_eq!((perf.gpu_ms, perf.gpu_ms_px), (Some(83.9), 24_000_000), "the last measurement stands");
perf.record_refresh(&refresh("gpu-rect", Some(timing(11.2, 1_098_640))));
assert_eq!((perf.gpu_ms, perf.gpu_ms_px), (Some(11.2), 1_098_640), "a newer measurement replaces it");
// The CPU compositor did this one: the GPU number belongs to no refresh on screen.
perf.record_refresh(&refresh("full", None));
assert_eq!((perf.gpu_ms, perf.gpu_ms_px), (None, 0), "a CPU refresh clears it rather than showing a stale one");
// And it comes back on the next GPU refresh that carries one.
perf.record_refresh(&refresh("gpu-full", Some(timing(42.0, 6_000_000))));
assert_eq!((perf.gpu_ms, perf.gpu_ms_px), (Some(42.0), 6_000_000));
}
#[test]
fn device_limits_support_v3d_shader_variable_limit() {
let supported = wgpu::Limits { max_texture_dimension_2d: 7680, max_inter_stage_shader_variables: 15, ..wgpu::Limits::default() };
let requested = device_limits_for(wgpu::Backend::Vulkan, supported.clone());
assert_eq!(requested.max_inter_stage_shader_variables, 15);
assert!(requested.check_limits(&supported));
assert_eq!(requested.max_texture_dimension_2d, 7680);
assert_eq!(requested.max_buffer_size, supported.max_buffer_size);
}
#[test]
fn device_limits_support_weaker_gl_adapters() {
let supported = wgpu::Limits {
max_texture_dimension_2d: 1024,
max_texture_dimension_3d: 128,
max_bind_groups: 2,
max_buffer_size: 128 << 20,
..wgpu::Limits::downlevel_webgl2_defaults()
};
let requested = device_limits_for(wgpu::Backend::Gl, supported.clone());
assert!(requested.check_limits(&supported));
assert_eq!(requested, supported);
}
#[test]
fn device_limits_preserve_backend_defaults_on_capable_adapters() {
let supported = wgpu::Limits {
max_texture_dimension_2d: 16_384,
max_buffer_size: 1 << 30,
max_bind_groups: 8,
max_inter_stage_shader_variables: 32,
min_uniform_buffer_offset_alignment: 64,
min_storage_buffer_offset_alignment: 64,
..wgpu::Limits::default()
};
for (backend, base) in [
(wgpu::Backend::Vulkan, wgpu::Limits::default()),
(wgpu::Backend::Dx12, wgpu::Limits::default()),
(wgpu::Backend::Metal, wgpu::Limits::default()),
(wgpu::Backend::Gl, wgpu::Limits::downlevel_webgl2_defaults()),
] {
let requested = device_limits_for(backend, supported.clone());
assert!(requested.check_limits(&supported));
assert_eq!(requested, wgpu::Limits { max_texture_dimension_2d: 16_384, max_buffer_size: 1 << 30, ..base }, "{backend:?}");
}
}
#[test]
fn device_limits_support_larger_minimum_alignments() {
let supported = wgpu::Limits { min_uniform_buffer_offset_alignment: 512, min_storage_buffer_offset_alignment: 1024, ..wgpu::Limits::default() };
for backend in [wgpu::Backend::Vulkan, wgpu::Backend::Gl] {
let requested = device_limits_for(backend, supported.clone());
assert!(requested.check_limits(&supported));
assert_eq!(requested.min_uniform_buffer_offset_alignment, 512);
assert_eq!(requested.min_storage_buffer_offset_alignment, 1024);
}
}
/// The scratch-texture workaround is for Intel's DX12 drivers (#892); other DX12 adapters
/// render straight into the level like every other backend (#4515).
#[test]
fn separate_mip_targets_only_for_intel_on_dx12() {
use wgpu::Backend::{Dx12, Metal, Vulkan};
let (intel, nvidia, amd) = (0x8086, 0x10de, 0x1002);
assert!(separate_mip_targets(Dx12, intel, None));
assert!(!separate_mip_targets(Dx12, nvidia, None));
assert!(!separate_mip_targets(Dx12, amd, None));
assert!(!separate_mip_targets(Vulkan, intel, None));
assert!(!separate_mip_targets(Metal, 0, None));
// PHOTOCRAFT_SEPARATE_MIPS forces either way; anything else leaves the default.
assert!(separate_mip_targets(Dx12, nvidia, Some("1")));
assert!(!separate_mip_targets(Dx12, intel, Some(" 0 ")));
assert!(separate_mip_targets(Dx12, intel, Some("yes")));
}
/// #6418: levels of at most WHOLE_MIP_SIDE are redrawn whole; larger ones keep the damage.
#[test]
fn small_mip_levels_are_redrawn_whole() {
// A 3 × 3 dab at (800, 500) of a 1791 × 1083 tile, at mip 1 (895 × 541): halved and padded.
assert_eq!(mip_damage([800, 500, 803, 503], 895, 541), [399, 249, 403, 253]);
// At most 128 px on either side: the whole level, wherever the damage is.
assert_eq!(mip_damage([100, 60, 102, 63], 111, 67), [0, 0, 111, 67]);
assert_eq!(mip_damage([0, 0, 1, 1], 128, 2), [0, 0, 128, 2]);
assert_eq!(mip_damage([0, 0, 1, 1], 129, 2), [0, 0, 2, 2]);
}
#[test]
fn gpu_budget_follows_memory_usage_and_ram() {
const G: u64 = 1 << 30;
// Card memory unknown (integrated, software, or unreadable): what Memory Usage leaves
// after the document, within a quarter of RAM.
assert_eq!(memory_budget(8 * G, 3 * G, Some(48 * G), None, 0), 5 * G);
assert_eq!(memory_budget(8 * G, 3 * G, Some(16 * G), None, 0), 4 * G);
assert_eq!(memory_budget(64 * G, 3 * G, Some(16 * G), None, 0), 4 * G);
// Never below the floor, even with nothing left; 16 GB assumed when RAM is unknown.
assert_eq!(memory_budget(8 * G, 10 * G, Some(48 * G), None, 0), MIN_GPU_BUDGET);
assert_eq!(memory_budget(64 * G, 0, None, None, 0), 4 * G);
// A card's own memory, known, doesn't hold the document's pixels: 10 GB of layers no
// longer squeeze the budget, which stays within 3/8 of the card (#4536).
assert_eq!(memory_budget(8 * G, 10 * G, Some(32 * G), Some(32 * G), 0), 8 * G);
assert_eq!(memory_budget(8 * G, 10 * G, Some(32 * G), Some(16 * G), 0), 6 * G);
assert_eq!(memory_budget(8 * G, 10 * G, Some(16 * G), Some(32 * G), 0), 4 * G);
// GPU Memory set: that much, within the card's share, above the floor.
assert_eq!(memory_budget(8 * G, 10 * G, Some(16 * G), None, 12 * G), 12 * G);
assert_eq!(memory_budget(8 * G, 10 * G, Some(16 * G), Some(16 * G), 12 * G), 6 * G);
assert_eq!(memory_budget(8 * G, 0, None, Some(32 * G), 1 << 20), MIN_GPU_BUDGET);
assert!(physical_memory().is_none_or(|b| b >= 256 << 20));
}
/// An 8 GB card in a 64 GB machine: both budgets used to plan for 16 GB, twice the card (#4536).
#[test]
fn gpu_budgets_fit_a_discrete_gpus_own_memory() {
const G: u64 = 1 << 30;
let (ram, vram) = (Some(64 * G), Some(8 * G));
assert_eq!(memory_budget(64 * G, 3 * G, ram, vram, 0), 3 * G);
assert_eq!(canvas_budget(ram, vram), 3 * G);
assert!(memory_budget(64 * G, 0, ram, vram, 0) + canvas_budget(ram, vram) <= 6 * G, "a quarter of the card stays free");
// A card larger than a quarter of RAM caps nothing (its own memory isn't charged for the
// document's 3 GB); a tiny one keeps the floor.
assert_eq!(memory_budget(8 * G, 3 * G, Some(48 * G), Some(24 * G), 0), 8 * G);
assert_eq!(canvas_budget(Some(16 * G), Some(24 * G)), 4 * G);
assert_eq!(memory_budget(64 * G, 0, ram, Some(G), 0), MIN_GPU_BUDGET);
assert_eq!(canvas_budget(ram, Some(G)), MIN_GPU_BUDGET);
}
/// DXGI reports each adapter's dedicated memory, found by the vendor and device ids wgpu gives.
#[cfg(windows)]
#[test]
fn windows_reports_the_adapters_own_memory() {
use winsafe::prelude::*;
let descs: Vec<_> = winsafe::CreateDXGIFactory1().unwrap().EnumAdapters1().map(|a| a.unwrap().GetDesc1().unwrap()).collect();
assert!(!descs.is_empty(), "DXGI lists at least its software adapter");
for d in descs.iter().filter(|d| d.DedicatedVideoMemory > 0) {
// The first adapter with these ids is the one matched.
let first = descs.iter().find(|e| e.VendorId == d.VendorId && e.DeviceId == d.DeviceId).unwrap();
assert_eq!(detect_video_memory(d.VendorId, d.DeviceId), Some(first.DedicatedVideoMemory as u64));
}
assert_eq!(detect_video_memory(0xdead, 0xbeef), None, "no such adapter");
}
/// System Info names the card's own memory, after the driver, when the card reports one; an
/// integrated GPU or an unknown card shows no such line.
#[test]
fn system_info_shows_the_cards_memory() {
let info = GpuInfo { adapter: "Card".into(), driver: "Driver 1".into(), video_memory_mb: Some(8192), ..Default::default() };
let lines = info.lines();
assert_eq!(lines.get(2).map(String::as_str), Some("Driver: Driver 1"));
assert_eq!(lines.get(3).map(String::as_str), Some("Graphics memory: 8.0G"));
let none = GpuInfo { video_memory_mb: None, ..info }.lines();
assert!(none.iter().all(|l| !l.starts_with("Graphics memory")), "{none:?}");
assert_eq!(none.len() + 1, lines.len());
}
/// The Linux reader finds the card by its PCI ids in a `/sys/class/drm`-shaped folder and reads
/// amdgpu's VRAM size; a card without one, unreadable ids or a malformed size give nothing.
#[test]
fn drm_video_memory_reads_the_matching_cards_vram() {
let drm = std::env::temp_dir().join(format!("pc-drm-{}", std::process::id()));
let card = |name: &str, vendor: &str, device: &str, vram: Option<&str>| {
let dev = drm.join(name).join("device");
std::fs::create_dir_all(&dev).unwrap();
std::fs::write(dev.join("vendor"), vendor).unwrap();
std::fs::write(dev.join("device"), device).unwrap();
if let Some(v) = vram {
std::fs::write(dev.join("mem_info_vram_total"), v).unwrap();
}
};
// An Intel iGPU (no VRAM file), an AMD card, and an entry with garbage ids.
card("card0", "0x8086\n", "0x9a49\n", None);
card("card1", "0x1002\n", "0x73bf\n", Some("17163091968\n"));
card("card2", "not hex\n", "0x73bf\n", Some("1\n"));
card("card3", "0x10de\n", "0x2684\n", Some("lots\n"));
assert_eq!(drm_video_memory(&drm, 0x1002, 0x73bf), Some(17_163_091_968));
assert_eq!(drm_video_memory(&drm, 0x8086, 0x9a49), None, "no amdgpu VRAM file");
assert_eq!(drm_video_memory(&drm, 0x10de, 0x2684), None, "a malformed size");
assert_eq!(drm_video_memory(&drm, 0xdead, 0xbeef), None, "no such card");
assert_eq!(drm_video_memory(&drm.join("missing"), 0x1002, 0x73bf), None, "no drm folder");
std::fs::remove_dir_all(&drm).unwrap();
}
/// #P60/P61: amdgpu's sysfs files have no NVIDIA equivalent, so a discrete NVIDIA card's own
/// memory comes from `nvidia-smi`'s CSV instead (real output: `0x2C0510DE, 16303`, device id
/// the high half of the hex, vendor the low). A second card, an upper-case `0X` prefix, extra
/// spaces, a non-matching id, a missing comma, a non-numeric size, empty output and a size
/// that would overflow all give nothing rather than the wrong (or a panicking) answer.
#[test]
fn parses_nvidia_smis_own_report_of_the_cards_memory() {
let two = "0x2C0510DE, 16303\n0x061C10DE, 24576\n";
assert_eq!(parse_nvidia_smi(two, NVIDIA_VENDOR, 0x2c05), Some(16303 << 20));
assert_eq!(parse_nvidia_smi(two, NVIDIA_VENDOR, 0x061c), Some(24576 << 20));
assert_eq!(parse_nvidia_smi("0X2C0510DE, 16303 \n", NVIDIA_VENDOR, 0x2c05), Some(16303 << 20), "upper-case prefix, loose spacing");
assert_eq!(parse_nvidia_smi(two, NVIDIA_VENDOR, 0xdead), None, "no such device id");
assert_eq!(parse_nvidia_smi(two, 0x1002, 0x2c05), None, "no such vendor id");
assert_eq!(parse_nvidia_smi("not csv at all", NVIDIA_VENDOR, 0x2c05), None);
assert_eq!(parse_nvidia_smi("0x2C0510DE 16303\n", NVIDIA_VENDOR, 0x2c05), None, "no comma");
assert_eq!(parse_nvidia_smi("0x2C0510DE, lots\n", NVIDIA_VENDOR, 0x2c05), None, "not a number");
assert_eq!(parse_nvidia_smi("", NVIDIA_VENDOR, 0x2c05), None, "empty output");
assert_eq!(parse_nvidia_smi(&format!("0x2C0510DE, {}\n", u64::MAX), NVIDIA_VENDOR, 0x2c05), None, "would overflow");
}
/// Two cards of one model (same vendor and device id) with different memory: wgpu's ids can't
/// tell which one it picked, so the budget assumes the smaller rather than whichever came first.
#[test]
fn nvidia_smi_cards_sharing_an_id_report_the_smaller_memory() {
assert_eq!(parse_nvidia_smi("0x2C0510DE, 16303\n0x2C0510DE, 8192\n", NVIDIA_VENDOR, 0x2c05), Some(8192 << 20));
assert_eq!(parse_nvidia_smi("0x2C0510DE, 8192\n0x2C0510DE, 16303\n", NVIDIA_VENDOR, 0x2c05), Some(8192 << 20));
assert_eq!(parse_nvidia_smi("0x2C0510DE, lots\n0x2C0510DE, 16303\n", NVIDIA_VENDOR, 0x2c05), Some(16303 << 20), "a bad line is skipped");
assert_eq!(parse_nvidia_smi("0x2C0510DE, 0\n0x2C0510DE, 16303\n", NVIDIA_VENDOR, 0x2c05), Some(16303 << 20), "a zero size is no answer");
}
/// `nvidia-smi` runs on the UI thread at startup, so a query the driver never answers must
/// give up at the deadline instead of keeping the window from opening.
#[cfg(any(unix, windows))]
#[test]
fn a_child_that_never_answers_gives_up_at_the_deadline() {
let slow = if cfg!(windows) {
let mut c = std::process::Command::new("ping");
c.args(["-n", "11", "127.0.0.1"]);
c
} else {
let mut c = std::process::Command::new("sleep");
c.arg("10");
c
};
let start = std::time::Instant::now();
assert_eq!(bounded_output(slow, std::time::Duration::from_millis(200)), None);
assert!(start.elapsed() < std::time::Duration::from_secs(2), "took {:?}", start.elapsed());
let quick = if cfg!(windows) {
let mut c = std::process::Command::new("cmd");
c.args(["/C", "echo 0x2C0510DE, 16303"]);
c
} else {
let mut c = std::process::Command::new("printf");
c.arg("0x2C0510DE, 16303\n");
c
};
let out = bounded_output(quick, std::time::Duration::from_secs(10)).expect("a quick command answers");
assert_eq!(parse_nvidia_smi(&String::from_utf8_lossy(&out), NVIDIA_VENDOR, 0x2c05), Some(16303 << 20));
let failing = if cfg!(windows) {
let mut c = std::process::Command::new("cmd");
c.args(["/C", "exit 3"]);
c
} else {
std::process::Command::new("false")
};
assert_eq!(bounded_output(failing, std::time::Duration::from_secs(10)), None, "a failed run");
assert_eq!(bounded_output(std::process::Command::new("photocraft-no-such-tool"), std::time::Duration::from_secs(1)), None, "not installed");
}
/// Only a discrete NVIDIA adapter asks `nvidia-smi`: nothing else spawns a process whose
/// answer it would then ignore anyway (`nvidia_video_memory` gates on the vendor id first).
#[cfg(target_os = "linux")]
#[test]
fn nvidia_video_memory_only_asks_for_an_nvidia_vendor_id() {
assert_eq!(nvidia_video_memory(0x1002, 0x73bf), None, "an AMD id never runs nvidia-smi");
assert_eq!(nvidia_video_memory(0x8086, 0x9a49), None, "an Intel id never runs nvidia-smi");
}
/// Windows used to report no RAM at all, so the budget assumed 16 GB on every machine.
#[cfg(windows)]
#[test]
fn windows_reports_installed_ram() {
let ram = detect_physical_memory().unwrap_or(0);
assert!(ram >= 256 << 20, "{ram} bytes");
assert!(ram < 1 << 50, "{ram} bytes");
}
#[test]
fn canvas_texture_bytes_price_every_tile_and_mip_level() {
// The same sum DocTextures builds tile by tile (and texture_info reports).
let brute = |size: [u32; 2], tile: u32, bpp: u64| -> u64 {
let mut total = 0;
for ty in (0..size[1]).step_by(tile as usize) {
for tx in (0..size[0]).step_by(tile as usize) {
let (w, h) = (tile.min(size[0] - tx), tile.min(size[1] - ty));
total += (0..mip_count(w, h)).map(|l| u64::from((w >> l).max(1)) * u64::from((h >> l).max(1)) * bpp).sum::<u64>();
}
}
total
};
for (size, tile) in [([1, 1], 64), ([300, 200], 64), ([128, 64], 64), ([1000, 7], 256), ([8192, 8193], 8192), ([20_000, 9_000], 8192)] {
for bpp in [4, 8] {
assert_eq!(canvas_texture_bytes(size, tile, bpp), brute(size, tile, bpp), "{size:?} tile {tile}");
}
}
assert_eq!(canvas_texture_bytes([0, 500], 64, 4), 0);
// A canvas declared in a few bytes of a file is priced without building (or looping over) it.
let huge = canvas_texture_bytes([300_000, 300_000], 8192, 4);
assert!(huge > 300_000u64 * 300_000 * 4 && huge > canvas_budget(Some(1 << 40), None));
assert_eq!(canvas_texture_bytes([u32::MAX, u32::MAX], 64, 8), u64::MAX, "saturates");
// A quarter of RAM (16 GB assumed), never below the compositor's floor.
assert_eq!(canvas_budget(None, None), 4 << 30);
assert_eq!(canvas_budget(Some(1 << 30), None), MIN_GPU_BUDGET);
assert!(canvas_texture_bytes([12_000, 8_000], DEFAULT_TILE, 8) < canvas_budget(None, None), "a 96 MP 16-bit canvas stays on the GPU");
}
#[test]
fn view_uniform_packs_rotation() {
assert_eq!(VIEW_FLOATS, 32);
assert_eq!(VIEW_UNIFORM_SIZE, 128);
assert_eq!(VIEW_FLOATS * 4, VIEW_UNIFORM_SIZE as usize);
assert!(gpu_view_ok(false, 0.0, 1.0));
assert!(gpu_view_ok(false, 45.0_f32.to_radians(), 1.0));
assert!(!gpu_view_ok(true, 45.0_f32.to_radians(), 1.0));
assert!(!gpu_view_ok(false, 0.0, 2.0), "pixel aspect correction draws on the CPU");
// Identity packing: rotation 0 matches the unrotated origin + scale map.
let origin = [10.0, 20.0];
let (scale, center) = (2.0, [40.0, 8.0]);
let a = map_doc_px(origin, scale, center, 1.0, 0.0, 5.0, 9.0);
assert!((a[0] - (origin[0] + 5.0 * scale)).abs() < 1e-4);
assert!((a[1] - (origin[1] + 9.0 * scale)).abs() < 1e-4);
let (x0, y0, x1, y1) = tile_screen_aabb(origin, scale, center, 1.0, 0.0, [0.0, 0.0, 10.0, 4.0]);
assert!((x0 - origin[0]).abs() < 1e-4 && (y0 - origin[1]).abs() < 1e-4);
assert!((x1 - (origin[0] + 20.0)).abs() < 1e-4 && (y1 - (origin[1] + 8.0)).abs() < 1e-4);
}
#[test]
fn filter_modes() {
assert_eq!(filter_mode(0.25), (0.0, 2.0));
assert_eq!(filter_mode(1.0).0, 2.0);
assert_eq!(filter_mode(1.5).0, 1.0);
assert_eq!(filter_mode(3.3).0, 2.0);
}
#[test]
fn mips_and_premultiply() {
assert_eq!(mip_count(1, 1), 1);
assert_eq!(mip_count(4096, 100), 13);
assert_eq!(mip_count(5, 3), 3);
assert_eq!(premultiply_rgba8(&[[1.0, 0.5, 0.0, 0.5]]), vec![128, 64, 0, 128]);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn half_floats() {
// Every finite half survives the round trip; ties round to even; overflow saturates.
for h in 0..=u16::MAX {
if h & 0x7c00 != 0x7c00 && h != 0x8000 {
assert_eq!(f32_to_f16(f16_to_f32(h)), h, "{h:#06x}");
}
}
assert_eq!(f32_to_f16(1.0), 0x3c00);
assert_eq!(f32_to_f16(1.0 + 2f32.powi(-11)), 0x3c00);
assert_eq!(f32_to_f16(1.0 + 3.0 * 2f32.powi(-11)), 0x3c02);
assert_eq!(f32_to_f16(2f32.powi(-24)), 1);
assert_eq!(f32_to_f16(2f32.powi(-26)), 0);
assert_eq!(f32_to_f16(65504.0), 0x7bff);
assert_eq!(f32_to_f16(1e9), 0x7bff);
assert_eq!(f32_to_f16(f32::INFINITY), 0x7bff);
assert_eq!(f32_to_f16(f32::NAN), 0);
assert_eq!(f32_to_f16(-2.0), 0xc000);
assert_eq!(premultiply_rgba16f(&[[2.0, -1.0, f32::NAN, 0.5]]), [0x00, 0x3c, 0, 0, 0, 0, 0x00, 0x38]);
}
#[cfg(not(target_arch = "wasm32"))]
#[test]
fn shaders_validate() {
use wgpu::naga;
for (name, src) in [("canvas", CANVAS_WGSL), ("mip", MIP_WGSL), ("encode", ENCODE_WGSL)] {
let module = naga::front::wgsl::parse_str(src).unwrap_or_else(|e| panic!("{name}: {}", e.emit_to_string(src)));
naga::valid::Validator::new(naga::valid::ValidationFlags::all(), naga::valid::Capabilities::empty())
.validate(&module)
.unwrap_or_else(|e| panic!("{name}: {e:?}"));
}
}
#[test]
fn failed_gpu_attempt_is_recorded_separately_and_counted_in_frame_time() {
let mut perf = Perf::default();
perf.record_refresh(&Refresh { kind: "full", composite_ms: 2.0, upload_ms: 3.0, gpu_attempt_ms: 7.0, ..Default::default() });
assert_eq!(perf.composite_ms, 2.0);
assert_eq!(perf.gpu_attempt_ms, 7.0);
assert_eq!(perf.stage.composite_ms + perf.stage.upload_ms, 12.0);
}
#[test]
fn a_refresh_recorded_directly_has_no_gpu_attempt_of_its_own() {
let mut perf = Perf::default();
perf.record_refresh(&Refresh { kind: "full", composite_ms: 2.0, upload_ms: 3.0, gpu_attempt_ms: 7.0, ..Default::default() });
perf.record("rect", 10, 1.0, 1.0);
assert_eq!(perf.gpu_attempt_ms, 0.0);
}
#[test]
fn a_deferred_redraws_gpu_attempt_is_counted_once_when_it_ends() {
let mut perf = Perf::default();
perf.record("background", 10, 2.0, 0.0);
perf.record_gpu_attempt(7.0);
assert_eq!(perf.composite_ms, 2.0);
assert_eq!(perf.gpu_attempt_ms, 7.0);
assert_eq!(perf.stage.composite_ms + perf.stage.upload_ms, 9.0);
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.