VectorCraft: An open-source, vector art tool written by scratch in pure Rust
refactor(render): move pattern.rs tests to pattern/tests.rs
aiongg9d38803cfa36
diff --git a/crates/render/src/pattern.rs b/crates/render/src/pattern.rsindex c2150c76e..4602ae8ff 100644--- a/crates/render/src/pattern.rs+++ b/crates/render/src/pattern.rs@@ -361,348 +361,4 @@ impl Renderer {}#[cfg(test)]-mod tests {- use super::*;- use vectorcraft_color::{Color, Paint};- use vectorcraft_doc::pattern::{PatternEdit, RepeatSpec, pattern_paint};- use vectorcraft_doc::{Appearance, NodeId, NodeKind};- use vectorcraft_geom::shapes;-- /// A 20×20 tile with a red 10×10 square in its top-left corner.- fn doc_with_pattern(tt: TileType) -> Document {- let mut d = Document::new(200.0, 200.0);- let red = Node::path(- NodeId(900),- shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)),- Appearance::basic(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::None, 0.0),- );- let mut def = PatternDef::new("Checks", vec![Arc::new(red)]);- def.tile = Rect::new(0.0, 0.0, 20.0, 20.0);- def.tile_type = tt;- d.patterns.push(def);- let id = d.alloc_id();- let n = Node::path(id, shapes::rectangle(Rect::new(0.0, 0.0, 200.0, 200.0)), Appearance::basic(pattern_paint("Checks"), Paint::None, 0.0));- let l = d.layers[0].id;- d.insert(Some(l), 0, n).unwrap();- d- }-- fn render(d: &Document, scale: f64) -> Rendered {- let px = (200.0 * scale) as u32;- Renderer::new().render(d, px, px, Affine::scale(scale), &RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() })- }-- fn is_red(p: [u8; 4]) -> bool {- p[0] > 200 && p[1] < 60 && p[2] < 60- }- fn is_white(p: [u8; 4]) -> bool {- p[0] > 200 && p[1] > 200 && p[2] > 200- }-- /// #1536: a raster effect drawn after a pattern fill is the same as without the pattern (the- /// pattern's paint transform must not resample the effect's raster).- #[test]- fn effects_after_a_pattern_fill_keep_their_place_and_size() {- let fx = |id: &str, params: serde_json::Value| vectorcraft_doc::Effect { id: id.into(), params, visible: true };- for effect in [- fx("blur.gaussian", serde_json::json!({"radius": 4.0})),- fx("stylize.dropShadow", serde_json::json!({"x": 6, "y": 6, "blur": 3, "opacity": 100})),- ] {- let make = |with_pattern: bool| {- let mut d = doc_with_pattern(TileType::Grid);- let l = d.layers[0].id;- let filled = d.children(Some(l)).unwrap()[0].id;- d.remove(filled).unwrap();- if with_pattern {- let id = d.alloc_id();- let n = Node::path(- id,- shapes::rectangle(Rect::new(0.0, 0.0, 80.0, 80.0)),- Appearance::basic(pattern_paint("Checks"), Paint::None, 0.0),- );- d.insert(Some(l), 0, n).unwrap();- }- let id = d.alloc_id();- let mut n = Node::path(- id,- shapes::ellipse(Rect::new(120.0, 110.0, 180.0, 170.0)),- Appearance::basic(Paint::solid(Color::rgb(0.5, 0.5, 0.5)), Paint::None, 0.0),- );- n.appearance.effects.push(effect.clone());- let at = d.children(Some(l)).map_or(0, Vec::len);- d.insert(Some(l), at, n).unwrap();- d- };- // Supersampled, as raster exports draw.- let one = |d: &Document| {- let mut r = Renderer::new();- r.render(- d,- 200,- 200,- Affine::IDENTITY,- &RenderOptions { background: Some([255, 255, 255, 255]), supersample: true, ..Default::default() },- )- };- let (with, without) = (one(&make(true)), one(&make(false)));- for (x, y) in [(150, 140), (125, 140), (176, 160), (150, 172), (184, 176)] {- assert_eq!(with.pixel(x, y), without.pixel(x, y), "{} at ({x}, {y})", effect.id);- }- }- }-- #[test]- fn pattern_fill_is_periodic() {- let d = doc_with_pattern(TileType::Grid);- let r = render(&d, 1.0);- for (x, y) in [(5, 5), (25, 5), (125, 145), (185, 65)] {- assert!(is_red(r.pixel(x, y)), "({x},{y}) {:?}", r.pixel(x, y));- }- for (x, y) in [(15, 5), (5, 15), (135, 135), (175, 195)] {- assert!(is_white(r.pixel(x, y)), "({x},{y}) {:?}", r.pixel(x, y));- }- // Periodic: pixel (x, y) equals (x + 20k, y + 20m).- for y in (1..20).step_by(3) {- for x in (1..20).step_by(3) {- if x == 10 || y == 10 {- continue;- }- assert_eq!(r.pixel(x, y), r.pixel(x + 60, y + 100));- }- }- }-- #[test]- fn pattern_fill_is_clipped_to_shape() {- let mut d = doc_with_pattern(TileType::Grid);- let id = d.layers[0].children().unwrap()[0].id;- *d.node_mut(id).unwrap().path_data_mut().unwrap() = shapes::rectangle(Rect::new(0.0, 0.0, 50.0, 50.0));- let r = render(&d, 1.0);- assert!(is_red(r.pixel(45, 45)));- assert!(is_white(r.pixel(65, 65)));- }-- #[test]- fn brick_pattern_shifts_rows() {- let d = doc_with_pattern(TileType::BrickByRow { offset: 0.5 });- let r = render(&d, 1.0);- assert!(is_red(r.pixel(5, 5)));- // Row 1 is shifted by half a tile.- assert!(is_white(r.pixel(5, 25)) && is_red(r.pixel(15, 25)), "{:?} {:?}", r.pixel(5, 25), r.pixel(15, 25));- assert!(is_red(r.pixel(5, 45)));- }-- #[test]- fn pattern_follows_zoom_and_paint_transform() {- let d = doc_with_pattern(TileType::Grid);- let r = render(&d, 2.0);- assert!(is_red(r.pixel(10, 10)) && is_white(r.pixel(30, 10)) && is_red(r.pixel(50, 10)));- let mut d2 = d.clone();- let id = d2.layers[0].children().unwrap()[0].id;- vectorcraft_doc::pattern::transform_pattern_paints(d2.node_mut(id).unwrap(), Affine::translate((10.0, 0.0)));- let r = render(&d2, 1.0);- assert!(is_white(r.pixel(5, 5)) && is_red(r.pixel(15, 5)));- }-- /// `doc_with_pattern(TileType::Grid)` with a 40×40 square on top of its rectangle, filled with- /// the same pattern scaled by `s`, as Transform Pattern Tiles leaves it.- fn doc_with_two_scales(s: f64) -> Document {- let mut d = doc_with_pattern(TileType::Grid);- let square = shapes::rectangle(Rect::new(120.0, 120.0, 160.0, 160.0));- let mut n = Node::path(d.alloc_id(), square, Appearance::basic(pattern_paint("Checks"), Paint::None, 0.0));- vectorcraft_doc::pattern::transform_pattern_paints(&mut n, Affine::scale(s));- let l = d.layers[0].id;- d.insert(Some(l), 1, n).unwrap();- d- }-- /// `d` drawn by `r` at `scale`.- fn frame(r: &mut Renderer, d: &Document, scale: f64) -> Rendered {- let px = (200.0 * scale) as u32;- r.render(d, px, px, Affine::scale(scale), &RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() })- }-- /// The tiles rasterized on this thread so far: the tile renderer counts a frame for each.- fn tiles_rasterized() -> u64 {- CACHE.with(|c| c.borrow().renderer.as_ref().map_or(0, |r| r.stamp))- }-- #[test]- fn objects_at_two_pattern_scales_keep_their_tiles_between_frames() {- // At 100% the rectangle's tile is rasterized at scale 1, and the square's tile is- // rasterized at 0.25, or at 2 when its tiles are scaled to 101%.- for s in [0.25, 1.01] {- let d = doc_with_two_scales(s);- let mut r = Renderer::new();- let start = tiles_rasterized();- let first = frame(&mut r, &d, 1.0).pixels;- assert_eq!(tiles_rasterized() - start, 2, "tiles scaled by {s}: a tile for each object");- for _ in 0..3 {- assert!(frame(&mut r, &d, 1.0).pixels == first, "tiles scaled by {s}");- }- assert_eq!(tiles_rasterized() - start, 2, "tiles scaled by {s}: later frames draw both objects from their tiles");- // After a frame at 200%, the next frame at 100% draws from the tiles made at 100%.- frame(&mut r, &d, 2.0);- let zoomed = tiles_rasterized();- assert!(frame(&mut r, &d, 1.0).pixels == first, "tiles scaled by {s}");- assert_eq!(tiles_rasterized(), zoomed, "tiles scaled by {s}: back at 100%");- }- }-- #[test]- fn kept_tiles_draw_what_a_new_renderer_draws() {- // A new renderer on a thread of its own starts with no tiles.- let fresh = |d: &Document, zoom: f64| {- let d = d.clone();- std::thread::spawn(move || frame(&mut Renderer::new(), &d, zoom).pixels).join().unwrap()- };- let mut d = doc_with_two_scales(0.25);- let mut r = Renderer::new();- // Pixel (130, 130) is red in the square's tiles and clear in the rectangle's, (133, 133) is- // clear in both, and (103, 103), outside the square, is red in the rectangle's.- let first = frame(&mut r, &d, 1.0);- assert!(is_red(first.pixel(130, 130)) && is_white(first.pixel(133, 133)) && is_red(first.pixel(103, 103)));- for zoom in [1.0, 2.0, 1.0, 0.5, 2.0, 1.0] {- assert!(frame(&mut r, &d, zoom).pixels == fresh(&d, zoom), "zoom {zoom}");- }- // Change the tile type as Pattern Options does.- d.patterns[0].tile_type = TileType::BrickByRow { offset: 0.5 };- for zoom in [2.0, 1.0] {- assert!(frame(&mut r, &d, zoom).pixels == fresh(&d, zoom), "brick, zoom {zoom}");- }- // Replace the art as Done Editing Pattern does.- let blue = Appearance::basic(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), Paint::None, 0.0);- d.patterns[0].art = vec![Arc::new(Node::path(NodeId(901), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), blue))];- for zoom in [1.0, 2.0] {- assert!(frame(&mut r, &d, zoom).pixels == fresh(&d, zoom), "new art, zoom {zoom}");- }- }-- #[test]- fn kept_tiles_stay_within_the_budget() {- // The rectangle's tile is 20 pixels a side per 100% of zoom, and the square's tile is 5- // pixels a side per 100% of zoom. The budget holds the rectangle's tile at 400% and both- // tiles at 200%; the tiles drawn from 100% to 400% need more.- let d = doc_with_two_scales(0.25);- let tile = |side: usize| size_of::<TileEntry>() + side * side * 4;- let budget = tile(80) + tile(40) + tile(10);- CACHE.with(|c| c.borrow_mut().tiles[Ink::Display as usize] = FrameCache::new(budget, usize::MAX));- let kept = || {- CACHE.with(|c| {- let c = c.borrow();- let tiles = &c.tiles[Ink::Display as usize];- (tiles.len(), tiles.bytes())- })- };- let mut r = Renderer::new();- for zoom in [1.0, 2.0, 4.0] {- frame(&mut r, &d, zoom);- let drawn = tiles_rasterized();- frame(&mut r, &d, zoom);- assert_eq!(tiles_rasterized(), drawn, "zoom {zoom}: the next frame draws from the tiles just made");- let (len, bytes) = kept();- assert!(len >= 2 && bytes <= budget, "zoom {zoom}: {len} tiles, {bytes} bytes");- }- // Tiles were rasterized at five scales (0.25, 0.5, 1, 2 and 4); the cache dropped the least- // recently used tiles first.- assert!(kept().0 < 5, "{:?}", kept());- let before = tiles_rasterized();- frame(&mut r, &d, 1.0);- assert!(tiles_rasterized() > before, "a tile of 100% was dropped");- assert!(kept().1 <= budget, "{:?}", kept());- }-- /// A pattern whose art is an image that can't be decoded: every frame that draws the pattern- /// counts the failure ([`crate::paint::decode_failures`]), from a new tile or from the- /// tile kept.- #[test]- fn kept_tiles_count_the_images_they_could_not_decode() {- use vectorcraft_doc::{ImageBlob, ImageObject};- let mut d = doc_with_pattern(TileType::Grid);- // A PNG signature with nothing after it.- d.images.insert("cut".into(), ImageBlob::new("image/png", b"\x89PNG\r\n\x1a\n".to_vec()));- let im =- ImageObject { key: "cut".into(), width: 10, height: 10, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };- d.patterns[0].art = vec![Arc::new(Node::new(NodeId(901), NodeKind::Image(Box::new(im))))];- let mut r = Renderer::new();- let start = tiles_rasterized();- for n in 0..3 {- let before = crate::paint::decode_failures();- frame(&mut r, &d, 1.0);- assert!(crate::paint::decode_failures() > before, "frame {n}");- }- assert_eq!(tiles_rasterized() - start, 1, "the later frames draw from the tile kept");- }-- #[test]- fn missing_pattern_is_grey() {- let mut d = doc_with_pattern(TileType::Grid);- d.patterns.clear();- let p = render(&d, 1.0).pixel(50, 50);- assert_eq!(p, [128, 128, 128, 255]);- }-- #[test]- fn swatch_thumbnail_renders() {- let d = doc_with_pattern(TileType::Grid);- let r = render_pattern_swatch(&d, "Checks", 20).unwrap();- assert!(is_red(r.pixel(3, 3)));- assert_eq!(r.pixel(15, 15)[3], 0);- assert!(render_pattern_swatch(&d, "Nope", 20).is_none());- }-- #[test]- fn edit_mode_draws_only_tile_layer_with_copies() {- let mut d = doc_with_pattern(TileType::Grid);- let l = d.add_layer(Some("Pattern Editing Mode"));- let art = d.patterns[0].art[0].clone();- d.insert(Some(l), 0, (*art).clone()).unwrap();- d.pattern_edit = Some(PatternEdit { pattern: "Checks".into(), layer: l, original: None });- d.patterns[0].dim_copies = 50.0;- d.patterns[0].show_tile_edge = false;- let r = render(&d, 1.0);- // The tile itself at full strength, copies dimmed, the filled document rect hidden.- assert!(is_red(r.pixel(5, 5)));- let c = r.pixel(25, 5);- assert!(c[0] > 200 && c[1] > 100 && c[1] < 160, "{c:?}");- assert!(is_white(r.pixel(15, 5)));- assert!(is_white(r.pixel(125, 125)), "outside the copies");- }-- #[test]- fn repeat_renders_instances() {- let mut d = Document::new(200.0, 200.0);- let sq = Node::path(- NodeId(50),- shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)),- Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0),- );- let id = d.alloc_id();- let l = d.layers[0].id;- d.insert(Some(l), 0, Node::new(id, NodeKind::Repeat(RepeatSpec::grid(vec![Arc::new(sq)], 10.0, 10.0)))).unwrap();- let r = render(&d, 1.0);- for (x, y) in [(5, 5), (25, 5), (45, 45)] {- assert_eq!(r.pixel(x, y), [0, 0, 0, 255], "({x},{y})");- }- assert!(is_white(r.pixel(15, 5)) && is_white(r.pixel(65, 5)));- }-- #[test]- fn raster_scale_is_power_of_two_and_capped() {- assert_eq!(raster_scale(1.0, (10.0, 10.0)), 1.0);- assert_eq!(raster_scale(1.5, (10.0, 10.0)), 2.0);- assert_eq!(raster_scale(3.0, (10.0, 10.0)), 4.0);- // A change within 2× keeps the raster.- assert_eq!(raster_scale(2.1, (10.0, 10.0)), raster_scale(3.9, (10.0, 10.0)));- assert!(raster_scale(64.0, (1000.0, 10.0)) * 1000.0 <= MAX_TILE_PX);- }-- #[test]- fn tile_renderer_depth_survives_caught_panics() {- for _ in 0..4 {- let r = std::panic::catch_unwind(|| with_tile_renderer(|_| panic!("tile boom")));- assert!(r.is_err());- }- assert!(with_tile_renderer(|_| ()).is_some(), "depth leaked after caught panics");- }-}+mod tests;diff --git a/crates/render/src/pattern/tests.rs b/crates/render/src/pattern/tests.rsnew file mode 100644index 000000000..dba6673e1--- /dev/null+++ b/crates/render/src/pattern/tests.rs@@ -0,0 +1,343 @@+use super::*;+use vectorcraft_color::{Color, Paint};+use vectorcraft_doc::pattern::{PatternEdit, RepeatSpec, pattern_paint};+use vectorcraft_doc::{Appearance, NodeId, NodeKind};+use vectorcraft_geom::shapes;++/// A 20×20 tile with a red 10×10 square in its top-left corner.+fn doc_with_pattern(tt: TileType) -> Document {+ let mut d = Document::new(200.0, 200.0);+ let red = Node::path(+ NodeId(900),+ shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)),+ Appearance::basic(Paint::solid(Color::rgb(1.0, 0.0, 0.0)), Paint::None, 0.0),+ );+ let mut def = PatternDef::new("Checks", vec![Arc::new(red)]);+ def.tile = Rect::new(0.0, 0.0, 20.0, 20.0);+ def.tile_type = tt;+ d.patterns.push(def);+ let id = d.alloc_id();+ let n = Node::path(id, shapes::rectangle(Rect::new(0.0, 0.0, 200.0, 200.0)), Appearance::basic(pattern_paint("Checks"), Paint::None, 0.0));+ let l = d.layers[0].id;+ d.insert(Some(l), 0, n).unwrap();+ d+}++fn render(d: &Document, scale: f64) -> Rendered {+ let px = (200.0 * scale) as u32;+ Renderer::new().render(d, px, px, Affine::scale(scale), &RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() })+}++fn is_red(p: [u8; 4]) -> bool {+ p[0] > 200 && p[1] < 60 && p[2] < 60+}+fn is_white(p: [u8; 4]) -> bool {+ p[0] > 200 && p[1] > 200 && p[2] > 200+}++/// #1536: a raster effect drawn after a pattern fill is the same as without the pattern (the+/// pattern's paint transform must not resample the effect's raster).+#[test]+fn effects_after_a_pattern_fill_keep_their_place_and_size() {+ let fx = |id: &str, params: serde_json::Value| vectorcraft_doc::Effect { id: id.into(), params, visible: true };+ for effect in [+ fx("blur.gaussian", serde_json::json!({"radius": 4.0})),+ fx("stylize.dropShadow", serde_json::json!({"x": 6, "y": 6, "blur": 3, "opacity": 100})),+ ] {+ let make = |with_pattern: bool| {+ let mut d = doc_with_pattern(TileType::Grid);+ let l = d.layers[0].id;+ let filled = d.children(Some(l)).unwrap()[0].id;+ d.remove(filled).unwrap();+ if with_pattern {+ let id = d.alloc_id();+ let n = Node::path(+ id,+ shapes::rectangle(Rect::new(0.0, 0.0, 80.0, 80.0)),+ Appearance::basic(pattern_paint("Checks"), Paint::None, 0.0),+ );+ d.insert(Some(l), 0, n).unwrap();+ }+ let id = d.alloc_id();+ let mut n = Node::path(+ id,+ shapes::ellipse(Rect::new(120.0, 110.0, 180.0, 170.0)),+ Appearance::basic(Paint::solid(Color::rgb(0.5, 0.5, 0.5)), Paint::None, 0.0),+ );+ n.appearance.effects.push(effect.clone());+ let at = d.children(Some(l)).map_or(0, Vec::len);+ d.insert(Some(l), at, n).unwrap();+ d+ };+ // Supersampled, as raster exports draw.+ let one = |d: &Document| {+ let mut r = Renderer::new();+ r.render(+ d,+ 200,+ 200,+ Affine::IDENTITY,+ &RenderOptions { background: Some([255, 255, 255, 255]), supersample: true, ..Default::default() },+ )+ };+ let (with, without) = (one(&make(true)), one(&make(false)));+ for (x, y) in [(150, 140), (125, 140), (176, 160), (150, 172), (184, 176)] {+ assert_eq!(with.pixel(x, y), without.pixel(x, y), "{} at ({x}, {y})", effect.id);+ }+ }+}++#[test]+fn pattern_fill_is_periodic() {+ let d = doc_with_pattern(TileType::Grid);+ let r = render(&d, 1.0);+ for (x, y) in [(5, 5), (25, 5), (125, 145), (185, 65)] {+ assert!(is_red(r.pixel(x, y)), "({x},{y}) {:?}", r.pixel(x, y));+ }+ for (x, y) in [(15, 5), (5, 15), (135, 135), (175, 195)] {+ assert!(is_white(r.pixel(x, y)), "({x},{y}) {:?}", r.pixel(x, y));+ }+ // Periodic: pixel (x, y) equals (x + 20k, y + 20m).+ for y in (1..20).step_by(3) {+ for x in (1..20).step_by(3) {+ if x == 10 || y == 10 {+ continue;+ }+ assert_eq!(r.pixel(x, y), r.pixel(x + 60, y + 100));+ }+ }+}++#[test]+fn pattern_fill_is_clipped_to_shape() {+ let mut d = doc_with_pattern(TileType::Grid);+ let id = d.layers[0].children().unwrap()[0].id;+ *d.node_mut(id).unwrap().path_data_mut().unwrap() = shapes::rectangle(Rect::new(0.0, 0.0, 50.0, 50.0));+ let r = render(&d, 1.0);+ assert!(is_red(r.pixel(45, 45)));+ assert!(is_white(r.pixel(65, 65)));+}++#[test]+fn brick_pattern_shifts_rows() {+ let d = doc_with_pattern(TileType::BrickByRow { offset: 0.5 });+ let r = render(&d, 1.0);+ assert!(is_red(r.pixel(5, 5)));+ // Row 1 is shifted by half a tile.+ assert!(is_white(r.pixel(5, 25)) && is_red(r.pixel(15, 25)), "{:?} {:?}", r.pixel(5, 25), r.pixel(15, 25));+ assert!(is_red(r.pixel(5, 45)));+}++#[test]+fn pattern_follows_zoom_and_paint_transform() {+ let d = doc_with_pattern(TileType::Grid);+ let r = render(&d, 2.0);+ assert!(is_red(r.pixel(10, 10)) && is_white(r.pixel(30, 10)) && is_red(r.pixel(50, 10)));+ let mut d2 = d.clone();+ let id = d2.layers[0].children().unwrap()[0].id;+ vectorcraft_doc::pattern::transform_pattern_paints(d2.node_mut(id).unwrap(), Affine::translate((10.0, 0.0)));+ let r = render(&d2, 1.0);+ assert!(is_white(r.pixel(5, 5)) && is_red(r.pixel(15, 5)));+}++/// `doc_with_pattern(TileType::Grid)` with a 40×40 square on top of its rectangle, filled with+/// the same pattern scaled by `s`, as Transform Pattern Tiles leaves it.+fn doc_with_two_scales(s: f64) -> Document {+ let mut d = doc_with_pattern(TileType::Grid);+ let square = shapes::rectangle(Rect::new(120.0, 120.0, 160.0, 160.0));+ let mut n = Node::path(d.alloc_id(), square, Appearance::basic(pattern_paint("Checks"), Paint::None, 0.0));+ vectorcraft_doc::pattern::transform_pattern_paints(&mut n, Affine::scale(s));+ let l = d.layers[0].id;+ d.insert(Some(l), 1, n).unwrap();+ d+}++/// `d` drawn by `r` at `scale`.+fn frame(r: &mut Renderer, d: &Document, scale: f64) -> Rendered {+ let px = (200.0 * scale) as u32;+ r.render(d, px, px, Affine::scale(scale), &RenderOptions { background: Some([255, 255, 255, 255]), ..Default::default() })+}++/// The tiles rasterized on this thread so far: the tile renderer counts a frame for each.+fn tiles_rasterized() -> u64 {+ CACHE.with(|c| c.borrow().renderer.as_ref().map_or(0, |r| r.stamp))+}++#[test]+fn objects_at_two_pattern_scales_keep_their_tiles_between_frames() {+ // At 100% the rectangle's tile is rasterized at scale 1, and the square's tile is+ // rasterized at 0.25, or at 2 when its tiles are scaled to 101%.+ for s in [0.25, 1.01] {+ let d = doc_with_two_scales(s);+ let mut r = Renderer::new();+ let start = tiles_rasterized();+ let first = frame(&mut r, &d, 1.0).pixels;+ assert_eq!(tiles_rasterized() - start, 2, "tiles scaled by {s}: a tile for each object");+ for _ in 0..3 {+ assert!(frame(&mut r, &d, 1.0).pixels == first, "tiles scaled by {s}");+ }+ assert_eq!(tiles_rasterized() - start, 2, "tiles scaled by {s}: later frames draw both objects from their tiles");+ // After a frame at 200%, the next frame at 100% draws from the tiles made at 100%.+ frame(&mut r, &d, 2.0);+ let zoomed = tiles_rasterized();+ assert!(frame(&mut r, &d, 1.0).pixels == first, "tiles scaled by {s}");+ assert_eq!(tiles_rasterized(), zoomed, "tiles scaled by {s}: back at 100%");+ }+}++#[test]+fn kept_tiles_draw_what_a_new_renderer_draws() {+ // A new renderer on a thread of its own starts with no tiles.+ let fresh = |d: &Document, zoom: f64| {+ let d = d.clone();+ std::thread::spawn(move || frame(&mut Renderer::new(), &d, zoom).pixels).join().unwrap()+ };+ let mut d = doc_with_two_scales(0.25);+ let mut r = Renderer::new();+ // Pixel (130, 130) is red in the square's tiles and clear in the rectangle's, (133, 133) is+ // clear in both, and (103, 103), outside the square, is red in the rectangle's.+ let first = frame(&mut r, &d, 1.0);+ assert!(is_red(first.pixel(130, 130)) && is_white(first.pixel(133, 133)) && is_red(first.pixel(103, 103)));+ for zoom in [1.0, 2.0, 1.0, 0.5, 2.0, 1.0] {+ assert!(frame(&mut r, &d, zoom).pixels == fresh(&d, zoom), "zoom {zoom}");+ }+ // Change the tile type as Pattern Options does.+ d.patterns[0].tile_type = TileType::BrickByRow { offset: 0.5 };+ for zoom in [2.0, 1.0] {+ assert!(frame(&mut r, &d, zoom).pixels == fresh(&d, zoom), "brick, zoom {zoom}");+ }+ // Replace the art as Done Editing Pattern does.+ let blue = Appearance::basic(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), Paint::None, 0.0);+ d.patterns[0].art = vec![Arc::new(Node::path(NodeId(901), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), blue))];+ for zoom in [1.0, 2.0] {+ assert!(frame(&mut r, &d, zoom).pixels == fresh(&d, zoom), "new art, zoom {zoom}");+ }+}++#[test]+fn kept_tiles_stay_within_the_budget() {+ // The rectangle's tile is 20 pixels a side per 100% of zoom, and the square's tile is 5+ // pixels a side per 100% of zoom. The budget holds the rectangle's tile at 400% and both+ // tiles at 200%; the tiles drawn from 100% to 400% need more.+ let d = doc_with_two_scales(0.25);+ let tile = |side: usize| size_of::<TileEntry>() + side * side * 4;+ let budget = tile(80) + tile(40) + tile(10);+ CACHE.with(|c| c.borrow_mut().tiles[Ink::Display as usize] = FrameCache::new(budget, usize::MAX));+ let kept = || {+ CACHE.with(|c| {+ let c = c.borrow();+ let tiles = &c.tiles[Ink::Display as usize];+ (tiles.len(), tiles.bytes())+ })+ };+ let mut r = Renderer::new();+ for zoom in [1.0, 2.0, 4.0] {+ frame(&mut r, &d, zoom);+ let drawn = tiles_rasterized();+ frame(&mut r, &d, zoom);+ assert_eq!(tiles_rasterized(), drawn, "zoom {zoom}: the next frame draws from the tiles just made");+ let (len, bytes) = kept();+ assert!(len >= 2 && bytes <= budget, "zoom {zoom}: {len} tiles, {bytes} bytes");+ }+ // Tiles were rasterized at five scales (0.25, 0.5, 1, 2 and 4); the cache dropped the least+ // recently used tiles first.+ assert!(kept().0 < 5, "{:?}", kept());+ let before = tiles_rasterized();+ frame(&mut r, &d, 1.0);+ assert!(tiles_rasterized() > before, "a tile of 100% was dropped");+ assert!(kept().1 <= budget, "{:?}", kept());+}++/// A pattern whose art is an image that can't be decoded: every frame that draws the pattern+/// counts the failure ([`crate::paint::decode_failures`]), from a new tile or from the+/// tile kept.+#[test]+fn kept_tiles_count_the_images_they_could_not_decode() {+ use vectorcraft_doc::{ImageBlob, ImageObject};+ let mut d = doc_with_pattern(TileType::Grid);+ // A PNG signature with nothing after it.+ d.images.insert("cut".into(), ImageBlob::new("image/png", b"\x89PNG\r\n\x1a\n".to_vec()));+ let im =+ ImageObject { key: "cut".into(), width: 10, height: 10, xf: Affine::IDENTITY, link: None, placement: Default::default(), pixels: None };+ d.patterns[0].art = vec![Arc::new(Node::new(NodeId(901), NodeKind::Image(Box::new(im))))];+ let mut r = Renderer::new();+ let start = tiles_rasterized();+ for n in 0..3 {+ let before = crate::paint::decode_failures();+ frame(&mut r, &d, 1.0);+ assert!(crate::paint::decode_failures() > before, "frame {n}");+ }+ assert_eq!(tiles_rasterized() - start, 1, "the later frames draw from the tile kept");+}++#[test]+fn missing_pattern_is_grey() {+ let mut d = doc_with_pattern(TileType::Grid);+ d.patterns.clear();+ let p = render(&d, 1.0).pixel(50, 50);+ assert_eq!(p, [128, 128, 128, 255]);+}++#[test]+fn swatch_thumbnail_renders() {+ let d = doc_with_pattern(TileType::Grid);+ let r = render_pattern_swatch(&d, "Checks", 20).unwrap();+ assert!(is_red(r.pixel(3, 3)));+ assert_eq!(r.pixel(15, 15)[3], 0);+ assert!(render_pattern_swatch(&d, "Nope", 20).is_none());+}++#[test]+fn edit_mode_draws_only_tile_layer_with_copies() {+ let mut d = doc_with_pattern(TileType::Grid);+ let l = d.add_layer(Some("Pattern Editing Mode"));+ let art = d.patterns[0].art[0].clone();+ d.insert(Some(l), 0, (*art).clone()).unwrap();+ d.pattern_edit = Some(PatternEdit { pattern: "Checks".into(), layer: l, original: None });+ d.patterns[0].dim_copies = 50.0;+ d.patterns[0].show_tile_edge = false;+ let r = render(&d, 1.0);+ // The tile itself at full strength, copies dimmed, the filled document rect hidden.+ assert!(is_red(r.pixel(5, 5)));+ let c = r.pixel(25, 5);+ assert!(c[0] > 200 && c[1] > 100 && c[1] < 160, "{c:?}");+ assert!(is_white(r.pixel(15, 5)));+ assert!(is_white(r.pixel(125, 125)), "outside the copies");+}++#[test]+fn repeat_renders_instances() {+ let mut d = Document::new(200.0, 200.0);+ let sq = Node::path(+ NodeId(50),+ shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)),+ Appearance::basic(Paint::solid(Color::BLACK), Paint::None, 0.0),+ );+ let id = d.alloc_id();+ let l = d.layers[0].id;+ d.insert(Some(l), 0, Node::new(id, NodeKind::Repeat(RepeatSpec::grid(vec![Arc::new(sq)], 10.0, 10.0)))).unwrap();+ let r = render(&d, 1.0);+ for (x, y) in [(5, 5), (25, 5), (45, 45)] {+ assert_eq!(r.pixel(x, y), [0, 0, 0, 255], "({x},{y})");+ }+ assert!(is_white(r.pixel(15, 5)) && is_white(r.pixel(65, 5)));+}++#[test]+fn raster_scale_is_power_of_two_and_capped() {+ assert_eq!(raster_scale(1.0, (10.0, 10.0)), 1.0);+ assert_eq!(raster_scale(1.5, (10.0, 10.0)), 2.0);+ assert_eq!(raster_scale(3.0, (10.0, 10.0)), 4.0);+ // A change within 2× keeps the raster.+ assert_eq!(raster_scale(2.1, (10.0, 10.0)), raster_scale(3.9, (10.0, 10.0)));+ assert!(raster_scale(64.0, (1000.0, 10.0)) * 1000.0 <= MAX_TILE_PX);+}++#[test]+fn tile_renderer_depth_survives_caught_panics() {+ for _ in 0..4 {+ let r = std::panic::catch_unwind(|| with_tile_renderer(|_| panic!("tile boom")));+ assert!(r.is_err());+ }+ assert!(with_tile_renderer(|_| ()).is_some(), "depth leaked after caught panics");+}