smudge-cpu 0.2.0

//! Behavior tests for the renderer.
//!
//! Every test drives the public API, so what it checks is what a caller sees:
//! the pixels of the surface after a frame.

use std::rc::Rc;

use smudge_core::app::FrameOutput;
use smudge_core::geometry::{Color, Corners, PixelRect, Point, Rect};
use smudge_core::paint::{DisplayList, GlyphRun, PaintOp};
use smudge_text::{TextLayout, TextStyle, TextSystem};

use crate::CpuRenderer;

/// Opaque white in premultiplied RGBA.
const WHITE: [u8; 4] = [255, 255, 255, 255];

/// Opaque black in premultiplied RGBA.
const BLACK: [u8; 4] = [0, 0, 0, 255];

/// Opaque red in premultiplied RGBA.
const RED: [u8; 4] = [255, 0, 0, 255];

/// The color every test surface starts from.
const CLEAR: Color = Color::WHITE;

/// Renders `list` for the physical rectangles in `damage`.
fn render(renderer: &mut CpuRenderer, list: &DisplayList, damage: &[PixelRect], scale: f32) {
    renderer.render(&FrameOutput {
        list,
        damage,
        full: false,
        clear_color: CLEAR,
        scale,
    });
}

/// Returns the premultiplied RGBA value of one pixel.
fn pixel(renderer: &CpuRenderer, x: u32, y: u32) -> [u8; 4] {
    let index = ((y * renderer.width() + x) * 4) as usize;
    let pixels = renderer.pixels();
    [
        pixels[index],
        pixels[index + 1],
        pixels[index + 2],
        pixels[index + 3],
    ]
}

/// Returns the first pixel where two surfaces differ.
fn first_difference(left: &CpuRenderer, right: &CpuRenderer) -> Option<(u32, u32)> {
    let width = left.width();
    for y in 0..left.height() {
        for x in 0..width {
            if pixel(left, x, y) != pixel(right, x, y) {
                return Some((x, y));
            }
        }
    }
    None
}

/// A display list holding one operation.
fn list_of(op: PaintOp) -> DisplayList {
    let mut list = DisplayList::new();
    list.push_op(op);
    list.finish();
    list
}

/// A filled rectangle with square corners.
fn fill(rect: Rect, color: Color) -> PaintOp {
    PaintOp::FillRect {
        rect,
        radius: Corners::ZERO,
        color,
    }
}

/// The damage rectangle covering a whole square surface.
fn surface(size: u32) -> PixelRect {
    PixelRect {
        x: 0,
        y: 0,
        width: size,
        height: size,
    }
}

/// Splits a square surface into tiles of `tile` pixels, cut short at the far
/// edges.
fn tiles(size: u32, tile: u32) -> Vec<PixelRect> {
    let mut tiles = Vec::new();
    for y in (0..size).step_by(tile as usize) {
        for x in (0..size).step_by(tile as usize) {
            tiles.push(PixelRect {
                x,
                y,
                width: tile.min(size - x),
                height: tile.min(size - y),
            });
        }
    }
    tiles
}

/// A rounded panel, a rounded inner rectangle with a border, and a clipped
/// fill that overflows its clip, so one frame exercises every drawing path.
fn scene(inner: Color) -> DisplayList {
    let mut list = DisplayList::new();
    list.push_op(fill(
        Rect::new(0.0, 0.0, 40.0, 40.0),
        Color::rgb(200, 200, 200),
    ));
    list.push_op(PaintOp::FillRect {
        rect: Rect::new(4.0, 4.0, 20.0, 20.0),
        radius: Corners::all(3.0),
        color: inner,
    });
    list.push_op(PaintOp::StrokeRect {
        rect: Rect::new(4.0, 4.0, 20.0, 20.0),
        radius: Corners::all(3.0),
        width: 1.5,
        color: Color::rgba(20, 40, 80, 180),
    });
    list.push_clip(Rect::new(6.0, 6.0, 30.0, 30.0));
    list.push_op(PaintOp::FillRect {
        rect: Rect::new(2.0, 2.0, 34.0, 34.0),
        radius: Corners::all(5.0),
        color: Color::rgb(220, 40, 90),
    });
    list.pop_clip();
    list.finish();
    list
}

