test: add SVGDraftman direct visitor tests

Add 27 tests covering each visit*() method in isolation:
- visitRectangle: dimensions, filled/stroked/both/neither color combos
- visitCircle: center calculation, fill/stroke variants
- visitTriangle: polygon points, fill style, stroke style
- visitText: content, position offset, font attributes, color fallbacks
- visitCollection: empty, multiple children, nested collections
- generateSVG: XML declaration, SVG namespace, closing tag, shape content

Closes #9

pom.xml

@@ -15,6 +15,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.13.0</version>
                 <configuration>
                     <source>16</source>
                     <target>16</target>
@@ -28,7 +29,7 @@
             <plugin>
                 <groupId>org.jacoco</groupId>
                 <artifactId>jacoco-maven-plugin</artifactId>
-                <version>0.8.11</version>
+                <version>0.8.13</version>
                 <executions>
                     <execution>
                         <goals>
@@ -70,13 +71,13 @@
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
-            <version>RELEASE</version>
+            <version>2.0.16</version>
         </dependency>
 
         <dependency>
             <groupId>ch.qos.logback</groupId>
             <artifactId>logback-classic</artifactId>
-            <version>RELEASE</version>
+            <version>1.5.12</version>
         </dependency>
 
         <dependency>
@@ -92,5 +93,12 @@
             <version>5.10.0</version>
             <scope>test</scope>
         </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <version>5.10.0</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

src/test/java/ovh/gasser/newshapes/attributes/ColorAttributesTest.java

@@ -0,0 +1,129 @@
+package ovh.gasser.newshapes.attributes;
+
+import org.junit.jupiter.api.Test;
+
+import java.awt.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ColorAttributesTest {
+
+    @Test
+    void testConstructorStoresFilledFlag() {
+        ColorAttributes attrs = new ColorAttributes(true, false, Color.RED, Color.BLACK);
+        assertTrue(attrs.filled, "filled flag should be true when constructed with true");
+    }
+
+    @Test
+    void testConstructorStoresStrokedFlag() {
+        ColorAttributes attrs = new ColorAttributes(false, true, Color.RED, Color.BLACK);
+        assertTrue(attrs.stroked, "stroked flag should be true when constructed with true");
+    }
+
+    @Test
+    void testConstructorStoresFilledColor() {
+        ColorAttributes attrs = new ColorAttributes(true, false, Color.BLUE, Color.BLACK);
+        assertEquals(Color.BLUE, attrs.filledColor, "filledColor should match the constructor argument");
+    }
+
+    @Test
+    void testConstructorStoresStrokedColor() {
+        ColorAttributes attrs = new ColorAttributes(false, true, Color.RED, Color.GREEN);
+        assertEquals(Color.GREEN, attrs.strokedColor, "strokedColor should match the constructor argument");
+    }
+
+    @Test
+    void testFilledAndStrokedBothTrue() {
+        ColorAttributes attrs = new ColorAttributes(true, true, Color.RED, Color.BLUE);
+        assertTrue(attrs.filled);
+        assertTrue(attrs.stroked);
+    }
+
+    @Test
+    void testFilledAndStrokedBothFalse() {
+        ColorAttributes attrs = new ColorAttributes(false, false, Color.RED, Color.BLUE);
+        assertFalse(attrs.filled);
+        assertFalse(attrs.stroked);
+    }
+
+    @Test
+    void testNullFilledColor() {
+        ColorAttributes attrs = new ColorAttributes(true, false, null, Color.BLACK);
+        assertNull(attrs.filledColor, "filledColor should accept null");
+    }
+
+    @Test
+    void testNullStrokedColor() {
+        ColorAttributes attrs = new ColorAttributes(false, true, Color.RED, null);
+        assertNull(attrs.strokedColor, "strokedColor should accept null");
+    }
+
+    @Test
+    void testBothColorsNull() {
+        ColorAttributes attrs = new ColorAttributes(false, false, null, null);
+        assertNull(attrs.filledColor);
+        assertNull(attrs.strokedColor);
+    }
+
+    @Test
+    void testGetIDReturnsCorrectValue() {
+        ColorAttributes attrs = new ColorAttributes(false, false, Color.RED, Color.BLACK);
+        assertEquals(ColorAttributes.ID, attrs.getID());
+    }
+
+    @Test
+    void testIDConstant() {
+        assertEquals("COLOR_ATTRS", ColorAttributes.ID);
+    }
+
+    @Test
+    void testImplementsAttributes() {
+        ColorAttributes attrs = new ColorAttributes(false, false, Color.RED, Color.BLACK);
+        assertInstanceOf(Attributes.class, attrs);
+    }
+
+    @Test
+    void testToStringContainsAllFields() {
+        ColorAttributes attrs = new ColorAttributes(true, false, Color.RED, Color.BLUE);
+        String str = attrs.toString();
+        assertTrue(str.contains("filled=true"), "toString should contain filled value");
+        assertTrue(str.contains("stroked=false"), "toString should contain stroked value");
+        assertTrue(str.contains("filledColor"), "toString should contain filledColor");
+        assertTrue(str.contains("strokedColor"), "toString should contain strokedColor");
+    }
+
+    @Test
+    void testToStringWithNullColors() {
+        ColorAttributes attrs = new ColorAttributes(false, false, null, null);
+        String str = attrs.toString();
+        assertNotNull(str, "toString should not throw with null colors");
+        assertTrue(str.contains("filledColor=null"), "toString should show null filledColor");
+        assertTrue(str.contains("strokedColor=null"), "toString should show null strokedColor");
+    }
+
+    @Test
+    void testTwoInstancesAreIndependent() {
+        ColorAttributes attrs1 = new ColorAttributes(true, false, Color.RED, Color.BLACK);
+        ColorAttributes attrs2 = new ColorAttributes(false, true, Color.BLUE, Color.GREEN);
+
+        assertTrue(attrs1.filled);
+        assertFalse(attrs2.filled);
+        assertFalse(attrs1.stroked);
+        assertTrue(attrs2.stroked);
+        assertEquals(Color.RED, attrs1.filledColor);
+        assertEquals(Color.BLUE, attrs2.filledColor);
+    }
+
+    @Test
+    void testFieldsAreImmutable() {
+        Color fillColor = Color.RED;
+        Color strokeColor = Color.BLACK;
+        ColorAttributes attrs = new ColorAttributes(true, true, fillColor, strokeColor);
+
+        // Since fields are final, verify they retain their values
+        assertEquals(Color.RED, attrs.filledColor);
+        assertEquals(Color.BLACK, attrs.strokedColor);
+        assertTrue(attrs.filled);
+        assertTrue(attrs.stroked);
+    }
+}

