Compare commits
1 Commits
master
...
bf6636da3b
| Author | SHA1 | Date | |
|---|---|---|---|
| bf6636da3b |
2
TODO.md
2
TODO.md
@@ -1,6 +1,6 @@
|
||||
# TODO
|
||||
|
||||
- [X] Box selection (drag to select multiple shapes)
|
||||
- [ ] Box selection (drag to select multiple shapes)
|
||||
- [ ] Undo/redo stack
|
||||
- [ ] Copy/paste functionality
|
||||
- [ ] Group/Ungroup shapes
|
||||
|
||||
@@ -57,7 +57,7 @@ public class SText extends AbstractShape {
|
||||
}
|
||||
|
||||
public void updateMeasuredBounds(int width, int height) {
|
||||
bounds.setSize(Math.max(width, 0), Math.max(height, 0));
|
||||
getBounds().setSize(Math.max(width, 0), Math.max(height, 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -1,129 +0,0 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -1,387 +0,0 @@
|
||||
package ovh.gasser.newshapes.shapes;
|
||||
|
||||
import org.junit.jupiter.api.Nested;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.awt.Color;
|
||||
import java.awt.Point;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Tests bounds-based hit-testing for all shape types.
|
||||
* Hit-testing is performed via {@code shape.getBounds().contains(Point)},
|
||||
* delegating to {@link java.awt.Rectangle#contains(Point)}.
|
||||
*
|
||||
* <p>Note on {@link java.awt.Rectangle#contains} boundary semantics:
|
||||
* A rectangle {@code (x, y, w, h)} contains a point {@code (px, py)} when:
|
||||
* {@code x <= px < x+w} and {@code y <= py < y+h}.
|
||||
* The top-left corner is <em>inclusive</em>; the bottom-right corner is <em>exclusive</em>.
|
||||
*/
|
||||
class ContainsPointTest {
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// SRectangle — bounds = (x, y, width, height)
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class SRectangleContainsPoint {
|
||||
|
||||
// Shape: origin (10, 20), size 80×60 → right-exclusive: x=90, y=80
|
||||
private final SRectangle rect = SRectangle.create(10, 20, 80, 60);
|
||||
|
||||
@Test
|
||||
void pointInsideShouldBeContained() {
|
||||
Point inside = new Point(50, 50);
|
||||
assertTrue(rect.getBounds().contains(inside),
|
||||
"A point clearly inside the rectangle should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOutsideShouldNotBeContained() {
|
||||
Point outside = new Point(5, 5);
|
||||
assertFalse(rect.getBounds().contains(outside),
|
||||
"A point outside the rectangle should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointFarOutsideShouldNotBeContained() {
|
||||
Point farOutside = new Point(200, 300);
|
||||
assertFalse(rect.getBounds().contains(farOutside),
|
||||
"A point far outside the rectangle should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void topLeftCornerShouldBeContained() {
|
||||
// Rectangle.contains is inclusive of the top-left corner
|
||||
Point topLeft = new Point(10, 20);
|
||||
assertTrue(rect.getBounds().contains(topLeft),
|
||||
"The top-left corner (inclusive boundary) should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void bottomRightCornerShouldNotBeContained() {
|
||||
// Rectangle.contains is exclusive of the bottom-right corner
|
||||
Point bottomRight = new Point(90, 80); // x + width, y + height
|
||||
assertFalse(rect.getBounds().contains(bottomRight),
|
||||
"The bottom-right corner (exclusive boundary) should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointJustInsideBottomRightShouldBeContained() {
|
||||
Point justInside = new Point(89, 79); // one pixel before exclusive boundary
|
||||
assertTrue(rect.getBounds().contains(justInside),
|
||||
"A point one pixel before the bottom-right boundary should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointAfterTranslateShouldBeAtNewPosition() {
|
||||
SRectangle moved = SRectangle.create(10, 20, 80, 60);
|
||||
moved.translate(30, 40); // new bounds: (40, 60, 80, 60)
|
||||
|
||||
Point oldCenter = new Point(50, 50);
|
||||
assertFalse(moved.getBounds().contains(oldCenter),
|
||||
"After translate, old center should no longer be contained");
|
||||
|
||||
Point newCenter = new Point(80, 90);
|
||||
assertTrue(moved.getBounds().contains(newCenter),
|
||||
"After translate, a point at the new center should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOnTopEdgeShouldBeContained() {
|
||||
Point topEdge = new Point(50, 20); // y == rect.y, inside x range
|
||||
assertTrue(rect.getBounds().contains(topEdge),
|
||||
"A point on the top edge should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOnLeftEdgeShouldBeContained() {
|
||||
Point leftEdge = new Point(10, 50); // x == rect.x, inside y range
|
||||
assertTrue(rect.getBounds().contains(leftEdge),
|
||||
"A point on the left edge should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOnRightEdgeShouldNotBeContained() {
|
||||
Point rightEdge = new Point(90, 50); // x == rect.x + rect.width (exclusive)
|
||||
assertFalse(rect.getBounds().contains(rightEdge),
|
||||
"A point exactly on the right edge (exclusive) should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOnBottomEdgeShouldNotBeContained() {
|
||||
Point bottomEdge = new Point(50, 80); // y == rect.y + rect.height (exclusive)
|
||||
assertFalse(rect.getBounds().contains(bottomEdge),
|
||||
"A point exactly on the bottom edge (exclusive) should not be contained");
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// SCircle — bounds = (x, y, radius*2, radius*2)
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class SCircleContainsPoint {
|
||||
|
||||
// Shape: origin (20, 30), radius=40 → bounds (20, 30, 80, 80)
|
||||
// right-exclusive corner: (100, 110)
|
||||
private final SCircle circle = SCircle.create(20, 30, 40);
|
||||
|
||||
@Test
|
||||
void pointInsideBoundsShouldBeContained() {
|
||||
Point inside = new Point(60, 70);
|
||||
assertTrue(circle.getBounds().contains(inside),
|
||||
"A point inside the bounding box should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOutsideBoundsShouldNotBeContained() {
|
||||
Point outside = new Point(10, 10);
|
||||
assertFalse(circle.getBounds().contains(outside),
|
||||
"A point outside the bounding box should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void topLeftCornerShouldBeContained() {
|
||||
Point topLeft = new Point(20, 30);
|
||||
assertTrue(circle.getBounds().contains(topLeft),
|
||||
"The top-left corner of the bounding box (inclusive) should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void bottomRightCornerShouldNotBeContained() {
|
||||
Point bottomRight = new Point(100, 110); // x + 2r, y + 2r
|
||||
assertFalse(circle.getBounds().contains(bottomRight),
|
||||
"The bottom-right corner of the bounding box (exclusive) should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointAfterTranslateShouldBeAtNewPosition() {
|
||||
SCircle moved = SCircle.create(20, 30, 40);
|
||||
moved.translate(50, 50); // new bounds: (70, 80, 80, 80)
|
||||
|
||||
Point oldCenter = new Point(60, 70);
|
||||
assertFalse(moved.getBounds().contains(oldCenter),
|
||||
"After translate, old center should no longer be contained");
|
||||
|
||||
Point newCenter = new Point(110, 120);
|
||||
assertTrue(moved.getBounds().contains(newCenter),
|
||||
"After translate, a point at the new center should be contained");
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// STriangle — bounds = (x, y, size, size)
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class STriangleContainsPoint {
|
||||
|
||||
// Shape: origin (5, 15), size=60 → bounds (5, 15, 60, 60)
|
||||
// right-exclusive corner: (65, 75)
|
||||
private final STriangle triangle = STriangle.create(5, 15, 60, Color.RED, Color.BLACK);
|
||||
|
||||
@Test
|
||||
void pointInsideBoundsShouldBeContained() {
|
||||
Point inside = new Point(35, 45);
|
||||
assertTrue(triangle.getBounds().contains(inside),
|
||||
"A point inside the bounding box should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOutsideBoundsShouldNotBeContained() {
|
||||
Point outside = new Point(0, 0);
|
||||
assertFalse(triangle.getBounds().contains(outside),
|
||||
"A point outside the bounding box should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void topLeftCornerShouldBeContained() {
|
||||
Point topLeft = new Point(5, 15);
|
||||
assertTrue(triangle.getBounds().contains(topLeft),
|
||||
"The top-left corner of the bounding box (inclusive) should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void bottomRightCornerShouldNotBeContained() {
|
||||
Point bottomRight = new Point(65, 75); // x + size, y + size
|
||||
assertFalse(triangle.getBounds().contains(bottomRight),
|
||||
"The bottom-right corner of the bounding box (exclusive) should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointAfterTranslateShouldBeAtNewPosition() {
|
||||
STriangle moved = STriangle.create(5, 15, 60, Color.RED, Color.BLACK);
|
||||
moved.translate(100, 100); // new bounds: (105, 115, 60, 60)
|
||||
|
||||
Point oldCenter = new Point(35, 45);
|
||||
assertFalse(moved.getBounds().contains(oldCenter),
|
||||
"After translate, old center should no longer be contained");
|
||||
|
||||
Point newCenter = new Point(135, 145);
|
||||
assertTrue(moved.getBounds().contains(newCenter),
|
||||
"After translate, a point at the new center should be contained");
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// SText — bounds = (x, y, 100, 20)
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class STextContainsPoint {
|
||||
|
||||
// Shape: origin (50, 100) → bounds (50, 100, 100, 20)
|
||||
// right-exclusive corner: (150, 120)
|
||||
private final SText text = SText.create(50, 100, "Hello");
|
||||
|
||||
@Test
|
||||
void pointInsideBoundsShouldBeContained() {
|
||||
Point inside = new Point(100, 110);
|
||||
assertTrue(text.getBounds().contains(inside),
|
||||
"A point inside the default text bounding box should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOutsideBoundsShouldNotBeContained() {
|
||||
Point outside = new Point(10, 10);
|
||||
assertFalse(text.getBounds().contains(outside),
|
||||
"A point outside the text bounding box should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void topLeftCornerShouldBeContained() {
|
||||
Point topLeft = new Point(50, 100);
|
||||
assertTrue(text.getBounds().contains(topLeft),
|
||||
"The top-left corner of the text bounding box (inclusive) should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void bottomRightCornerShouldNotBeContained() {
|
||||
// Default bounds width=100, height=20 → exclusive corner at (150, 120)
|
||||
Point bottomRight = new Point(150, 120);
|
||||
assertFalse(text.getBounds().contains(bottomRight),
|
||||
"The bottom-right corner of the text bounding box (exclusive) should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointJustBeforeBottomRightShouldBeContained() {
|
||||
Point justInside = new Point(149, 119);
|
||||
assertTrue(text.getBounds().contains(justInside),
|
||||
"A point one pixel before the exclusive bottom-right boundary should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointAfterTranslateShouldBeAtNewPosition() {
|
||||
// Original bounds: (50, 100, 100, 20) — covers x∈[50,150), y∈[100,120)
|
||||
SText moved = SText.create(50, 100, "Hello");
|
||||
moved.translate(-40, 10); // new bounds: (10, 110, 100, 20) — covers x∈[10,110), y∈[110,130)
|
||||
|
||||
// (130, 105) was inside original bounds but is now outside (x=130 >= 110, y=105 < 110)
|
||||
Point oldPosition = new Point(130, 105);
|
||||
assertFalse(moved.getBounds().contains(oldPosition),
|
||||
"After translate, a point that was in the old bounds should no longer be contained");
|
||||
|
||||
// (50, 115) is inside new bounds: x∈[10,110), y∈[110,130) ✓
|
||||
Point newPosition = new Point(50, 115);
|
||||
assertTrue(moved.getBounds().contains(newPosition),
|
||||
"After translate, a point in the new bounds should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void blankTextUsesDefaultPlaceholderAndSameBounds() {
|
||||
// Even blank/null text falls back to the placeholder — bounds remain (x, y, 100, 20)
|
||||
SText blankText = SText.create(0, 0, "");
|
||||
Point inside = new Point(50, 10);
|
||||
assertTrue(blankText.getBounds().contains(inside),
|
||||
"Blank text still uses default bounds; interior point should be contained");
|
||||
}
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// SCollection — bounds = union of children bounds
|
||||
// -----------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class SCollectionContainsPoint {
|
||||
|
||||
// Two non-overlapping children:
|
||||
// rect1: (10, 10, 50, 50) → covers x∈[10,60), y∈[10,60)
|
||||
// rect2: (100, 100, 40, 40) → covers x∈[100,140), y∈[100,140)
|
||||
// Union bounds: (10, 10, 130, 130) → exclusive corner: (140, 140)
|
||||
private final SRectangle child1 = SRectangle.create(10, 10, 50, 50);
|
||||
private final SRectangle child2 = SRectangle.create(100, 100, 40, 40);
|
||||
private final SCollection collection = SCollection.of(child1, child2);
|
||||
|
||||
@Test
|
||||
void pointInsideFirstChildBoundsShouldBeContained() {
|
||||
Point insideChild1 = new Point(30, 30);
|
||||
assertTrue(collection.getBounds().contains(insideChild1),
|
||||
"A point inside the first child's bounds is within the union and should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointInsideSecondChildBoundsShouldBeContained() {
|
||||
Point insideChild2 = new Point(120, 120);
|
||||
assertTrue(collection.getBounds().contains(insideChild2),
|
||||
"A point inside the second child's bounds is within the union and should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointInGapBetweenChildrenShouldBeContained() {
|
||||
// The union rectangle spans the gap between the two children
|
||||
Point inGap = new Point(70, 70);
|
||||
assertTrue(collection.getBounds().contains(inGap),
|
||||
"A point in the gap between children is still inside the union bounds and should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointOutsideUnionShouldNotBeContained() {
|
||||
Point outside = new Point(0, 0);
|
||||
assertFalse(collection.getBounds().contains(outside),
|
||||
"A point outside the union bounds should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void topLeftCornerOfUnionShouldBeContained() {
|
||||
// Union top-left = (10, 10) — inclusive
|
||||
Point topLeft = new Point(10, 10);
|
||||
assertTrue(collection.getBounds().contains(topLeft),
|
||||
"The top-left corner of the union bounds (inclusive) should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void bottomRightCornerOfUnionShouldNotBeContained() {
|
||||
// Union: x=10, y=10, w=130, h=130 → exclusive corner (140, 140)
|
||||
Point bottomRight = new Point(140, 140);
|
||||
assertFalse(collection.getBounds().contains(bottomRight),
|
||||
"The bottom-right corner of the union bounds (exclusive) should not be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void pointAfterTranslatingChildrenShouldBeAtNewPosition() {
|
||||
SRectangle movableChild = SRectangle.create(0, 0, 30, 30);
|
||||
SCollection movable = SCollection.of(movableChild);
|
||||
|
||||
movable.translate(50, 50); // child now at (50, 50, 30, 30)
|
||||
|
||||
Point oldPoint = new Point(15, 15);
|
||||
assertFalse(movable.getBounds().contains(oldPoint),
|
||||
"After translate, a point at the old location should not be contained");
|
||||
|
||||
Point newPoint = new Point(65, 65);
|
||||
assertTrue(movable.getBounds().contains(newPoint),
|
||||
"After translate, a point at the new location should be contained");
|
||||
}
|
||||
|
||||
@Test
|
||||
void singleChildCollectionBoundsMatchChildBounds() {
|
||||
SRectangle only = SRectangle.create(5, 5, 20, 20);
|
||||
SCollection single = SCollection.of(only);
|
||||
|
||||
assertEquals(only.getBounds(), single.getBounds(),
|
||||
"A single-child collection's bounds should equal the child's own bounds");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,223 +0,0 @@
|
||||
package ovh.gasser.newshapes.shapes;
|
||||
|
||||
import ovh.gasser.newshapes.App;
|
||||
import ovh.gasser.newshapes.attributes.SelectionAttributes;
|
||||
import org.junit.jupiter.api.Nested;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.awt.*;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class EdgeCaseTest {
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// NegativeCoordinates
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class NegativeCoordinates {
|
||||
|
||||
@Test
|
||||
void rectangleAtNegativeCoordsShouldPreserveBounds() {
|
||||
SRectangle rect = SRectangle.create(-10, -20, 50, 50);
|
||||
Rectangle bounds = rect.getBounds();
|
||||
assertEquals(-10, bounds.x, "x should be -10");
|
||||
assertEquals(-20, bounds.y, "y should be -20");
|
||||
assertEquals(50, bounds.width, "width should be 50");
|
||||
assertEquals(50, bounds.height, "height should be 50");
|
||||
}
|
||||
|
||||
@Test
|
||||
void circleAtNegativeCoordsShouldPreserveBounds() {
|
||||
SCircle circle = SCircle.create(-30, -40, 25);
|
||||
Rectangle bounds = circle.getBounds();
|
||||
assertEquals(-30, bounds.x, "x should be -30");
|
||||
assertEquals(-40, bounds.y, "y should be -40");
|
||||
assertEquals(50, bounds.width, "width should be radius*2 = 50");
|
||||
assertEquals(50, bounds.height, "height should be radius*2 = 50");
|
||||
}
|
||||
|
||||
@Test
|
||||
void triangleAtNegativeCoordsShouldPreserveBounds() {
|
||||
STriangle tri = STriangle.create(-5, -15, 60, Color.RED, Color.BLACK);
|
||||
Rectangle bounds = tri.getBounds();
|
||||
assertEquals(-5, bounds.x, "x should be -5");
|
||||
assertEquals(-15, bounds.y, "y should be -15");
|
||||
assertEquals(60, bounds.width, "width should be 60");
|
||||
assertEquals(60, bounds.height, "height should be 60");
|
||||
}
|
||||
|
||||
@Test
|
||||
void translateToNegativePositionShouldUpdateBoundsCorrectly() {
|
||||
SRectangle rect = SRectangle.create(10, 20, 80, 40);
|
||||
rect.translate(-50, -70);
|
||||
Rectangle bounds = rect.getBounds();
|
||||
assertEquals(-40, bounds.x, "x after translate should be -40");
|
||||
assertEquals(-50, bounds.y, "y after translate should be -50");
|
||||
// dimensions must be unchanged
|
||||
assertEquals(80, bounds.width, "width must remain 80 after translate");
|
||||
assertEquals(40, bounds.height, "height must remain 40 after translate");
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// ZeroDimensions
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class ZeroDimensions {
|
||||
|
||||
@Test
|
||||
void rectangleWithZeroWidthShouldReturnZeroWidthFromFactory() {
|
||||
SRectangle rect = SRectangle.create(0, 0, 0, 50);
|
||||
assertEquals(0, rect.getBounds().width,
|
||||
"factory should allow zero width without clamping");
|
||||
}
|
||||
|
||||
@Test
|
||||
void rectangleWithZeroHeightShouldReturnZeroHeightFromFactory() {
|
||||
SRectangle rect = SRectangle.create(0, 0, 50, 0);
|
||||
assertEquals(0, rect.getBounds().height,
|
||||
"factory should allow zero height without clamping");
|
||||
}
|
||||
|
||||
@Test
|
||||
void circleWithZeroRadiusShouldHaveZeroBoundsDimensions() {
|
||||
SCircle circle = SCircle.create(5, 10, 0);
|
||||
assertEquals(0, circle.getRadius(), "radius should be 0");
|
||||
assertEquals(0, circle.getBounds().width, "bounds width should be 0 (radius*2)");
|
||||
assertEquals(0, circle.getBounds().height, "bounds height should be 0 (radius*2)");
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// ResizeClamping
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class ResizeClamping {
|
||||
|
||||
@Test
|
||||
void rectangleResizedToNegativeShouldClampWidthToOne() {
|
||||
// Start with a 10x10 rect and drag the E handle far to the left
|
||||
SRectangle rect = SRectangle.create(0, 0, 10, 10);
|
||||
rect.resize(ResizeHandle.E, -200, 0);
|
||||
assertTrue(rect.getBounds().width >= 1,
|
||||
"width must be clamped to a minimum of 1 after negative resize");
|
||||
assertEquals(1, rect.getBounds().width,
|
||||
"width should be exactly 1 after extreme negative resize on E handle");
|
||||
}
|
||||
|
||||
@Test
|
||||
void rectangleResizedToNegativeShouldClampHeightToOne() {
|
||||
SRectangle rect = SRectangle.create(0, 0, 10, 10);
|
||||
rect.resize(ResizeHandle.S, 0, -200);
|
||||
assertTrue(rect.getBounds().height >= 1,
|
||||
"height must be clamped to a minimum of 1 after negative resize");
|
||||
assertEquals(1, rect.getBounds().height,
|
||||
"height should be exactly 1 after extreme negative resize on S handle");
|
||||
}
|
||||
|
||||
@Test
|
||||
void circleResizedToNegativeShouldClampToTwo() {
|
||||
SCircle circle = SCircle.create(0, 0, 50);
|
||||
// Drag E handle far to the left → shrink
|
||||
circle.resize(ResizeHandle.E, -500, 0);
|
||||
assertTrue(circle.getBounds().width >= 2,
|
||||
"circle width must be clamped to a minimum of 2");
|
||||
assertTrue(circle.getBounds().height >= 2,
|
||||
"circle height must be clamped to a minimum of 2");
|
||||
assertEquals(2, circle.getBounds().width,
|
||||
"circle width should be exactly 2 after extreme negative resize");
|
||||
assertEquals(2, circle.getBounds().height,
|
||||
"circle height should be exactly 2 after extreme negative resize");
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// NullHandling
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class NullHandling {
|
||||
|
||||
@Test
|
||||
void textCreatedWithNullShouldReturnPlaceholder() {
|
||||
SText text = SText.create(0, 0, null);
|
||||
assertEquals(SText.PLACEHOLDER_TEXT, text.getText(),
|
||||
"null input should be normalized to the placeholder text");
|
||||
}
|
||||
|
||||
@Test
|
||||
void textCreatedWithBlankStringShouldReturnPlaceholder() {
|
||||
SText text = SText.create(0, 0, " ");
|
||||
assertEquals(SText.PLACEHOLDER_TEXT, text.getText(),
|
||||
"blank string input should be normalized to the placeholder text");
|
||||
}
|
||||
|
||||
@Test
|
||||
void getAttributesWithUnknownKeyShouldReturnNull() {
|
||||
SRectangle rect = SRectangle.create(0, 0, 50, 50);
|
||||
assertNull(rect.getAttributes("NONEXISTENT"),
|
||||
"getAttributes() with an unknown key must return null");
|
||||
}
|
||||
|
||||
@Test
|
||||
void emptyCollectionCreationShouldNotThrow() {
|
||||
assertDoesNotThrow(() -> SCollection.of(),
|
||||
"SCollection.of() with no arguments must not throw");
|
||||
}
|
||||
|
||||
@Test
|
||||
void emptyCollectionGetBoundsShouldReturnWindowSize() {
|
||||
SCollection collection = SCollection.of();
|
||||
Rectangle bounds = collection.getBounds();
|
||||
assertNotNull(bounds, "getBounds() on empty collection must not return null");
|
||||
assertEquals(App.WIN_SIZE.width, bounds.width,
|
||||
"empty collection bounds width should equal WIN_SIZE.width");
|
||||
assertEquals(App.WIN_SIZE.height, bounds.height,
|
||||
"empty collection bounds height should equal WIN_SIZE.height");
|
||||
}
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// LargeValues
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
@Nested
|
||||
class LargeValues {
|
||||
|
||||
@Test
|
||||
void rectangleAtMaxIntHalfCoordsShouldNotThrow() {
|
||||
int halfMax = Integer.MAX_VALUE / 2;
|
||||
assertDoesNotThrow(() -> SRectangle.create(halfMax, halfMax, 100, 100),
|
||||
"SRectangle.create() with very large coordinates must not throw");
|
||||
}
|
||||
|
||||
@Test
|
||||
void rectangleAtMaxIntHalfCoordsPreservesBounds() {
|
||||
int halfMax = Integer.MAX_VALUE / 2;
|
||||
SRectangle rect = SRectangle.create(halfMax, halfMax, 100, 100);
|
||||
assertEquals(halfMax, rect.getBounds().x, "x should be Integer.MAX_VALUE/2");
|
||||
assertEquals(halfMax, rect.getBounds().y, "y should be Integer.MAX_VALUE/2");
|
||||
assertEquals(100, rect.getBounds().width, "width should be 100");
|
||||
assertEquals(100, rect.getBounds().height, "height should be 100");
|
||||
}
|
||||
|
||||
@Test
|
||||
void translateWithLargeValuesShouldNotThrow() {
|
||||
SRectangle rect = SRectangle.create(0, 0, 50, 50);
|
||||
// Integer overflow is a known platform behaviour; we only assert no exception
|
||||
assertDoesNotThrow(() -> rect.translate(Integer.MAX_VALUE, Integer.MAX_VALUE),
|
||||
"translate() with Integer.MAX_VALUE must not throw (overflow is acceptable)");
|
||||
}
|
||||
|
||||
@Test
|
||||
void translateWithLargeNegativeValuesShouldNotThrow() {
|
||||
SRectangle rect = SRectangle.create(0, 0, 50, 50);
|
||||
assertDoesNotThrow(() -> rect.translate(Integer.MIN_VALUE, Integer.MIN_VALUE),
|
||||
"translate() with Integer.MIN_VALUE must not throw (overflow is acceptable)");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,94 +0,0 @@
|
||||
package ovh.gasser.newshapes.shapes;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import java.awt.Cursor;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class ResizeHandleTest {
|
||||
|
||||
@Test
|
||||
void testEightHandlesExist() {
|
||||
assertEquals(8, ResizeHandle.values().length,
|
||||
"ResizeHandle enum should define exactly 8 handles");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testAllHandleNamesExist() {
|
||||
assertNotNull(ResizeHandle.valueOf("NW"), "Handle NW should exist");
|
||||
assertNotNull(ResizeHandle.valueOf("N"), "Handle N should exist");
|
||||
assertNotNull(ResizeHandle.valueOf("NE"), "Handle NE should exist");
|
||||
assertNotNull(ResizeHandle.valueOf("E"), "Handle E should exist");
|
||||
assertNotNull(ResizeHandle.valueOf("SE"), "Handle SE should exist");
|
||||
assertNotNull(ResizeHandle.valueOf("S"), "Handle S should exist");
|
||||
assertNotNull(ResizeHandle.valueOf("SW"), "Handle SW should exist");
|
||||
assertNotNull(ResizeHandle.valueOf("W"), "Handle W should exist");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNwMapsToCorrectCursorType() {
|
||||
assertEquals(Cursor.NW_RESIZE_CURSOR, ResizeHandle.NW.getCursorType(),
|
||||
"NW handle should map to Cursor.NW_RESIZE_CURSOR");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNMapsToCorrectCursorType() {
|
||||
assertEquals(Cursor.N_RESIZE_CURSOR, ResizeHandle.N.getCursorType(),
|
||||
"N handle should map to Cursor.N_RESIZE_CURSOR");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testNeMapsToCorrectCursorType() {
|
||||
assertEquals(Cursor.NE_RESIZE_CURSOR, ResizeHandle.NE.getCursorType(),
|
||||
"NE handle should map to Cursor.NE_RESIZE_CURSOR");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testEMapsToCorrectCursorType() {
|
||||
assertEquals(Cursor.E_RESIZE_CURSOR, ResizeHandle.E.getCursorType(),
|
||||
"E handle should map to Cursor.E_RESIZE_CURSOR");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSeMapsToCorrectCursorType() {
|
||||
assertEquals(Cursor.SE_RESIZE_CURSOR, ResizeHandle.SE.getCursorType(),
|
||||
"SE handle should map to Cursor.SE_RESIZE_CURSOR");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSMapsToCorrectCursorType() {
|
||||
assertEquals(Cursor.S_RESIZE_CURSOR, ResizeHandle.S.getCursorType(),
|
||||
"S handle should map to Cursor.S_RESIZE_CURSOR");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testSwMapsToCorrectCursorType() {
|
||||
assertEquals(Cursor.SW_RESIZE_CURSOR, ResizeHandle.SW.getCursorType(),
|
||||
"SW handle should map to Cursor.SW_RESIZE_CURSOR");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testWMapsToCorrectCursorType() {
|
||||
assertEquals(Cursor.W_RESIZE_CURSOR, ResizeHandle.W.getCursorType(),
|
||||
"W handle should map to Cursor.W_RESIZE_CURSOR");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValueOfReturnsCorrectConstant() {
|
||||
assertSame(ResizeHandle.NW, ResizeHandle.valueOf("NW"), "valueOf(\"NW\") should return ResizeHandle.NW");
|
||||
assertSame(ResizeHandle.N, ResizeHandle.valueOf("N"), "valueOf(\"N\") should return ResizeHandle.N");
|
||||
assertSame(ResizeHandle.NE, ResizeHandle.valueOf("NE"), "valueOf(\"NE\") should return ResizeHandle.NE");
|
||||
assertSame(ResizeHandle.E, ResizeHandle.valueOf("E"), "valueOf(\"E\") should return ResizeHandle.E");
|
||||
assertSame(ResizeHandle.SE, ResizeHandle.valueOf("SE"), "valueOf(\"SE\") should return ResizeHandle.SE");
|
||||
assertSame(ResizeHandle.S, ResizeHandle.valueOf("S"), "valueOf(\"S\") should return ResizeHandle.S");
|
||||
assertSame(ResizeHandle.SW, ResizeHandle.valueOf("SW"), "valueOf(\"SW\") should return ResizeHandle.SW");
|
||||
assertSame(ResizeHandle.W, ResizeHandle.valueOf("W"), "valueOf(\"W\") should return ResizeHandle.W");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testValueOfWithInvalidNameThrowsIllegalArgumentException() {
|
||||
assertThrows(IllegalArgumentException.class,
|
||||
() -> ResizeHandle.valueOf("INVALID"),
|
||||
"valueOf() with an unknown name should throw IllegalArgumentException");
|
||||
}
|
||||
}
|
||||
@@ -44,40 +44,4 @@ class STextTest {
|
||||
SText text = SText.create(0, 0, null);
|
||||
assertEquals(SText.PLACEHOLDER_TEXT, text.getText());
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUpdateMeasuredBoundsActuallyUpdatesBounds() {
|
||||
SText text = SText.create(10, 20, "Hello");
|
||||
text.updateMeasuredBounds(200, 30);
|
||||
Rectangle bounds = text.getBounds();
|
||||
assertEquals(200, bounds.width, "updateMeasuredBounds must update width");
|
||||
assertEquals(30, bounds.height, "updateMeasuredBounds must update height");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUpdateMeasuredBoundsDoesNotChangePosition() {
|
||||
SText text = SText.create(10, 20, "Hello");
|
||||
text.updateMeasuredBounds(200, 30);
|
||||
Rectangle bounds = text.getBounds();
|
||||
assertEquals(10, bounds.x, "updateMeasuredBounds must not change x");
|
||||
assertEquals(20, bounds.y, "updateMeasuredBounds must not change y");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUpdateMeasuredBoundsNegativeClampedToZero() {
|
||||
SText text = SText.create(0, 0, "Hello");
|
||||
text.updateMeasuredBounds(-5, -10);
|
||||
Rectangle bounds = text.getBounds();
|
||||
assertEquals(0, bounds.width, "negative width must be clamped to 0");
|
||||
assertEquals(0, bounds.height, "negative height must be clamped to 0");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testUpdateMeasuredBoundsZeroIsAllowed() {
|
||||
SText text = SText.create(0, 0, "Hello");
|
||||
text.updateMeasuredBounds(0, 0);
|
||||
Rectangle bounds = text.getBounds();
|
||||
assertEquals(0, bounds.width);
|
||||
assertEquals(0, bounds.height);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,409 +0,0 @@
|
||||
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 HTMLDraftmanTest {
|
||||
|
||||
private StringWriter htmlBuffer;
|
||||
private StringWriter cssBuffer;
|
||||
private PrintWriter htmlWriter;
|
||||
private PrintWriter cssWriter;
|
||||
private HTMLDraftman draftman;
|
||||
|
||||
@BeforeEach
|
||||
void setUp() {
|
||||
htmlBuffer = new StringWriter();
|
||||
cssBuffer = new StringWriter();
|
||||
htmlWriter = new PrintWriter(htmlBuffer);
|
||||
cssWriter = new PrintWriter(cssBuffer);
|
||||
draftman = new HTMLDraftman(htmlWriter, cssWriter);
|
||||
}
|
||||
|
||||
private String html() {
|
||||
htmlWriter.flush();
|
||||
return htmlBuffer.toString();
|
||||
}
|
||||
|
||||
private String css() {
|
||||
cssWriter.flush();
|
||||
return cssBuffer.toString();
|
||||
}
|
||||
|
||||
// ── visitRectangle ──────────────────────────────────────────────
|
||||
|
||||
@Nested
|
||||
class VisitRectangleTests {
|
||||
|
||||
@Test
|
||||
void testRectangleProducesDivWithId() {
|
||||
SRectangle rect = SRectangle.create(10, 20, 100, 50);
|
||||
draftman.visitRectangle(rect);
|
||||
|
||||
assertTrue(html().contains("<div id=\"rec"), "Should produce a div with rec id");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testRectangleCssContainsCorrectPosition() {
|
||||
SRectangle rect = SRectangle.create(10, 20, 100, 50);
|
||||
draftman.visitRectangle(rect);
|
||||
|
||||
String cssOut = css();
|
||||
assertTrue(cssOut.contains("top:20px"), "CSS should contain correct top");
|
||||
assertTrue(cssOut.contains("left:10px"), "CSS should contain correct left");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testRectangleCssContainsCorrectDimensions() {
|
||||
SRectangle rect = SRectangle.create(10, 20, 100, 50);
|
||||
draftman.visitRectangle(rect);
|
||||
|
||||
String cssOut = css();
|
||||
assertTrue(cssOut.contains("width:100px"), "CSS should contain correct width");
|
||||
assertTrue(cssOut.contains("height:50px"), "CSS should contain correct height");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testRectangleCssPositionIsAbsolute() {
|
||||
SRectangle rect = SRectangle.create(0, 0, 30, 30);
|
||||
draftman.visitRectangle(rect);
|
||||
|
||||
assertTrue(css().contains("position:absolute"), "CSS should use absolute positioning");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testRectangleHtmlIdMatchesCssSelector() {
|
||||
SRectangle rect = SRectangle.create(0, 0, 30, 30);
|
||||
draftman.visitRectangle(rect);
|
||||
|
||||
String id = "rec" + rect.hashCode();
|
||||
assertTrue(html().contains("id=\"" + id + "\""), "HTML should contain div with correct id");
|
||||
assertTrue(css().contains("#" + id), "CSS should reference same id");
|
||||
}
|
||||
|
||||
@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 cssOut = css();
|
||||
assertTrue(cssOut.contains("background:"), "CSS should contain background");
|
||||
assertTrue(cssOut.contains("border:"), "CSS should contain border");
|
||||
}
|
||||
|
||||
@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 cssOut = css();
|
||||
assertTrue(cssOut.contains("background:"), "CSS should contain background for filled");
|
||||
assertFalse(cssOut.contains("border:"), "CSS should not contain border when not stroked");
|
||||
}
|
||||
|
||||
@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 cssOut = css();
|
||||
assertTrue(cssOut.contains("border:"), "CSS should contain border for stroked");
|
||||
assertTrue(cssOut.contains("background:#ffffff"), "CSS should have white background when not filled");
|
||||
}
|
||||
|
||||
@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 cssOut = css();
|
||||
assertFalse(cssOut.contains("background:"), "CSS should not contain background");
|
||||
assertFalse(cssOut.contains("border:"), "CSS should not contain border");
|
||||
}
|
||||
}
|
||||
|
||||
// ── visitCircle ─────────────────────────────────────────────────
|
||||
|
||||
@Nested
|
||||
class VisitCircleTests {
|
||||
|
||||
@Test
|
||||
void testCircleProducesDivWithClass() {
|
||||
SCircle circle = SCircle.create(50, 60, 30);
|
||||
draftman.visitCircle(circle);
|
||||
|
||||
assertTrue(html().contains("circle"), "HTML should contain circle class div");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCircleCssContainsBorderRadius() {
|
||||
SCircle circle = SCircle.create(50, 60, 30);
|
||||
draftman.visitCircle(circle);
|
||||
|
||||
String cssOut = css();
|
||||
assertTrue(cssOut.contains("border-radius:"), "CSS should contain border-radius");
|
||||
assertTrue(cssOut.contains("-webkit-border-radius:"), "CSS should contain webkit prefix");
|
||||
assertTrue(cssOut.contains("-moz-border-radius:"), "CSS should contain moz prefix");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCircleCssContainsCorrectPosition() {
|
||||
SCircle circle = SCircle.create(50, 60, 30);
|
||||
draftman.visitCircle(circle);
|
||||
|
||||
String cssOut = css();
|
||||
assertTrue(cssOut.contains("top:60px"), "CSS should contain correct top");
|
||||
assertTrue(cssOut.contains("left:50px"), "CSS should contain correct left");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCircleHtmlClassMatchesCssSelector() {
|
||||
SCircle circle = SCircle.create(0, 0, 20);
|
||||
draftman.visitCircle(circle);
|
||||
|
||||
String className = "circle" + circle.hashCode();
|
||||
assertTrue(html().contains(className), "HTML should have circle class");
|
||||
assertTrue(css().contains("." + className), "CSS should reference same class");
|
||||
}
|
||||
}
|
||||
|
||||
// ── visitTriangle ───────────────────────────────────────────────
|
||||
|
||||
@Nested
|
||||
class VisitTriangleTests {
|
||||
|
||||
@Test
|
||||
void testTriangleProducesDivWithClass() {
|
||||
STriangle tri = STriangle.create(10, 20, 40, Color.RED, Color.BLACK);
|
||||
draftman.visitTriangle(tri);
|
||||
|
||||
assertTrue(html().contains("triangle"), "HTML should contain triangle class div");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTriangleCssContainsBorderTrick() {
|
||||
STriangle tri = STriangle.create(10, 20, 40, Color.RED, Color.BLACK);
|
||||
draftman.visitTriangle(tri);
|
||||
|
||||
String cssOut = css();
|
||||
assertTrue(cssOut.contains("border-left-width:"), "CSS should use border-left-width");
|
||||
assertTrue(cssOut.contains("border-right-width:"), "CSS should use border-right-width");
|
||||
assertTrue(cssOut.contains("border-bottom:"), "CSS should use border-bottom");
|
||||
assertTrue(cssOut.contains("width: 0px"), "CSS should set width to 0");
|
||||
assertTrue(cssOut.contains("height: 0px"), "CSS should set height to 0");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTriangleCssContainsCorrectPosition() {
|
||||
STriangle tri = STriangle.create(10, 20, 40, Color.RED, Color.BLACK);
|
||||
draftman.visitTriangle(tri);
|
||||
|
||||
String cssOut = css();
|
||||
assertTrue(cssOut.contains("top: 20px"), "CSS should contain correct top");
|
||||
assertTrue(cssOut.contains("left: 10px"), "CSS should contain correct left");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTriangleCssContainsFillColor() {
|
||||
STriangle tri = STriangle.create(0, 0, 20, Color.BLUE, Color.BLACK);
|
||||
tri.addAttributes(new ColorAttributes(true, false, Color.BLUE, Color.BLACK));
|
||||
draftman.visitTriangle(tri);
|
||||
|
||||
assertTrue(css().contains("#0000ff"), "CSS should contain the triangle fill color");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTriangleHtmlClassMatchesCssSelector_regressionHashCode() {
|
||||
// Regression test: visitTriangle previously used this.hashCode()
|
||||
// instead of sTriangle.hashCode(), causing HTML class and CSS
|
||||
// selector mismatch when rendered by a different draftman instance.
|
||||
STriangle tri = STriangle.create(5, 5, 30, Color.RED, Color.BLACK);
|
||||
draftman.visitTriangle(tri);
|
||||
|
||||
String htmlOut = html();
|
||||
String cssOut = css();
|
||||
|
||||
// Extract the class name from HTML: class="triangleNNN"
|
||||
int classStart = htmlOut.indexOf("triangle");
|
||||
assertNotEquals(-1, classStart, "HTML should contain triangle class");
|
||||
int classEnd = htmlOut.indexOf("\"", classStart);
|
||||
String htmlClassName = htmlOut.substring(classStart, classEnd);
|
||||
|
||||
// CSS should use the same class name
|
||||
assertTrue(cssOut.contains("." + htmlClassName),
|
||||
"CSS selector should match HTML class — " +
|
||||
"if this fails, visitTriangle may be using this.hashCode() instead of sTriangle.hashCode()");
|
||||
}
|
||||
}
|
||||
|
||||
// ── visitText ───────────────────────────────────────────────────
|
||||
|
||||
@Nested
|
||||
class VisitTextTests {
|
||||
|
||||
@Test
|
||||
void testTextProducesDivWithContent() {
|
||||
SText text = SText.create(10, 20, "Hello");
|
||||
draftman.visitText(text);
|
||||
|
||||
assertTrue(html().contains(">Hello</div>"), "HTML should contain text content in div");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTextHtmlIdMatchesCssSelector() {
|
||||
SText text = SText.create(0, 0, "Test");
|
||||
draftman.visitText(text);
|
||||
|
||||
String id = "txt" + text.hashCode();
|
||||
assertTrue(html().contains("id=\"" + id + "\""), "HTML should contain text div with correct id");
|
||||
assertTrue(css().contains("#" + id), "CSS should reference same text id");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTextCssContainsPosition() {
|
||||
SText text = SText.create(15, 25, "Pos");
|
||||
draftman.visitText(text);
|
||||
|
||||
String cssOut = css();
|
||||
assertTrue(cssOut.contains("top:25px"), "CSS should contain correct top");
|
||||
assertTrue(cssOut.contains("left:15px"), "CSS should contain correct left");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTextCssContainsDefaultFontAttributes() {
|
||||
SText text = SText.create(0, 0, "Font");
|
||||
draftman.visitText(text);
|
||||
|
||||
String cssOut = css();
|
||||
assertTrue(cssOut.contains("font-family:"), "CSS should contain font-family");
|
||||
assertTrue(cssOut.contains("font-size:16px"), "CSS should contain default font size");
|
||||
assertTrue(cssOut.contains("font-style:normal"), "CSS should contain normal font style");
|
||||
assertTrue(cssOut.contains("font-weight:normal"), "CSS should contain normal font weight");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTextCssContainsColor() {
|
||||
SText text = SText.create(0, 0, "Colored");
|
||||
text.addAttributes(new ColorAttributes(true, false, Color.RED, Color.BLACK));
|
||||
draftman.visitText(text);
|
||||
|
||||
assertTrue(css().contains("color:#ff0000"), "CSS should contain fill color as text color");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTextCssWhiteSpaceNowrap() {
|
||||
SText text = SText.create(0, 0, "NoWrap");
|
||||
draftman.visitText(text);
|
||||
|
||||
assertTrue(css().contains("white-space: nowrap"), "CSS should prevent text wrapping");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testTextWithNullColorAttributesFallsBackToBlack() {
|
||||
SText text = SText.create(0, 0, "Fallback");
|
||||
text.addAttributes(new ColorAttributes(false, false, null, null));
|
||||
draftman.visitText(text);
|
||||
|
||||
assertTrue(css().contains("color:#000000"), "Should fall back to black with null colors");
|
||||
}
|
||||
}
|
||||
|
||||
// ── visitCollection ─────────────────────────────────────────────
|
||||
|
||||
@Nested
|
||||
class VisitCollectionTests {
|
||||
|
||||
@Test
|
||||
void testEmptyCollection() {
|
||||
SCollection empty = SCollection.of();
|
||||
draftman.visitCollection(empty);
|
||||
|
||||
assertEquals("", html(), "Empty collection should produce no HTML");
|
||||
assertEquals("", css(), "Empty collection should produce no CSS");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testCollectionVisitsAllChildren() {
|
||||
SCollection coll = SCollection.of(
|
||||
SRectangle.create(0, 0, 10, 10),
|
||||
SCircle.create(20, 20, 5)
|
||||
);
|
||||
draftman.visitCollection(coll);
|
||||
|
||||
assertTrue(html().contains("rec"), "Should visit rectangle");
|
||||
assertTrue(html().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);
|
||||
|
||||
assertTrue(html().contains("rec"), "Should visit nested rectangle");
|
||||
assertTrue(html().contains("circle"), "Should visit circle at outer level");
|
||||
}
|
||||
}
|
||||
|
||||
// ── generateHTML ────────────────────────────────────────────────
|
||||
|
||||
@Nested
|
||||
class GenerateHTMLTests {
|
||||
|
||||
@Test
|
||||
void testGenerateHTMLIncludesDoctype() {
|
||||
SCollection model = SCollection.of();
|
||||
draftman.generateHTML(model);
|
||||
|
||||
assertTrue(html().contains("<!DOCTYPE html>"), "Should include DOCTYPE");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGenerateHTMLIncludesHtmlStructure() {
|
||||
SCollection model = SCollection.of();
|
||||
draftman.generateHTML(model);
|
||||
|
||||
String htmlOut = html();
|
||||
assertTrue(htmlOut.contains("<html"), "Should include html tag");
|
||||
assertTrue(htmlOut.contains("<head>"), "Should include head tag");
|
||||
assertTrue(htmlOut.contains("<body>"), "Should include body tag");
|
||||
assertTrue(htmlOut.contains("</body>"), "Should close body tag");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGenerateHTMLReferencesStylesheet() {
|
||||
SCollection model = SCollection.of();
|
||||
draftman.generateHTML(model);
|
||||
|
||||
assertTrue(html().contains("style.css"), "Should reference CSS stylesheet");
|
||||
}
|
||||
|
||||
@Test
|
||||
void testGenerateHTMLIncludesShapeContent() {
|
||||
SCollection model = SCollection.of(
|
||||
SRectangle.create(1, 2, 3, 4)
|
||||
);
|
||||
draftman.generateHTML(model);
|
||||
|
||||
assertTrue(html().contains("<div id=\"rec"), "Should include shape elements");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,370 +0,0 @@
|
||||
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");
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user