#[test]
fn damage_leaves_pixels_outside_it_unchanged() {
    let mut renderer = CpuRenderer::new(16, 16);
    let black = list_of(fill(Rect::new(0.0, 0.0, 16.0, 16.0), Color::BLACK));
    render(&mut renderer, &black, &[surface(16)], 1.0);
    assert_eq!(pixel(&renderer, 0, 0), BLACK);

    let white = list_of(fill(Rect::new(0.0, 0.0, 16.0, 16.0), Color::WHITE));
    let damage = [PixelRect {
        x: 4,
        y: 4,
        width: 4,
        height: 4,
    }];
    render(&mut renderer, &white, &damage, 1.0);

    for y in 0..16 {
        for x in 0..16 {
            let inside = (4..8).contains(&x) && (4..8).contains(&y);
            let expected = if inside { WHITE } else { BLACK };
            assert_eq!(pixel(&renderer, x, y), expected, "pixel ({x}, {y})");
        }
    }
}

#[test]
fn fill_rect_at_scale_two_colors_its_physical_rect() {
    let mut renderer = CpuRenderer::new(80, 80);
    let red = list_of(fill(
        Rect::new(10.0, 10.0, 30.0, 30.0),
        Color::rgb(255, 0, 0),
    ));
    render(&mut renderer, &red, &[surface(80)], 2.0);

    assert_eq!(pixel(&renderer, 20, 20), RED);
    assert_eq!(pixel(&renderer, 59, 59), RED);
    assert_eq!(pixel(&renderer, 19, 20), WHITE, "left of the rectangle");
    assert_eq!(pixel(&renderer, 20, 19), WHITE, "above the rectangle");
    assert_eq!(pixel(&renderer, 60, 20), WHITE, "right of the rectangle");
    assert_eq!(pixel(&renderer, 20, 60), WHITE, "below the rectangle");
}

#[test]
fn partly_covered_pixels_blend_by_the_covered_area() {
    let cases = [
        (Color::BLACK, 127..=128, 191..=192),
        (Color::rgba(0, 0, 0, 128), 191..=192, 223..=224),
    ];
    for (color, half, quarter) in cases {
        let mut renderer = CpuRenderer::new(16, 16);
        let list = list_of(fill(Rect::new(0.5, 0.5, 10.0, 10.0), color));
        render(&mut renderer, &list, &[surface(16)], 1.0);

        for (x, y, expected, place) in [
            (5, 0, &half, "half covered on the top edge"),
            (0, 5, &half, "half covered on the left edge"),
            (0, 0, &quarter, "quarter covered in the corner"),
        ] {
            let [r, g, b, a] = pixel(&renderer, x, y);
            assert!(
                expected.contains(&r) && r == g && g == b && a == 255,
                "{place} with alpha {}: {:?}",
                color.a,
                [r, g, b, a]
            );
        }
    }
}

#[test]
fn op_inside_a_clip_draws_nothing_outside_it() {
    let mut renderer = CpuRenderer::new(40, 40);
    let mut list = DisplayList::new();
    list.push_clip(Rect::new(10.0, 10.0, 20.0, 20.0));
    list.push_op(fill(Rect::new(0.0, 0.0, 40.0, 40.0), Color::BLACK));
    list.pop_clip();
    list.finish();

    render(&mut renderer, &list, &[surface(40)], 1.0);

    assert_eq!(pixel(&renderer, 10, 10), BLACK);
    assert_eq!(pixel(&renderer, 19, 19), BLACK);
    assert_eq!(pixel(&renderer, 9, 15), WHITE, "left of the clip");
    assert_eq!(pixel(&renderer, 15, 9), WHITE, "above the clip");
    assert_eq!(pixel(&renderer, 20, 15), WHITE, "right of the clip");
    assert_eq!(pixel(&renderer, 15, 20), WHITE, "below the clip");
}