src/test/java/ovh/gasser/newshapes/attributes/SelectionAttributesTest.java

@@ -0,0 +1,72 @@
+package ovh.gasser.newshapes.attributes;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SelectionAttributesTest {
+
+    @Test
+    void testDefaultConstructorIsUnselected() {
+        SelectionAttributes attrs = new SelectionAttributes();
+        assertFalse(attrs.selected, "Default constructor should create unselected state");
+    }
+
+    @Test
+    void testConstructorWithTrue() {
+        SelectionAttributes attrs = new SelectionAttributes(true);
+        assertTrue(attrs.selected, "Constructor with true should create selected state");
+    }
+
+    @Test
+    void testConstructorWithFalse() {
+        SelectionAttributes attrs = new SelectionAttributes(false);
+        assertFalse(attrs.selected, "Constructor with false should create unselected state");
+    }
+
+    @Test
+    void testGetIDReturnsCorrectValue() {
+        SelectionAttributes attrs = new SelectionAttributes();
+        assertEquals(SelectionAttributes.ID, attrs.getID());
+    }
+
+    @Test
+    void testIDConstant() {
+        assertEquals("SELECTION_ATTRS", SelectionAttributes.ID);
+    }
+
+    @Test
+    void testImplementsAttributes() {
+        SelectionAttributes attrs = new SelectionAttributes();
+        assertInstanceOf(Attributes.class, attrs);
+    }
+
+    @Test
+    void testSelectedFieldCanBeToggled() {
+        SelectionAttributes attrs = new SelectionAttributes(false);
+        assertFalse(attrs.selected);
+
+        attrs.selected = true;
+        assertTrue(attrs.selected);
+
+        attrs.selected = false;
+        assertFalse(attrs.selected);
+    }
+
+    @Test
+    void testTwoInstancesAreIndependent() {
+        SelectionAttributes attrs1 = new SelectionAttributes(true);
+        SelectionAttributes attrs2 = new SelectionAttributes(false);
+
+        assertNotEquals(attrs1.selected, attrs2.selected);
+
+        attrs2.selected = true;
+        assertTrue(attrs1.selected);
+        assertTrue(attrs2.selected);
+
+        // Mutating one doesn't affect the other
+        attrs1.selected = false;
+        assertFalse(attrs1.selected);
+        assertTrue(attrs2.selected);
+    }
+}

