b45255bb6fe2
image_budget_tests.rs
//! Decoded images within a memory budget (#203): an image too large is refused from its header,
//! before its pixels are decoded, and the decoded-image caches hold a bounded number of bytes
//! however many images, filters and colour profiles a document uses.
use std::sync::Arc;
use figcraft_color::ColorProfile;
use tiny_skia::Pixmap;
use super::*;
fn png(w: u32, h: u32) -> Vec<u8> {
let img = image::RgbaImage::from_pixel(w, h, image::Rgba([200, 40, 40, 255]));
let mut out = Vec::new();
img.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
out
}
/// A PNG whose header claims `w` × `h` but which holds no pixel data at all.
fn png_header_only(w: u32, h: u32) -> Vec<u8> {
let mut ihdr = Vec::new();
ihdr.extend_from_slice(&w.to_be_bytes());
ihdr.extend_from_slice(&h.to_be_bytes());
ihdr.extend_from_slice(&[8, 6, 0, 0, 0]);
let mut out = b"\x89PNG\r\n\x1a\n".to_vec();
out.extend_from_slice(&13u32.to_be_bytes());
let chunk: Vec<u8> = b"IHDR".iter().copied().chain(ihdr).collect();
out.extend_from_slice(&chunk);
out.extend_from_slice(&crc32(&chunk).to_be_bytes());
out
}
fn crc32(data: &[u8]) -> u32 {
let mut crc = !0u32;
for b in data {
crc ^= u32::from(*b);
for _ in 0..8 {
crc = if crc & 1 == 1 { (crc >> 1) ^ 0xEDB8_8320 } else { crc >> 1 };
}
}
!crc
}
#[test]
fn an_image_within_the_limits_decodes() {
let (p, _) = images::decode_within(&png(30, 20), ColorProfile::Srgb, 30, 30 * 20 * 4).unwrap();
assert_eq!((p.width(), p.height()), (30, 20));
}
#[test]
fn an_image_wider_or_taller_than_the_limit_is_scaled_down_to_fit() {
let (p, _) = images::decode_within(&png(30, 20), ColorProfile::Srgb, 15, u64::MAX).unwrap();
assert_eq!((p.width(), p.height()), (15, 10));
let (p, _) = images::decode_within(&png(20, 30), ColorProfile::Srgb, 15, u64::MAX).unwrap();
assert_eq!((p.width(), p.height()), (10, 15));
}
#[test]
fn an_image_whose_pixels_pass_the_byte_budget_is_refused() {
assert!(images::decode_within(&png(30, 20), ColorProfile::Srgb, 1000, 30 * 20 * 4 - 1).is_none());
}
#[test]
fn a_huge_image_is_refused_from_its_header_alone() {
// 16 000 × 16 000 is within the side limit; its pixels (1 GB) aren't within a 1 MB budget, and
// the file has none to decode: only the header is read.
assert!(images::decode_within(&png_header_only(16_000, 16_000), ColorProfile::Srgb, 16_384, 1 << 20).is_none());
// Past the side limit, the shipped decode reads its header and finds no pixels to scale down.
assert!(images::decode(&png_header_only(20_000, 10)).is_none());
}
#[test]
fn an_image_past_the_side_limit_is_drawn_downscaled() {
// #1336: one side over 16 384 px drew nothing.
let p = images::decode(&png(16_385, 4)).unwrap();
assert_eq!(p.width(), 16_384);
assert!(p.height() >= 1 && p.height() <= 4);
assert!(p.pixels().iter().all(|c| c.alpha() == 255));
let p = images::decode(&png(4, 18_078)).unwrap();
assert_eq!(p.height(), 16_384);
assert!(p.width() >= 1 && p.width() <= 4);
}
fn key(name: &str) -> images::Key {
(name.to_string(), [0; 7], ColorProfile::Srgb, 0)
}
fn pixmap(side: u32) -> Arc<Pixmap> {
Arc::new(Pixmap::new(side, side).unwrap())
}
#[test]
fn the_image_cache_keeps_within_its_byte_budget() {
// 10 × 10 pixmaps are 400 bytes; 1000 bytes hold two.
let mut c = images::PixmapCache::default();
for name in ["a", "b", "c", "d", "e"] {
c.insert(key(name), pixmap(10), 1000);
assert!(c.bytes() <= 1000, "{} bytes held", c.bytes());
assert!(c.get(&key(name)).is_some(), "{name} was just added");
}
}
#[test]
fn a_full_image_cache_drops_the_least_recently_used_image_only() {
// 1000 bytes hold two 400-byte pixmaps: the third drops the one used longest ago.
let mut c = images::PixmapCache::default();
c.insert(key("a"), pixmap(10), 1000);
c.insert(key("b"), pixmap(10), 1000);
assert!(c.get(&key("a")).is_some());
c.insert(key("c"), pixmap(10), 1000);
assert!(c.get(&key("a")).is_some(), "used since b: kept");
assert!(c.get(&key("b")).is_none(), "used longest ago: dropped");
assert!(c.get(&key("c")).is_some());
assert_eq!(c.bytes(), 800);
}
#[test]
fn an_image_larger_than_the_budget_is_held_alone() {
let mut c = images::PixmapCache::default();
c.insert(key("small"), pixmap(10), 1000);
c.insert(key("big"), pixmap(20), 1000);
assert!(c.get(&key("big")).is_some());
assert!(c.get(&key("small")).is_none());
assert_eq!(c.bytes(), 20 * 20 * 4);
// The next image takes its place.
c.insert(key("next"), pixmap(10), 1000);
assert_eq!(c.bytes(), 400);
}
#[test]
fn filter_and_profile_variants_count_against_one_budget() {
let mut c = images::PixmapCache::default();
for (i, profile) in [ColorProfile::Srgb, ColorProfile::DisplayP3].into_iter().enumerate() {
for f in 0..4 {
c.insert(("img".to_string(), [f, 0, 0, 0, 0, 0, i as i32], profile, 0), pixmap(10), 1000);
assert!(c.bytes() <= 1000, "{} bytes held", c.bytes());
}
}
}
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.