#[test]
fn op_inside_a_narrow_clip_keeps_its_own_edges() {
    let mut renderer = CpuRenderer::new(40, 40);
    let mut list = DisplayList::new();
    list.push_clip(Rect::new(10.0, 10.0, 30.0, 30.0));
    list.push_op(fill(Rect::new(12.0, 12.0, 18.0, 18.0), Color::BLACK));
    list.pop_clip();
    list.finish();

    render(&mut renderer, &list, &[surface(40)], 1.0);

    assert_eq!(pixel(&renderer, 12, 12), BLACK);
    assert_eq!(pixel(&renderer, 17, 17), BLACK);
    assert_eq!(pixel(&renderer, 11, 12), WHITE);
    assert_eq!(pixel(&renderer, 18, 17), WHITE);
}

#[test]
fn nested_clips_intersect() {
    let mut renderer = CpuRenderer::new(40, 40);
    let mut list = DisplayList::new();
    list.push_clip(Rect::new(8.0, 8.0, 30.0, 30.0));
    list.push_clip(Rect::new(20.0, 4.0, 36.0, 24.0));
    list.push_op(fill(Rect::new(0.0, 0.0, 40.0, 40.0), Color::BLACK));
    list.pop_clip();
    list.pop_clip();
    list.finish();

    render(&mut renderer, &list, &[surface(40)], 1.0);

    assert_eq!(pixel(&renderer, 20, 8), BLACK);
    assert_eq!(pixel(&renderer, 29, 23), BLACK);
    assert_eq!(pixel(&renderer, 19, 15), WHITE, "left of the inner clip");
    assert_eq!(pixel(&renderer, 25, 7), WHITE, "above the inner clip");
    assert_eq!(pixel(&renderer, 30, 15), WHITE, "right of the outer clip");
    assert_eq!(pixel(&renderer, 25, 24), WHITE, "below the inner clip");
}

#[test]
fn damage_render_equals_a_full_repaint() {
    let mut damaged = CpuRenderer::new(40, 40);
    render(&mut damaged, &scene(Color::BLACK), &[surface(40)], 1.0);
    let changed = PixelRect {
        x: 4,
        y: 4,
        width: 16,
        height: 16,
    };
    render(
        &mut damaged,
        &scene(Color::rgb(10, 20, 30)),
        &[changed],
        1.0,
    );

    let mut full = CpuRenderer::new(40, 40);
    render(
        &mut full,
        &scene(Color::rgb(10, 20, 30)),
        &[surface(40)],
        1.0,
    );

    assert_eq!(first_difference(&full, &damaged), None);
}

#[test]
fn damage_render_equals_a_full_repaint_at_a_fractional_scale() {
    let mut damaged = CpuRenderer::new(40, 40);
    render(&mut damaged, &scene(Color::BLACK), &[surface(40)], 1.5);
    let changed = PixelRect {
        x: 6,
        y: 6,
        width: 24,
        height: 24,
    };
    render(
        &mut damaged,
        &scene(Color::rgb(10, 20, 30)),
        &[changed],
        1.5,
    );

    let mut full = CpuRenderer::new(40, 40);
    render(
        &mut full,
        &scene(Color::rgb(10, 20, 30)),
        &[surface(40)],
        1.5,
    );

    assert_eq!(first_difference(&full, &damaged), None);
}

