summaryrefslogtreecommitdiff
path: root/gerbonara/gerber/tests/test_primitives.py
diff options
context:
space:
mode:
Diffstat (limited to 'gerbonara/gerber/tests/test_primitives.py')
-rw-r--r--gerbonara/gerber/tests/test_primitives.py1429
1 files changed, 1429 insertions, 0 deletions
diff --git a/gerbonara/gerber/tests/test_primitives.py b/gerbonara/gerber/tests/test_primitives.py
new file mode 100644
index 0000000..ad5b34f
--- /dev/null
+++ b/gerbonara/gerber/tests/test_primitives.py
@@ -0,0 +1,1429 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Author: Hamilton Kibbe <ham@hamiltonkib.be>
+
+import pytest
+from operator import add
+from ..primitives import *
+
+
+def test_primitive_smoketest():
+ p = Primitive()
+ try:
+ p.bounding_box
+ assert not True, "should have thrown the exception"
+ except NotImplementedError:
+ pass
+ # pytest.raises(NotImplementedError, p.bounding_box)
+
+ p.to_metric()
+ p.to_inch()
+ # try:
+ # p.offset(1, 1)
+ # assert_false(True, 'should have thrown the exception')
+ # except NotImplementedError:
+ # pass
+
+
+def test_line_angle():
+ """ Test Line primitive angle calculation
+ """
+ cases = [
+ ((0, 0), (1, 0), math.radians(0)),
+ ((0, 0), (1, 1), math.radians(45)),
+ ((0, 0), (0, 1), math.radians(90)),
+ ((0, 0), (-1, 1), math.radians(135)),
+ ((0, 0), (-1, 0), math.radians(180)),
+ ((0, 0), (-1, -1), math.radians(225)),
+ ((0, 0), (0, -1), math.radians(270)),
+ ((0, 0), (1, -1), math.radians(315)),
+ ]
+ for start, end, expected in cases:
+ l = Line(start, end, 0)
+ line_angle = (l.angle + 2 * math.pi) % (2 * math.pi)
+ pytest.approx(line_angle, expected)
+
+
+def test_line_bounds():
+ """ Test Line primitive bounding box calculation
+ """
+ cases = [
+ ((0, 0), (1, 1), ((-1, 2), (-1, 2))),
+ ((-1, -1), (1, 1), ((-2, 2), (-2, 2))),
+ ((1, 1), (-1, -1), ((-2, 2), (-2, 2))),
+ ((-1, 1), (1, -1), ((-2, 2), (-2, 2))),
+ ]
+
+ c = Circle((0, 0), 2)
+ r = Rectangle((0, 0), 2, 2)
+ for shape in (c, r):
+ for start, end, expected in cases:
+ l = Line(start, end, shape)
+ assert l.bounding_box == expected
+ # Test a non-square rectangle
+ r = Rectangle((0, 0), 3, 2)
+ cases = [
+ ((0, 0), (1, 1), ((-1.5, 2.5), (-1, 2))),
+ ((-1, -1), (1, 1), ((-2.5, 2.5), (-2, 2))),
+ ((1, 1), (-1, -1), ((-2.5, 2.5), (-2, 2))),
+ ((-1, 1), (1, -1), ((-2.5, 2.5), (-2, 2))),
+ ]
+ for start, end, expected in cases:
+ l = Line(start, end, r)
+ assert l.bounding_box == expected
+
+
+def test_line_vertices():
+ c = Circle((0, 0), 2)
+ l = Line((0, 0), (1, 1), c)
+ assert l.vertices == None
+
+ # All 4 compass points, all 4 quadrants and the case where start == end
+ test_cases = [
+ ((0, 0), (1, 0), ((-1, -1), (-1, 1), (2, 1), (2, -1))),
+ ((0, 0), (1, 1), ((-1, -1), (-1, 1), (0, 2), (2, 2), (2, 0), (1, -1))),
+ ((0, 0), (0, 1), ((-1, -1), (-1, 2), (1, 2), (1, -1))),
+ ((0, 0), (-1, 1), ((-1, -1), (-2, 0), (-2, 2), (0, 2), (1, 1), (1, -1))),
+ ((0, 0), (-1, 0), ((-2, -1), (-2, 1), (1, 1), (1, -1))),
+ ((0, 0), (-1, -1), ((-2, -2), (1, -1), (1, 1), (-1, 1), (-2, 0), (0, -2))),
+ ((0, 0), (0, -1), ((-1, -2), (-1, 1), (1, 1), (1, -2))),
+ ((0, 0), (1, -1), ((-1, -1), (0, -2), (2, -2), (2, 0), (1, 1), (-1, 1))),
+ ((0, 0), (0, 0), ((-1, -1), (-1, 1), (1, 1), (1, -1))),
+ ]
+ r = Rectangle((0, 0), 2, 2)
+
+ for start, end, vertices in test_cases:
+ l = Line(start, end, r)
+ assert set(vertices) == set(l.vertices)
+
+
+def test_line_conversion():
+ c = Circle((0, 0), 25.4, units="metric")
+ l = Line((2.54, 25.4), (254.0, 2540.0), c, units="metric")
+
+ # No effect
+ l.to_metric()
+ assert l.start == (2.54, 25.4)
+ assert l.end == (254.0, 2540.0)
+ assert l.aperture.diameter == 25.4
+
+ l.to_inch()
+ assert l.start == (0.1, 1.0)
+ assert l.end == (10.0, 100.0)
+ assert l.aperture.diameter == 1.0
+
+ # No effect
+ l.to_inch()
+ assert l.start == (0.1, 1.0)
+ assert l.end == (10.0, 100.0)
+ assert l.aperture.diameter == 1.0
+
+ c = Circle((0, 0), 1.0, units="inch")
+ l = Line((0.1, 1.0), (10.0, 100.0), c, units="inch")
+
+ # No effect
+ l.to_inch()
+ assert l.start == (0.1, 1.0)
+ assert l.end == (10.0, 100.0)
+ assert l.aperture.diameter == 1.0
+
+ l.to_metric()
+ assert l.start == (2.54, 25.4)
+ assert l.end == (254.0, 2540.0)
+ assert l.aperture.diameter == 25.4
+
+ # No effect
+ l.to_metric()
+ assert l.start == (2.54, 25.4)
+ assert l.end == (254.0, 2540.0)
+ assert l.aperture.diameter == 25.4
+
+ r = Rectangle((0, 0), 25.4, 254.0, units="metric")
+ l = Line((2.54, 25.4), (254.0, 2540.0), r, units="metric")
+ l.to_inch()
+ assert l.start == (0.1, 1.0)
+ assert l.end == (10.0, 100.0)
+ assert l.aperture.width == 1.0
+ assert l.aperture.height == 10.0
+
+ r = Rectangle((0, 0), 1.0, 10.0, units="inch")
+ l = Line((0.1, 1.0), (10.0, 100.0), r, units="inch")
+ l.to_metric()
+ assert l.start == (2.54, 25.4)
+ assert l.end == (254.0, 2540.0)
+ assert l.aperture.width == 25.4
+ assert l.aperture.height == 254.0
+
+
+def test_line_offset():
+ c = Circle((0, 0), 1)
+ l = Line((0, 0), (1, 1), c)
+ l.offset(1, 0)
+ assert l.start == (1.0, 0.0)
+ assert l.end == (2.0, 1.0)
+ l.offset(0, 1)
+ assert l.start == (1.0, 1.0)
+ assert l.end == (2.0, 2.0)
+
+
+def test_arc_radius():
+ """ Test Arc primitive radius calculation
+ """
+ cases = [((-3, 4), (5, 0), (0, 0), 5), ((0, 1), (1, 0), (0, 0), 1)]
+
+ for start, end, center, radius in cases:
+ a = Arc(start, end, center, "clockwise", 0, "single-quadrant")
+ assert a.radius == radius
+
+
+def test_arc_sweep_angle():
+ """ Test Arc primitive sweep angle calculation
+ """
+ cases = [
+ ((1, 0), (0, 1), (0, 0), "counterclockwise", math.radians(90)),
+ ((1, 0), (0, 1), (0, 0), "clockwise", math.radians(270)),
+ ((1, 0), (-1, 0), (0, 0), "clockwise", math.radians(180)),
+ ((1, 0), (-1, 0), (0, 0), "counterclockwise", math.radians(180)),
+ ]
+
+ for start, end, center, direction, sweep in cases:
+ c = Circle((0, 0), 1)
+ a = Arc(start, end, center, direction, c, "single-quadrant")
+ assert a.sweep_angle == sweep
+
+
+def test_arc_bounds():
+ """ Test Arc primitive bounding box calculation
+ """
+ cases = [
+ ((1, 0), (0, 1), (0, 0), "clockwise", ((-1.5, 1.5), (-1.5, 1.5))),
+ ((1, 0), (0, 1), (0, 0), "counterclockwise", ((-0.5, 1.5), (-0.5, 1.5))),
+ ((0, 1), (-1, 0), (0, 0), "clockwise", ((-1.5, 1.5), (-1.5, 1.5))),
+ ((0, 1), (-1, 0), (0, 0), "counterclockwise", ((-1.5, 0.5), (-0.5, 1.5))),
+ ((-1, 0), (0, -1), (0, 0), "clockwise", ((-1.5, 1.5), (-1.5, 1.5))),
+ ((-1, 0), (0, -1), (0, 0), "counterclockwise", ((-1.5, 0.5), (-1.5, 0.5))),
+ ((0, -1), (1, 0), (0, 0), "clockwise", ((-1.5, 1.5), (-1.5, 1.5))),
+ ((0, -1), (1, 0), (0, 0), "counterclockwise", ((-0.5, 1.5), (-1.5, 0.5))),
+ # Arcs with the same start and end point render a full circle
+ ((1, 0), (1, 0), (0, 0), "clockwise", ((-1.5, 1.5), (-1.5, 1.5))),
+ ((1, 0), (1, 0), (0, 0), "counterclockwise", ((-1.5, 1.5), (-1.5, 1.5))),
+ ]
+ for start, end, center, direction, bounds in cases:
+ c = Circle((0, 0), 1)
+ a = Arc(start, end, center, direction, c, "multi-quadrant")
+ assert a.bounding_box == bounds
+
+
+def test_arc_bounds_no_aperture():
+ """ Test Arc primitive bounding box calculation ignoring aperture
+ """
+ cases = [
+ ((1, 0), (0, 1), (0, 0), "clockwise", ((-1.0, 1.0), (-1.0, 1.0))),
+ ((1, 0), (0, 1), (0, 0), "counterclockwise", ((0.0, 1.0), (0.0, 1.0))),
+ ((0, 1), (-1, 0), (0, 0), "clockwise", ((-1.0, 1.0), (-1.0, 1.0))),
+ ((0, 1), (-1, 0), (0, 0), "counterclockwise", ((-1.0, 0.0), (0.0, 1.0))),
+ ((-1, 0), (0, -1), (0, 0), "clockwise", ((-1.0, 1.0), (-1.0, 1.0))),
+ ((-1, 0), (0, -1), (0, 0), "counterclockwise", ((-1.0, 0.0), (-1.0, 0.0))),
+ ((0, -1), (1, 0), (0, 0), "clockwise", ((-1.0, 1.0), (-1.0, 1.0))),
+ ((0, -1), (1, 0), (0, 0), "counterclockwise", ((-0.0, 1.0), (-1.0, 0.0))),
+ # Arcs with the same start and end point render a full circle
+ ((1, 0), (1, 0), (0, 0), "clockwise", ((-1.0, 1.0), (-1.0, 1.0))),
+ ((1, 0), (1, 0), (0, 0), "counterclockwise", ((-1.0, 1.0), (-1.0, 1.0))),
+ ]
+ for start, end, center, direction, bounds in cases:
+ c = Circle((0, 0), 1)
+ a = Arc(start, end, center, direction, c, "multi-quadrant")
+ assert a.bounding_box_no_aperture == bounds
+
+
+def test_arc_conversion():
+ c = Circle((0, 0), 25.4, units="metric")
+ a = Arc(
+ (2.54, 25.4),
+ (254.0, 2540.0),
+ (25400.0, 254000.0),
+ "clockwise",
+ c,
+ "single-quadrant",
+ units="metric",
+ )
+
+ # No effect
+ a.to_metric()
+ assert a.start == (2.54, 25.4)
+ assert a.end == (254.0, 2540.0)
+ assert a.center == (25400.0, 254000.0)
+ assert a.aperture.diameter == 25.4
+
+ a.to_inch()
+ assert a.start == (0.1, 1.0)
+ assert a.end == (10.0, 100.0)
+ assert a.center == (1000.0, 10000.0)
+ assert a.aperture.diameter == 1.0
+
+ # no effect
+ a.to_inch()
+ assert a.start == (0.1, 1.0)
+ assert a.end == (10.0, 100.0)
+ assert a.center == (1000.0, 10000.0)
+ assert a.aperture.diameter == 1.0
+
+ c = Circle((0, 0), 1.0, units="inch")
+ a = Arc(
+ (0.1, 1.0),
+ (10.0, 100.0),
+ (1000.0, 10000.0),
+ "clockwise",
+ c,
+ "single-quadrant",
+ units="inch",
+ )
+ a.to_metric()
+ assert a.start == (2.54, 25.4)
+ assert a.end == (254.0, 2540.0)
+ assert a.center == (25400.0, 254000.0)
+ assert a.aperture.diameter == 25.4
+
+
+def test_arc_offset():
+ c = Circle((0, 0), 1)
+ a = Arc((0, 0), (1, 1), (2, 2), "clockwise", c, "single-quadrant")
+ a.offset(1, 0)
+ assert a.start == (1.0, 0.0)
+ assert a.end == (2.0, 1.0)
+ assert a.center == (3.0, 2.0)
+ a.offset(0, 1)
+ assert a.start == (1.0, 1.0)
+ assert a.end == (2.0, 2.0)
+ assert a.center == (3.0, 3.0)
+
+
+def test_circle_radius():
+ """ Test Circle primitive radius calculation
+ """
+ c = Circle((1, 1), 2)
+ assert c.radius == 1
+
+
+def test_circle_hole_radius():
+ """ Test Circle primitive hole radius calculation
+ """
+ c = Circle((1, 1), 4, 2)
+ assert c.hole_radius == 1
+
+
+def test_circle_bounds():
+ """ Test Circle bounding box calculation
+ """
+ c = Circle((1, 1), 2)
+ assert c.bounding_box == ((0, 2), (0, 2))
+
+
+def test_circle_conversion():
+ """Circle conversion of units"""
+ # Circle initially metric, no hole
+ c = Circle((2.54, 25.4), 254.0, units="metric")
+
+ c.to_metric() # shouldn't do antyhing
+ assert c.position == (2.54, 25.4)
+ assert c.diameter == 254.0
+ assert c.hole_diameter == None
+
+ c.to_inch()
+ assert c.position == (0.1, 1.0)
+ assert c.diameter == 10.0
+ assert c.hole_diameter == None
+
+ # no effect
+ c.to_inch()
+ assert c.position == (0.1, 1.0)
+ assert c.diameter == 10.0
+ assert c.hole_diameter == None
+
+ # Circle initially metric, with hole
+ c = Circle((2.54, 25.4), 254.0, 127.0, units="metric")
+
+ c.to_metric() # shouldn't do antyhing
+ assert c.position == (2.54, 25.4)
+ assert c.diameter == 254.0
+ assert c.hole_diameter == 127.0
+
+ c.to_inch()
+ assert c.position == (0.1, 1.0)
+ assert c.diameter == 10.0
+ assert c.hole_diameter == 5.0
+
+ # no effect
+ c.to_inch()
+ assert c.position == (0.1, 1.0)
+ assert c.diameter == 10.0
+ assert c.hole_diameter == 5.0
+
+ # Circle initially inch, no hole
+ c = Circle((0.1, 1.0), 10.0, units="inch")
+ # No effect
+ c.to_inch()
+ assert c.position == (0.1, 1.0)
+ assert c.diameter == 10.0
+ assert c.hole_diameter == None
+
+ c.to_metric()
+ assert c.position == (2.54, 25.4)
+ assert c.diameter == 254.0
+ assert c.hole_diameter == None
+
+ # no effect
+ c.to_metric()
+ assert c.position == (2.54, 25.4)
+ assert c.diameter == 254.0
+ assert c.hole_diameter == None
+
+ c = Circle((0.1, 1.0), 10.0, 5.0, units="inch")
+ # No effect
+ c.to_inch()
+ assert c.position == (0.1, 1.0)
+ assert c.diameter == 10.0
+ assert c.hole_diameter == 5.0
+
+ c.to_metric()
+ assert c.position == (2.54, 25.4)
+ assert c.diameter == 254.0
+ assert c.hole_diameter == 127.0
+
+ # no effect
+ c.to_metric()
+ assert c.position == (2.54, 25.4)
+ assert c.diameter == 254.0
+ assert c.hole_diameter == 127.0
+
+
+def test_circle_offset():
+ c = Circle((0, 0), 1)
+ c.offset(1, 0)
+ assert c.position == (1.0, 0.0)
+ c.offset(0, 1)
+ assert c.position == (1.0, 1.0)
+
+
+def test_ellipse_ctor():
+ """ Test ellipse creation
+ """
+ e = Ellipse((2, 2), 3, 2)
+ assert e.position == (2, 2)
+ assert e.width == 3
+ assert e.height == 2
+
+
+def test_ellipse_bounds():
+ """ Test ellipse bounding box calculation
+ """
+ e = Ellipse((2, 2), 4, 2)
+ assert e.bounding_box == ((0, 4), (1, 3))
+ e = Ellipse((2, 2), 4, 2, rotation=90)
+ assert e.bounding_box == ((1, 3), (0, 4))
+ e = Ellipse((2, 2), 4, 2, rotation=180)
+ assert e.bounding_box == ((0, 4), (1, 3))
+ e = Ellipse((2, 2), 4, 2, rotation=270)
+ assert e.bounding_box == ((1, 3), (0, 4))
+
+
+def test_ellipse_conversion():
+ e = Ellipse((2.54, 25.4), 254.0, 2540.0, units="metric")
+
+ # No effect
+ e.to_metric()
+ assert e.position == (2.54, 25.4)
+ assert e.width == 254.0
+ assert e.height == 2540.0
+
+ e.to_inch()
+ assert e.position == (0.1, 1.0)
+ assert e.width == 10.0
+ assert e.height == 100.0
+
+ # No effect
+ e.to_inch()
+ assert e.position == (0.1, 1.0)
+ assert e.width == 10.0
+ assert e.height == 100.0
+
+ e = Ellipse((0.1, 1.0), 10.0, 100.0, units="inch")
+
+ # no effect
+ e.to_inch()
+ assert e.position == (0.1, 1.0)
+ assert e.width == 10.0
+ assert e.height == 100.0
+
+ e.to_metric()
+ assert e.position == (2.54, 25.4)
+ assert e.width == 254.0
+ assert e.height == 2540.0
+
+ # No effect
+ e.to_metric()
+ assert e.position == (2.54, 25.4)
+ assert e.width == 254.0
+ assert e.height == 2540.0
+
+
+def test_ellipse_offset():
+ e = Ellipse((0, 0), 1, 2)
+ e.offset(1, 0)
+ assert e.position == (1.0, 0.0)
+ e.offset(0, 1)
+ assert e.position == (1.0, 1.0)
+
+
+def test_rectangle_ctor():
+ """ Test rectangle creation
+ """
+ test_cases = (((0, 0), 1, 1), ((0, 0), 1, 2), ((1, 1), 1, 2))
+ for pos, width, height in test_cases:
+ r = Rectangle(pos, width, height)
+ assert r.position == pos
+ assert r.width == width
+ assert r.height == height
+
+
+def test_rectangle_hole_radius():
+ """ Test rectangle hole diameter calculation
+ """
+ r = Rectangle((0, 0), 2, 2)
+ assert 0 == r.hole_radius
+
+ r = Rectangle((0, 0), 2, 2, 1)
+ assert 0.5 == r.hole_radius
+
+
+def test_rectangle_bounds():
+ """ Test rectangle bounding box calculation
+ """
+ r = Rectangle((0, 0), 2, 2)
+ xbounds, ybounds = r.bounding_box
+ pytest.approx(xbounds, (-1, 1))
+ pytest.approx(ybounds, (-1, 1))
+ r = Rectangle((0, 0), 2, 2, rotation=45)
+ xbounds, ybounds = r.bounding_box
+ pytest.approx(xbounds, (-math.sqrt(2), math.sqrt(2)))
+ pytest.approx(ybounds, (-math.sqrt(2), math.sqrt(2)))
+
+
+def test_rectangle_vertices():
+ sqrt2 = math.sqrt(2.0)
+ TEST_VECTORS = [
+ ((0, 0), 2.0, 2.0, 0.0, ((-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0))),
+ ((0, 0), 2.0, 3.0, 0.0, ((-1.0, -1.5), (-1.0, 1.5), (1.0, 1.5), (1.0, -1.5))),
+ ((0, 0), 2.0, 2.0, 90.0, ((-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0))),
+ ((0, 0), 3.0, 2.0, 90.0, ((-1.0, -1.5), (-1.0, 1.5), (1.0, 1.5), (1.0, -1.5))),
+ (
+ (0, 0),
+ 2.0,
+ 2.0,
+ 45.0,
+ ((-sqrt2, 0.0), (0.0, sqrt2), (sqrt2, 0), (0, -sqrt2)),
+ ),
+ ]
+ for pos, width, height, rotation, expected in TEST_VECTORS:
+ r = Rectangle(pos, width, height, rotation=rotation)
+ for test, expect in zip(sorted(r.vertices), sorted(expected)):
+ pytest.approx(test, expect)
+
+ r = Rectangle((0, 0), 2.0, 2.0, rotation=0.0)
+ r.rotation = 45.0
+ for test, expect in zip(
+ sorted(r.vertices),
+ sorted(((-sqrt2, 0.0), (0.0, sqrt2), (sqrt2, 0), (0, -sqrt2))),
+ ):
+ pytest.approx(test, expect)
+
+
+def test_rectangle_segments():
+
+ r = Rectangle((0, 0), 2.0, 2.0)
+ expected = [vtx for segment in r.segments for vtx in segment]
+ for vertex in r.vertices:
+ assert vertex in expected
+
+
+def test_rectangle_conversion():
+ """Test converting rectangles between units"""
+
+ # Initially metric no hole
+ r = Rectangle((2.54, 25.4), 254.0, 2540.0, units="metric")
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+
+ # Initially metric with hole
+ r = Rectangle((2.54, 25.4), 254.0, 2540.0, 127.0, units="metric")
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.hole_diameter == 127.0
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.hole_diameter == 5.0
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.hole_diameter == 5.0
+
+ # Initially inch, no hole
+ r = Rectangle((0.1, 1.0), 10.0, 100.0, units="inch")
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+
+ # Initially inch with hole
+ r = Rectangle((0.1, 1.0), 10.0, 100.0, 5.0, units="inch")
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.hole_diameter == 5.0
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.hole_diameter == 127.0
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.hole_diameter == 127.0
+
+
+def test_rectangle_offset():
+ r = Rectangle((0, 0), 1, 2)
+ r.offset(1, 0)
+ assert r.position == (1.0, 0.0)
+ r.offset(0, 1)
+ assert r.position == (1.0, 1.0)
+
+
+def test_diamond_ctor():
+ """ Test diamond creation
+ """
+ test_cases = (((0, 0), 1, 1), ((0, 0), 1, 2), ((1, 1), 1, 2))
+ for pos, width, height in test_cases:
+ d = Diamond(pos, width, height)
+ assert d.position == pos
+ assert d.width == width
+ assert d.height == height
+
+
+def test_diamond_bounds():
+ """ Test diamond bounding box calculation
+ """
+ d = Diamond((0, 0), 2, 2)
+ xbounds, ybounds = d.bounding_box
+ pytest.approx(xbounds, (-1, 1))
+ pytest.approx(ybounds, (-1, 1))
+ d = Diamond((0, 0), math.sqrt(2), math.sqrt(2), rotation=45)
+ xbounds, ybounds = d.bounding_box
+ pytest.approx(xbounds, (-1, 1))
+ pytest.approx(ybounds, (-1, 1))
+
+
+def test_diamond_conversion():
+ d = Diamond((2.54, 25.4), 254.0, 2540.0, units="metric")
+
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.width == 254.0
+ assert d.height == 2540.0
+
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.width == 10.0
+ assert d.height == 100.0
+
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.width == 10.0
+ assert d.height == 100.0
+
+ d = Diamond((0.1, 1.0), 10.0, 100.0, units="inch")
+
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.width == 10.0
+ assert d.height == 100.0
+
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.width == 254.0
+ assert d.height == 2540.0
+
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.width == 254.0
+ assert d.height == 2540.0
+
+
+def test_diamond_offset():
+ d = Diamond((0, 0), 1, 2)
+ d.offset(1, 0)
+ assert d.position == (1.0, 0.0)
+ d.offset(0, 1)
+ assert d.position == (1.0, 1.0)
+
+
+def test_chamfer_rectangle_ctor():
+ """ Test chamfer rectangle creation
+ """
+ test_cases = (
+ ((0, 0), 1, 1, 0.2, (True, True, False, False)),
+ ((0, 0), 1, 2, 0.3, (True, True, True, True)),
+ ((1, 1), 1, 2, 0.4, (False, False, False, False)),
+ )
+ for pos, width, height, chamfer, corners in test_cases:
+ r = ChamferRectangle(pos, width, height, chamfer, corners)
+ assert r.position == pos
+ assert r.width == width
+ assert r.height == height
+ assert r.chamfer == chamfer
+ pytest.approx(r.corners, corners)
+
+
+def test_chamfer_rectangle_bounds():
+ """ Test chamfer rectangle bounding box calculation
+ """
+ r = ChamferRectangle((0, 0), 2, 2, 0.2, (True, True, False, False))
+ xbounds, ybounds = r.bounding_box
+ pytest.approx(xbounds, (-1, 1))
+ pytest.approx(ybounds, (-1, 1))
+ r = ChamferRectangle((0, 0), 2, 2, 0.2, (True, True, False, False), rotation=45)
+ xbounds, ybounds = r.bounding_box
+ pytest.approx(xbounds, (-math.sqrt(2), math.sqrt(2)))
+ pytest.approx(ybounds, (-math.sqrt(2), math.sqrt(2)))
+
+
+def test_chamfer_rectangle_conversion():
+ r = ChamferRectangle(
+ (2.54, 25.4), 254.0, 2540.0, 0.254, (True, True, False, False), units="metric"
+ )
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.chamfer == 0.254
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.chamfer == 0.01
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.chamfer == 0.01
+
+ r = ChamferRectangle(
+ (0.1, 1.0), 10.0, 100.0, 0.01, (True, True, False, False), units="inch"
+ )
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.chamfer == 0.01
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.chamfer == 0.254
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.chamfer == 0.254
+
+
+def test_chamfer_rectangle_offset():
+ r = ChamferRectangle((0, 0), 1, 2, 0.01, (True, True, False, False))
+ r.offset(1, 0)
+ assert r.position == (1.0, 0.0)
+ r.offset(0, 1)
+ assert r.position == (1.0, 1.0)
+
+
+def test_chamfer_rectangle_vertices():
+ TEST_VECTORS = [
+ (
+ 1.0,
+ (True, True, True, True),
+ (
+ (-2.5, -1.5),
+ (-2.5, 1.5),
+ (-1.5, 2.5),
+ (1.5, 2.5),
+ (2.5, 1.5),
+ (2.5, -1.5),
+ (1.5, -2.5),
+ (-1.5, -2.5),
+ ),
+ ),
+ (
+ 1.0,
+ (True, False, False, False),
+ ((-2.5, -2.5), (-2.5, 2.5), (1.5, 2.5), (2.5, 1.5), (2.5, -2.5)),
+ ),
+ (
+ 1.0,
+ (False, True, False, False),
+ ((-2.5, -2.5), (-2.5, 1.5), (-1.5, 2.5), (2.5, 2.5), (2.5, -2.5)),
+ ),
+ (
+ 1.0,
+ (False, False, True, False),
+ ((-2.5, -1.5), (-2.5, 2.5), (2.5, 2.5), (2.5, -2.5), (-1.5, -2.5)),
+ ),
+ (
+ 1.0,
+ (False, False, False, True),
+ ((-2.5, -2.5), (-2.5, 2.5), (2.5, 2.5), (2.5, -1.5), (1.5, -2.5)),
+ ),
+ ]
+ for chamfer, corners, expected in TEST_VECTORS:
+ r = ChamferRectangle((0, 0), 5, 5, chamfer, corners)
+ assert set(r.vertices) == set(expected)
+
+
+def test_round_rectangle_ctor():
+ """ Test round rectangle creation
+ """
+ test_cases = (
+ ((0, 0), 1, 1, 0.2, (True, True, False, False)),
+ ((0, 0), 1, 2, 0.3, (True, True, True, True)),
+ ((1, 1), 1, 2, 0.4, (False, False, False, False)),
+ )
+ for pos, width, height, radius, corners in test_cases:
+ r = RoundRectangle(pos, width, height, radius, corners)
+ assert r.position == pos
+ assert r.width == width
+ assert r.height == height
+ assert r.radius == radius
+ pytest.approx(r.corners, corners)
+
+
+def test_round_rectangle_bounds():
+ """ Test round rectangle bounding box calculation
+ """
+ r = RoundRectangle((0, 0), 2, 2, 0.2, (True, True, False, False))
+ xbounds, ybounds = r.bounding_box
+ pytest.approx(xbounds, (-1, 1))
+ pytest.approx(ybounds, (-1, 1))
+ r = RoundRectangle((0, 0), 2, 2, 0.2, (True, True, False, False), rotation=45)
+ xbounds, ybounds = r.bounding_box
+ pytest.approx(xbounds, (-math.sqrt(2), math.sqrt(2)))
+ pytest.approx(ybounds, (-math.sqrt(2), math.sqrt(2)))
+
+
+def test_round_rectangle_conversion():
+ r = RoundRectangle(
+ (2.54, 25.4), 254.0, 2540.0, 0.254, (True, True, False, False), units="metric"
+ )
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.radius == 0.254
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.radius == 0.01
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.radius == 0.01
+
+ r = RoundRectangle(
+ (0.1, 1.0), 10.0, 100.0, 0.01, (True, True, False, False), units="inch"
+ )
+
+ r.to_inch()
+ assert r.position == (0.1, 1.0)
+ assert r.width == 10.0
+ assert r.height == 100.0
+ assert r.radius == 0.01
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.radius == 0.254
+
+ r.to_metric()
+ assert r.position == (2.54, 25.4)
+ assert r.width == 254.0
+ assert r.height == 2540.0
+ assert r.radius == 0.254
+
+
+def test_round_rectangle_offset():
+ r = RoundRectangle((0, 0), 1, 2, 0.01, (True, True, False, False))
+ r.offset(1, 0)
+ assert r.position == (1.0, 0.0)
+ r.offset(0, 1)
+ assert r.position == (1.0, 1.0)
+
+
+def test_obround_ctor():
+ """ Test obround creation
+ """
+ test_cases = (((0, 0), 1, 1), ((0, 0), 1, 2), ((1, 1), 1, 2))
+ for pos, width, height in test_cases:
+ o = Obround(pos, width, height)
+ assert o.position == pos
+ assert o.width == width
+ assert o.height == height
+
+
+def test_obround_bounds():
+ """ Test obround bounding box calculation
+ """
+ o = Obround((2, 2), 2, 4)
+ xbounds, ybounds = o.bounding_box
+ pytest.approx(xbounds, (1, 3))
+ pytest.approx(ybounds, (0, 4))
+ o = Obround((2, 2), 4, 2)
+ xbounds, ybounds = o.bounding_box
+ pytest.approx(xbounds, (0, 4))
+ pytest.approx(ybounds, (1, 3))
+
+
+def test_obround_orientation():
+ o = Obround((0, 0), 2, 1)
+ assert o.orientation == "horizontal"
+ o = Obround((0, 0), 1, 2)
+ assert o.orientation == "vertical"
+
+
+def test_obround_subshapes():
+ o = Obround((0, 0), 1, 4)
+ ss = o.subshapes
+ pytest.approx(ss["rectangle"].position, (0, 0))
+ pytest.approx(ss["circle1"].position, (0, 1.5))
+ pytest.approx(ss["circle2"].position, (0, -1.5))
+ o = Obround((0, 0), 4, 1)
+ ss = o.subshapes
+ pytest.approx(ss["rectangle"].position, (0, 0))
+ pytest.approx(ss["circle1"].position, (1.5, 0))
+ pytest.approx(ss["circle2"].position, (-1.5, 0))
+
+
+def test_obround_conversion():
+ o = Obround((2.54, 25.4), 254.0, 2540.0, units="metric")
+
+ # No effect
+ o.to_metric()
+ assert o.position == (2.54, 25.4)
+ assert o.width == 254.0
+ assert o.height == 2540.0
+
+ o.to_inch()
+ assert o.position == (0.1, 1.0)
+ assert o.width == 10.0
+ assert o.height == 100.0
+
+ # No effect
+ o.to_inch()
+ assert o.position == (0.1, 1.0)
+ assert o.width == 10.0
+ assert o.height == 100.0
+
+ o = Obround((0.1, 1.0), 10.0, 100.0, units="inch")
+
+ # No effect
+ o.to_inch()
+ assert o.position == (0.1, 1.0)
+ assert o.width == 10.0
+ assert o.height == 100.0
+
+ o.to_metric()
+ assert o.position == (2.54, 25.4)
+ assert o.width == 254.0
+ assert o.height == 2540.0
+
+ # No effect
+ o.to_metric()
+ assert o.position == (2.54, 25.4)
+ assert o.width == 254.0
+ assert o.height == 2540.0
+
+
+def test_obround_offset():
+ o = Obround((0, 0), 1, 2)
+ o.offset(1, 0)
+ assert o.position == (1.0, 0.0)
+ o.offset(0, 1)
+ assert o.position == (1.0, 1.0)
+
+
+def test_polygon_ctor():
+ """ Test polygon creation
+ """
+ test_cases = (((0, 0), 3, 5, 0), ((0, 0), 5, 6, 0), ((1, 1), 7, 7, 45))
+ for pos, sides, radius, hole_diameter in test_cases:
+ p = Polygon(pos, sides, radius, hole_diameter)
+ assert p.position == pos
+ assert p.sides == sides
+ assert p.radius == radius
+ assert p.hole_diameter == hole_diameter
+
+
+def test_polygon_bounds():
+ """ Test polygon bounding box calculation
+ """
+ p = Polygon((2, 2), 3, 2, 0)
+ xbounds, ybounds = p.bounding_box
+ pytest.approx(xbounds, (0, 4))
+ pytest.approx(ybounds, (0, 4))
+ p = Polygon((2, 2), 3, 4, 0)
+ xbounds, ybounds = p.bounding_box
+ pytest.approx(xbounds, (-2, 6))
+ pytest.approx(ybounds, (-2, 6))
+
+
+def test_polygon_conversion():
+ p = Polygon((2.54, 25.4), 3, 254.0, 0, units="metric")
+
+ # No effect
+ p.to_metric()
+ assert p.position == (2.54, 25.4)
+ assert p.radius == 254.0
+
+ p.to_inch()
+ assert p.position == (0.1, 1.0)
+ assert p.radius == 10.0
+
+ # No effect
+ p.to_inch()
+ assert p.position == (0.1, 1.0)
+ assert p.radius == 10.0
+
+ p = Polygon((0.1, 1.0), 3, 10.0, 0, units="inch")
+
+ # No effect
+ p.to_inch()
+ assert p.position == (0.1, 1.0)
+ assert p.radius == 10.0
+
+ p.to_metric()
+ assert p.position == (2.54, 25.4)
+ assert p.radius == 254.0
+
+ # No effect
+ p.to_metric()
+ assert p.position == (2.54, 25.4)
+ assert p.radius == 254.0
+
+
+def test_polygon_offset():
+ p = Polygon((0, 0), 5, 10, 0)
+ p.offset(1, 0)
+ assert p.position == (1.0, 0.0)
+ p.offset(0, 1)
+ assert p.position == (1.0, 1.0)
+
+
+def test_region_ctor():
+ """ Test Region creation
+ """
+ apt = Circle((0, 0), 0)
+ lines = (
+ Line((0, 0), (1, 0), apt),
+ Line((1, 0), (1, 1), apt),
+ Line((1, 1), (0, 1), apt),
+ Line((0, 1), (0, 0), apt),
+ )
+ points = ((0, 0), (1, 0), (1, 1), (0, 1))
+ r = Region(lines)
+ for i, p in enumerate(lines):
+ assert r.primitives[i] == p
+
+
+def test_region_bounds():
+ """ Test region bounding box calculation
+ """
+ apt = Circle((0, 0), 0)
+ lines = (
+ Line((0, 0), (1, 0), apt),
+ Line((1, 0), (1, 1), apt),
+ Line((1, 1), (0, 1), apt),
+ Line((0, 1), (0, 0), apt),
+ )
+ r = Region(lines)
+ xbounds, ybounds = r.bounding_box
+ pytest.approx(xbounds, (0, 1))
+ pytest.approx(ybounds, (0, 1))
+
+
+def test_region_offset():
+ apt = Circle((0, 0), 0)
+ lines = (
+ Line((0, 0), (1, 0), apt),
+ Line((1, 0), (1, 1), apt),
+ Line((1, 1), (0, 1), apt),
+ Line((0, 1), (0, 0), apt),
+ )
+ r = Region(lines)
+ xlim, ylim = r.bounding_box
+ r.offset(0, 1)
+ new_xlim, new_ylim = r.bounding_box
+ pytest.approx(new_xlim, xlim)
+ pytest.approx(new_ylim, tuple([y + 1 for y in ylim]))
+
+
+def test_round_butterfly_ctor():
+ """ Test round butterfly creation
+ """
+ test_cases = (((0, 0), 3), ((0, 0), 5), ((1, 1), 7))
+ for pos, diameter in test_cases:
+ b = RoundButterfly(pos, diameter)
+ assert b.position == pos
+ assert b.diameter == diameter
+ assert b.radius == diameter / 2.0
+
+
+def test_round_butterfly_ctor_validation():
+ """ Test RoundButterfly argument validation
+ """
+ pytest.raises(TypeError, RoundButterfly, 3, 5)
+ pytest.raises(TypeError, RoundButterfly, (3, 4, 5), 5)
+
+
+def test_round_butterfly_conversion():
+ b = RoundButterfly((2.54, 25.4), 254.0, units="metric")
+
+ # No Effect
+ b.to_metric()
+ assert b.position == (2.54, 25.4)
+ assert b.diameter == (254.0)
+
+ b.to_inch()
+ assert b.position == (0.1, 1.0)
+ assert b.diameter == 10.0
+
+ # No effect
+ b.to_inch()
+ assert b.position == (0.1, 1.0)
+ assert b.diameter == 10.0
+
+ b = RoundButterfly((0.1, 1.0), 10.0, units="inch")
+
+ # No effect
+ b.to_inch()
+ assert b.position == (0.1, 1.0)
+ assert b.diameter == 10.0
+
+ b.to_metric()
+ assert b.position == (2.54, 25.4)
+ assert b.diameter == (254.0)
+
+ # No Effect
+ b.to_metric()
+ assert b.position == (2.54, 25.4)
+ assert b.diameter == (254.0)
+
+
+def test_round_butterfly_offset():
+ b = RoundButterfly((0, 0), 1)
+ b.offset(1, 0)
+ assert b.position == (1.0, 0.0)
+ b.offset(0, 1)
+ assert b.position == (1.0, 1.0)
+
+
+def test_round_butterfly_bounds():
+ """ Test RoundButterfly bounding box calculation
+ """
+ b = RoundButterfly((0, 0), 2)
+ xbounds, ybounds = b.bounding_box
+ pytest.approx(xbounds, (-1, 1))
+ pytest.approx(ybounds, (-1, 1))
+
+
+def test_square_butterfly_ctor():
+ """ Test SquareButterfly creation
+ """
+ test_cases = (((0, 0), 3), ((0, 0), 5), ((1, 1), 7))
+ for pos, side in test_cases:
+ b = SquareButterfly(pos, side)
+ assert b.position == pos
+ assert b.side == side
+
+
+def test_square_butterfly_ctor_validation():
+ """ Test SquareButterfly argument validation
+ """
+ pytest.raises(TypeError, SquareButterfly, 3, 5)
+ pytest.raises(TypeError, SquareButterfly, (3, 4, 5), 5)
+
+
+def test_square_butterfly_bounds():
+ """ Test SquareButterfly bounding box calculation
+ """
+ b = SquareButterfly((0, 0), 2)
+ xbounds, ybounds = b.bounding_box
+ pytest.approx(xbounds, (-1, 1))
+ pytest.approx(ybounds, (-1, 1))
+
+
+def test_squarebutterfly_conversion():
+ b = SquareButterfly((2.54, 25.4), 254.0, units="metric")
+
+ # No effect
+ b.to_metric()
+ assert b.position == (2.54, 25.4)
+ assert b.side == (254.0)
+
+ b.to_inch()
+ assert b.position == (0.1, 1.0)
+ assert b.side == 10.0
+
+ # No effect
+ b.to_inch()
+ assert b.position == (0.1, 1.0)
+ assert b.side == 10.0
+
+ b = SquareButterfly((0.1, 1.0), 10.0, units="inch")
+
+ # No effect
+ b.to_inch()
+ assert b.position == (0.1, 1.0)
+ assert b.side == 10.0
+
+ b.to_metric()
+ assert b.position == (2.54, 25.4)
+ assert b.side == (254.0)
+
+ # No effect
+ b.to_metric()
+ assert b.position == (2.54, 25.4)
+ assert b.side == (254.0)
+
+
+def test_square_butterfly_offset():
+ b = SquareButterfly((0, 0), 1)
+ b.offset(1, 0)
+ assert b.position == (1.0, 0.0)
+ b.offset(0, 1)
+ assert b.position == (1.0, 1.0)
+
+
+def test_donut_ctor():
+ """ Test Donut primitive creation
+ """
+ test_cases = (
+ ((0, 0), "round", 3, 5),
+ ((0, 0), "square", 5, 7),
+ ((1, 1), "hexagon", 7, 9),
+ ((2, 2), "octagon", 9, 11),
+ )
+ for pos, shape, in_d, out_d in test_cases:
+ d = Donut(pos, shape, in_d, out_d)
+ assert d.position == pos
+ assert d.shape == shape
+ assert d.inner_diameter == in_d
+ assert d.outer_diameter == out_d
+
+
+def test_donut_ctor_validation():
+ pytest.raises(TypeError, Donut, 3, "round", 5, 7)
+ pytest.raises(TypeError, Donut, (3, 4, 5), "round", 5, 7)
+ pytest.raises(ValueError, Donut, (0, 0), "triangle", 3, 5)
+ pytest.raises(ValueError, Donut, (0, 0), "round", 5, 3)
+
+
+def test_donut_bounds():
+ d = Donut((0, 0), "round", 0.0, 2.0)
+ xbounds, ybounds = d.bounding_box
+ assert xbounds == (-1.0, 1.0)
+ assert ybounds == (-1.0, 1.0)
+
+
+def test_donut_conversion():
+ d = Donut((2.54, 25.4), "round", 254.0, 2540.0, units="metric")
+
+ # No effect
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.inner_diameter == 254.0
+ assert d.outer_diameter == 2540.0
+
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.inner_diameter == 10.0
+ assert d.outer_diameter == 100.0
+
+ # No effect
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.inner_diameter == 10.0
+ assert d.outer_diameter == 100.0
+
+ d = Donut((0.1, 1.0), "round", 10.0, 100.0, units="inch")
+
+ # No effect
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.inner_diameter == 10.0
+ assert d.outer_diameter == 100.0
+
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.inner_diameter == 254.0
+ assert d.outer_diameter == 2540.0
+
+ # No effect
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.inner_diameter == 254.0
+ assert d.outer_diameter == 2540.0
+
+
+def test_donut_offset():
+ d = Donut((0, 0), "round", 1, 10)
+ d.offset(1, 0)
+ assert d.position == (1.0, 0.0)
+ d.offset(0, 1)
+ assert d.position == (1.0, 1.0)
+
+
+def test_drill_ctor():
+ """ Test drill primitive creation
+ """
+ test_cases = (((0, 0), 2), ((1, 1), 3), ((2, 2), 5))
+ for position, diameter in test_cases:
+ d = Drill(position, diameter)
+ assert d.position == position
+ assert d.diameter == diameter
+ assert d.radius == diameter / 2.0
+
+
+def test_drill_ctor_validation():
+ """ Test drill argument validation
+ """
+ pytest.raises(TypeError, Drill, 3, 5)
+ pytest.raises(TypeError, Drill, (3, 4, 5), 5)
+
+
+def test_drill_bounds():
+ d = Drill((0, 0), 2)
+ xbounds, ybounds = d.bounding_box
+ pytest.approx(xbounds, (-1, 1))
+ pytest.approx(ybounds, (-1, 1))
+ d = Drill((1, 2), 2)
+ xbounds, ybounds = d.bounding_box
+ pytest.approx(xbounds, (0, 2))
+ pytest.approx(ybounds, (1, 3))
+
+
+def test_drill_conversion():
+ d = Drill((2.54, 25.4), 254.0, units="metric")
+
+ # No effect
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.diameter == 254.0
+
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.diameter == 10.0
+
+ # No effect
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.diameter == 10.0
+
+ d = Drill((0.1, 1.0), 10.0, units="inch")
+
+ # No effect
+ d.to_inch()
+ assert d.position == (0.1, 1.0)
+ assert d.diameter == 10.0
+
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.diameter == 254.0
+
+ # No effect
+ d.to_metric()
+ assert d.position == (2.54, 25.4)
+ assert d.diameter == 254.0
+
+
+def test_drill_offset():
+ d = Drill((0, 0), 1.0)
+ d.offset(1, 0)
+ assert d.position == (1.0, 0.0)
+ d.offset(0, 1)
+ assert d.position == (1.0, 1.0)
+
+
+def test_drill_equality():
+ d = Drill((2.54, 25.4), 254.0)
+ d1 = Drill((2.54, 25.4), 254.0)
+ assert d == d1
+ d1 = Drill((2.54, 25.4), 254.2)
+ assert d != d1
+
+
+def test_slot_bounds():
+ """ Test Slot primitive bounding box calculation
+ """
+ cases = [
+ ((0, 0), (1, 1), ((-1, 2), (-1, 2))),
+ ((-1, -1), (1, 1), ((-2, 2), (-2, 2))),
+ ((1, 1), (-1, -1), ((-2, 2), (-2, 2))),
+ ((-1, 1), (1, -1), ((-2, 2), (-2, 2))),
+ ]
+
+ for start, end, expected in cases:
+ s = Slot(start, end, 2.0)
+ assert s.bounding_box == expected