# coding=utf-8 # SPDX-License-Identifier: GPL-2.0-or-later # Copyright (C) 2026 Alex """Tests of the "Dog Bandana Pattern Fill" extension (pytest).""" import os import re import xml.etree.ElementTree as ET import pytest import math import numpy as np from dog_bandana_core import (chain_polylines, erode, grid_pixels, laser_order, order_polylines, parse_color, polylines_to_d, rasterize, simplify_polyline, skeletonize, smooth_polyline, trace_skeleton, travel_length, turing_pattern) HERE = os.path.dirname(os.path.abspath(__file__)) SHAPES = os.path.join(HERE, "tests", "data", "shapes.svg") SCALED = os.path.join(HERE, "tests", "data", "scaled.svg") # -------------------------------------------------------------------------- # Core (without inkex) # -------------------------------------------------------------------------- def test_parse_color_inkscape_integer(): assert parse_color("3014898687") == ("#b3b3b3", 1.0) assert parse_color(str(0xFF000080)) == ("#ff0000", round(0x80 / 255, 4)) def test_parse_color_hex_and_invalid(): assert parse_color("#123456") == ("#123456", 1.0) assert parse_color("#abc") == ("#aabbcc", 1.0) assert parse_color("not a color") == ("#b3b3b3", 1.0) def test_polylines_to_d(): d = polylines_to_d([[(0, 0), (1, 2)], [(3, 4), (5, 6)]], precision=1) assert d == "M 0.0,0.0 L 1.0,2.0 M 3.0,4.0 L 5.0,6.0" def covered_segments(polylines): """Segments (rounded, direction ignored) covered by polylines.""" out = [] for line in polylines: for p, q in zip(line, line[1:]): a, b = tuple(round(v, 6) for v in p), tuple(round(v, 6) for v in q) out.append(min((a, b), (b, a))) return sorted(out) def test_chain_polylines_joins_touching_lines(): # A "Y" (4 odd nodes: at least 2 strokes) and an isolated stroke. y_shape = [[(0, 0), (0, -1)], [(0, 0), (1, 1)], [(-1, 1), (0, 0)]] lone = [[(5, 5), (6, 5), (7, 6)]] chained = chain_polylines(y_shape + lone) assert len(chained) == 3 assert covered_segments(chained) == covered_segments(y_shape + lone) def test_chain_polylines_closed_circuit(): square = [[(0, 0), (1, 0)], [(1, 0), (1, 1)], [(1, 1), (0, 1)], [(0, 1), (0, 0)]] chained = chain_polylines(square) assert len(chained) == 1 and len(chained[0]) == 5 assert chained[0][0] == chained[0][-1] def test_order_polylines_nearest_and_reversed(): lines = [[(10, 0), (20, 0)], [(3, 0), (1, 0)], [(30, 0), (21, 0)]] ordered = order_polylines(lines, start=(0, 0)) assert ordered == [[(1, 0), (3, 0)], [(10, 0), (20, 0)], [(21, 0), (30, 0)]] assert travel_length(ordered) == pytest.approx(1 + 7 + 1) def test_order_polylines_rotates_loops(): loop = [(0, 0), (10, 0), (10, 10), (0, 10), (0, 0)] ordered = order_polylines([loop], start=(11, 11)) assert ordered[0][0] == ordered[0][-1] == (10, 10) assert len(ordered[0]) == 5 def test_laser_order_cuts_travel_on_a_grid(): # Grid of unit segments in an unfavourable order. segments = [[(x, y), (x + 1, y)] for x in range(20) for y in range(0, 20, 2)] segments += [[(x, y), (x, y + 1)] for y in range(20) for x in range(0, 20, 2)] segments = segments[::2] + segments[1::2] ordered = laser_order(segments) assert covered_segments(ordered) == covered_segments(segments) assert travel_length(ordered) < travel_length(segments) / 4 # -------------------------------------------------------------------------- # Turing pattern: steps # -------------------------------------------------------------------------- def test_rasterize_square_with_hole_even_odd(): outer = [(0, 0), (10, 0), (10, 10), (0, 10)] hole = [(3, 3), (7, 3), (7, 7), (3, 7)] mask = rasterize([outer, hole], 0, 0, 1.0, 12, 12) assert mask.sum() == 100 - 16 assert mask[1, 1] and not mask[5, 5] and not mask[11, 11] def test_rasterize_vertex_on_scanline_counted_once(): # Vertices of this diamond exactly on pixel row centers. diamond = [(5, 0.5), (9.5, 5.5), (5, 10.5), (0.5, 5.5)] mask = rasterize([diamond], 0, 0, 1.0, 10, 11) for row in mask: # each row: a single run assert np.count_nonzero(np.diff(row.astype(int))) <= 2 def test_erode_shrinks_by_radius(): mask = np.zeros((40, 40), dtype=bool) mask[10:30, 10:30] = True eroded = erode(mask, 3) rows = np.nonzero(eroded.any(axis=1))[0] assert rows[0] == 13 and rows[-1] == 26 assert erode(mask, 0).sum() == mask.sum() def test_skeletonize_bar_to_single_line(): bar = np.zeros((15, 40), dtype=bool) bar[5:10, 5:35] = True skeleton = skeletonize(bar) assert skeleton.any() assert skeleton.sum(axis=0).max() == 1 # one pixel per column assert (skeleton <= bar).all() def test_trace_skeleton_line_cross_dot_and_loop(): img = np.zeros((30, 30), dtype=bool) img[2, 2:12] = True # segment img[20, 5] = True # isolated dot lines = trace_skeleton(img) assert sorted(len(line) for line in lines) == [1, 10] cross = np.zeros((21, 21), dtype=bool) cross[10, :] = True cross[:, 10] = True assert len(trace_skeleton(cross)) == 4 loop = np.zeros((12, 12), dtype=bool) loop[2, 2:9] = loop[8, 2:9] = loop[2:9, 2] = loop[2:9, 8] = True lines = trace_skeleton(loop) assert len(lines) == 1 and lines[0][0] == lines[0][-1] def test_trace_skeleton_prunes_short_spurs(): img = np.zeros((20, 30), dtype=bool) img[10, 2:28] = True img[8:10, 15] = True # 2-pixel spur assert len(trace_skeleton(img)) == 3 assert len(trace_skeleton(img, min_spur=4)) == 2 def test_smooth_keeps_ends_and_loops(): zigzag = [(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)] smooth = smooth_polyline(zigzag, 3) assert smooth[0] == (0, 0) and smooth[-1] == (4, 0) assert max(y for _x, y in smooth[1:-1]) < 1 loop = [(0, 0), (4, 0), (4, 4), (0, 4), (0, 0)] smooth = smooth_polyline(loop, 2) assert smooth[0] == smooth[-1] and len(smooth) == 5 def test_simplify_straight_line(): line = [(x, 0.001 * (x % 2)) for x in range(20)] assert simplify_polyline(line, 0.01) == [(0.0, 0.0), (19.0, 0.001)] corner = [(0, 0), (5, 0), (5, 5)] assert len(simplify_polyline(corner, 0.1)) == 3 # -------------------------------------------------------------------------- # Turing pattern: result # -------------------------------------------------------------------------- RECT = [[(0, 0), (60, 0), (60, 40), (0, 40)]] def polyline_length(line): return sum(math.hypot(q[0] - p[0], q[1] - p[1]) for p, q in zip(line, line[1:])) @pytest.mark.parametrize("edge", ["cut", "follow"]) def test_pattern_stays_inside_with_margin(edge): period, width, margin = 4.0, 2.0, 1.5 lines = turing_pattern(RECT, period, width, margin, seed=3, edge=edge) assert lines inset = margin + width / 2 tolerance = period / 8 # one computation pixel for line in lines: for x, y in line: assert inset - tolerance <= x <= 60 - inset + tolerance assert inset - tolerance <= y <= 40 - inset + tolerance def test_pattern_density_matches_period(): """Line length ~ area / period: bands one period apart.""" period = 4.0 lines = turing_pattern(RECT, period, 2.0, seed=1) total = sum(polyline_length(line) for line in lines) ratio = total * period / (60 * 40) assert 0.6 < ratio < 1.2 def test_pattern_reproducible_and_seeded(): a = turing_pattern(RECT, 4.0, 2.0, seed=7) assert a == turing_pattern(RECT, 4.0, 2.0, seed=7) assert a != turing_pattern(RECT, 4.0, 2.0, seed=8) def test_more_iterations_give_fewer_longer_lines(): few = turing_pattern(RECT, 4.0, 2.0, seed=2, steps=30) many = turing_pattern(RECT, 4.0, 2.0, seed=2, steps=300) assert len(many) < len(few) def test_pattern_respects_holes(): outer = [(0, 0), (60, 0), (60, 60), (0, 60)] hole = [(20, 20), (40, 20), (40, 40), (20, 40)] lines = turing_pattern([outer, hole], 4.0, 2.0, seed=1) inside = [(x, y) for line in lines for x, y in line if 21.5 < x < 38.5 and 21.5 < y < 38.5] assert not inside def test_pattern_empty_cases(): assert turing_pattern([], 4.0, 2.0) == [] assert turing_pattern(RECT, 0, 2.0) == [] # Strip narrower than the stroke: nothing to draw. assert turing_pattern([[(0, 0), (60, 0), (60, 1.5), (0, 1.5)]], 4.0, 2.0) == [] def test_dots_are_two_point_polylines(): lines = turing_pattern(RECT, 4.0, 2.0, seed=1, steps=20) assert all(len(line) >= 2 for line in lines) def test_grid_pixels(): assert grid_pixels([], 4.0) == 0 assert grid_pixels(RECT, 4.0) == (120 + 32) * (80 + 32) def test_laser_order_cuts_travel_on_pattern(): lines = turing_pattern(RECT, 4.0, 2.0, seed=1) ordered = laser_order(lines) assert travel_length(ordered) < travel_length(lines) / 3 # -------------------------------------------------------------------------- # End to end (requires inkex) # -------------------------------------------------------------------------- def run_extension(tmp_path, *args, source=SHAPES): pytest.importorskip("inkex") from dog_bandana import DogBandana out = tmp_path / "out.svg" DogBandana().run([*args, "--output={}".format(out), source]) return out.read_text(encoding="utf-8") def test_end_to_end_default(tmp_path): svg = run_extension(tmp_path, "--id=rect1") assert "Dog Bandana pattern" in svg assert 'id="rect1"' in svg assert "stroke-linecap:round" in svg def test_end_to_end_group_and_holes(tmp_path): svg = run_extension(tmp_path, "--id=group1", "--id=path2") assert svg.count("Dog Bandana pattern") == 2 @pytest.mark.parametrize("args, message", [ (["--line_width=5", "--period=4"], "smaller than the period"), (["--margin=30"], "too narrow"), ]) def test_end_to_end_errors(tmp_path, capsys, args, message): # Unchanged document: inkex writes no output, only the message matters. pytest.importorskip("inkex") from dog_bandana import DogBandana DogBandana().run(["--id=rect1", *args, "--output={}".format(tmp_path / "out.svg"), SHAPES]) assert message in capsys.readouterr().err def test_end_to_end_non_standard_document_scale(tmp_path): """400 mm page for 538.72 user units: svg.unittouu() would get it wrong.""" svg = run_extension(tmp_path, "--id=rect1", source=SCALED) width = re.search(r"stroke-width:([\d.]+)", svg) assert float(width.group(1)) == pytest.approx(2.0 * 538.72053 / 400, abs=0.001) def test_end_to_end_removes_original(tmp_path): svg = run_extension(tmp_path, "--id=rect1", "--keep_original=false") assert 'id="rect1"' not in svg def test_end_to_end_color(tmp_path): svg = run_extension(tmp_path, "--id=rect1", "--stroke_color={}".format(0x336699FF)) assert re.search(r"stroke:#336699", svg) # -------------------------------------------------------------------------- # Translations # -------------------------------------------------------------------------- def test_translations_up_to_date_and_complete(): """Every text of the .inx and .py files is translated in every catalog.""" import gettext import i18n msgids = [msgid for msgid, _refs in i18n.extract()] assert "Dog Bandana Pattern Fill" in msgids assert "mm" not in msgids # units marked translatable="no" for language in i18n.LANGUAGES: entries = i18n.read_po(i18n.po_path(language)) missing = [m for m in msgids if not entries.get(m, ("", False))[0]] assert not missing, "{}.po incomplete: {}".format(language, missing) catalog = gettext.translation(i18n.DOMAIN, i18n.LOCALE_DIR, [language]) for msgid in msgids: assert catalog.gettext(msgid) == entries[msgid][0], \ "{}: .mo must be recompiled (python i18n.py)".format(language) def test_po_roundtrip(tmp_path): import i18n messages = [("Simple", ["a"]), ('Quote "x" and \\ back', ["a"]), ("Two\nlines", ["a"]), ("Tab\tend\n", ["a"])] path = str(tmp_path / "xx.po") i18n.write_po(path, "fr", messages, {m: ("<" + m + ">", False) for m, _r in messages}) entries = i18n.read_po(path) for msgid, _refs in messages: assert entries[msgid] == ("<" + msgid + ">", False) def test_inx_matches_arguments(): """Every of the .inx has its add_argument, and vice versa.""" root = ET.parse(os.path.join(HERE, "dog_bandana.inx")).getroot() params = {elem.get("name") for elem in root.iter() if elem.tag.rsplit("}", 1)[-1] == "param"} with open(os.path.join(HERE, "dog_bandana.py"), encoding="utf-8") as handle: arguments = set(re.findall(r'add_argument\("--(\w+)"', handle.read())) assert params == arguments def test_inx_images_exist(): """Dialog images exist (path relative to the .inx).""" root = ET.parse(os.path.join(HERE, "dog_bandana.inx")).getroot() for elem in root.iter(): if elem.tag.rsplit("}", 1)[-1] == "image": assert os.path.isfile(os.path.join(HERE, elem.text.strip())), elem.text