/// A rounded image stretched over most of the surface, and a translucent
/// rounded image over part of it, so one frame exercises bilinear sampling,
/// premultiplied blending and the rounded-rect coverage together.
fn image_scene() -> DisplayList {
    let mut list = DisplayList::new();
    list.push_op(PaintOp::Image {
        rect: Rect::new(2.0, 2.0, 30.0, 26.0),
        radius: Corners::all(6.0),
        image: gradient_image(16, 12),
    });
    list.push_op(PaintOp::Image {
        rect: Rect::new(10.0, 14.0, 26.0, 34.0),
        radius: Corners::all(3.0),
        image: gradient_image(4, 4),
    });
    list.finish();
    list
}

/// A `width` by `height` image of a diagonal gradient with a translucent
/// band, so sampling and premultiplied blending both have something to
/// interpolate. The color channels are premultiplied by the alpha, as the
/// format asks.
fn gradient_image(width: u32, height: u32) -> smudge_core::image::Image {
    let mut pixels = Vec::with_capacity(width as usize * height as usize * 4);
    for y in 0..height {
        for x in 0..width {
            let alpha: u32 = if y % 3 == 0 { 128 } else { 255 };
            let red = (x * 255) / (width - 1).max(1);
            let green = (y * 255) / (height - 1).max(1);
            let premultiply = |channel: u32| ((channel * alpha + 127) / 255) as u8;
            pixels.push(premultiply(red));
            pixels.push(premultiply(green));
            pixels.push(premultiply(90));
            pixels.push(alpha as u8);
        }
    }
    smudge_core::image::Image::from_premultiplied_rgba(width, height, pixels)
        .expect("the gradient fills the buffer")
}

#[test]
fn damage_through_an_image_matches_a_full_repaint() {
    for scale in [1.0, 1.5] {
        let size = (40.0 * scale) as u32;
        let list = image_scene();
        let mut full = CpuRenderer::new(size, size);
        render(&mut full, &list, &[surface(size)], scale);

        for tile in 1..=19 {
            let mut tiled = CpuRenderer::new(size, size);
            render(&mut tiled, &list, &tiles(size, tile), scale);
            assert_eq!(
                first_difference(&full, &tiled),
                None,
                "tiles of {tile} pixels at scale {scale}"
            );
        }
    }
}

#[test]
fn moving_an_image_between_damage_passes_matches_a_full_repaint() {
    // The image is drawn at one position with full damage, then at a moved
    // position with damage covering only the image's old and new area plus
    // one rect nowhere near it, and both passes must match a full repaint of
    // the same list, because sampling reads only the absolute position.
    for scale in [1.0, 1.5] {
        let size = (40.0 * scale) as u32;
        let image = gradient_image(8, 8);
        let at = |x0: f32, y0: f32| {
            let mut list = DisplayList::new();
            list.push_op(PaintOp::Image {
                rect: Rect::new(x0, y0, x0 + 20.0, y0 + 20.0),
                radius: Corners::all(4.0),
                image: image.clone(),
            });
            list.finish();
            list
        };
        let mut full = CpuRenderer::new(size, size);
        render(&mut full, &at(4.0, 4.0), &[surface(size)], scale);
        render(&mut full, &at(9.0, 7.0), &[surface(size)], scale);

        // The device rect that covers a logical rect at this scale.
        let area = |x0: f32, y0: f32, x1: f32, y1: f32| PixelRect {
            x: (x0 * scale) as u32,
            y: (y0 * scale) as u32,
            width: (x1 * scale).ceil() as u32 - (x0 * scale) as u32,
            height: (y1 * scale).ceil() as u32 - (y0 * scale) as u32,
        };
        // The union of the image's old and new bounds, and a disjoint rect.
        let moved = [area(4.0, 4.0, 29.0, 27.0), area(31.0, 31.0, 38.0, 38.0)];
        let mut tiled = CpuRenderer::new(size, size);
        render(&mut tiled, &at(4.0, 4.0), &tiles(size, 7), scale);
        render(&mut tiled, &at(9.0, 7.0), &moved, scale);
        assert_eq!(
            first_difference(&full, &tiled),
            None,
            "a moved image at scale {scale}"
        );
    }
}