src/test/java/ovh/gasser/newshapes/shapes/ShapeContractTest.java

@@ -0,0 +1,73 @@
+package ovh.gasser.newshapes.shapes;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.awt.Rectangle;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Parameterized contract tests verifying Shape interface invariants
+ * across all implementations (SRectangle, SCircle, STriangle, SText, SCollection).
+ */
+class ShapeContractTest {
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("ovh.gasser.newshapes.shapes.ShapeFactory#allShapes")
+    void cloneReturnsIndependentCopy(Shape shape) {
+        Shape cloned = shape.clone();
+
+        // clone must not be the same instance
+        assertNotSame(shape, cloned, "clone() must return a new instance");
+
+        // clone must have equal bounds
+        assertEquals(shape.getBounds(), cloned.getBounds(),
+                "clone() must preserve bounds");
+
+        // mutating the clone must not affect the original
+        Rectangle originalBounds = shape.getBounds();
+        cloned.translate(999, 999);
+        assertEquals(originalBounds, shape.getBounds(),
+                "Translating the clone must not affect the original's bounds");
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("ovh.gasser.newshapes.shapes.ShapeFactory#allShapes")
+    void getBoundsReturnsCopy(Shape shape) {
+        Rectangle bounds1 = shape.getBounds();
+        Rectangle bounds2 = shape.getBounds();
+
+        // successive calls must return equal bounds
+        assertEquals(bounds1, bounds2,
+                "getBounds() must return consistent values");
+
+        // but not the same object (defensive copy)
+        assertNotSame(bounds1, bounds2,
+                "getBounds() must return a copy, not internal state");
+
+        // mutating the returned Rectangle must not affect the shape
+        bounds1.translate(500, 500);
+        assertEquals(bounds2, shape.getBounds(),
+                "Mutating the returned Rectangle must not affect the shape");
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("ovh.gasser.newshapes.shapes.ShapeFactory#allShapes")
+    void translateMutatesInPlace(Shape shape) {
+        Rectangle before = shape.getBounds();
+        int dx = 7, dy = -3;
+
+        shape.translate(dx, dy);
+
+        Rectangle after = shape.getBounds();
+        assertEquals(before.x + dx, after.x,
+                "translate() must shift x by dx");
+        assertEquals(before.y + dy, after.y,
+                "translate() must shift y by dy");
+        assertEquals(before.width, after.width,
+                "translate() must not change width");
+        assertEquals(before.height, after.height,
+                "translate() must not change height");
+    }
+}

src/test/java/ovh/gasser/newshapes/shapes/ShapeFactory.java

@@ -0,0 +1,25 @@
+package ovh.gasser.newshapes.shapes;
+
+import java.awt.Color;
+import java.util.stream.Stream;
+
+/**
+ * Provides Shape instances for parameterized contract tests.
+ */
+public final class ShapeFactory {
+
+    private ShapeFactory() {}
+
+    static Stream<Shape> allShapes() {
+        return Stream.of(
+                SRectangle.create(10, 20, 100, 50),
+                SCircle.create(5, 5, 30),
+                STriangle.create(0, 0, 40, Color.RED, Color.BLACK),
+                SText.create(15, 25, "Hello"),
+                SCollection.of(
+                        SRectangle.create(0, 0, 20, 20),
+                        SCircle.create(10, 10, 5)
+                )
+        );
+    }
+}

src/test/java/ovh/gasser/newshapes/ui/visitors/SVGDraftmanTest.java

@@ -0,0 +1,370 @@
+package ovh.gasser.newshapes.ui.visitors;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import ovh.gasser.newshapes.attributes.ColorAttributes;
+import ovh.gasser.newshapes.shapes.*;
+
+import java.awt.*;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SVGDraftmanTest {
+
+    private StringWriter buffer;
+    private PrintWriter writer;
+    private SVGDraftman draftman;
+
+    @BeforeEach
+    void setUp() {
+        buffer = new StringWriter();
+        writer = new PrintWriter(buffer);
+        draftman = new SVGDraftman(writer);
+    }
+
+    private String output() {
+        writer.flush();
+        return buffer.toString();
+    }
+
+    // ── visitRectangle ──────────────────────────────────────────────
+
+    @Nested
+    class VisitRectangleTests {
+
+        @Test
+        void testRectangleElementWithCorrectDimensions() {
+            SRectangle rect = SRectangle.create(10, 20, 100, 50);
+            draftman.visitRectangle(rect);
+
+            String svg = output();
+            assertTrue(svg.contains("<rect"), "Should produce a <rect> element");
+            assertTrue(svg.contains("width=\"100\""), "Should have correct width");
+            assertTrue(svg.contains("height=\"50\""), "Should have correct height");
+            assertTrue(svg.contains("x=\"10\""), "Should have correct x");
+            assertTrue(svg.contains("y=\"20\""), "Should have correct y");
+        }
+
+        @Test
+        void testRectangleFilledOnly() {
+            SRectangle rect = SRectangle.create(0, 0, 30, 30);
+            rect.addAttributes(new ColorAttributes(true, false, Color.RED, Color.BLACK));
+            draftman.visitRectangle(rect);
+
+            String svg = output();
+            assertTrue(svg.contains("fill=\"#ff0000\""), "Should contain fill color");
+            assertFalse(svg.contains("stroke="), "Should not contain stroke when stroked=false");
+        }
+
+        @Test
+        void testRectangleStrokedOnly() {
+            SRectangle rect = SRectangle.create(0, 0, 30, 30);
+            rect.addAttributes(new ColorAttributes(false, true, Color.RED, Color.BLUE));
+            draftman.visitRectangle(rect);
+
+            String svg = output();
+            assertTrue(svg.contains("stroke=\"#0000ff\""), "Should contain stroke color");
+            assertTrue(svg.contains("stroke-width=\"1\""), "Should contain stroke-width");
+            assertTrue(svg.contains("fill=\"none\""), "Should have fill=none when not filled");
+        }
+
+        @Test
+        void testRectangleFilledAndStroked() {
+            SRectangle rect = SRectangle.create(0, 0, 30, 30);
+            rect.addAttributes(new ColorAttributes(true, true, Color.RED, Color.BLUE));
+            draftman.visitRectangle(rect);
+
+            String svg = output();
+            assertTrue(svg.contains("fill=\"#ff0000\""), "Should contain fill color");
+            assertTrue(svg.contains("stroke=\"#0000ff\""), "Should contain stroke color");
+        }
+
+        @Test
+        void testRectangleNeitherFilledNorStroked() {
+            SRectangle rect = SRectangle.create(0, 0, 30, 30);
+            rect.addAttributes(new ColorAttributes(false, false, Color.RED, Color.BLUE));
+            draftman.visitRectangle(rect);
+
+            String svg = output();
+            assertTrue(svg.contains("fill=\"none\""), "Should have fill=none");
+            assertFalse(svg.contains("stroke="), "Should not have stroke attribute");
+        }
+    }
+
+    // ── visitCircle ─────────────────────────────────────────────────
+
+    @Nested
+    class VisitCircleTests {
+
+        @Test
+        void testCircleElementWithCorrectAttributes() {
+            SCircle circle = SCircle.create(50, 60, 30);
+            draftman.visitCircle(circle);
+
+            String svg = output();
+            assertTrue(svg.contains("<circle"), "Should produce a <circle> element");
+            // cx = x + r = 50 + 30 = 80, cy = y + r = 60 + 30 = 90
+            assertTrue(svg.contains("cx=\"80\""), "cx should be x + radius");
+            assertTrue(svg.contains("cy=\"90\""), "cy should be y + radius");
+            assertTrue(svg.contains("r=\"30\""), "Should have correct radius");
+        }
+
+        @Test
+        void testCircleFilledOnly() {
+            SCircle circle = SCircle.create(0, 0, 20);
+            circle.addAttributes(new ColorAttributes(true, false, Color.GREEN, Color.BLACK));
+            draftman.visitCircle(circle);
+
+            String svg = output();
+            assertTrue(svg.contains("fill=\"#00ff00\""), "Should contain fill color");
+            assertFalse(svg.contains("stroke="), "Should not contain stroke");
+        }
+
+        @Test
+        void testCircleStrokedOnly() {
+            SCircle circle = SCircle.create(0, 0, 20);
+            circle.addAttributes(new ColorAttributes(false, true, Color.RED, Color.MAGENTA));
+            draftman.visitCircle(circle);
+
+            String svg = output();
+            assertTrue(svg.contains("stroke=\"#ff00ff\""), "Should contain stroke color");
+            assertTrue(svg.contains("fill=\"none\""), "Should have fill=none");
+        }
+
+        @Test
+        void testCircleFilledAndStroked() {
+            SCircle circle = SCircle.create(0, 0, 15);
+            circle.addAttributes(new ColorAttributes(true, true, Color.YELLOW, Color.BLACK));
+            draftman.visitCircle(circle);
+
+            String svg = output();
+            assertTrue(svg.contains("fill=\"#ffff00\""), "Should contain fill color");
+            assertTrue(svg.contains("stroke=\"#000000\""), "Should contain stroke color");
+        }
+    }
+
+    // ── visitTriangle ───────────────────────────────────────────────
+
+    @Nested
+    class VisitTriangleTests {
+
+        @Test
+        void testTriangleProducesPolygonElement() {
+            STriangle tri = STriangle.create(10, 20, 40, Color.RED, Color.BLACK);
+            draftman.visitTriangle(tri);
+
+            String svg = output();
+            assertTrue(svg.contains("<polygon"), "Should produce a <polygon> element");
+            assertTrue(svg.contains("points="), "Should have points attribute");
+        }
+
+        @Test
+        void testTrianglePointsAreCorrect() {
+            STriangle tri = STriangle.create(10, 20, 40, Color.RED, Color.BLACK);
+            draftman.visitTriangle(tri);
+
+            String svg = output();
+            // bottom-left: (x, y+size) = (10, 60)
+            assertTrue(svg.contains("10,60"), "Should contain bottom-left point");
+            // top-center: (x + size/2, y) = (30, 20)
+            assertTrue(svg.contains("30,20"), "Should contain top-center point");
+            // bottom-right: (x + size, y + size) = (50, 60)
+            assertTrue(svg.contains("50,60"), "Should contain bottom-right point");
+        }
+
+        @Test
+        void testTriangleFilledOnly() {
+            STriangle tri = STriangle.create(0, 0, 20, Color.BLUE, Color.BLACK);
+            tri.addAttributes(new ColorAttributes(true, false, Color.BLUE, Color.BLACK));
+            draftman.visitTriangle(tri);
+
+            String svg = output();
+            assertTrue(svg.contains("fill:#0000ff"), "Should contain fill style");
+            assertFalse(svg.contains("stroke:"), "Should not contain stroke style when not stroked");
+        }
+
+        @Test
+        void testTriangleStrokedAndFilled() {
+            STriangle tri = STriangle.create(0, 0, 20, Color.RED, Color.GREEN);
+            tri.addAttributes(new ColorAttributes(true, true, Color.RED, Color.GREEN));
+            draftman.visitTriangle(tri);
+
+            String svg = output();
+            assertTrue(svg.contains("fill:#ff0000"), "Should contain fill style");
+            assertTrue(svg.contains("stroke:#00ff00"), "Should contain stroke style");
+        }
+
+        @Test
+        void testTriangleNotFilled() {
+            STriangle tri = STriangle.create(0, 0, 20, Color.RED, Color.BLACK);
+            tri.addAttributes(new ColorAttributes(false, true, Color.RED, Color.BLACK));
+            draftman.visitTriangle(tri);
+
+            String svg = output();
+            assertTrue(svg.contains("fill:none"), "Should have fill:none when not filled");
+        }
+    }
+
+    // ── visitText ───────────────────────────────────────────────────
+
+    @Nested
+    class VisitTextTests {
+
+        @Test
+        void testTextElementWithCorrectContent() {
+            SText text = SText.create(10, 20, "Hello");
+            draftman.visitText(text);
+
+            String svg = output();
+            assertTrue(svg.contains("<text"), "Should produce a <text> element");
+            assertTrue(svg.contains(">Hello</text>"), "Should contain the text content");
+        }
+
+        @Test
+        void testTextPositionIncludesFontSizeOffset() {
+            SText text = SText.create(10, 20, "Hi");
+            draftman.visitText(text);
+
+            String svg = output();
+            assertTrue(svg.contains("x=\"10\""), "x should match bounds.x");
+            // y = bounds.y + fontSize = 20 + 16 = 36
+            assertTrue(svg.contains("y=\"36\""), "y should be bounds.y + fontSize");
+        }
+
+        @Test
+        void testTextDefaultFontAttributes() {
+            SText text = SText.create(0, 0, "Test");
+            draftman.visitText(text);
+
+            String svg = output();
+            assertTrue(svg.contains("font-family=\"SansSerif\""), "Should use default font family");
+            assertTrue(svg.contains("font-size=\"16\""), "Should use default font size");
+            assertTrue(svg.contains("font-style=\"normal\""), "Default style should be normal");
+            assertTrue(svg.contains("font-weight=\"normal\""), "Default weight should be normal");
+        }
+
+        @Test
+        void testTextDefaultColorIsBlack() {
+            SText text = SText.create(0, 0, "Test");
+            // default ColorAttributes: filled=true, filledColor=BLACK
+            draftman.visitText(text);
+
+            String svg = output();
+            assertTrue(svg.contains("fill=\"#000000\""), "Default text color should be black");
+        }
+
+        @Test
+        void testTextWithCustomFillColor() {
+            SText text = SText.create(0, 0, "Colored");
+            text.addAttributes(new ColorAttributes(true, false, Color.RED, Color.BLACK));
+            draftman.visitText(text);
+
+            String svg = output();
+            assertTrue(svg.contains("fill=\"#ff0000\""), "Text should use filledColor");
+        }
+
+        @Test
+        void testTextWithNullColorAttributesFallsBackToBlack() {
+            SText text = SText.create(0, 0, "NoColor");
+            text.addAttributes(new ColorAttributes(false, false, null, null));
+            draftman.visitText(text);
+
+            String svg = output();
+            assertTrue(svg.contains("fill=\"#000000\""), "Should fall back to black with null colors");
+        }
+    }
+
+    // ── visitCollection ─────────────────────────────────────────────
+
+    @Nested
+    class VisitCollectionTests {
+
+        @Test
+        void testEmptyCollection() {
+            SCollection empty = SCollection.of();
+            draftman.visitCollection(empty);
+
+            String svg = output();
+            assertEquals("", svg, "Empty collection should produce no output");
+        }
+
+        @Test
+        void testCollectionVisitsAllChildren() {
+            SCollection coll = SCollection.of(
+                    SRectangle.create(0, 0, 10, 10),
+                    SCircle.create(20, 20, 5)
+            );
+            draftman.visitCollection(coll);
+
+            String svg = output();
+            assertTrue(svg.contains("<rect"), "Should visit rectangle");
+            assertTrue(svg.contains("<circle"), "Should visit circle");
+        }
+
+        @Test
+        void testNestedCollectionVisitsAllDescendants() {
+            SCollection inner = SCollection.of(
+                    SRectangle.create(0, 0, 5, 5)
+            );
+            SCollection outer = SCollection.of(
+                    inner,
+                    SCircle.create(10, 10, 3)
+            );
+            draftman.visitCollection(outer);
+
+            String svg = output();
+            assertTrue(svg.contains("<rect"), "Should visit nested rectangle");
+            assertTrue(svg.contains("<circle"), "Should visit circle at outer level");
+        }
+    }
+
+    // ── generateSVG ─────────────────────────────────────────────────
+
+    @Nested
+    class GenerateSVGTests {
+
+        @Test
+        void testGenerateSVGIncludesXmlDeclaration() {
+            SCollection model = SCollection.of();
+            draftman.generateSVG(model);
+
+            String svg = output();
+            assertTrue(svg.contains("<?xml version=\"1.0\" encoding=\"utf-8\"?>"),
+                    "Should include XML declaration");
+        }
+
+        @Test
+        void testGenerateSVGIncludesSvgNamespace() {
+            SCollection model = SCollection.of();
+            draftman.generateSVG(model);
+
+            String svg = output();
+            assertTrue(svg.contains("xmlns=\"http://www.w3.org/2000/svg\""),
+                    "Should include SVG namespace");
+        }
+
+        @Test
+        void testGenerateSVGClosesSvgTag() {
+            SCollection model = SCollection.of();
+            draftman.generateSVG(model);
+
+            String svg = output();
+            assertTrue(svg.contains("</svg>"), "Should close <svg> tag");
+        }
+
+        @Test
+        void testGenerateSVGIncludesShapeContent() {
+            SCollection model = SCollection.of(
+                    SRectangle.create(1, 2, 3, 4)
+            );
+            draftman.generateSVG(model);
+
+            String svg = output();
+            assertTrue(svg.contains("<rect"), "Should include shape elements");
+            assertTrue(svg.contains("</svg>"), "Should close SVG after shapes");
+        }
+    }
+}