Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-render

Source of release 0.6.2

0.6.2 / tests / raster / fill.lucb

#==============================================================================================
#
#   fill - tiny-skia's integration tests: fill.rs
#
#   DESCRIPTION:
#       Port of tiny-skia 0.12.0 tests/integration/fill.rs. Each test renders with the
#       rasterizer and compares against tiny-skia's reference image, pixel for pixel.
#
#       Copyright (c) 2020 Yevhenii Reizner (tiny-skia's tests)
#       Copyright (c) 2026 the luce-browser authors.
#       SPDX-License-Identifier: BSD-3-Clause (see LICENSE-tiny-skia)
#
#==============================================================================================

import harness
from luce_browser_render import raster
from harness import Test, TestCase
from luce_browser_render.raster import Paint, PathBuilder, Pixmap, PixmapPaint, Transform, Rect, Point, Color, ColorU8, Stroke, StrokeDash, LineCap, LineJoin, FillRule, BlendMode, SpreadMode, FilterQuality, GradientStop, LinearGradient, RadialGradient, SweepGradient, Pattern, Mask, MaskType, IntRect, ColorSpace, Shader

func horizontal_line(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 10.0)
    pb.line_to(90.0, 10.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/empty.png")

func vertical_line(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 10.0)
    pb.line_to(10.0, 90.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/empty.png")

func single_line(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 10.0)
    pb.line_to(90.0, 90.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/empty.png")

func int_rect(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    let rect = (Rect.from_xywh(10.0, 15.0, 80.0, 70.0) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/int-rect.png")

func float_rect(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    let rect = (Rect.from_xywh(10.3, 15.4, 80.5, 70.6) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/float-rect.png")

func int_rect_aa(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    let rect = (Rect.from_xywh(10.0, 15.0, 80.0, 70.0) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/int-rect-aa.png")

func float_rect_aa(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    let rect = (Rect.from_xywh(10.3, 15.4, 80.5, 70.6) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/float-rect-aa.png")

func float_rect_aa_highp(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true
    paint.force_hq_pipeline = true

    let rect = (Rect.from_xywh(10.3, 15.4, 80.5, 70.6) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/float-rect-aa-highp.png")

func tiny_float_rect(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    let rect = (Rect.from_xywh(1.3, 1.4, 0.5, 0.6) else trap("unwrap"))
    var pixmap = Pixmap.new_(3, 3) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    let expected: raster.PremultipliedColorU8[9] = [
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(50, 127, 150, 200).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
    ]
    harness.expect_pixels(t, &pixmap, expected)

func tiny_float_rect_aa(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    let rect = (Rect.from_xywh(1.3, 1.4, 0.5, 0.6) else trap("unwrap"))

    var pixmap = Pixmap.new_(3, 3) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    let expected: raster.PremultipliedColorU8[9] = [
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        # Skia m144 (NEON div255 and 1/255 colors); tiny-skia expects (51, 128, 153, 60) demultiplied.
        raster.PremultipliedColorU8.from_rgba(12, 30, 35, 60) else trap("color"),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
        ColorU8.from_rgba(0, 0, 0, 0).premultiply(),
    ]
    harness.expect_pixels(t, &pixmap, expected)

func tiny_rect_aa(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(0, 0, 0, 0)
    paint.anti_alias = true
    let rect = (Rect.from_xywh(0.7, 0.0, 1.0, 2.0) else trap("unwrap"))
    var pixmap = Pixmap.new_(10, 10) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

func float_rect_clip_top_left_aa(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    let rect = (Rect.from_xywh(-10.3, -20.4, 100.5, 70.2) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/float-rect-clip-top-left-aa.png")

func float_rect_clip_top_right_aa(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    let rect = (Rect.from_xywh(60.3, -20.4, 100.5, 70.2) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/float-rect-clip-top-right-aa.png")

func float_rect_clip_bottom_right_aa(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    let rect = (Rect.from_xywh(60.3, 40.4, 100.5, 70.2) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/float-rect-clip-bottom-right-aa.png")

func int_rect_with_ts_clip_right(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    let rect = (Rect.from_xywh(0.0, 0.0, 100.0, 100.0) else trap("unwrap"))

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect(rect, &paint, Transform.from_row(1.0, 0.0, 0.0, 1.0, 0.5, 0.5), none)

    harness.expect_png(t, &pixmap, "fill/int-rect-with-ts-clip-right.png")

func open_polygon(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(75.160671, 88.756136)
    pb.line_to(24.797274, 88.734053)
    pb.line_to(9.255130, 40.828792)
    pb.line_to(50.012955, 11.243795)
    pb.line_to(90.744819, 40.864522)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/polygon.png")

# Must be the same a open.
func closed_polygon(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(75.160671, 88.756136)
    pb.line_to(24.797274, 88.734053)
    pb.line_to(9.255130, 40.828792)
    pb.line_to(50.012955, 11.243795)
    pb.line_to(90.744819, 40.864522)
    pb.close()
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/polygon.png")

func winding_star(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(50.0, 7.5)
    pb.line_to(75.0, 87.5)
    pb.line_to(10.0, 37.5)
    pb.line_to(90.0, 37.5)
    pb.line_to(25.0, 87.5)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/winding-star.png")

func even_odd_star(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(50.0, 7.5)
    pb.line_to(75.0, 87.5)
    pb.line_to(10.0, 37.5)
    pb.line_to(90.0, 37.5)
    pb.line_to(25.0, 87.5)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.even_odd, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/even-odd-star.png")

func quad_curve(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 15.0)
    pb.quad_to(95.0, 35.0, 75.0, 90.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.even_odd, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/quad.png")

func cubic_curve(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 15.0)
    pb.cubic_to(95.0, 35.0, 0.0, 75.0, 75.0, 90.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.even_odd, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/cubic.png")

func memset2d(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 255)
    paint.anti_alias = false

    var path = PathBuilder.from_rect((Rect.from_ltrb(10.0, 10.0, 90.0, 90.0) else trap("unwrap")))
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/memset2d.png")

# Make sure we do not write past pixmap memory.
func memset2d_out_of_bounds(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 255)
    paint.anti_alias = false

    var path = PathBuilder.from_rect((Rect.from_ltrb(50.0, 50.0, 120.0, 120.0) else trap("unwrap")))
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/memset2d-2.png")

# Not sure how to properly test anti-aliasing,
# so for now simply check that it actually applied.
func fill_aa(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(50.0, 7.5)
    pb.line_to(75.0, 87.5)
    pb.line_to(10.0, 37.5)
    pb.line_to(90.0, 37.5)
    pb.line_to(25.0, 87.5)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.even_odd, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/star-aa.png")

func overflow_in_walk_edges_1(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 20.0)
    pb.cubic_to(39.0, 163.0, 117.0, 61.0, 130.0, 70.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    # Must not panic.
    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

func clip_line_1(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(50.0, -15.0)
    pb.line_to(-15.0, 50.0)
    pb.line_to(50.0, 115.0)
    pb.line_to(115.0, 50.0)
    pb.close()
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/clip-line-1.png")

func clip_line_2(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    # This strange path forces `line_clipper::clip` to return an empty array.
    # And we're checking that this case is handled correctly.
    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(0.0, -1.0)
    pb.line_to(50.0, 0.0)
    pb.line_to(0.0, 50.0)
    pb.close()
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/clip-line-2.png")

func clip_quad(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 85.0)
    pb.quad_to(150.0, 150.0, 85.0, 15.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/clip-quad.png")

func clip_cubic_1(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    # `line_clipper::clip` produces 2 points for this path.
    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 50.0)
    pb.cubic_to(0.0, 175.0, 195.0, 70.0, 75.0, 20.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/clip-cubic-1.png")

func clip_cubic_2(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = false

    # `line_clipper::clip` produces 3 points for this path.
    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(10.0, 50.0)
    pb.cubic_to(10.0, 40.0, 90.0, 120.0, 125.0, 20.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/clip-cubic-2.png")

func aa_endless_loop(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.anti_alias = true

    # This path was causing an endless loop before.
    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(2.1537175, 11.560721)
    pb.quad_to(1.9999998, 10.787931, 2.0, 10.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    # Must not loop.
    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

func clear_aa(t: Test*):
    # Make sure that Clear with AA doesn't fallback to memset.
    var paint = Paint()
    defer paint.release()
    paint.anti_alias = true
    paint.blend_mode = BlendMode.clear

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill(Color.from_rgba8(50, 127, 150, 200))
    var tmp_path1 = PathBuilder.from_circle(50.0, 50.0, 40.0) else trap("unwrap")
    defer tmp_path1.release()
    pixmap.fill_path(&tmp_path1, &paint, FillRule.winding, Transform.identity(), none)

    harness.expect_png(t, &pixmap, "fill/clear-aa.png")

func line_curve(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.anti_alias = true

    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(100.0, 20.0)
    pb.cubic_to(100.0, 40.0, 100.0, 160.0, 100.0, 180.0)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var pixmap = Pixmap.new_(200, 200) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.identity(), none)

# Must not panic.

func vertical_lines_merging_bug(t: Test*):
    # This path must not trigger edge_builder::combine_vertical,
    # otherwise AlphaRuns::add will crash later.
    var pb = PathBuilder.new_()
    defer pb.release()
    pb.move_to(765.56, 158.56)
    pb.line_to(754.4, 168.28)
    pb.cubic_to(754.4, 168.28, 754.4, 168.24, 754.4, 168.17)
    pb.cubic_to(754.4, 168.09, 754.4, 168.02, 754.4, 167.95)
    pb.line_to(754.4, 168.06)
    var path = pb.finish() else trap("finish")
    defer path.release()

    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    # Must not panic.
    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_path(&path, &paint, FillRule.winding, Transform.from_row(5.4, 0.0, 0.0, 5.4, -4050.0, -840.0), none)

    harness.expect_png(t, &pixmap, "fill/vertical-lines-merging-bug.png")

func fill_rect(t: Test*):
    var paint = Paint()
    defer paint.release()
    paint.set_color_rgba8(50, 127, 150, 200)
    paint.anti_alias = true

    var pixmap = Pixmap.new_(100, 100) else trap("pixmap")
    defer pixmap.release()
    pixmap.fill_rect((Rect.from_xywh(20.3, 10.4, 50.5, 30.2) else trap("unwrap")), &paint, Transform.from_row(1.2, 0.3, -0.7, 0.8, 12.0, 15.3), none)

    harness.expect_png(t, &pixmap, "canvas/fill-rect.png")

pub let tests: TestCase[35] = [
    TestCase(name = "fill::horizontal_line", run = horizontal_line),
    TestCase(name = "fill::vertical_line", run = vertical_line),
    TestCase(name = "fill::single_line", run = single_line),
    TestCase(name = "fill::int_rect", run = int_rect),
    TestCase(name = "fill::float_rect", run = float_rect),
    TestCase(name = "fill::int_rect_aa", run = int_rect_aa),
    TestCase(name = "fill::float_rect_aa", run = float_rect_aa),
    TestCase(name = "fill::float_rect_aa_highp", run = float_rect_aa_highp),
    TestCase(name = "fill::tiny_float_rect", run = tiny_float_rect),
    TestCase(name = "fill::tiny_float_rect_aa", run = tiny_float_rect_aa),
    TestCase(name = "fill::tiny_rect_aa", run = tiny_rect_aa),
    TestCase(name = "fill::float_rect_clip_top_left_aa", run = float_rect_clip_top_left_aa),
    TestCase(name = "fill::float_rect_clip_top_right_aa", run = float_rect_clip_top_right_aa),
    TestCase(name = "fill::float_rect_clip_bottom_right_aa", run = float_rect_clip_bottom_right_aa),
    TestCase(name = "fill::int_rect_with_ts_clip_right", run = int_rect_with_ts_clip_right),
    TestCase(name = "fill::open_polygon", run = open_polygon),
    TestCase(name = "fill::closed_polygon", run = closed_polygon),
    TestCase(name = "fill::winding_star", run = winding_star),
    TestCase(name = "fill::even_odd_star", run = even_odd_star),
    TestCase(name = "fill::quad_curve", run = quad_curve),
    TestCase(name = "fill::cubic_curve", run = cubic_curve),
    TestCase(name = "fill::memset2d", run = memset2d),
    TestCase(name = "fill::memset2d_out_of_bounds", run = memset2d_out_of_bounds),
    TestCase(name = "fill::fill_aa", run = fill_aa),
    TestCase(name = "fill::overflow_in_walk_edges_1", run = overflow_in_walk_edges_1),
    TestCase(name = "fill::clip_line_1", run = clip_line_1),
    TestCase(name = "fill::clip_line_2", run = clip_line_2),
    TestCase(name = "fill::clip_quad", run = clip_quad),
    TestCase(name = "fill::clip_cubic_1", run = clip_cubic_1),
    TestCase(name = "fill::clip_cubic_2", run = clip_cubic_2),
    TestCase(name = "fill::aa_endless_loop", run = aa_endless_loop),
    TestCase(name = "fill::clear_aa", run = clear_aa),
    TestCase(name = "fill::line_curve", run = line_curve),
    TestCase(name = "fill::vertical_lines_merging_bug", run = vertical_lines_merging_bug),
    TestCase(name = "fill::fill_rect", run = fill_rect),
]