#[test]
fn an_image_blends_over_a_translucent_surface() {
    // The clear is premultiplied for the surface: (100, 150, 200) at 128
    // leaves [50, 75, 100, 128]. The one-texel source is premultiplied
    // [64, 0, 32, 128], so at full coverage the effective source alpha is
    // 128 and the output is, per channel,
    // (src * 255 + dst * (255 - 128) + 127) / 255.
    let image = smudge_core::image::Image::from_premultiplied_rgba(1, 1, vec![64, 0, 32, 128])
        .expect("one texel fills the buffer");
    let mut list = DisplayList::new();
    list.push_op(PaintOp::Image {
        rect: Rect::new(0.0, 0.0, 1.0, 1.0),
        radius: Corners::ZERO,
        image,
    });
    list.finish();

    let mut renderer = CpuRenderer::new(2, 2);
    let damage = [PixelRect {
        x: 0,
        y: 0,
        width: 2,
        height: 2,
    }];
    renderer.render(&FrameOutput {
        list: &list,
        damage: &damage,
        full: true,
        clear_color: Color::rgba(100, 150, 200, 128),
        scale: 1.0,
    });

    assert_eq!(pixel(&renderer, 0, 0), [89, 37, 82, 192]);
    assert_eq!(
        pixel(&renderer, 1, 1),
        [50, 75, 100, 128],
        "the pixels the image does not cover keep the clear"
    );
}

#[test]
fn a_fully_transparent_texel_leaves_the_surface_alone() {
    // The second texel has alpha zero, so the row it covers must come
    // back exactly as the clear left it, alpha included.
    let image =
        smudge_core::image::Image::from_premultiplied_rgba(1, 2, vec![64, 0, 32, 128, 0, 0, 0, 0])
            .expect("two texels fill the buffer");
    let mut list = DisplayList::new();
    list.push_op(PaintOp::Image {
        rect: Rect::new(0.0, 0.0, 1.0, 2.0),
        radius: Corners::ZERO,
        image,
    });
    list.finish();

    let mut renderer = CpuRenderer::new(2, 2);
    let damage = [PixelRect {
        x: 0,
        y: 0,
        width: 2,
        height: 2,
    }];
    renderer.render(&FrameOutput {
        list: &list,
        damage: &damage,
        full: true,
        clear_color: Color::rgba(100, 150, 200, 128),
        scale: 1.0,
    });

    assert_eq!(pixel(&renderer, 0, 0), [89, 37, 82, 192]);
    assert_eq!(pixel(&renderer, 0, 1), [50, 75, 100, 128]);
}

#[test]
fn a_wide_image_indexes_rows_by_its_true_width() {
    // f32 holds integers exactly only up to 2^24, so a dimension past that
    // must never pass through one: 16_777_219 rounds up to 16_777_220 as
    // f32, and a stride built from the rounded width shifts every row past
    // the first by one texel. The pattern of the second row differs under
    // that shift, so sampling it catches the wrong stride byte for byte.
    let width = (1 << 24) + 3;
    let pattern = |x: u32| -> [u8; 4] {
        match x % 4 {
            0 => [0, 50, 60, 255],
            1 => [200, 50, 60, 255],
            2 => [40, 50, 60, 255],
            _ => [240, 50, 60, 255],
        }
    };
    let mut pixels = Vec::with_capacity(width as usize * 2 * 4);
    for _y in 0..2u32 {
        for x in 0..width {
            pixels.extend_from_slice(&pattern(x));
        }
    }
    let image = smudge_core::image::Image::from_premultiplied_rgba(width, 2, pixels)
        .expect("the pattern fills the buffer");
    let mut list = DisplayList::new();
    list.push_op(PaintOp::Image {
        rect: Rect::new(0.0, 0.0, 2.0, 2.0),
        radius: Corners::ZERO,
        image,
    });
    list.finish();

    let mut renderer = CpuRenderer::new(2, 2);
    let damage = [PixelRect {
        x: 0,
        y: 0,
        width: 2,
        height: 2,
    }];
    renderer.render(&FrameOutput {
        list: &list,
        damage: &damage,
        full: true,
        clear_color: CLEAR,
        scale: 1.0,
    });

    // The pixel center sits halfway between two texels of the second row,
    // at a coordinate below 2^23 where f32 keeps the half exactly. With the
    // true width the red channel averages pattern 0 and 1 into 100; with the
    // f32-rounded width the pair shifts to pattern 1 and 2, which average
    // 120.
    let sampled = pixel(&renderer, 0, 1);
    assert_eq!(
        sampled,
        [100, 50, 60, 255],
        "row one is indexed by the true width, not the f32-rounded one"
    );
}

#[test]
fn damage_edges_through_rounded_corners_match_a_full_repaint() {
    for scale in [1.0, 1.5] {
        let size = (40.0 * scale) as u32;
        let list = scene(Color::BLACK);
        let mut full = CpuRenderer::new(size, size);
        render(&mut full, &list, &[surface(size)], scale);

        for tile in 1..=19 {
            let mut tiled = CpuRenderer::new(size, size);
            render(&mut tiled, &list, &tiles(size, tile), scale);
            assert_eq!(
                first_difference(&full, &tiled),
                None,
                "tiles of {tile} pixels at scale {scale}"
            );
        }
    }
}

#[test]
fn corner_radius_is_in_logical_pixels() {
    let mut renderer = CpuRenderer::new(80, 80);
    let list = list_of(PaintOp::FillRect {
        rect: Rect::new(0.0, 0.0, 40.0, 40.0),
        radius: Corners::all(10.0),
        color: Color::BLACK,
    });
    render(&mut renderer, &list, &[surface(80)], 2.0);

    assert_eq!(pixel(&renderer, 3, 3), WHITE, "outside a 20 pixel corner");
    assert_eq!(pixel(&renderer, 8, 8), BLACK, "inside a 20 pixel corner");
}

#[test]
fn border_outer_edge_follows_a_background_with_the_same_radius() {
    let rect = Rect::new(0.0, 0.0, 40.0, 40.0);
    let radius = Corners::all(8.0);
    let background = list_of(PaintOp::FillRect {
        rect,
        radius,
        color: Color::BLACK,
    });
    let border = list_of(PaintOp::StrokeRect {
        rect,
        radius,
        width: 4.0,
        color: Color::BLACK,
    });
    let mut filled = CpuRenderer::new(40, 40);
    render(&mut filled, &background, &[surface(40)], 1.0);
    let mut stroked = CpuRenderer::new(40, 40);
    render(&mut stroked, &border, &[surface(40)], 1.0);

    for y in 0..12 {
        for x in 0..12 {
            if x < 4 || y < 4 {
                assert_eq!(
                    pixel(&stroked, x, y),
                    pixel(&filled, x, y),
                    "pixel ({x}, {y}) between the outer edge and the border's inner edge"
                );
            }
        }
    }
}

#[test]
fn op_under_an_offset_draws_at_the_offset() {
    let mut renderer = CpuRenderer::new(40, 40);
    let mut list = DisplayList::new();
    list.push_offset(Point { x: 10.0, y: 6.0 });
    list.push_op(fill(Rect::new(2.0, 2.0, 20.0, 20.0), Color::BLACK));
    list.pop_offset();
    list.push_op(fill(Rect::new(30.0, 30.0, 40.0, 40.0), Color::BLACK));
    list.finish();

    render(&mut renderer, &list, &[surface(40)], 1.0);

    assert_eq!(
        pixel(&renderer, 12, 8),
        BLACK,
        "the moved fill's first pixel"
    );
    assert_eq!(
        pixel(&renderer, 29, 25),
        BLACK,
        "the moved fill's last pixel"
    );
    assert_eq!(pixel(&renderer, 11, 8), WHITE, "left of the moved fill");
    assert_eq!(pixel(&renderer, 12, 7), WHITE, "above the moved fill");
    assert_eq!(pixel(&renderer, 30, 8), WHITE, "right of the moved fill");
    assert_eq!(pixel(&renderer, 12, 26), WHITE, "below the moved fill");
    assert_eq!(
        pixel(&renderer, 30, 30),
        BLACK,
        "the unmoved fill's first pixel"
    );
    assert_eq!(pixel(&renderer, 29, 30), WHITE, "left of the unmoved fill");
}

#[test]
fn a_clip_under_an_offset_clips_where_the_offset_puts_it() {
    let mut renderer = CpuRenderer::new(40, 40);
    let mut list = DisplayList::new();
    list.push_offset(Point { x: 8.0, y: 8.0 });
    list.push_clip(Rect::new(4.0, 4.0, 20.0, 20.0));
    list.push_op(fill(Rect::new(0.0, 0.0, 40.0, 40.0), Color::BLACK));
    list.pop_clip();
    list.pop_offset();
    list.finish();

    render(&mut renderer, &list, &[surface(40)], 1.0);

    assert_eq!(pixel(&renderer, 12, 12), BLACK);
    assert_eq!(pixel(&renderer, 27, 27), BLACK);
    assert_eq!(pixel(&renderer, 11, 12), WHITE, "left of the moved clip");
    assert_eq!(pixel(&renderer, 12, 11), WHITE, "above the moved clip");
    assert_eq!(pixel(&renderer, 28, 15), WHITE, "right of the moved clip");
    assert_eq!(pixel(&renderer, 15, 28), WHITE, "below the moved clip");
}

#[test]
fn nested_offsets_compose() {
    let mut renderer = CpuRenderer::new(48, 48);
    let mut list = DisplayList::new();
    list.push_offset(Point { x: 10.0, y: 4.0 });
    list.push_offset(Point { x: 2.0, y: 30.0 });
    list.push_op(fill(Rect::new(0.0, 0.0, 8.0, 8.0), Color::BLACK));
    list.pop_offset();
    list.push_op(fill(Rect::new(0.0, 0.0, 8.0, 8.0), Color::BLACK));
    list.pop_offset();
    list.finish();

    render(&mut renderer, &list, &[surface(48)], 1.0);

    assert_eq!(pixel(&renderer, 12, 34), BLACK, "inside both offsets");
    assert_eq!(pixel(&renderer, 17, 39), BLACK);
    assert_eq!(pixel(&renderer, 11, 34), WHITE, "left of the inner fill");
    assert_eq!(
        pixel(&renderer, 10, 4),
        BLACK,
        "inside the outer offset only"
    );
    assert_eq!(pixel(&renderer, 17, 11), BLACK);
    assert_eq!(pixel(&renderer, 9, 4), WHITE, "left of the outer fill");
}

#[test]
fn an_offset_at_a_fractional_scale_lands_on_physical_pixels() {
    let mut renderer = CpuRenderer::new(48, 48);
    let mut list = DisplayList::new();
    list.push_offset(Point { x: 5.0, y: 7.0 });
    list.push_op(fill(Rect::new(2.0, 2.0, 14.0, 14.0), Color::BLACK));
    list.pop_offset();
    list.finish();

    render(&mut renderer, &list, &[surface(48)], 2.0);

    assert_eq!(pixel(&renderer, 14, 18), BLACK);
    assert_eq!(pixel(&renderer, 37, 41), BLACK);
    assert_eq!(pixel(&renderer, 13, 18), WHITE, "left of the moved fill");
    assert_eq!(pixel(&renderer, 14, 17), WHITE, "above the moved fill");
    assert_eq!(pixel(&renderer, 38, 18), WHITE, "right of the moved fill");
    assert_eq!(pixel(&renderer, 14, 42), WHITE, "below the moved fill");
}

#[test]
fn text_under_an_offset_draws_the_same_bytes_as_translated_text() {
    TextSystem::bundled_only().install();
    let run = TextLayout::new("Smudge", &TextStyle::default(), None)
        .glyph_runs_at(Point { x: 4.0, y: 4.0 }, Color::BLACK)
        .into_iter()
        .next()
        .expect("the label shapes one run");
    let moved = {
        let mut glyphs = run.glyphs.clone();
        for glyph in &mut glyphs {
            glyph.x += 10.0;
            glyph.y += 12.0;
        }
        GlyphRun {
            font: run.font.clone(),
            size: run.size,
            color: run.color,
            glyphs,
            ink_bounds: run.ink_bounds.translated(Point { x: 10.0, y: 12.0 }),
        }
    };

    let mut list = DisplayList::new();
    list.push_offset(Point { x: 10.0, y: 12.0 });
    list.push_op(PaintOp::Glyphs(Rc::new(run)));
    list.pop_offset();
    list.finish();
    let translated = list_of(PaintOp::Glyphs(Rc::new(moved)));

    let mut shifted = CpuRenderer::new(40, 40);
    render(&mut shifted, &list, &[surface(40)], 1.0);
    let mut direct = CpuRenderer::new(40, 40);
    render(&mut direct, &translated, &[surface(40)], 1.0);

    assert_eq!(first_difference(&shifted, &direct), None);
}

#[test]
fn damage_render_equals_a_full_repaint_under_an_offset() {
    let shifted = |inner: Color| {
        let mut list = DisplayList::new();
        list.push_offset(Point { x: 6.0, y: 2.0 });
        list.push_clip(Rect::new(2.0, 2.0, 30.0, 30.0));
        list.push_op(fill(
            Rect::new(0.0, 0.0, 40.0, 40.0),
            Color::rgb(200, 200, 200),
        ));
        list.push_op(PaintOp::FillRect {
            rect: Rect::new(4.0, 4.0, 20.0, 20.0),
            radius: Corners::all(3.0),
            color: inner,
        });
        list.pop_clip();
        list.pop_offset();
        list.finish();
        list
    };

    let mut damaged = CpuRenderer::new(40, 40);
    render(&mut damaged, &shifted(Color::BLACK), &[surface(40)], 1.0);
    render(
        &mut damaged,
        &shifted(Color::rgb(10, 20, 30)),
        &[PixelRect {
            x: 10,
            y: 6,
            width: 16,
            height: 16,
        }],
        1.0,
    );

    let mut full = CpuRenderer::new(40, 40);
    render(
        &mut full,
        &shifted(Color::rgb(10, 20, 30)),
        &[surface(40)],
        1.0,
    );

    assert_eq!(first_difference(&full, &damaged), None);
}

#[test]
fn empty_surface_holds_no_pixels() {
    let mut renderer = CpuRenderer::new(0, 0);
    render(&mut renderer, &DisplayList::new(), &[], 1.0);

    assert_eq!(renderer.width(), 0);
    assert_eq!(renderer.height(), 0);
    assert!(renderer.pixels().is_empty());
    assert!(renderer.encode_png().is_empty());
}

#[test]
fn resize_replaces_the_surface_size() {
    let mut renderer = CpuRenderer::new(8, 8);
    renderer.resize(16, 4);

    assert_eq!(renderer.width(), 16);
    assert_eq!(renderer.height(), 4);
    assert_eq!(renderer.pixels().len(), 16 * 4 * 4);
}

#[test]
#[should_panic(expected = "different surface size")]
fn render_panics_when_damage_reaches_outside_the_surface() {
    let mut renderer = CpuRenderer::new(8, 8);
    let damage = [PixelRect {
        x: 4,
        y: 4,
        width: 8,
        height: 8,
    }];
    render(&mut renderer, &DisplayList::new(), &damage, 1.0);
}