Migrate to pytest (#111)

* Migrate to pytest

All tests were update to use pytest.

Tests were alse black formatted. Eventually all code
will be black formatted but need to merge some PRs first.

14 files changed, 2333 insertions, 2076 deletions

diff --git a/gerber/tests/test_am_statements.py b/gerber/tests/test_am_statements.py
index c97556a..0d100b5 100644
--- a/gerber/tests/test_am_statements.py
+++ b/gerber/tests/test_am_statements.py
@@ -3,385 +3,393 @@
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
 
-from .tests import *
+import pytest
+
 from ..am_statements import *
 from ..am_statements import inch, metric
 
 
 def test_AMPrimitive_ctor():
-    for exposure in ('on', 'off', 'ON', 'OFF'):
+    for exposure in ("on", "off", "ON", "OFF"):
         for code in (0, 1, 2, 4, 5, 6, 7, 20, 21, 22):
             p = AMPrimitive(code, exposure)
-            assert_equal(p.code, code)
-            assert_equal(p.exposure, exposure.lower())
+            assert p.code == code
+            assert p.exposure == exposure.lower()
 
 
 def test_AMPrimitive_validation():
-    assert_raises(TypeError, AMPrimitive, '1', 'off')
-    assert_raises(ValueError, AMPrimitive, 0, 'exposed')
-    assert_raises(ValueError, AMPrimitive, 3, 'off')
+    pytest.raises(TypeError, AMPrimitive, "1", "off")
+    pytest.raises(ValueError, AMPrimitive, 0, "exposed")
+    pytest.raises(ValueError, AMPrimitive, 3, "off")
 
 
 def test_AMPrimitive_conversion():
-    p = AMPrimitive(4, 'on')
-    assert_raises(NotImplementedError, p.to_inch)
-    assert_raises(NotImplementedError, p.to_metric)
+    p = AMPrimitive(4, "on")
+    pytest.raises(NotImplementedError, p.to_inch)
+    pytest.raises(NotImplementedError, p.to_metric)
 
 
 def test_AMCommentPrimitive_ctor():
-    c = AMCommentPrimitive(0, ' This is a comment *')
-    assert_equal(c.code, 0)
-    assert_equal(c.comment, 'This is a comment')
+    c = AMCommentPrimitive(0, " This is a comment *")
+    assert c.code == 0
+    assert c.comment == "This is a comment"
 
 
 def test_AMCommentPrimitive_validation():
-    assert_raises(ValueError, AMCommentPrimitive, 1, 'This is a comment')
+    pytest.raises(ValueError, AMCommentPrimitive, 1, "This is a comment")
 
 
 def test_AMCommentPrimitive_factory():
-    c = AMCommentPrimitive.from_gerber('0 Rectangle with rounded corners. *')
-    assert_equal(c.code, 0)
-    assert_equal(c.comment, 'Rectangle with rounded corners.')
+    c = AMCommentPrimitive.from_gerber("0 Rectangle with rounded corners. *")
+    assert c.code == 0
+    assert c.comment == "Rectangle with rounded corners."
 
 
 def test_AMCommentPrimitive_dump():
-    c = AMCommentPrimitive(0, 'Rectangle with rounded corners.')
-    assert_equal(c.to_gerber(), '0 Rectangle with rounded corners. *')
+    c = AMCommentPrimitive(0, "Rectangle with rounded corners.")
+    assert c.to_gerber() == "0 Rectangle with rounded corners. *"
 
 
 def test_AMCommentPrimitive_conversion():
-    c = AMCommentPrimitive(0, 'Rectangle with rounded corners.')
+    c = AMCommentPrimitive(0, "Rectangle with rounded corners.")
     ci = c
     cm = c
     ci.to_inch()
     cm.to_metric()
-    assert_equal(c, ci)
-    assert_equal(c, cm)
+    assert c == ci
+    assert c == cm
 
 
 def test_AMCommentPrimitive_string():
-    c = AMCommentPrimitive(0, 'Test Comment')
-    assert_equal(str(c), '<Aperture Macro Comment: Test Comment>')
+    c = AMCommentPrimitive(0, "Test Comment")
+    assert str(c) == "<Aperture Macro Comment: Test Comment>"
 
 
 def test_AMCirclePrimitive_ctor():
-    test_cases = ((1, 'on', 0, (0, 0)),
-                  (1, 'off', 1, (0, 1)),
-                  (1, 'on', 2.5, (0, 2)),
-                  (1, 'off', 5.0, (3, 3)))
+    test_cases = (
+        (1, "on", 0, (0, 0)),
+        (1, "off", 1, (0, 1)),
+        (1, "on", 2.5, (0, 2)),
+        (1, "off", 5.0, (3, 3)),
+    )
     for code, exposure, diameter, position in test_cases:
         c = AMCirclePrimitive(code, exposure, diameter, position)
-        assert_equal(c.code, code)
-        assert_equal(c.exposure, exposure)
-        assert_equal(c.diameter, diameter)
-        assert_equal(c.position, position)
+        assert c.code == code
+        assert c.exposure == exposure
+        assert c.diameter == diameter
+        assert c.position == position
 
 
 def test_AMCirclePrimitive_validation():
-    assert_raises(ValueError, AMCirclePrimitive, 2, 'on', 0, (0, 0))
+    pytest.raises(ValueError, AMCirclePrimitive, 2, "on", 0, (0, 0))
 
 
 def test_AMCirclePrimitive_factory():
-    c = AMCirclePrimitive.from_gerber('1,0,5,0,0*')
-    assert_equal(c.code, 1)
-    assert_equal(c.exposure, 'off')
-    assert_equal(c.diameter, 5)
-    assert_equal(c.position, (0, 0))
+    c = AMCirclePrimitive.from_gerber("1,0,5,0,0*")
+    assert c.code == 1
+    assert c.exposure == "off"
+    assert c.diameter == 5
+    assert c.position == (0, 0)
 
 
 def test_AMCirclePrimitive_dump():
-    c = AMCirclePrimitive(1, 'off', 5, (0, 0))
-    assert_equal(c.to_gerber(), '1,0,5,0,0*')
-    c = AMCirclePrimitive(1, 'on', 5, (0, 0))
-    assert_equal(c.to_gerber(), '1,1,5,0,0*')
+    c = AMCirclePrimitive(1, "off", 5, (0, 0))
+    assert c.to_gerber() == "1,0,5,0,0*"
+    c = AMCirclePrimitive(1, "on", 5, (0, 0))
+    assert c.to_gerber() == "1,1,5,0,0*"
 
 
 def test_AMCirclePrimitive_conversion():
-    c = AMCirclePrimitive(1, 'off', 25.4, (25.4, 0))
+    c = AMCirclePrimitive(1, "off", 25.4, (25.4, 0))
     c.to_inch()
-    assert_equal(c.diameter, 1)
-    assert_equal(c.position, (1, 0))
+    assert c.diameter == 1
+    assert c.position == (1, 0)
 
-    c = AMCirclePrimitive(1, 'off', 1, (1, 0))
+    c = AMCirclePrimitive(1, "off", 1, (1, 0))
     c.to_metric()
-    assert_equal(c.diameter, 25.4)
-    assert_equal(c.position, (25.4, 0))
+    assert c.diameter == 25.4
+    assert c.position == (25.4, 0)
 
 
 def test_AMVectorLinePrimitive_validation():
-    assert_raises(ValueError, AMVectorLinePrimitive,
-                  3, 'on', 0.1, (0, 0), (3.3, 5.4), 0)
+    pytest.raises(
+        ValueError, AMVectorLinePrimitive, 3, "on", 0.1, (0, 0), (3.3, 5.4), 0
+    )
 
 
 def test_AMVectorLinePrimitive_factory():
-    l = AMVectorLinePrimitive.from_gerber('20,1,0.9,0,0.45,12,0.45,0*')
-    assert_equal(l.code, 20)
-    assert_equal(l.exposure, 'on')
-    assert_equal(l.width, 0.9)
-    assert_equal(l.start, (0, 0.45))
-    assert_equal(l.end, (12, 0.45))
-    assert_equal(l.rotation, 0)
+    l = AMVectorLinePrimitive.from_gerber("20,1,0.9,0,0.45,12,0.45,0*")
+    assert l.code == 20
+    assert l.exposure == "on"
+    assert l.width == 0.9
+    assert l.start == (0, 0.45)
+    assert l.end == (12, 0.45)
+    assert l.rotation == 0
 
 
 def test_AMVectorLinePrimitive_dump():
-    l = AMVectorLinePrimitive.from_gerber('20,1,0.9,0,0.45,12,0.45,0*')
-    assert_equal(l.to_gerber(), '20,1,0.9,0.0,0.45,12.0,0.45,0.0*')
+    l = AMVectorLinePrimitive.from_gerber("20,1,0.9,0,0.45,12,0.45,0*")
+    assert l.to_gerber() == "20,1,0.9,0.0,0.45,12.0,0.45,0.0*"
 
 
 def test_AMVectorLinePrimtive_conversion():
-    l = AMVectorLinePrimitive(20, 'on', 25.4, (0, 0), (25.4, 25.4), 0)
+    l = AMVectorLinePrimitive(20, "on", 25.4, (0, 0), (25.4, 25.4), 0)
     l.to_inch()
-    assert_equal(l.width, 1)
-    assert_equal(l.start, (0, 0))
-    assert_equal(l.end, (1, 1))
+    assert l.width == 1
+    assert l.start == (0, 0)
+    assert l.end == (1, 1)
 
-    l = AMVectorLinePrimitive(20, 'on', 1, (0, 0), (1, 1), 0)
+    l = AMVectorLinePrimitive(20, "on", 1, (0, 0), (1, 1), 0)
     l.to_metric()
-    assert_equal(l.width, 25.4)
-    assert_equal(l.start, (0, 0))
-    assert_equal(l.end, (25.4, 25.4))
+    assert l.width == 25.4
+    assert l.start == (0, 0)
+    assert l.end == (25.4, 25.4)
 
 
 def test_AMOutlinePrimitive_validation():
-    assert_raises(ValueError, AMOutlinePrimitive, 7, 'on',
-                  (0, 0), [(3.3, 5.4), (4.0, 5.4), (0, 0)], 0)
-    assert_raises(ValueError, AMOutlinePrimitive, 4, 'on',
-                  (0, 0), [(3.3, 5.4), (4.0, 5.4), (0, 1)], 0)
+    pytest.raises(
+        ValueError,
+        AMOutlinePrimitive,
+        7,
+        "on",
+        (0, 0),
+        [(3.3, 5.4), (4.0, 5.4), (0, 0)],
+        0,
+    )
+    pytest.raises(
+        ValueError,
+        AMOutlinePrimitive,
+        4,
+        "on",
+        (0, 0),
+        [(3.3, 5.4), (4.0, 5.4), (0, 1)],
+        0,
+    )
 
 
 def test_AMOutlinePrimitive_factory():
-    o = AMOutlinePrimitive.from_gerber('4,1,3,0,0,3,3,3,0,0,0,0*')
-    assert_equal(o.code, 4)
-    assert_equal(o.exposure, 'on')
-    assert_equal(o.start_point, (0, 0))
-    assert_equal(o.points, [(3, 3), (3, 0), (0, 0)])
-    assert_equal(o.rotation, 0)
+    o = AMOutlinePrimitive.from_gerber("4,1,3,0,0,3,3,3,0,0,0,0*")
+    assert o.code == 4
+    assert o.exposure == "on"
+    assert o.start_point == (0, 0)
+    assert o.points == [(3, 3), (3, 0), (0, 0)]
+    assert o.rotation == 0
 
 
 def test_AMOUtlinePrimitive_dump():
-    o = AMOutlinePrimitive(4, 'on', (0, 0), [(3, 3), (3, 0), (0, 0)], 0)
+    o = AMOutlinePrimitive(4, "on", (0, 0), [(3, 3), (3, 0), (0, 0)], 0)
     # New lines don't matter for Gerber, but we insert them to make it easier to remove
     # For test purposes we can ignore them
-    assert_equal(o.to_gerber().replace('\n', ''), '4,1,3,0,0,3,3,3,0,0,0,0*')
-
-
+    assert o.to_gerber().replace("\n", "") == "4,1,3,0,0,3,3,3,0,0,0,0*"
 
 
 def test_AMOutlinePrimitive_conversion():
-    o = AMOutlinePrimitive(
-        4, 'on', (0, 0), [(25.4, 25.4), (25.4, 0), (0, 0)], 0)
+    o = AMOutlinePrimitive(4, "on", (0, 0), [(25.4, 25.4), (25.4, 0), (0, 0)], 0)
     o.to_inch()
-    assert_equal(o.start_point, (0, 0))
-    assert_equal(o.points, ((1., 1.), (1., 0.), (0., 0.)))
+    assert o.start_point == (0, 0)
+    assert o.points == ((1.0, 1.0), (1.0, 0.0), (0.0, 0.0))
 
-    o = AMOutlinePrimitive(4, 'on', (0, 0), [(1, 1), (1, 0), (0, 0)], 0)
+    o = AMOutlinePrimitive(4, "on", (0, 0), [(1, 1), (1, 0), (0, 0)], 0)
     o.to_metric()
-    assert_equal(o.start_point, (0, 0))
-    assert_equal(o.points, ((25.4, 25.4), (25.4, 0), (0, 0)))
+    assert o.start_point == (0, 0)
+    assert o.points == ((25.4, 25.4), (25.4, 0), (0, 0))
 
 
 def test_AMPolygonPrimitive_validation():
-    assert_raises(ValueError, AMPolygonPrimitive, 6, 'on', 3, (3.3, 5.4), 3, 0)
-    assert_raises(ValueError, AMPolygonPrimitive, 5, 'on', 2, (3.3, 5.4), 3, 0)
-    assert_raises(ValueError, AMPolygonPrimitive, 5, 'on', 13, (3.3, 5.4), 3, 0)
+    pytest.raises(ValueError, AMPolygonPrimitive, 6, "on", 3, (3.3, 5.4), 3, 0)
+    pytest.raises(ValueError, AMPolygonPrimitive, 5, "on", 2, (3.3, 5.4), 3, 0)
+    pytest.raises(ValueError, AMPolygonPrimitive, 5, "on", 13, (3.3, 5.4), 3, 0)
 
 
 def test_AMPolygonPrimitive_factory():
-    p = AMPolygonPrimitive.from_gerber('5,1,3,3.3,5.4,3,0')
-    assert_equal(p.code, 5)
-    assert_equal(p.exposure, 'on')
-    assert_equal(p.vertices, 3)
-    assert_equal(p.position, (3.3, 5.4))
-    assert_equal(p.diameter, 3)
-    assert_equal(p.rotation, 0)
+    p = AMPolygonPrimitive.from_gerber("5,1,3,3.3,5.4,3,0")
+    assert p.code == 5
+    assert p.exposure == "on"
+    assert p.vertices == 3
+    assert p.position == (3.3, 5.4)
+    assert p.diameter == 3
+    assert p.rotation == 0
 
 
 def test_AMPolygonPrimitive_dump():
-    p = AMPolygonPrimitive(5, 'on', 3, (3.3, 5.4), 3, 0)
-    assert_equal(p.to_gerber(), '5,1,3,3.3,5.4,3,0*')
+    p = AMPolygonPrimitive(5, "on", 3, (3.3, 5.4), 3, 0)
+    assert p.to_gerber() == "5,1,3,3.3,5.4,3,0*"
 
 
 def test_AMPolygonPrimitive_conversion():
-    p = AMPolygonPrimitive(5, 'off', 3, (25.4, 0), 25.4, 0)
+    p = AMPolygonPrimitive(5, "off", 3, (25.4, 0), 25.4, 0)
     p.to_inch()
-    assert_equal(p.diameter, 1)
-    assert_equal(p.position, (1, 0))
+    assert p.diameter == 1
+    assert p.position == (1, 0)
 
-    p = AMPolygonPrimitive(5, 'off', 3, (1, 0), 1, 0)
+    p = AMPolygonPrimitive(5, "off", 3, (1, 0), 1, 0)
     p.to_metric()
-    assert_equal(p.diameter, 25.4)
-    assert_equal(p.position, (25.4, 0))
+    assert p.diameter == 25.4
+    assert p.position == (25.4, 0)
 
 
 def test_AMMoirePrimitive_validation():
-    assert_raises(ValueError, AMMoirePrimitive, 7,
-                  (0, 0), 5.1, 0.2, 0.4, 6, 0.1, 6.1, 0)
+    pytest.raises(
+        ValueError, AMMoirePrimitive, 7, (0, 0), 5.1, 0.2, 0.4, 6, 0.1, 6.1, 0
+    )
 
 
 def test_AMMoirePrimitive_factory():
-    m = AMMoirePrimitive.from_gerber('6,0,0,5,0.5,0.5,2,0.1,6,0*')
-    assert_equal(m.code, 6)
-    assert_equal(m.position, (0, 0))
-    assert_equal(m.diameter, 5)
-    assert_equal(m.ring_thickness, 0.5)
-    assert_equal(m.gap, 0.5)
-    assert_equal(m.max_rings, 2)
-    assert_equal(m.crosshair_thickness, 0.1)
-    assert_equal(m.crosshair_length, 6)
-    assert_equal(m.rotation, 0)
+    m = AMMoirePrimitive.from_gerber("6,0,0,5,0.5,0.5,2,0.1,6,0*")
+    assert m.code == 6
+    assert m.position == (0, 0)
+    assert m.diameter == 5
+    assert m.ring_thickness == 0.5
+    assert m.gap == 0.5
+    assert m.max_rings == 2
+    assert m.crosshair_thickness == 0.1
+    assert m.crosshair_length == 6
+    assert m.rotation == 0
 
 
 def test_AMMoirePrimitive_dump():
-    m = AMMoirePrimitive.from_gerber('6,0,0,5,0.5,0.5,2,0.1,6,0*')
-    assert_equal(m.to_gerber(), '6,0,0,5.0,0.5,0.5,2,0.1,6.0,0.0*')
+    m = AMMoirePrimitive.from_gerber("6,0,0,5,0.5,0.5,2,0.1,6,0*")
+    assert m.to_gerber() == "6,0,0,5.0,0.5,0.5,2,0.1,6.0,0.0*"
 
 
 def test_AMMoirePrimitive_conversion():
     m = AMMoirePrimitive(6, (25.4, 25.4), 25.4, 25.4, 25.4, 6, 25.4, 25.4, 0)
     m.to_inch()
-    assert_equal(m.position, (1., 1.))
-    assert_equal(m.diameter, 1.)
-    assert_equal(m.ring_thickness, 1.)
-    assert_equal(m.gap, 1.)
-    assert_equal(m.crosshair_thickness, 1.)
-    assert_equal(m.crosshair_length, 1.)
+    assert m.position == (1.0, 1.0)
+    assert m.diameter == 1.0
+    assert m.ring_thickness == 1.0
+    assert m.gap == 1.0
+    assert m.crosshair_thickness == 1.0
+    assert m.crosshair_length == 1.0
 
     m = AMMoirePrimitive(6, (1, 1), 1, 1, 1, 6, 1, 1, 0)
     m.to_metric()
-    assert_equal(m.position, (25.4, 25.4))
-    assert_equal(m.diameter, 25.4)
-    assert_equal(m.ring_thickness, 25.4)
-    assert_equal(m.gap, 25.4)
-    assert_equal(m.crosshair_thickness, 25.4)
-    assert_equal(m.crosshair_length, 25.4)
+    assert m.position == (25.4, 25.4)
+    assert m.diameter == 25.4
+    assert m.ring_thickness == 25.4
+    assert m.gap == 25.4
+    assert m.crosshair_thickness == 25.4
+    assert m.crosshair_length == 25.4
 
 
 def test_AMThermalPrimitive_validation():
-    assert_raises(ValueError, AMThermalPrimitive, 8, (0.0, 0.0), 7, 5, 0.2, 0.0)
-    assert_raises(TypeError, AMThermalPrimitive, 7, (0.0, '0'), 7, 5, 0.2, 0.0)
-
-
+    pytest.raises(ValueError, AMThermalPrimitive, 8, (0.0, 0.0), 7, 5, 0.2, 0.0)
+    pytest.raises(TypeError, AMThermalPrimitive, 7, (0.0, "0"), 7, 5, 0.2, 0.0)
 
 
 def test_AMThermalPrimitive_factory():
-    t = AMThermalPrimitive.from_gerber('7,0,0,7,6,0.2,45*')
-    assert_equal(t.code, 7)
-    assert_equal(t.position, (0, 0))
-    assert_equal(t.outer_diameter, 7)
-    assert_equal(t.inner_diameter, 6)
-    assert_equal(t.gap, 0.2)
-    assert_equal(t.rotation, 45)
-
-
+    t = AMThermalPrimitive.from_gerber("7,0,0,7,6,0.2,45*")
+    assert t.code == 7
+    assert t.position == (0, 0)
+    assert t.outer_diameter == 7
+    assert t.inner_diameter == 6
+    assert t.gap == 0.2
+    assert t.rotation == 45
 
 
 def test_AMThermalPrimitive_dump():
-    t = AMThermalPrimitive.from_gerber('7,0,0,7,6,0.2,30*')
-    assert_equal(t.to_gerber(), '7,0,0,7.0,6.0,0.2,30.0*')
-
-
+    t = AMThermalPrimitive.from_gerber("7,0,0,7,6,0.2,30*")
+    assert t.to_gerber() == "7,0,0,7.0,6.0,0.2,30.0*"
 
 
 def test_AMThermalPrimitive_conversion():
     t = AMThermalPrimitive(7, (25.4, 25.4), 25.4, 25.4, 25.4, 0.0)
     t.to_inch()
-    assert_equal(t.position, (1., 1.))
-    assert_equal(t.outer_diameter, 1.)
-    assert_equal(t.inner_diameter, 1.)
-    assert_equal(t.gap, 1.)
+    assert t.position == (1.0, 1.0)
+    assert t.outer_diameter == 1.0
+    assert t.inner_diameter == 1.0
+    assert t.gap == 1.0
 
     t = AMThermalPrimitive(7, (1, 1), 1, 1, 1, 0)
     t.to_metric()
-    assert_equal(t.position, (25.4, 25.4))
-    assert_equal(t.outer_diameter, 25.4)
-    assert_equal(t.inner_diameter, 25.4)
-    assert_equal(t.gap, 25.4)
+    assert t.position == (25.4, 25.4)
+    assert t.outer_diameter == 25.4
+    assert t.inner_diameter == 25.4
+    assert t.gap == 25.4
 
 
 def test_AMCenterLinePrimitive_validation():
-    assert_raises(ValueError, AMCenterLinePrimitive,
-                  22, 1, 0.2, 0.5, (0, 0), 0)
+    pytest.raises(ValueError, AMCenterLinePrimitive, 22, 1, 0.2, 0.5, (0, 0), 0)
 
 
 def test_AMCenterLinePrimtive_factory():
-    l = AMCenterLinePrimitive.from_gerber('21,1,6.8,1.2,3.4,0.6,0*')
-    assert_equal(l.code, 21)
-    assert_equal(l.exposure, 'on')
-    assert_equal(l.width, 6.8)
-    assert_equal(l.height, 1.2)
-    assert_equal(l.center, (3.4, 0.6))
-    assert_equal(l.rotation, 0)
+    l = AMCenterLinePrimitive.from_gerber("21,1,6.8,1.2,3.4,0.6,0*")
+    assert l.code == 21
+    assert l.exposure == "on"
+    assert l.width == 6.8
+    assert l.height == 1.2
+    assert l.center == (3.4, 0.6)
+    assert l.rotation == 0
 
 
 def test_AMCenterLinePrimitive_dump():
-    l = AMCenterLinePrimitive.from_gerber('21,1,6.8,1.2,3.4,0.6,0*')
-    assert_equal(l.to_gerber(), '21,1,6.8,1.2,3.4,0.6,0.0*')
+    l = AMCenterLinePrimitive.from_gerber("21,1,6.8,1.2,3.4,0.6,0*")
+    assert l.to_gerber() == "21,1,6.8,1.2,3.4,0.6,0.0*"
 
 
 def test_AMCenterLinePrimitive_conversion():
-    l = AMCenterLinePrimitive(21, 'on', 25.4, 25.4, (25.4, 25.4), 0)
+    l = AMCenterLinePrimitive(21, "on", 25.4, 25.4, (25.4, 25.4), 0)
     l.to_inch()
-    assert_equal(l.width, 1.)
-    assert_equal(l.height, 1.)
-    assert_equal(l.center, (1., 1.))
+    assert l.width == 1.0
+    assert l.height == 1.0
+    assert l.center == (1.0, 1.0)
 
-    l = AMCenterLinePrimitive(21, 'on', 1, 1, (1, 1), 0)
+    l = AMCenterLinePrimitive(21, "on", 1, 1, (1, 1), 0)
     l.to_metric()
-    assert_equal(l.width, 25.4)
-    assert_equal(l.height, 25.4)
-    assert_equal(l.center, (25.4, 25.4))
+    assert l.width == 25.4
+    assert l.height == 25.4
+    assert l.center == (25.4, 25.4)
 
 
 def test_AMLowerLeftLinePrimitive_validation():
-    assert_raises(ValueError, AMLowerLeftLinePrimitive,
-                  23, 1, 0.2, 0.5, (0, 0), 0)
+    pytest.raises(ValueError, AMLowerLeftLinePrimitive, 23, 1, 0.2, 0.5, (0, 0), 0)
 
 
 def test_AMLowerLeftLinePrimtive_factory():
-    l = AMLowerLeftLinePrimitive.from_gerber('22,1,6.8,1.2,3.4,0.6,0*')
-    assert_equal(l.code, 22)
-    assert_equal(l.exposure, 'on')
-    assert_equal(l.width, 6.8)
-    assert_equal(l.height, 1.2)
-    assert_equal(l.lower_left, (3.4, 0.6))
-    assert_equal(l.rotation, 0)
+    l = AMLowerLeftLinePrimitive.from_gerber("22,1,6.8,1.2,3.4,0.6,0*")
+    assert l.code == 22
+    assert l.exposure == "on"
+    assert l.width == 6.8
+    assert l.height == 1.2
+    assert l.lower_left == (3.4, 0.6)
+    assert l.rotation == 0
 
 
 def test_AMLowerLeftLinePrimitive_dump():
-    l = AMLowerLeftLinePrimitive.from_gerber('22,1,6.8,1.2,3.4,0.6,0*')
-    assert_equal(l.to_gerber(), '22,1,6.8,1.2,3.4,0.6,0.0*')
+    l = AMLowerLeftLinePrimitive.from_gerber("22,1,6.8,1.2,3.4,0.6,0*")
+    assert l.to_gerber() == "22,1,6.8,1.2,3.4,0.6,0.0*"
 
 
 def test_AMLowerLeftLinePrimitive_conversion():
-    l = AMLowerLeftLinePrimitive(22, 'on', 25.4, 25.4, (25.4, 25.4), 0)
+    l = AMLowerLeftLinePrimitive(22, "on", 25.4, 25.4, (25.4, 25.4), 0)
     l.to_inch()
-    assert_equal(l.width, 1.)
-    assert_equal(l.height, 1.)
-    assert_equal(l.lower_left, (1., 1.))
+    assert l.width == 1.0
+    assert l.height == 1.0
+    assert l.lower_left == (1.0, 1.0)
 
-    l = AMLowerLeftLinePrimitive(22, 'on', 1, 1, (1, 1), 0)
+    l = AMLowerLeftLinePrimitive(22, "on", 1, 1, (1, 1), 0)
     l.to_metric()
-    assert_equal(l.width, 25.4)
-    assert_equal(l.height, 25.4)
-    assert_equal(l.lower_left, (25.4, 25.4))
+    assert l.width == 25.4
+    assert l.height == 25.4
+    assert l.lower_left == (25.4, 25.4)
 
 
 def test_AMUnsupportPrimitive():
-    u = AMUnsupportPrimitive.from_gerber('Test')
-    assert_equal(u.primitive, 'Test')
-    u = AMUnsupportPrimitive('Test')
-    assert_equal(u.to_gerber(), 'Test')
+    u = AMUnsupportPrimitive.from_gerber("Test")
+    assert u.primitive == "Test"
+    u = AMUnsupportPrimitive("Test")
+    assert u.to_gerber() == "Test"
 
 
 def test_AMUnsupportPrimitive_smoketest():
-    u = AMUnsupportPrimitive.from_gerber('Test')
+    u = AMUnsupportPrimitive.from_gerber("Test")
     u.to_inch()
     u.to_metric()
 
 
 def test_inch():
-    assert_equal(inch(25.4), 1)
+    assert inch(25.4) == 1
 
 
 def test_metric():
-    assert_equal(metric(1), 25.4)
+    assert metric(1) == 25.4
diff --git a/gerber/tests/test_cairo_backend.py b/gerber/tests/test_cairo_backend.py
index d5ce4ed..51007a9 100644
--- a/gerber/tests/test_cairo_backend.py
+++ b/gerber/tests/test_cairo_backend.py
@@ -8,63 +8,87 @@ import tempfile
 
 from ..render.cairo_backend import GerberCairoContext
 from ..rs274x import read
-from .tests import *
-from nose.tools import assert_tuple_equal
+
 
 def _DISABLED_test_render_two_boxes():
     """Umaco exapmle of two boxes"""
-    _test_render('resources/example_two_square_boxes.gbr', 'golden/example_two_square_boxes.png')
+    _test_render(
+        "resources/example_two_square_boxes.gbr", "golden/example_two_square_boxes.png"
+    )
 
 
 def _DISABLED_test_render_single_quadrant():
     """Umaco exapmle of a single quadrant arc"""
-    _test_render('resources/example_single_quadrant.gbr', 'golden/example_single_quadrant.png')
+    _test_render(
+        "resources/example_single_quadrant.gbr", "golden/example_single_quadrant.png"
+    )
 
 
-def  _DISABLED_test_render_simple_contour():
+def _DISABLED_test_render_simple_contour():
     """Umaco exapmle of a simple arrow-shaped contour"""
-    gerber = _test_render('resources/example_simple_contour.gbr', 'golden/example_simple_contour.png')
+    gerber = _test_render(
+        "resources/example_simple_contour.gbr", "golden/example_simple_contour.png"
+    )
 
     # Check the resulting dimensions
-    assert_tuple_equal(((2.0, 11.0), (1.0, 9.0)), gerber.bounding_box)
+    assert ((2.0, 11.0), (1.0, 9.0)) == gerber.bounding_box
 
 
 def _DISABLED_test_render_single_contour_1():
     """Umaco example of a single contour
 
     The resulting image for this test is used by other tests because they must generate the same output."""
-    _test_render('resources/example_single_contour_1.gbr', 'golden/example_single_contour.png')
+    _test_render(
+        "resources/example_single_contour_1.gbr", "golden/example_single_contour.png"
+    )
 
 
 def _DISABLED_test_render_single_contour_2():
     """Umaco exapmle of a single contour, alternate contour end order
 
     The resulting image for this test is used by other tests because they must generate the same output."""
-    _test_render('resources/example_single_contour_2.gbr', 'golden/example_single_contour.png')
+    _test_render(
+        "resources/example_single_contour_2.gbr", "golden/example_single_contour.png"
+    )
 
 
 def _DISABLED_test_render_single_contour_3():
     """Umaco exapmle of a single contour with extra line"""
-    _test_render('resources/example_single_contour_3.gbr', 'golden/example_single_contour_3.png')
+    _test_render(
+        "resources/example_single_contour_3.gbr", "golden/example_single_contour_3.png"
+    )
 
 
-def  _DISABLED_test_render_not_overlapping_contour():
+def _DISABLED_test_render_not_overlapping_contour():
     """Umaco example of D02 staring a second contour"""
-    _test_render('resources/example_not_overlapping_contour.gbr', 'golden/example_not_overlapping_contour.png')
+    _test_render(
+        "resources/example_not_overlapping_contour.gbr",
+        "golden/example_not_overlapping_contour.png",
+    )
+
 
-def  _DISABLED_test_render_not_overlapping_touching():
+def _DISABLED_test_render_not_overlapping_touching():
     """Umaco example of D02 staring a second contour"""
-    _test_render('resources/example_not_overlapping_touching.gbr', 'golden/example_not_overlapping_touching.png')
+    _test_render(
+        "resources/example_not_overlapping_touching.gbr",
+        "golden/example_not_overlapping_touching.png",
+    )
 
 
 def test_render_overlapping_touching():
     """Umaco example of D02 staring a second contour"""
-    _test_render('resources/example_overlapping_touching.gbr', 'golden/example_overlapping_touching.png')
+    _test_render(
+        "resources/example_overlapping_touching.gbr",
+        "golden/example_overlapping_touching.png",
+    )
 
 
 def test_render_overlapping_contour():
     """Umaco example of D02 staring a second contour"""
-    _test_render('resources/example_overlapping_contour.gbr', 'golden/example_overlapping_contour.png')
+    _test_render(
+        "resources/example_overlapping_contour.gbr",
+        "golden/example_overlapping_contour.png",
+    )
 
 
 def _DISABLED_test_render_level_holes():
@@ -72,82 +96,107 @@ def _DISABLED_test_render_level_holes():
 
     # TODO This is clearly rendering wrong. I'm temporarily checking this in because there are more
     # rendering fixes in the related repository that may resolve these.
-    _test_render('resources/example_level_holes.gbr', 'golden/example_overlapping_contour.png')
+    _test_render(
+        "resources/example_level_holes.gbr", "golden/example_overlapping_contour.png"
+    )
 
 
 def _DISABLED_test_render_cutin():
     """Umaco example of using a cutin"""
 
     # TODO This is clearly rendering wrong.
-    _test_render('resources/example_cutin.gbr', 'golden/example_cutin.png', '/Users/ham/Desktop/cutin.png')
+    _test_render(
+        "resources/example_cutin.gbr",
+        "golden/example_cutin.png",
+        "/Users/ham/Desktop/cutin.png",
+    )
 
 
-def  _DISABLED_test_render_fully_coincident():
+def _DISABLED_test_render_fully_coincident():
     """Umaco example of coincident lines rendering two contours"""
 
-    _test_render('resources/example_fully_coincident.gbr', 'golden/example_fully_coincident.png')
+    _test_render(
+        "resources/example_fully_coincident.gbr", "golden/example_fully_coincident.png"
+    )
 
 
-def  _DISABLED_test_render_coincident_hole():
+def _DISABLED_test_render_coincident_hole():
     """Umaco example of coincident lines rendering a hole in the contour"""
 
-    _test_render('resources/example_coincident_hole.gbr', 'golden/example_coincident_hole.png')
+    _test_render(
+        "resources/example_coincident_hole.gbr", "golden/example_coincident_hole.png"
+    )
 
 
 def test_render_cutin_multiple():
     """Umaco example of a region with multiple cutins"""
 
-    _test_render('resources/example_cutin_multiple.gbr', 'golden/example_cutin_multiple.png')
+    _test_render(
+        "resources/example_cutin_multiple.gbr", "golden/example_cutin_multiple.png"
+    )
 
 
 def _DISABLED_test_flash_circle():
     """Umaco example a simple circular flash with and without a hole"""
 
-    _test_render('resources/example_flash_circle.gbr', 'golden/example_flash_circle.png',
-                 '/Users/ham/Desktop/flashcircle.png')
+    _test_render(
+        "resources/example_flash_circle.gbr",
+        "golden/example_flash_circle.png",
+        "/Users/ham/Desktop/flashcircle.png",
+    )
 
 
 def _DISABLED_test_flash_rectangle():
     """Umaco example a simple rectangular flash with and without a hole"""
 
-    _test_render('resources/example_flash_rectangle.gbr', 'golden/example_flash_rectangle.png')
+    _test_render(
+        "resources/example_flash_rectangle.gbr", "golden/example_flash_rectangle.png"
+    )
 
 
 def _DISABLED_test_flash_obround():
     """Umaco example a simple obround flash with and without a hole"""
 
-    _test_render('resources/example_flash_obround.gbr', 'golden/example_flash_obround.png')
+    _test_render(
+        "resources/example_flash_obround.gbr", "golden/example_flash_obround.png"
+    )
 
 
 def _DISABLED_test_flash_polygon():
     """Umaco example a simple polygon flash with and without a hole"""
 
-    _test_render('resources/example_flash_polygon.gbr', 'golden/example_flash_polygon.png')
+    _test_render(
+        "resources/example_flash_polygon.gbr", "golden/example_flash_polygon.png"
+    )
 
 
 def _DISABLED_test_holes_dont_clear():
     """Umaco example that an aperture with a hole does not clear the area"""
 
-    _test_render('resources/example_holes_dont_clear.gbr', 'golden/example_holes_dont_clear.png')
+    _test_render(
+        "resources/example_holes_dont_clear.gbr", "golden/example_holes_dont_clear.png"
+    )
 
 
 def _DISABLED_test_render_am_exposure_modifier():
     """Umaco example that an aperture macro with a hole does not clear the area"""
 
-    _test_render('resources/example_am_exposure_modifier.gbr', 'golden/example_am_exposure_modifier.png')
+    _test_render(
+        "resources/example_am_exposure_modifier.gbr",
+        "golden/example_am_exposure_modifier.png",
+    )
 
 
 def test_render_svg_simple_contour():
     """Example of rendering to an SVG file"""
-    _test_simple_render_svg('resources/example_simple_contour.gbr')
+    _test_simple_render_svg("resources/example_simple_contour.gbr")
 
 
 def _resolve_path(path):
-    return os.path.join(os.path.dirname(__file__),
-                                path)
+    return os.path.join(os.path.dirname(__file__), path)
 
 
-def _test_render(gerber_path, png_expected_path, create_output_path = None):
+def _test_render(gerber_path, png_expected_path, create_output_path=None):
     """Render the gerber file and compare to the expected PNG output.
 
     Parameters
@@ -176,21 +225,24 @@ def _test_render(gerber_path, png_expected_path, create_output_path = None):
 
     # If we want to write the file bytes, do it now. This happens
     if create_output_path:
-        with open(create_output_path, 'wb') as out_file:
+        with open(create_output_path, "wb") as out_file:
             out_file.write(actual_bytes)
         # Creating the output is dangerous - it could overwrite the expected result.
         # So if we are creating the output, we make the test fail on purpose so you
         # won't forget to disable this
-        assert_false(True, 'Test created the output %s. This needs to be disabled to make sure the test behaves correctly' % (create_output_path,))
+        assert not True, (
+            "Test created the output %s. This needs to be disabled to make sure the test behaves correctly"
+            % (create_output_path,)
+        )
 
     # Read the expected PNG file
 
-    with open(png_expected_path, 'rb') as expected_file:
+    with open(png_expected_path, "rb") as expected_file:
         expected_bytes = expected_file.read()
 
     # Don't directly use assert_equal otherwise any failure pollutes the test results
-    equal = (expected_bytes == actual_bytes)
-    assert_true(equal)
+    equal = expected_bytes == actual_bytes
+    assert equal
 
     return gerber
 
@@ -214,14 +266,14 @@ def _test_simple_render_svg(gerber_path):
     gerber.render(ctx)
 
     temp_dir = tempfile.mkdtemp()
-    svg_temp_path = os.path.join(temp_dir, 'output.svg')
+    svg_temp_path = os.path.join(temp_dir, "output.svg")
 
-    assert_false(os.path.exists(svg_temp_path))
+    assert not os.path.exists(svg_temp_path)
     ctx.dump(svg_temp_path)
-    assert_true(os.path.exists(svg_temp_path))
+    assert os.path.exists(svg_temp_path)
 
-    with open(svg_temp_path, 'r') as expected_file:
+    with open(svg_temp_path, "r") as expected_file:
         expected_bytes = expected_file.read()
-    assert_equal(expected_bytes[:38], '<?xml version="1.0" encoding="UTF-8"?>')
+    assert expected_bytes[:38] == '<?xml version="1.0" encoding="UTF-8"?>'
 
     shutil.rmtree(temp_dir)
diff --git a/gerber/tests/test_cam.py b/gerber/tests/test_cam.py
index ba5e99d..8a71a32 100644
--- a/gerber/tests/test_cam.py
+++ b/gerber/tests/test_cam.py
@@ -3,56 +3,57 @@
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
 
+import pytest
+
 from ..cam import CamFile, FileSettings
-from .tests import *
 
 
 def test_filesettings_defaults():
     """ Test FileSettings default values
     """
     fs = FileSettings()
-    assert_equal(fs.format, (2, 5))
-    assert_equal(fs.notation, 'absolute')
-    assert_equal(fs.zero_suppression, 'trailing')
-    assert_equal(fs.units, 'inch')
+    assert fs.format == (2, 5)
+    assert fs.notation == "absolute"
+    assert fs.zero_suppression == "trailing"
+    assert fs.units == "inch"
 
 
 def test_filesettings_dict():
     """ Test FileSettings Dict
     """
     fs = FileSettings()
-    assert_equal(fs['format'], (2, 5))
-    assert_equal(fs['notation'], 'absolute')
-    assert_equal(fs['zero_suppression'], 'trailing')
-    assert_equal(fs['units'], 'inch')
+    assert fs["format"] == (2, 5)
+    assert fs["notation"] == "absolute"
+    assert fs["zero_suppression"] == "trailing"
+    assert fs["units"] == "inch"
 
 
 def test_filesettings_assign():
     """ Test FileSettings attribute assignment
     """
     fs = FileSettings()
-    fs.units = 'test1'
-    fs.notation = 'test2'
-    fs.zero_suppression = 'test3'
-    fs.format = 'test4'
-    assert_equal(fs.units, 'test1')
-    assert_equal(fs.notation, 'test2')
-    assert_equal(fs.zero_suppression, 'test3')
-    assert_equal(fs.format, 'test4')
+    fs.units = "test1"
+    fs.notation = "test2"
+    fs.zero_suppression = "test3"
+    fs.format = "test4"
+    assert fs.units == "test1"
+    assert fs.notation == "test2"
+    assert fs.zero_suppression == "test3"
+    assert fs.format == "test4"
 
 
 def test_filesettings_dict_assign():
     """ Test FileSettings dict-style attribute assignment
     """
     fs = FileSettings()
-    fs['units'] = 'metric'
-    fs['notation'] = 'incremental'
-    fs['zero_suppression'] = 'leading'
-    fs['format'] = (1, 2)
-    assert_equal(fs.units, 'metric')
-    assert_equal(fs.notation, 'incremental')
-    assert_equal(fs.zero_suppression, 'leading')
-    assert_equal(fs.format, (1, 2))
+    fs["units"] = "metric"
+    fs["notation"] = "incremental"
+    fs["zero_suppression"] = "leading"
+    fs["format"] = (1, 2)
+    assert fs.units == "metric"
+    assert fs.notation == "incremental"
+    assert fs.zero_suppression == "leading"
+    assert fs.format == (1, 2)
 
 
 def test_camfile_init():
@@ -65,7 +66,7 @@ def test_camfile_settings():
     """ Test CamFile Default Settings
     """
     cf = CamFile()
-    assert_equal(cf.settings, FileSettings())
+    assert cf.settings == FileSettings()
 
 
 def test_bounds_override_smoketest():
@@ -77,73 +78,74 @@ def test_zeros():
     """ Test zero/zero_suppression interaction
     """
     fs = FileSettings()
-    assert_equal(fs.zero_suppression, 'trailing')
-    assert_equal(fs.zeros, 'leading')
+    assert fs.zero_suppression == "trailing"
+    assert fs.zeros == "leading"
 
-    fs['zero_suppression'] = 'leading'
-    assert_equal(fs.zero_suppression, 'leading')
-    assert_equal(fs.zeros, 'trailing')
+    fs["zero_suppression"] = "leading"
+    assert fs.zero_suppression == "leading"
+    assert fs.zeros == "trailing"
 
-    fs.zero_suppression = 'trailing'
-    assert_equal(fs.zero_suppression, 'trailing')
-    assert_equal(fs.zeros, 'leading')
+    fs.zero_suppression = "trailing"
+    assert fs.zero_suppression == "trailing"
+    assert fs.zeros == "leading"
 
-    fs['zeros'] = 'trailing'
-    assert_equal(fs.zeros, 'trailing')
-    assert_equal(fs.zero_suppression, 'leading')
+    fs["zeros"] = "trailing"
+    assert fs.zeros == "trailing"
+    assert fs.zero_suppression == "leading"
 
-    fs.zeros = 'leading'
-    assert_equal(fs.zeros, 'leading')
-    assert_equal(fs.zero_suppression, 'trailing')
+    fs.zeros = "leading"
+    assert fs.zeros == "leading"
+    assert fs.zero_suppression == "trailing"
 
-    fs = FileSettings(zeros='leading')
-    assert_equal(fs.zeros, 'leading')
-    assert_equal(fs.zero_suppression, 'trailing')
+    fs = FileSettings(zeros="leading")
+    assert fs.zeros == "leading"
+    assert fs.zero_suppression == "trailing"
 
-    fs = FileSettings(zero_suppression='leading')
-    assert_equal(fs.zeros, 'trailing')
-    assert_equal(fs.zero_suppression, 'leading')
+    fs = FileSettings(zero_suppression="leading")
+    assert fs.zeros == "trailing"
+    assert fs.zero_suppression == "leading"
 
-    fs = FileSettings(zeros='leading', zero_suppression='trailing')
-    assert_equal(fs.zeros, 'leading')
-    assert_equal(fs.zero_suppression, 'trailing')
+    fs = FileSettings(zeros="leading", zero_suppression="trailing")
+    assert fs.zeros == "leading"
+    assert fs.zero_suppression == "trailing"
 
-    fs = FileSettings(zeros='trailing', zero_suppression='leading')
-    assert_equal(fs.zeros, 'trailing')
-    assert_equal(fs.zero_suppression, 'leading')
+    fs = FileSettings(zeros="trailing", zero_suppression="leading")
+    assert fs.zeros == "trailing"
+    assert fs.zero_suppression == "leading"
 
 
 def test_filesettings_validation():
     """ Test FileSettings constructor argument validation
     """
     # absolute-ish is not a valid notation
-    assert_raises(ValueError, FileSettings, 'absolute-ish',
-                  'inch', None, (2, 5), None)
+    pytest.raises(ValueError, FileSettings, "absolute-ish", "inch", None, (2, 5), None)
 
     # degrees kelvin isn't a valid unit for a CAM file
-    assert_raises(ValueError, FileSettings, 'absolute',
-                  'degrees kelvin', None, (2, 5), None)
+    pytest.raises(
+        ValueError, FileSettings, "absolute", "degrees kelvin", None, (2, 5), None
+    )
 
-    assert_raises(ValueError, FileSettings, 'absolute',
-                  'inch', 'leading', (2, 5), 'leading')
+    pytest.raises(
+        ValueError, FileSettings, "absolute", "inch", "leading", (2, 5), "leading"
+    )
 
     # Technnically this should be an error, but Eangle files often do this incorrectly so we
     # allow it
-    #assert_raises(ValueError, FileSettings, 'absolute',
+    # pytest.raises(ValueError, FileSettings, 'absolute',
     #              'inch', 'following', (2, 5), None)
 
-    assert_raises(ValueError, FileSettings, 'absolute',
-                  'inch', None, (2, 5), 'following')
-    assert_raises(ValueError, FileSettings, 'absolute',
-                  'inch', None, (2, 5, 6), None)
+    pytest.raises(
+        ValueError, FileSettings, "absolute", "inch", None, (2, 5), "following"
+    )
+    pytest.raises(ValueError, FileSettings, "absolute", "inch", None, (2, 5, 6), None)
 
 
 def test_key_validation():
     fs = FileSettings()
-    assert_raises(KeyError, fs.__getitem__, 'octopus')
-    assert_raises(KeyError, fs.__setitem__, 'octopus', 'do not care')
-    assert_raises(ValueError, fs.__setitem__, 'notation', 'absolute-ish')
-    assert_raises(ValueError, fs.__setitem__, 'units', 'degrees kelvin')
-    assert_raises(ValueError, fs.__setitem__, 'zero_suppression', 'following')
-    assert_raises(ValueError, fs.__setitem__, 'zeros', 'following')
-    assert_raises(ValueError, fs.__setitem__, 'format', (2, 5, 6))
+    pytest.raises(KeyError, fs.__getitem__, "octopus")
+    pytest.raises(KeyError, fs.__setitem__, "octopus", "do not care")
+    pytest.raises(ValueError, fs.__setitem__, "notation", "absolute-ish")
+    pytest.raises(ValueError, fs.__setitem__, "units", "degrees kelvin")
+    pytest.raises(ValueError, fs.__setitem__, "zero_suppression", "following")
+    pytest.raises(ValueError, fs.__setitem__, "zeros", "following")
+    pytest.raises(ValueError, fs.__setitem__, "format", (2, 5, 6))
diff --git a/gerber/tests/test_common.py b/gerber/tests/test_common.py
index 0224c48..a6b1264 100644
--- a/gerber/tests/test_common.py
+++ b/gerber/tests/test_common.py
@@ -6,15 +6,12 @@ from ..exceptions import ParseError
 from ..common import read, loads
 from ..excellon import ExcellonFile
 from ..rs274x import GerberFile
-from .tests import *
-
 import os
+import pytest
 
 
-NCDRILL_FILE = os.path.join(os.path.dirname(__file__),
-                            'resources/ncdrill.DRD')
-TOP_COPPER_FILE = os.path.join(os.path.dirname(__file__),
-                               'resources/top_copper.GTL')
+NCDRILL_FILE = os.path.join(os.path.dirname(__file__), "resources/ncdrill.DRD")
+TOP_COPPER_FILE = os.path.join(os.path.dirname(__file__), "resources/top_copper.GTL")
 
 
 def test_file_type_detection():
@@ -22,20 +19,20 @@ def test_file_type_detection():
     """
     ncdrill = read(NCDRILL_FILE)
     top_copper = read(TOP_COPPER_FILE)
-    assert_true(isinstance(ncdrill, ExcellonFile))
-    assert_true(isinstance(top_copper, GerberFile))
+    assert isinstance(ncdrill, ExcellonFile)
+    assert isinstance(top_copper, GerberFile)
 
 
 def test_load_from_string():
-    with open(NCDRILL_FILE, 'rU') as f:
+    with open(NCDRILL_FILE, "rU") as f:
         ncdrill = loads(f.read())
-    with open(TOP_COPPER_FILE, 'rU') as f:
+    with open(TOP_COPPER_FILE, "rU") as f:
         top_copper = loads(f.read())
-    assert_true(isinstance(ncdrill, ExcellonFile))
-    assert_true(isinstance(top_copper, GerberFile))
+    assert isinstance(ncdrill, ExcellonFile)
+    assert isinstance(top_copper, GerberFile)
 
 
 def test_file_type_validation():
     """ Test file format validation
     """
-    assert_raises(ParseError, read, __file__)
+    pytest.raises(ParseError, read, __file__)
diff --git a/gerber/tests/test_excellon.py b/gerber/tests/test_excellon.py
index d17791c..d6e83cc 100644
--- a/gerber/tests/test_excellon.py
+++ b/gerber/tests/test_excellon.py
@@ -3,16 +3,15 @@
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
 import os
+import pytest
 
 from ..cam import FileSettings
 from ..excellon import read, detect_excellon_format, ExcellonFile, ExcellonParser
 from ..excellon import DrillHit, DrillSlot
 from ..excellon_statements import ExcellonTool, RouteModeStmt
-from .tests import *
 
 
-NCDRILL_FILE = os.path.join(os.path.dirname(__file__),
-                            'resources/ncdrill.DRD')
+NCDRILL_FILE = os.path.join(os.path.dirname(__file__), "resources/ncdrill.DRD")
 
 
 def test_format_detection():
@@ -21,320 +20,327 @@ def test_format_detection():
     with open(NCDRILL_FILE, "rU") as f:
         data = f.read()
     settings = detect_excellon_format(data)
-    assert_equal(settings['format'], (2, 4))
-    assert_equal(settings['zeros'], 'trailing')
+    assert settings["format"] == (2, 4)
+    assert settings["zeros"] == "trailing"
 
     settings = detect_excellon_format(filename=NCDRILL_FILE)
-    assert_equal(settings['format'], (2, 4))
-    assert_equal(settings['zeros'], 'trailing')
+    assert settings["format"] == (2, 4)
+    assert settings["zeros"] == "trailing"
 
 
 def test_read():
     ncdrill = read(NCDRILL_FILE)
-    assert(isinstance(ncdrill, ExcellonFile))
+    assert isinstance(ncdrill, ExcellonFile)
 
 
 def test_write():
     ncdrill = read(NCDRILL_FILE)
-    ncdrill.write('test.ncd')
+    ncdrill.write("test.ncd")
     with open(NCDRILL_FILE, "rU") as src:
         srclines = src.readlines()
-    with open('test.ncd', "rU") as res:
+    with open("test.ncd", "rU") as res:
         for idx, line in enumerate(res):
-            assert_equal(line.strip(), srclines[idx].strip())
-    os.remove('test.ncd')
+            assert line.strip() == srclines[idx].strip()
+    os.remove("test.ncd")
 
 
 def test_read_settings():
     ncdrill = read(NCDRILL_FILE)
-    assert_equal(ncdrill.settings['format'], (2, 4))
-    assert_equal(ncdrill.settings['zeros'], 'trailing')
+    assert ncdrill.settings["format"] == (2, 4)
+    assert ncdrill.settings["zeros"] == "trailing"
 
 
 def test_bounding_box():
     ncdrill = read(NCDRILL_FILE)
     xbound, ybound = ncdrill.bounding_box
-    assert_array_almost_equal(xbound, (0.1300, 2.1430))
-    assert_array_almost_equal(ybound, (0.3946, 1.7164))
+    pytest.approx(xbound, (0.1300, 2.1430))
+    pytest.approx(ybound, (0.3946, 1.7164))
 
 
 def test_report():
     ncdrill = read(NCDRILL_FILE)
     rprt = ncdrill.report()
 
+
 def test_conversion():
     import copy
+
     ncdrill = read(NCDRILL_FILE)
-    assert_equal(ncdrill.settings.units, 'inch')
+    assert ncdrill.settings.units == "inch"
     ncdrill_inch = copy.deepcopy(ncdrill)
 
     ncdrill.to_metric()
-    assert_equal(ncdrill.settings.units, 'metric')
+    assert ncdrill.settings.units == "metric"
     for tool in iter(ncdrill_inch.tools.values()):
         tool.to_metric()
 
     for statement in ncdrill_inch.statements:
         statement.to_metric()
 
-    for m_tool, i_tool in zip(iter(ncdrill.tools.values()),
-                              iter(ncdrill_inch.tools.values())):
-        assert_equal(i_tool, m_tool)
+    for m_tool, i_tool in zip(
+        iter(ncdrill.tools.values()), iter(ncdrill_inch.tools.values())
+    ):
+        assert i_tool == m_tool
 
     for m, i in zip(ncdrill.primitives, ncdrill_inch.primitives):
 
-        assert_equal(m.position, i.position, '%s not equal to %s' % (m, i))
-        assert_equal(m.diameter, i.diameter, '%s not equal to %s' % (m, i))
+        assert m.position == i.position, "%s not equal to %s" % (m, i)
+        assert m.diameter == i.diameter, "%s not equal to %s" % (m, i)
 
 
 def test_parser_hole_count():
     settings = FileSettings(**detect_excellon_format(NCDRILL_FILE))
     p = ExcellonParser(settings)
     p.parse(NCDRILL_FILE)
-    assert_equal(p.hole_count, 36)
+    assert p.hole_count == 36
 
 
 def test_parser_hole_sizes():
     settings = FileSettings(**detect_excellon_format(NCDRILL_FILE))
     p = ExcellonParser(settings)
     p.parse(NCDRILL_FILE)
-    assert_equal(p.hole_sizes, [0.0236, 0.0354, 0.04, 0.126, 0.128])
+    assert p.hole_sizes == [0.0236, 0.0354, 0.04, 0.126, 0.128]
 
 
 def test_parse_whitespace():
     p = ExcellonParser(FileSettings())
-    assert_equal(p._parse_line('         '), None)
+    assert p._parse_line("         ") == None
 
 
 def test_parse_comment():
     p = ExcellonParser(FileSettings())
-    p._parse_line(';A comment')
-    assert_equal(p.statements[0].comment, 'A comment')
+    p._parse_line(";A comment")
+    assert p.statements[0].comment == "A comment"
 
 
 def test_parse_format_comment():
     p = ExcellonParser(FileSettings())
-    p._parse_line('; FILE_FORMAT=9:9 ')
-    assert_equal(p.format, (9, 9))
+    p._parse_line("; FILE_FORMAT=9:9 ")
+    assert p.format == (9, 9)
 
 
 def test_parse_header():
     p = ExcellonParser(FileSettings())
-    p._parse_line('M48   ')
-    assert_equal(p.state, 'HEADER')
-    p._parse_line('M95   ')
-    assert_equal(p.state, 'DRILL')
+    p._parse_line("M48   ")
+    assert p.state == "HEADER"
+    p._parse_line("M95   ")
+    assert p.state == "DRILL"
 
 
 def test_parse_rout():
     p = ExcellonParser(FileSettings())
-    p._parse_line('G00X040944Y019842')
-    assert_equal(p.state, 'ROUT')
-    p._parse_line('G05 ')
-    assert_equal(p.state, 'DRILL')
+    p._parse_line("G00X040944Y019842")
+    assert p.state == "ROUT"
+    p._parse_line("G05 ")
+    assert p.state == "DRILL"
 
 
 def test_parse_version():
     p = ExcellonParser(FileSettings())
-    p._parse_line('VER,1  ')
-    assert_equal(p.statements[0].version, 1)
-    p._parse_line('VER,2  ')
-    assert_equal(p.statements[1].version, 2)
+    p._parse_line("VER,1  ")
+    assert p.statements[0].version == 1
+    p._parse_line("VER,2  ")
+    assert p.statements[1].version == 2
 
 
 def test_parse_format():
     p = ExcellonParser(FileSettings())
-    p._parse_line('FMAT,1  ')
-    assert_equal(p.statements[0].format, 1)
-    p._parse_line('FMAT,2  ')
-    assert_equal(p.statements[1].format, 2)
+    p._parse_line("FMAT,1  ")
+    assert p.statements[0].format == 1
+    p._parse_line("FMAT,2  ")
+    assert p.statements[1].format == 2
 
 
 def test_parse_units():
-    settings = FileSettings(units='inch', zeros='trailing')
+    settings = FileSettings(units="inch", zeros="trailing")
     p = ExcellonParser(settings)
-    p._parse_line(';METRIC,LZ')
-    assert_equal(p.units, 'inch')
-    assert_equal(p.zeros, 'trailing')
-    p._parse_line('METRIC,LZ')
-    assert_equal(p.units, 'metric')
-    assert_equal(p.zeros, 'leading')
+    p._parse_line(";METRIC,LZ")
+    assert p.units == "inch"
+    assert p.zeros == "trailing"
+    p._parse_line("METRIC,LZ")
+    assert p.units == "metric"
+    assert p.zeros == "leading"
 
 
 def test_parse_incremental_mode():
-    settings = FileSettings(units='inch', zeros='trailing')
+    settings = FileSettings(units="inch", zeros="trailing")
     p = ExcellonParser(settings)
-    assert_equal(p.notation, 'absolute')
-    p._parse_line('ICI,ON  ')
-    assert_equal(p.notation, 'incremental')
-    p._parse_line('ICI,OFF  ')
-    assert_equal(p.notation, 'absolute')
+    assert p.notation == "absolute"
+    p._parse_line("ICI,ON  ")
+    assert p.notation == "incremental"
+    p._parse_line("ICI,OFF  ")
+    assert p.notation == "absolute"
 
 
 def test_parse_absolute_mode():
-    settings = FileSettings(units='inch', zeros='trailing')
+    settings = FileSettings(units="inch", zeros="trailing")
     p = ExcellonParser(settings)
-    assert_equal(p.notation, 'absolute')
-    p._parse_line('ICI,ON  ')
-    assert_equal(p.notation, 'incremental')
-    p._parse_line('G90  ')
-    assert_equal(p.notation, 'absolute')
+    assert p.notation == "absolute"
+    p._parse_line("ICI,ON  ")
+    assert p.notation == "incremental"
+    p._parse_line("G90  ")
+    assert p.notation == "absolute"
 
 
 def test_parse_repeat_hole():
     p = ExcellonParser(FileSettings())
     p.active_tool = ExcellonTool(FileSettings(), number=8)
-    p._parse_line('R03X1.5Y1.5')
-    assert_equal(p.statements[0].count, 3)
+    p._parse_line("R03X1.5Y1.5")
+    assert p.statements[0].count == 3
 
 
 def test_parse_incremental_position():
-    p = ExcellonParser(FileSettings(notation='incremental'))
-    p._parse_line('X01Y01')
-    p._parse_line('X01Y01')
-    assert_equal(p.pos, [2., 2.])
+    p = ExcellonParser(FileSettings(notation="incremental"))
+    p._parse_line("X01Y01")
+    p._parse_line("X01Y01")
+    assert p.pos == [2.0, 2.0]
 
 
 def test_parse_unknown():
     p = ExcellonParser(FileSettings())
-    p._parse_line('Not A Valid Statement')
-    assert_equal(p.statements[0].stmt, 'Not A Valid Statement')
+    p._parse_line("Not A Valid Statement")
+    assert p.statements[0].stmt == "Not A Valid Statement"
+
 
 def test_drill_hit_units_conversion():
     """ Test unit conversion for drill hits
     """
     # Inch hit
-    settings = FileSettings(units='inch')
+    settings = FileSettings(units="inch")
     tool = ExcellonTool(settings, diameter=1.0)
     hit = DrillHit(tool, (1.0, 1.0))
 
-    assert_equal(hit.tool.settings.units, 'inch')
-    assert_equal(hit.tool.diameter, 1.0)
-    assert_equal(hit.position, (1.0, 1.0))
+    assert hit.tool.settings.units == "inch"
+    assert hit.tool.diameter == 1.0
+    assert hit.position == (1.0, 1.0)
 
     # No Effect
     hit.to_inch()
 
-    assert_equal(hit.tool.settings.units, 'inch')
-    assert_equal(hit.tool.diameter, 1.0)
-    assert_equal(hit.position, (1.0, 1.0))
+    assert hit.tool.settings.units == "inch"
+    assert hit.tool.diameter == 1.0
+    assert hit.position == (1.0, 1.0)
 
     # Should convert
     hit.to_metric()
 
-    assert_equal(hit.tool.settings.units, 'metric')
-    assert_equal(hit.tool.diameter, 25.4)
-    assert_equal(hit.position, (25.4, 25.4))
+    assert hit.tool.settings.units == "metric"
+    assert hit.tool.diameter == 25.4
+    assert hit.position == (25.4, 25.4)
 
     # No Effect
     hit.to_metric()
 
-    assert_equal(hit.tool.settings.units, 'metric')
-    assert_equal(hit.tool.diameter, 25.4)
-    assert_equal(hit.position, (25.4, 25.4))
+    assert hit.tool.settings.units == "metric"
+    assert hit.tool.diameter == 25.4
+    assert hit.position == (25.4, 25.4)
 
     # Convert back to inch
     hit.to_inch()
 
-    assert_equal(hit.tool.settings.units, 'inch')
-    assert_equal(hit.tool.diameter, 1.0)
-    assert_equal(hit.position, (1.0, 1.0))
+    assert hit.tool.settings.units == "inch"
+    assert hit.tool.diameter == 1.0
+    assert hit.position == (1.0, 1.0)
+
 
 def test_drill_hit_offset():
     TEST_VECTORS = [
-        ((0.0 ,0.0), (0.0, 1.0), (0.0, 1.0)),
+        ((0.0, 0.0), (0.0, 1.0), (0.0, 1.0)),
         ((0.0, 0.0), (1.0, 1.0), (1.0, 1.0)),
         ((1.0, 1.0), (0.0, -1.0), (1.0, 0.0)),
         ((1.0, 1.0), (-1.0, -1.0), (0.0, 0.0)),
-
     ]
     for position, offset, expected in TEST_VECTORS:
-        settings = FileSettings(units='inch')
+        settings = FileSettings(units="inch")
         tool = ExcellonTool(settings, diameter=1.0)
         hit = DrillHit(tool, position)
 
-        assert_equal(hit.position, position)
+        assert hit.position == position
 
         hit.offset(offset[0], offset[1])
 
-        assert_equal(hit.position, expected)
+        assert hit.position == expected
 
 
 def test_drill_slot_units_conversion():
     """ Test unit conversion for drill hits
     """
     # Inch hit
-    settings = FileSettings(units='inch')
+    settings = FileSettings(units="inch")
     tool = ExcellonTool(settings, diameter=1.0)
     hit = DrillSlot(tool, (1.0, 1.0), (10.0, 10.0), DrillSlot.TYPE_ROUT)
 
-    assert_equal(hit.tool.settings.units, 'inch')
-    assert_equal(hit.tool.diameter, 1.0)
-    assert_equal(hit.start, (1.0, 1.0))
-    assert_equal(hit.end, (10.0, 10.0))
+    assert hit.tool.settings.units == "inch"
+    assert hit.tool.diameter == 1.0
+    assert hit.start == (1.0, 1.0)
+    assert hit.end == (10.0, 10.0)
 
     # No Effect
     hit.to_inch()
 
-    assert_equal(hit.tool.settings.units, 'inch')
-    assert_equal(hit.tool.diameter, 1.0)
-    assert_equal(hit.start, (1.0, 1.0))
-    assert_equal(hit.end, (10.0, 10.0))
+    assert hit.tool.settings.units == "inch"
+    assert hit.tool.diameter == 1.0
+    assert hit.start == (1.0, 1.0)
+    assert hit.end == (10.0, 10.0)
 
     # Should convert
     hit.to_metric()
 
-    assert_equal(hit.tool.settings.units, 'metric')
-    assert_equal(hit.tool.diameter, 25.4)
-    assert_equal(hit.start, (25.4, 25.4))
-    assert_equal(hit.end, (254.0, 254.0))
+    assert hit.tool.settings.units == "metric"
+    assert hit.tool.diameter == 25.4
+    assert hit.start == (25.4, 25.4)
+    assert hit.end == (254.0, 254.0)
 
     # No Effect
     hit.to_metric()
 
-    assert_equal(hit.tool.settings.units, 'metric')
-    assert_equal(hit.tool.diameter, 25.4)
-    assert_equal(hit.start, (25.4, 25.4))
-    assert_equal(hit.end, (254.0, 254.0))
+    assert hit.tool.settings.units == "metric"
+    assert hit.tool.diameter == 25.4
+    assert hit.start == (25.4, 25.4)
+    assert hit.end == (254.0, 254.0)
 
     # Convert back to inch
     hit.to_inch()
 
-    assert_equal(hit.tool.settings.units, 'inch')
-    assert_equal(hit.tool.diameter, 1.0)
-    assert_equal(hit.start, (1.0, 1.0))
-    assert_equal(hit.end, (10.0, 10.0))
+    assert hit.tool.settings.units == "inch"
+    assert hit.tool.diameter == 1.0
+    assert hit.start == (1.0, 1.0)
+    assert hit.end == (10.0, 10.0)
+
 
 def test_drill_slot_offset():
     TEST_VECTORS = [
-        ((0.0 ,0.0), (1.0, 1.0), (0.0, 0.0), (0.0, 0.0), (1.0, 1.0)),
+        ((0.0, 0.0), (1.0, 1.0), (0.0, 0.0), (0.0, 0.0), (1.0, 1.0)),
         ((0.0, 0.0), (1.0, 1.0), (1.0, 0.0), (1.0, 0.0), (2.0, 1.0)),
         ((0.0, 0.0), (1.0, 1.0), (1.0, 1.0), (1.0, 1.0), (2.0, 2.0)),
         ((0.0, 0.0), (1.0, 1.0), (-1.0, 1.0), (-1.0, 1.0), (0.0, 2.0)),
     ]
     for start, end, offset, expected_start, expected_end in TEST_VECTORS:
-        settings = FileSettings(units='inch')
+        settings = FileSettings(units="inch")
         tool = ExcellonTool(settings, diameter=1.0)
         slot = DrillSlot(tool, start, end, DrillSlot.TYPE_ROUT)
 
-        assert_equal(slot.start, start)
-        assert_equal(slot.end, end)
+        assert slot.start == start
+        assert slot.end == end
 
         slot.offset(offset[0], offset[1])
 
-        assert_equal(slot.start, expected_start)
-        assert_equal(slot.end, expected_end)
+        assert slot.start == expected_start
+        assert slot.end == expected_end
+
 
 def test_drill_slot_bounds():
     TEST_VECTORS = [
         ((0.0, 0.0), (1.0, 1.0), 1.0, ((-0.5, 1.5), (-0.5, 1.5))),
         ((0.0, 0.0), (1.0, 1.0), 0.5, ((-0.25, 1.25), (-0.25, 1.25))),
     ]
-    for start, end, diameter, expected, in TEST_VECTORS:
-        settings = FileSettings(units='inch')
+    for start, end, diameter, expected in TEST_VECTORS:
+        settings = FileSettings(units="inch")
         tool = ExcellonTool(settings, diameter=diameter)
         slot = DrillSlot(tool, start, end, DrillSlot.TYPE_ROUT)
 
-        assert_equal(slot.bounding_box, expected)
+        assert slot.bounding_box == expected
+
 
 def test_handling_multi_line_g00_and_g1():
     """Route Mode statements with coordinates on separate line are handled
@@ -355,6 +361,6 @@ M16
 """
     uut = ExcellonParser()
     uut.parse_raw(test_data)
-    assert_equal(len([stmt for stmt in uut.statements
-                      if isinstance(stmt, RouteModeStmt)]), 2)
-
+    assert (
+        len([stmt for stmt in uut.statements if isinstance(stmt, RouteModeStmt)]) == 2
+    )
diff --git a/gerber/tests/test_excellon_statements.py b/gerber/tests/test_excellon_statements.py
index 8e6e06e..41fe294 100644
--- a/gerber/tests/test_excellon_statements.py
+++ b/gerber/tests/test_excellon_statements.py
@@ -3,15 +3,15 @@
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
 
-from .tests import assert_equal, assert_not_equal, assert_raises
+import pytest
 from ..excellon_statements import *
 from ..cam import FileSettings
 
 
 def test_excellon_statement_implementation():
     stmt = ExcellonStatement()
-    assert_raises(NotImplementedError, stmt.from_excellon, None)
-    assert_raises(NotImplementedError, stmt.to_excellon)
+    pytest.raises(NotImplementedError, stmt.from_excellon, None)
+    pytest.raises(NotImplementedError, stmt.to_excellon)
 
 
 def test_excellontstmt():
@@ -26,154 +26,173 @@ def test_excellontstmt():
 def test_excellontool_factory():
     """ Test ExcellonTool factory methods
     """
-    exc_line = 'T8F01B02S00003H04Z05C0.12500'
-    settings = FileSettings(format=(2, 5), zero_suppression='trailing',
-                            units='inch', notation='absolute')
+    exc_line = "T8F01B02S00003H04Z05C0.12500"
+    settings = FileSettings(
+        format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute"
+    )
     tool = ExcellonTool.from_excellon(exc_line, settings)
-    assert_equal(tool.number, 8)
-    assert_equal(tool.diameter, 0.125)
-    assert_equal(tool.feed_rate, 1)
-    assert_equal(tool.retract_rate, 2)
-    assert_equal(tool.rpm, 3)
-    assert_equal(tool.max_hit_count, 4)
-    assert_equal(tool.depth_offset, 5)
-
-    stmt = {'number': 8, 'feed_rate': 1, 'retract_rate': 2, 'rpm': 3,
-            'diameter': 0.125, 'max_hit_count': 4, 'depth_offset': 5}
+    assert tool.number == 8
+    assert tool.diameter == 0.125
+    assert tool.feed_rate == 1
+    assert tool.retract_rate == 2
+    assert tool.rpm == 3
+    assert tool.max_hit_count == 4
+    assert tool.depth_offset == 5
+
+    stmt = {
+        "number": 8,
+        "feed_rate": 1,
+        "retract_rate": 2,
+        "rpm": 3,
+        "diameter": 0.125,
+        "max_hit_count": 4,
+        "depth_offset": 5,
+    }
     tool = ExcellonTool.from_dict(settings, stmt)
-    assert_equal(tool.number, 8)
-    assert_equal(tool.diameter, 0.125)
-    assert_equal(tool.feed_rate, 1)
-    assert_equal(tool.retract_rate, 2)
-    assert_equal(tool.rpm, 3)
-    assert_equal(tool.max_hit_count, 4)
-    assert_equal(tool.depth_offset, 5)
+    assert tool.number == 8
+    assert tool.diameter == 0.125
+    assert tool.feed_rate == 1
+    assert tool.retract_rate == 2
+    assert tool.rpm == 3
+    assert tool.max_hit_count == 4
+    assert tool.depth_offset == 5
 
 
 def test_excellontool_dump():
     """ Test ExcellonTool to_excellon()
     """
-    exc_lines = ['T01F0S0C0.01200', 'T02F0S0C0.01500', 'T03F0S0C0.01968',
-                 'T04F0S0C0.02800', 'T05F0S0C0.03300', 'T06F0S0C0.03800',
-                 'T07F0S0C0.04300', 'T08F0S0C0.12500', 'T09F0S0C0.13000',
-                 'T08B01F02H03S00003C0.12500Z04', 'T01F0S300.999C0.01200']
-    settings = FileSettings(format=(2, 5), zero_suppression='trailing',
-                            units='inch', notation='absolute')
+    exc_lines = [
+        "T01F0S0C0.01200",
+        "T02F0S0C0.01500",
+        "T03F0S0C0.01968",
+        "T04F0S0C0.02800",
+        "T05F0S0C0.03300",
+        "T06F0S0C0.03800",
+        "T07F0S0C0.04300",
+        "T08F0S0C0.12500",
+        "T09F0S0C0.13000",
+        "T08B01F02H03S00003C0.12500Z04",
+        "T01F0S300.999C0.01200",
+    ]
+    settings = FileSettings(
+        format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute"
+    )
     for line in exc_lines:
         tool = ExcellonTool.from_excellon(line, settings)
-        assert_equal(tool.to_excellon(), line)
+        assert tool.to_excellon() == line
 
 
 def test_excellontool_order():
-    settings = FileSettings(format=(2, 5), zero_suppression='trailing',
-                            units='inch', notation='absolute')
-    line = 'T8F00S00C0.12500'
+    settings = FileSettings(
+        format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute"
+    )
+    line = "T8F00S00C0.12500"
     tool1 = ExcellonTool.from_excellon(line, settings)
-    line = 'T8C0.12500F00S00'
+    line = "T8C0.12500F00S00"
     tool2 = ExcellonTool.from_excellon(line, settings)
-    assert_equal(tool1.diameter, tool2.diameter)
-    assert_equal(tool1.feed_rate, tool2.feed_rate)
-    assert_equal(tool1.rpm, tool2.rpm)
+    assert tool1.diameter == tool2.diameter
+    assert tool1.feed_rate == tool2.feed_rate
+    assert tool1.rpm == tool2.rpm
 
 
 def test_excellontool_conversion():
-    tool = ExcellonTool.from_dict(FileSettings(units='metric'),
-                                  {'number': 8, 'diameter': 25.4})
+    tool = ExcellonTool.from_dict(
+        FileSettings(units="metric"), {"number": 8, "diameter": 25.4}
+    )
     tool.to_inch()
-    assert_equal(tool.diameter, 1.)
-    tool = ExcellonTool.from_dict(FileSettings(units='inch'),
-                                  {'number': 8, 'diameter': 1.})
+    assert tool.diameter == 1.0
+    tool = ExcellonTool.from_dict(
+        FileSettings(units="inch"), {"number": 8, "diameter": 1.0}
+    )
     tool.to_metric()
-    assert_equal(tool.diameter, 25.4)
+    assert tool.diameter == 25.4
 
     # Shouldn't change units if we're already using target units
-    tool = ExcellonTool.from_dict(FileSettings(units='inch'),
-                                  {'number': 8, 'diameter': 25.4})
+    tool = ExcellonTool.from_dict(
+        FileSettings(units="inch"), {"number": 8, "diameter": 25.4}
+    )
     tool.to_inch()
-    assert_equal(tool.diameter, 25.4)
-    tool = ExcellonTool.from_dict(FileSettings(units='metric'),
-                                  {'number': 8, 'diameter': 1.})
+    assert tool.diameter == 25.4
+    tool = ExcellonTool.from_dict(
+        FileSettings(units="metric"), {"number": 8, "diameter": 1.0}
+    )
     tool.to_metric()
-    assert_equal(tool.diameter, 1.)
+    assert tool.diameter == 1.0
 
 
 def test_excellontool_repr():
-    tool = ExcellonTool.from_dict(FileSettings(),
-                                  {'number': 8, 'diameter': 0.125})
-    assert_equal(str(tool), '<ExcellonTool 08: 0.125in. dia.>')
-    tool = ExcellonTool.from_dict(FileSettings(units='metric'),
-                                  {'number': 8, 'diameter': 0.125})
-    assert_equal(str(tool), '<ExcellonTool 08: 0.125mm dia.>')
+    tool = ExcellonTool.from_dict(FileSettings(), {"number": 8, "diameter": 0.125})
+    assert str(tool) == "<ExcellonTool 08: 0.125in. dia.>"
+    tool = ExcellonTool.from_dict(
+        FileSettings(units="metric"), {"number": 8, "diameter": 0.125}
+    )
+    assert str(tool) == "<ExcellonTool 08: 0.125mm dia.>"
 
 
 def test_excellontool_equality():
-    t = ExcellonTool.from_dict(
-        FileSettings(), {'number': 8, 'diameter': 0.125})
+    t = ExcellonTool.from_dict(FileSettings(), {"number": 8, "diameter": 0.125})
+    t1 = ExcellonTool.from_dict(FileSettings(), {"number": 8, "diameter": 0.125})
+    assert t == t1
     t1 = ExcellonTool.from_dict(
-        FileSettings(), {'number': 8, 'diameter': 0.125})
-    assert_equal(t, t1)
-    t1 = ExcellonTool.from_dict(FileSettings(units='metric'),
-                                {'number': 8, 'diameter': 0.125})
-    assert_not_equal(t, t1)
+        FileSettings(units="metric"), {"number": 8, "diameter": 0.125}
+    )
+    assert t != t1
 
 
 def test_toolselection_factory():
     """ Test ToolSelectionStmt factory method
     """
-    stmt = ToolSelectionStmt.from_excellon('T01')
-    assert_equal(stmt.tool, 1)
-    assert_equal(stmt.compensation_index, None)
-    stmt = ToolSelectionStmt.from_excellon('T0223')
-    assert_equal(stmt.tool, 2)
-    assert_equal(stmt.compensation_index, 23)
-    stmt = ToolSelectionStmt.from_excellon('T042')
-    assert_equal(stmt.tool, 42)
-    assert_equal(stmt.compensation_index, None)
+    stmt = ToolSelectionStmt.from_excellon("T01")
+    assert stmt.tool == 1
+    assert stmt.compensation_index == None
+    stmt = ToolSelectionStmt.from_excellon("T0223")
+    assert stmt.tool == 2
+    assert stmt.compensation_index == 23
+    stmt = ToolSelectionStmt.from_excellon("T042")
+    assert stmt.tool == 42
+    assert stmt.compensation_index == None
 
 
 def test_toolselection_dump():
     """ Test ToolSelectionStmt to_excellon()
     """
-    lines = ['T01', 'T0223', 'T10', 'T09', 'T0000']
+    lines = ["T01", "T0223", "T10", "T09", "T0000"]
     for line in lines:
         stmt = ToolSelectionStmt.from_excellon(line)
-        assert_equal(stmt.to_excellon(), line)
+        assert stmt.to_excellon() == line
 
 
 def test_z_axis_infeed_rate_factory():
     """ Test ZAxisInfeedRateStmt factory method
     """
-    stmt = ZAxisInfeedRateStmt.from_excellon('F01')
-    assert_equal(stmt.rate, 1)
-    stmt = ZAxisInfeedRateStmt.from_excellon('F2')
-    assert_equal(stmt.rate, 2)
-    stmt = ZAxisInfeedRateStmt.from_excellon('F03')
-    assert_equal(stmt.rate, 3)
+    stmt = ZAxisInfeedRateStmt.from_excellon("F01")
+    assert stmt.rate == 1
+    stmt = ZAxisInfeedRateStmt.from_excellon("F2")
+    assert stmt.rate == 2
+    stmt = ZAxisInfeedRateStmt.from_excellon("F03")
+    assert stmt.rate == 3
 
 
 def test_z_axis_infeed_rate_dump():
     """ Test ZAxisInfeedRateStmt to_excellon()
     """
-    inputs = [
-        ('F01', 'F01'),
-        ('F2', 'F02'),
-        ('F00003', 'F03')
-    ]
+    inputs = [("F01", "F01"), ("F2", "F02"), ("F00003", "F03")]
     for input_rate, expected_output in inputs:
         stmt = ZAxisInfeedRateStmt.from_excellon(input_rate)
-        assert_equal(stmt.to_excellon(), expected_output)
+        assert stmt.to_excellon() == expected_output
 
 
 def test_coordinatestmt_factory():
     """ Test CoordinateStmt factory method
     """
-    settings = FileSettings(format=(2, 5), zero_suppression='trailing',
-                            units='inch', notation='absolute')
+    settings = FileSettings(
+        format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute"
+    )
 
-    line = 'X0278207Y0065293'
+    line = "X0278207Y0065293"
     stmt = CoordinateStmt.from_excellon(line, settings)
-    assert_equal(stmt.x, 2.78207)
-    assert_equal(stmt.y, 0.65293)
+    assert stmt.x == 2.78207
+    assert stmt.y == 0.65293
 
     # line = 'X02945'
     # stmt = CoordinateStmt.from_excellon(line)
@@ -183,518 +202,533 @@ def test_coordinatestmt_factory():
     # stmt = CoordinateStmt.from_excellon(line)
     # assert_equal(stmt.y, 0.575)
 
-    settings = FileSettings(format=(2, 4), zero_suppression='leading',
-                            units='inch', notation='absolute')
+    settings = FileSettings(
+        format=(2, 4), zero_suppression="leading", units="inch", notation="absolute"
+    )
 
-    line = 'X9660Y4639'
+    line = "X9660Y4639"
     stmt = CoordinateStmt.from_excellon(line, settings)
-    assert_equal(stmt.x, 0.9660)
-    assert_equal(stmt.y, 0.4639)
-    assert_equal(stmt.to_excellon(settings), "X9660Y4639")
-    assert_equal(stmt.units, 'inch')
+    assert stmt.x == 0.9660
+    assert stmt.y == 0.4639
+    assert stmt.to_excellon(settings) == "X9660Y4639"
+    assert stmt.units == "inch"
 
-    settings.units = 'metric'
+    settings.units = "metric"
     stmt = CoordinateStmt.from_excellon(line, settings)
-    assert_equal(stmt.units, 'metric')
+    assert stmt.units == "metric"
 
 
 def test_coordinatestmt_dump():
     """ Test CoordinateStmt to_excellon()
     """
-    lines = ['X278207Y65293', 'X243795', 'Y82528', 'Y86028',
-             'X251295Y81528', 'X2525Y78', 'X255Y575', 'Y52',
-             'X2675', 'Y575', 'X2425', 'Y52', 'X23', ]
-    settings = FileSettings(format=(2, 4), zero_suppression='leading',
-                            units='inch', notation='absolute')
+    lines = [
+        "X278207Y65293",
+        "X243795",
+        "Y82528",
+        "Y86028",
+        "X251295Y81528",
+        "X2525Y78",
+        "X255Y575",
+        "Y52",
+        "X2675",
+        "Y575",
+        "X2425",
+        "Y52",
+        "X23",
+    ]
+    settings = FileSettings(
+        format=(2, 4), zero_suppression="leading", units="inch", notation="absolute"
+    )
     for line in lines:
         stmt = CoordinateStmt.from_excellon(line, settings)
-        assert_equal(stmt.to_excellon(settings), line)
+        assert stmt.to_excellon(settings) == line
 
 
 def test_coordinatestmt_conversion():
 
     settings = FileSettings()
-    settings.units = 'metric'
-    stmt = CoordinateStmt.from_excellon('X254Y254', settings)
+    settings.units = "metric"
+    stmt = CoordinateStmt.from_excellon("X254Y254", settings)
 
     # No effect
     stmt.to_metric()
-    assert_equal(stmt.x, 25.4)
-    assert_equal(stmt.y, 25.4)
+    assert stmt.x == 25.4
+    assert stmt.y == 25.4
 
     stmt.to_inch()
-    assert_equal(stmt.units, 'inch')
-    assert_equal(stmt.x, 1.)
-    assert_equal(stmt.y, 1.)
+    assert stmt.units == "inch"
+    assert stmt.x == 1.0
+    assert stmt.y == 1.0
 
     # No effect
     stmt.to_inch()
-    assert_equal(stmt.x, 1.)
-    assert_equal(stmt.y, 1.)
+    assert stmt.x == 1.0
+    assert stmt.y == 1.0
 
-    settings.units = 'inch'
-    stmt = CoordinateStmt.from_excellon('X01Y01', settings)
+    settings.units = "inch"
+    stmt = CoordinateStmt.from_excellon("X01Y01", settings)
 
     # No effect
     stmt.to_inch()
-    assert_equal(stmt.x, 1.)
-    assert_equal(stmt.y, 1.)
+    assert stmt.x == 1.0
+    assert stmt.y == 1.0
 
     stmt.to_metric()
-    assert_equal(stmt.units, 'metric')
-    assert_equal(stmt.x, 25.4)
-    assert_equal(stmt.y, 25.4)
+    assert stmt.units == "metric"
+    assert stmt.x == 25.4
+    assert stmt.y == 25.4
 
     # No effect
     stmt.to_metric()
-    assert_equal(stmt.x, 25.4)
-    assert_equal(stmt.y, 25.4)
+    assert stmt.x == 25.4
+    assert stmt.y == 25.4
 
 
 def test_coordinatestmt_offset():
-    stmt = CoordinateStmt.from_excellon('X01Y01', FileSettings())
+    stmt = CoordinateStmt.from_excellon("X01Y01", FileSettings())
     stmt.offset()
-    assert_equal(stmt.x, 1)
-    assert_equal(stmt.y, 1)
+    assert stmt.x == 1
+    assert stmt.y == 1
     stmt.offset(1, 0)
-    assert_equal(stmt.x, 2.)
-    assert_equal(stmt.y, 1.)
+    assert stmt.x == 2.0
+    assert stmt.y == 1.0
     stmt.offset(0, 1)
-    assert_equal(stmt.x, 2.)
-    assert_equal(stmt.y, 2.)
+    assert stmt.x == 2.0
+    assert stmt.y == 2.0
 
 
 def test_coordinatestmt_string():
-    settings = FileSettings(format=(2, 4), zero_suppression='leading',
-                            units='inch', notation='absolute')
-    stmt = CoordinateStmt.from_excellon('X9660Y4639', settings)
-    assert_equal(str(stmt), '<Coordinate Statement: X: 0.966 Y: 0.4639 >')
+    settings = FileSettings(
+        format=(2, 4), zero_suppression="leading", units="inch", notation="absolute"
+    )
+    stmt = CoordinateStmt.from_excellon("X9660Y4639", settings)
+    assert str(stmt) == "<Coordinate Statement: X: 0.966 Y: 0.4639 >"
 
 
 def test_repeathole_stmt_factory():
-    stmt = RepeatHoleStmt.from_excellon('R0004X015Y32',
-                                        FileSettings(zeros='leading',
-                                                     units='inch'))
-    assert_equal(stmt.count, 4)
-    assert_equal(stmt.xdelta, 1.5)
-    assert_equal(stmt.ydelta, 32)
-    assert_equal(stmt.units, 'inch')
+    stmt = RepeatHoleStmt.from_excellon(
+        "R0004X015Y32", FileSettings(zeros="leading", units="inch")
+    )
+    assert stmt.count == 4
+    assert stmt.xdelta == 1.5
+    assert stmt.ydelta == 32
+    assert stmt.units == "inch"
 
-    stmt = RepeatHoleStmt.from_excellon('R0004X015Y32',
-                                        FileSettings(zeros='leading',
-                                                     units='metric'))
-    assert_equal(stmt.units, 'metric')
+    stmt = RepeatHoleStmt.from_excellon(
+        "R0004X015Y32", FileSettings(zeros="leading", units="metric")
+    )
+    assert stmt.units == "metric"
 
 
 def test_repeatholestmt_dump():
-    line = 'R4X015Y32'
+    line = "R4X015Y32"
     stmt = RepeatHoleStmt.from_excellon(line, FileSettings())
-    assert_equal(stmt.to_excellon(FileSettings()), line)
+    assert stmt.to_excellon(FileSettings()) == line
 
 
 def test_repeatholestmt_conversion():
-    line = 'R4X0254Y254'
+    line = "R4X0254Y254"
     settings = FileSettings()
-    settings.units = 'metric'
+    settings.units = "metric"
     stmt = RepeatHoleStmt.from_excellon(line, settings)
 
     # No effect
     stmt.to_metric()
-    assert_equal(stmt.xdelta, 2.54)
-    assert_equal(stmt.ydelta, 25.4)
+    assert stmt.xdelta == 2.54
+    assert stmt.ydelta == 25.4
 
     stmt.to_inch()
-    assert_equal(stmt.units, 'inch')
-    assert_equal(stmt.xdelta, 0.1)
-    assert_equal(stmt.ydelta, 1.)
+    assert stmt.units == "inch"
+    assert stmt.xdelta == 0.1
+    assert stmt.ydelta == 1.0
 
     # no effect
     stmt.to_inch()
-    assert_equal(stmt.xdelta, 0.1)
-    assert_equal(stmt.ydelta, 1.)
+    assert stmt.xdelta == 0.1
+    assert stmt.ydelta == 1.0
 
-    line = 'R4X01Y1'
-    settings.units = 'inch'
+    line = "R4X01Y1"
+    settings.units = "inch"
     stmt = RepeatHoleStmt.from_excellon(line, settings)
 
     # no effect
     stmt.to_inch()
-    assert_equal(stmt.xdelta, 1.)
-    assert_equal(stmt.ydelta, 10.)
+    assert stmt.xdelta == 1.0
+    assert stmt.ydelta == 10.0
 
     stmt.to_metric()
-    assert_equal(stmt.units, 'metric')
-    assert_equal(stmt.xdelta, 25.4)
-    assert_equal(stmt.ydelta, 254.)
+    assert stmt.units == "metric"
+    assert stmt.xdelta == 25.4
+    assert stmt.ydelta == 254.0
 
     # No effect
     stmt.to_metric()
-    assert_equal(stmt.xdelta, 25.4)
-    assert_equal(stmt.ydelta, 254.)
+    assert stmt.xdelta == 25.4
+    assert stmt.ydelta == 254.0
 
 
 def test_repeathole_str():
-    stmt = RepeatHoleStmt.from_excellon('R4X015Y32', FileSettings())
-    assert_equal(str(stmt), '<Repeat Hole: 4 times, offset X: 1.5 Y: 32>')
+    stmt = RepeatHoleStmt.from_excellon("R4X015Y32", FileSettings())
+    assert str(stmt) == "<Repeat Hole: 4 times, offset X: 1.5 Y: 32>"
 
 
 def test_commentstmt_factory():
     """ Test CommentStmt factory method
     """
-    line = ';Layer_Color=9474304'
+    line = ";Layer_Color=9474304"
     stmt = CommentStmt.from_excellon(line)
-    assert_equal(stmt.comment, line[1:])
+    assert stmt.comment == line[1:]
 
-    line = ';FILE_FORMAT=2:5'
+    line = ";FILE_FORMAT=2:5"
     stmt = CommentStmt.from_excellon(line)
-    assert_equal(stmt.comment, line[1:])
+    assert stmt.comment == line[1:]
 
-    line = ';TYPE=PLATED'
+    line = ";TYPE=PLATED"
     stmt = CommentStmt.from_excellon(line)
-    assert_equal(stmt.comment, line[1:])
+    assert stmt.comment == line[1:]
 
 
 def test_commentstmt_dump():
     """ Test CommentStmt to_excellon()
     """
-    lines = [';Layer_Color=9474304', ';FILE_FORMAT=2:5', ';TYPE=PLATED', ]
+    lines = [";Layer_Color=9474304", ";FILE_FORMAT=2:5", ";TYPE=PLATED"]
     for line in lines:
         stmt = CommentStmt.from_excellon(line)
-        assert_equal(stmt.to_excellon(), line)
+        assert stmt.to_excellon() == line
 
 
 def test_header_begin_stmt():
     stmt = HeaderBeginStmt()
-    assert_equal(stmt.to_excellon(None), 'M48')
+    assert stmt.to_excellon(None) == "M48"
 
 
 def test_header_end_stmt():
     stmt = HeaderEndStmt()
-    assert_equal(stmt.to_excellon(None), 'M95')
+    assert stmt.to_excellon(None) == "M95"
 
 
 def test_rewindstop_stmt():
     stmt = RewindStopStmt()
-    assert_equal(stmt.to_excellon(None), '%')
+    assert stmt.to_excellon(None) == "%"
 
 
 def test_z_axis_rout_position_stmt():
     stmt = ZAxisRoutPositionStmt()
-    assert_equal(stmt.to_excellon(None), 'M15')
+    assert stmt.to_excellon(None) == "M15"
 
 
 def test_retract_with_clamping_stmt():
     stmt = RetractWithClampingStmt()
-    assert_equal(stmt.to_excellon(None), 'M16')
+    assert stmt.to_excellon(None) == "M16"
 
 
 def test_retract_without_clamping_stmt():
     stmt = RetractWithoutClampingStmt()
-    assert_equal(stmt.to_excellon(None), 'M17')
+    assert stmt.to_excellon(None) == "M17"
 
 
 def test_cutter_compensation_off_stmt():
     stmt = CutterCompensationOffStmt()
-    assert_equal(stmt.to_excellon(None), 'G40')
+    assert stmt.to_excellon(None) == "G40"
 
 
 def test_cutter_compensation_left_stmt():
     stmt = CutterCompensationLeftStmt()
-    assert_equal(stmt.to_excellon(None), 'G41')
+    assert stmt.to_excellon(None) == "G41"
 
 
 def test_cutter_compensation_right_stmt():
     stmt = CutterCompensationRightStmt()
-    assert_equal(stmt.to_excellon(None), 'G42')
+    assert stmt.to_excellon(None) == "G42"
 
 
 def test_endofprogramstmt_factory():
-    settings = FileSettings(units='inch')
-    stmt = EndOfProgramStmt.from_excellon('M30X01Y02', settings)
-    assert_equal(stmt.x, 1.)
-    assert_equal(stmt.y, 2.)
-    assert_equal(stmt.units, 'inch')
-    settings.units = 'metric'
-    stmt = EndOfProgramStmt.from_excellon('M30X01', settings)
-    assert_equal(stmt.x, 1.)
-    assert_equal(stmt.y, None)
-    assert_equal(stmt.units, 'metric')
-    stmt = EndOfProgramStmt.from_excellon('M30Y02', FileSettings())
-    assert_equal(stmt.x, None)
-    assert_equal(stmt.y, 2.)
+    settings = FileSettings(units="inch")
+    stmt = EndOfProgramStmt.from_excellon("M30X01Y02", settings)
+    assert stmt.x == 1.0
+    assert stmt.y == 2.0
+    assert stmt.units == "inch"
+    settings.units = "metric"
+    stmt = EndOfProgramStmt.from_excellon("M30X01", settings)
+    assert stmt.x == 1.0
+    assert stmt.y == None
+    assert stmt.units == "metric"
+    stmt = EndOfProgramStmt.from_excellon("M30Y02", FileSettings())
+    assert stmt.x == None
+    assert stmt.y == 2.0
 
 
 def test_endofprogramStmt_dump():
-    lines = ['M30X01Y02', ]
+    lines = ["M30X01Y02"]
     for line in lines:
         stmt = EndOfProgramStmt.from_excellon(line, FileSettings())
-        assert_equal(stmt.to_excellon(FileSettings()), line)
+        assert stmt.to_excellon(FileSettings()) == line
 
 
 def test_endofprogramstmt_conversion():
     settings = FileSettings()
-    settings.units = 'metric'
-    stmt = EndOfProgramStmt.from_excellon('M30X0254Y254', settings)
+    settings.units = "metric"
+    stmt = EndOfProgramStmt.from_excellon("M30X0254Y254", settings)
     # No effect
     stmt.to_metric()
-    assert_equal(stmt.x, 2.54)
-    assert_equal(stmt.y, 25.4)
+    assert stmt.x == 2.54
+    assert stmt.y == 25.4
 
     stmt.to_inch()
-    assert_equal(stmt.units, 'inch')
-    assert_equal(stmt.x, 0.1)
-    assert_equal(stmt.y, 1.0)
+    assert stmt.units == "inch"
+    assert stmt.x == 0.1
+    assert stmt.y == 1.0
 
     # No effect
     stmt.to_inch()
-    assert_equal(stmt.x, 0.1)
-    assert_equal(stmt.y, 1.0)
+    assert stmt.x == 0.1
+    assert stmt.y == 1.0
 
-    settings.units = 'inch'
-    stmt = EndOfProgramStmt.from_excellon('M30X01Y1', settings)
+    settings.units = "inch"
+    stmt = EndOfProgramStmt.from_excellon("M30X01Y1", settings)
 
     # No effect
     stmt.to_inch()
-    assert_equal(stmt.x, 1.)
-    assert_equal(stmt.y, 10.0)
+    assert stmt.x == 1.0
+    assert stmt.y == 10.0
 
     stmt.to_metric()
-    assert_equal(stmt.units, 'metric')
-    assert_equal(stmt.x, 25.4)
-    assert_equal(stmt.y, 254.)
+    assert stmt.units == "metric"
+    assert stmt.x == 25.4
+    assert stmt.y == 254.0
 
     # No effect
     stmt.to_metric()
-    assert_equal(stmt.x, 25.4)
-    assert_equal(stmt.y, 254.)
+    assert stmt.x == 25.4
+    assert stmt.y == 254.0
 
 
 def test_endofprogramstmt_offset():
     stmt = EndOfProgramStmt(1, 1)
     stmt.offset()
-    assert_equal(stmt.x, 1)
-    assert_equal(stmt.y, 1)
+    assert stmt.x == 1
+    assert stmt.y == 1
     stmt.offset(1, 0)
-    assert_equal(stmt.x, 2.)
-    assert_equal(stmt.y, 1.)
+    assert stmt.x == 2.0
+    assert stmt.y == 1.0
     stmt.offset(0, 1)
-    assert_equal(stmt.x, 2.)
-    assert_equal(stmt.y, 2.)
+    assert stmt.x == 2.0
+    assert stmt.y == 2.0
 
 
 def test_unitstmt_factory():
     """ Test UnitStmt factory method
     """
-    line = 'INCH,LZ'
+    line = "INCH,LZ"
     stmt = UnitStmt.from_excellon(line)
-    assert_equal(stmt.units, 'inch')
-    assert_equal(stmt.zeros, 'leading')
+    assert stmt.units == "inch"
+    assert stmt.zeros == "leading"
 
-    line = 'INCH,TZ'
+    line = "INCH,TZ"
     stmt = UnitStmt.from_excellon(line)
-    assert_equal(stmt.units, 'inch')
-    assert_equal(stmt.zeros, 'trailing')
+    assert stmt.units == "inch"
+    assert stmt.zeros == "trailing"
 
-    line = 'METRIC,LZ'
+    line = "METRIC,LZ"
     stmt = UnitStmt.from_excellon(line)
-    assert_equal(stmt.units, 'metric')
-    assert_equal(stmt.zeros, 'leading')
+    assert stmt.units == "metric"
+    assert stmt.zeros == "leading"
 
-    line = 'METRIC,TZ'
+    line = "METRIC,TZ"
     stmt = UnitStmt.from_excellon(line)
-    assert_equal(stmt.units, 'metric')
-    assert_equal(stmt.zeros, 'trailing')
+    assert stmt.units == "metric"
+    assert stmt.zeros == "trailing"
 
 
 def test_unitstmt_dump():
     """ Test UnitStmt to_excellon()
     """
-    lines = ['INCH,LZ', 'INCH,TZ', 'METRIC,LZ', 'METRIC,TZ', ]
+    lines = ["INCH,LZ", "INCH,TZ", "METRIC,LZ", "METRIC,TZ"]
     for line in lines:
         stmt = UnitStmt.from_excellon(line)
-        assert_equal(stmt.to_excellon(), line)
+        assert stmt.to_excellon() == line
 
 
 def test_unitstmt_conversion():
-    stmt = UnitStmt.from_excellon('METRIC,TZ')
+    stmt = UnitStmt.from_excellon("METRIC,TZ")
     stmt.to_inch()
-    assert_equal(stmt.units, 'inch')
+    assert stmt.units == "inch"
 
-    stmt = UnitStmt.from_excellon('INCH,TZ')
+    stmt = UnitStmt.from_excellon("INCH,TZ")
     stmt.to_metric()
-    assert_equal(stmt.units, 'metric')
+    assert stmt.units == "metric"
 
 
 def test_incrementalmode_factory():
     """ Test IncrementalModeStmt factory method
     """
-    line = 'ICI,ON'
+    line = "ICI,ON"
     stmt = IncrementalModeStmt.from_excellon(line)
-    assert_equal(stmt.mode, 'on')
+    assert stmt.mode == "on"
 
-    line = 'ICI,OFF'
+    line = "ICI,OFF"
     stmt = IncrementalModeStmt.from_excellon(line)
-    assert_equal(stmt.mode, 'off')
+    assert stmt.mode == "off"
 
 
 def test_incrementalmode_dump():
     """ Test IncrementalModeStmt to_excellon()
     """
-    lines = ['ICI,ON', 'ICI,OFF', ]
+    lines = ["ICI,ON", "ICI,OFF"]
     for line in lines:
         stmt = IncrementalModeStmt.from_excellon(line)
-        assert_equal(stmt.to_excellon(), line)
+        assert stmt.to_excellon() == line
 
 
 def test_incrementalmode_validation():
     """ Test IncrementalModeStmt input validation
     """
-    assert_raises(ValueError, IncrementalModeStmt, 'OFF-ISH')
+    pytest.raises(ValueError, IncrementalModeStmt, "OFF-ISH")
 
 
 def test_versionstmt_factory():
     """ Test VersionStmt factory method
     """
-    line = 'VER,1'
+    line = "VER,1"
     stmt = VersionStmt.from_excellon(line)
-    assert_equal(stmt.version, 1)
+    assert stmt.version == 1
 
-    line = 'VER,2'
+    line = "VER,2"
     stmt = VersionStmt.from_excellon(line)
-    assert_equal(stmt.version, 2)
+    assert stmt.version == 2
 
 
 def test_versionstmt_dump():
     """ Test VersionStmt to_excellon()
     """
-    lines = ['VER,1', 'VER,2', ]
+    lines = ["VER,1", "VER,2"]
     for line in lines:
         stmt = VersionStmt.from_excellon(line)
-        assert_equal(stmt.to_excellon(), line)
+        assert stmt.to_excellon() == line
 
 
 def test_versionstmt_validation():
     """ Test VersionStmt input validation
     """
-    assert_raises(ValueError, VersionStmt, 3)
+    pytest.raises(ValueError, VersionStmt, 3)
 
 
 def test_formatstmt_factory():
     """ Test FormatStmt factory method
     """
-    line = 'FMAT,1'
+    line = "FMAT,1"
     stmt = FormatStmt.from_excellon(line)
-    assert_equal(stmt.format, 1)
+    assert stmt.format == 1
 
-    line = 'FMAT,2'
+    line = "FMAT,2"
     stmt = FormatStmt.from_excellon(line)
-    assert_equal(stmt.format, 2)
+    assert stmt.format == 2
 
 
 def test_formatstmt_dump():
     """ Test FormatStmt to_excellon()
     """
-    lines = ['FMAT,1', 'FMAT,2', ]
+    lines = ["FMAT,1", "FMAT,2"]
     for line in lines:
         stmt = FormatStmt.from_excellon(line)
-        assert_equal(stmt.to_excellon(), line)
+        assert stmt.to_excellon() == line
 
 
 def test_formatstmt_validation():
     """ Test FormatStmt input validation
     """
-    assert_raises(ValueError, FormatStmt, 3)
+    pytest.raises(ValueError, FormatStmt, 3)
 
 
 def test_linktoolstmt_factory():
     """ Test LinkToolStmt factory method
     """
-    line = '1/2/3/4'
+    line = "1/2/3/4"
     stmt = LinkToolStmt.from_excellon(line)
-    assert_equal(stmt.linked_tools, [1, 2, 3, 4])
+    assert stmt.linked_tools == [1, 2, 3, 4]
 
-    line = '01/02/03/04'
+    line = "01/02/03/04"
     stmt = LinkToolStmt.from_excellon(line)
-    assert_equal(stmt.linked_tools, [1, 2, 3, 4])
+    assert stmt.linked_tools == [1, 2, 3, 4]
 
 
 def test_linktoolstmt_dump():
     """ Test LinkToolStmt to_excellon()
     """
-    lines = ['1/2/3/4', '5/6/7', ]
+    lines = ["1/2/3/4", "5/6/7"]
     for line in lines:
         stmt = LinkToolStmt.from_excellon(line)
-        assert_equal(stmt.to_excellon(), line)
+        assert stmt.to_excellon() == line
 
 
 def test_measmodestmt_factory():
     """ Test MeasuringModeStmt factory method
     """
-    line = 'M72'
+    line = "M72"
     stmt = MeasuringModeStmt.from_excellon(line)
-    assert_equal(stmt.units, 'inch')
+    assert stmt.units == "inch"
 
-    line = 'M71'
+    line = "M71"
     stmt = MeasuringModeStmt.from_excellon(line)
-    assert_equal(stmt.units, 'metric')
+    assert stmt.units == "metric"
 
 
 def test_measmodestmt_dump():
     """ Test MeasuringModeStmt to_excellon()
     """
-    lines = ['M71', 'M72', ]
+    lines = ["M71", "M72"]
     for line in lines:
         stmt = MeasuringModeStmt.from_excellon(line)
-        assert_equal(stmt.to_excellon(), line)
+        assert stmt.to_excellon() == line
 
 
 def test_measmodestmt_validation():
     """ Test MeasuringModeStmt input validation
     """
-    assert_raises(ValueError, MeasuringModeStmt.from_excellon, 'M70')
-    assert_raises(ValueError, MeasuringModeStmt, 'millimeters')
+    pytest.raises(ValueError, MeasuringModeStmt.from_excellon, "M70")
+    pytest.raises(ValueError, MeasuringModeStmt, "millimeters")
 
 
 def test_measmodestmt_conversion():
-    line = 'M72'
+    line = "M72"
     stmt = MeasuringModeStmt.from_excellon(line)
-    assert_equal(stmt.units, 'inch')
+    assert stmt.units == "inch"
     stmt.to_metric()
-    assert_equal(stmt.units, 'metric')
+    assert stmt.units == "metric"
 
-    line = 'M71'
+    line = "M71"
     stmt = MeasuringModeStmt.from_excellon(line)
-    assert_equal(stmt.units, 'metric')
+    assert stmt.units == "metric"
     stmt.to_inch()
-    assert_equal(stmt.units, 'inch')
+    assert stmt.units == "inch"
 
 
 def test_routemode_stmt():
     stmt = RouteModeStmt()
-    assert_equal(stmt.to_excellon(FileSettings()), 'G00')
+    assert stmt.to_excellon(FileSettings()) == "G00"
 
 
 def test_linearmode_stmt():
     stmt = LinearModeStmt()
-    assert_equal(stmt.to_excellon(FileSettings()), 'G01')
+    assert stmt.to_excellon(FileSettings()) == "G01"
 
 
 def test_drillmode_stmt():
     stmt = DrillModeStmt()
-    assert_equal(stmt.to_excellon(FileSettings()), 'G05')
+    assert stmt.to_excellon(FileSettings()) == "G05"
 
 
 def test_absolutemode_stmt():
     stmt = AbsoluteModeStmt()
-    assert_equal(stmt.to_excellon(FileSettings()), 'G90')
+    assert stmt.to_excellon(FileSettings()) == "G90"
 
 
 def test_unknownstmt():
-    stmt = UnknownStmt('TEST')
-    assert_equal(stmt.stmt, 'TEST')
-    assert_equal(str(stmt), '<Unknown Statement: TEST>')
+    stmt = UnknownStmt("TEST")
+    assert stmt.stmt == "TEST"
+    assert str(stmt) == "<Unknown Statement: TEST>"
 
 
 def test_unknownstmt_dump():
-    stmt = UnknownStmt('TEST')
-    assert_equal(stmt.to_excellon(FileSettings()), 'TEST')
+    stmt = UnknownStmt("TEST")
+    assert stmt.to_excellon(FileSettings()) == "TEST"
diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py
index 15f35a1..140cbd1 100644
--- a/gerber/tests/test_gerber_statements.py
+++ b/gerber/tests/test_gerber_statements.py
@@ -3,414 +3,413 @@
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
 
-from .tests import *
+import pytest
 from ..gerber_statements import *
 from ..cam import FileSettings
 
 
 def test_Statement_smoketest():
-    stmt = Statement('Test')
-    assert_equal(stmt.type, 'Test')
+    stmt = Statement("Test")
+    assert stmt.type == "Test"
     stmt.to_metric()
-    assert_in('units=metric', str(stmt))
+    assert "units=metric" in str(stmt)
     stmt.to_inch()
-    assert_in('units=inch', str(stmt))
+    assert "units=inch" in str(stmt)
     stmt.to_metric()
     stmt.offset(1, 1)
-    assert_in('type=Test', str(stmt))
+    assert "type=Test" in str(stmt)
 
 
 def test_FSParamStmt_factory():
     """ Test FSParamStruct factory
     """
-    stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'}
+    stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"}
     fs = FSParamStmt.from_dict(stmt)
-    assert_equal(fs.param, 'FS')
-    assert_equal(fs.zero_suppression, 'leading')
-    assert_equal(fs.notation, 'absolute')
-    assert_equal(fs.format, (2, 7))
+    assert fs.param == "FS"
+    assert fs.zero_suppression == "leading"
+    assert fs.notation == "absolute"
+    assert fs.format == (2, 7)
 
-    stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '27'}
+    stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "27"}
     fs = FSParamStmt.from_dict(stmt)
-    assert_equal(fs.param, 'FS')
-    assert_equal(fs.zero_suppression, 'trailing')
-    assert_equal(fs.notation, 'incremental')
-    assert_equal(fs.format, (2, 7))
+    assert fs.param == "FS"
+    assert fs.zero_suppression == "trailing"
+    assert fs.notation == "incremental"
+    assert fs.format == (2, 7)
 
 
 def test_FSParamStmt():
     """ Test FSParamStmt initialization
     """
-    param = 'FS'
-    zeros = 'trailing'
-    notation = 'absolute'
+    param = "FS"
+    zeros = "trailing"
+    notation = "absolute"
     fmt = (2, 5)
     stmt = FSParamStmt(param, zeros, notation, fmt)
-    assert_equal(stmt.param, param)
-    assert_equal(stmt.zero_suppression, zeros)
-    assert_equal(stmt.notation, notation)
-    assert_equal(stmt.format, fmt)
+    assert stmt.param == param
+    assert stmt.zero_suppression == zeros
+    assert stmt.notation == notation
+    assert stmt.format == fmt
 
 
 def test_FSParamStmt_dump():
     """ Test FSParamStmt to_gerber()
     """
-    stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'}
+    stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"}
     fs = FSParamStmt.from_dict(stmt)
-    assert_equal(fs.to_gerber(), '%FSLAX27Y27*%')
+    assert fs.to_gerber() == "%FSLAX27Y27*%"
 
-    stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'}
+    stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "25"}
     fs = FSParamStmt.from_dict(stmt)
-    assert_equal(fs.to_gerber(), '%FSTIX25Y25*%')
+    assert fs.to_gerber() == "%FSTIX25Y25*%"
 
-    settings = FileSettings(zero_suppression='leading', notation='absolute')
-    assert_equal(fs.to_gerber(settings), '%FSLAX25Y25*%')
+    settings = FileSettings(zero_suppression="leading", notation="absolute")
+    assert fs.to_gerber(settings) == "%FSLAX25Y25*%"
 
 
 def test_FSParamStmt_string():
     """ Test FSParamStmt.__str__()
     """
-    stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'}
+    stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"}
     fs = FSParamStmt.from_dict(stmt)
-    assert_equal(str(fs),
-                 '<Format Spec: 2:7 leading zero suppression absolute notation>')
+    assert str(fs) == "<Format Spec: 2:7 leading zero suppression absolute notation>"
 
-    stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'}
+    stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "25"}
     fs = FSParamStmt.from_dict(stmt)
-    assert_equal(str(fs),
-                 '<Format Spec: 2:5 trailing zero suppression incremental notation>')
+    assert (
+        str(fs) == "<Format Spec: 2:5 trailing zero suppression incremental notation>"
+    )
 
 
 def test_MOParamStmt_factory():
     """ Test MOParamStruct factory
     """
-    stmts = [{'param': 'MO', 'mo': 'IN'}, {'param': 'MO', 'mo': 'in'}, ]
+    stmts = [{"param": "MO", "mo": "IN"}, {"param": "MO", "mo": "in"}]
     for stmt in stmts:
         mo = MOParamStmt.from_dict(stmt)
-        assert_equal(mo.param, 'MO')
-        assert_equal(mo.mode, 'inch')
+        assert mo.param == "MO"
+        assert mo.mode == "inch"
 
-    stmts = [{'param': 'MO', 'mo': 'MM'}, {'param': 'MO', 'mo': 'mm'}, ]
+    stmts = [{"param": "MO", "mo": "MM"}, {"param": "MO", "mo": "mm"}]
     for stmt in stmts:
         mo = MOParamStmt.from_dict(stmt)
-        assert_equal(mo.param, 'MO')
-        assert_equal(mo.mode, 'metric')
+        assert mo.param == "MO"
+        assert mo.mode == "metric"
 
-    stmt = {'param': 'MO'}
+    stmt = {"param": "MO"}
     mo = MOParamStmt.from_dict(stmt)
-    assert_equal(mo.mode, None)
-    stmt = {'param': 'MO', 'mo': 'degrees kelvin'}
-    assert_raises(ValueError, MOParamStmt.from_dict, stmt)
+    assert mo.mode == None
+    stmt = {"param": "MO", "mo": "degrees kelvin"}
+    pytest.raises(ValueError, MOParamStmt.from_dict, stmt)
 
 
 def test_MOParamStmt():
     """ Test MOParamStmt initialization
     """
-    param = 'MO'
-    mode = 'inch'
+    param = "MO"
+    mode = "inch"
     stmt = MOParamStmt(param, mode)
-    assert_equal(stmt.param, param)
+    assert stmt.param == param
 
-    for mode in ['inch', 'metric']:
+    for mode in ["inch", "metric"]:
         stmt = MOParamStmt(param, mode)
-        assert_equal(stmt.mode, mode)
+        assert stmt.mode == mode
 
 
 def test_MOParamStmt_dump():
     """ Test MOParamStmt to_gerber()
     """
-    stmt = {'param': 'MO', 'mo': 'IN'}
+    stmt = {"param": "MO", "mo": "IN"}
     mo = MOParamStmt.from_dict(stmt)
-    assert_equal(mo.to_gerber(), '%MOIN*%')
+    assert mo.to_gerber() == "%MOIN*%"
 
-    stmt = {'param': 'MO', 'mo': 'MM'}
+    stmt = {"param": "MO", "mo": "MM"}
     mo = MOParamStmt.from_dict(stmt)
-    assert_equal(mo.to_gerber(), '%MOMM*%')
+    assert mo.to_gerber() == "%MOMM*%"
 
 
 def test_MOParamStmt_conversion():
-    stmt = {'param': 'MO', 'mo': 'MM'}
+    stmt = {"param": "MO", "mo": "MM"}
     mo = MOParamStmt.from_dict(stmt)
     mo.to_inch()
-    assert_equal(mo.mode, 'inch')
+    assert mo.mode == "inch"
 
-    stmt = {'param': 'MO', 'mo': 'IN'}
+    stmt = {"param": "MO", "mo": "IN"}
     mo = MOParamStmt.from_dict(stmt)
     mo.to_metric()
-    assert_equal(mo.mode, 'metric')
+    assert mo.mode == "metric"
 
 
 def test_MOParamStmt_string():
     """ Test MOParamStmt.__str__()
     """
-    stmt = {'param': 'MO', 'mo': 'IN'}
+    stmt = {"param": "MO", "mo": "IN"}
     mo = MOParamStmt.from_dict(stmt)
-    assert_equal(str(mo), '<Mode: inches>')
+    assert str(mo) == "<Mode: inches>"
 
-    stmt = {'param': 'MO', 'mo': 'MM'}
+    stmt = {"param": "MO", "mo": "MM"}
     mo = MOParamStmt.from_dict(stmt)
-    assert_equal(str(mo), '<Mode: millimeters>')
+    assert str(mo) == "<Mode: millimeters>"
 
 
 def test_IPParamStmt_factory():
     """ Test IPParamStruct factory
     """
-    stmt = {'param': 'IP', 'ip': 'POS'}
+    stmt = {"param": "IP", "ip": "POS"}
     ip = IPParamStmt.from_dict(stmt)
-    assert_equal(ip.ip, 'positive')
+    assert ip.ip == "positive"
 
-    stmt = {'param': 'IP', 'ip': 'NEG'}
+    stmt = {"param": "IP", "ip": "NEG"}
     ip = IPParamStmt.from_dict(stmt)
-    assert_equal(ip.ip, 'negative')
+    assert ip.ip == "negative"
 
 
 def test_IPParamStmt():
     """ Test IPParamStmt initialization
     """
-    param = 'IP'
-    for ip in ['positive', 'negative']:
+    param = "IP"
+    for ip in ["positive", "negative"]:
         stmt = IPParamStmt(param, ip)
-        assert_equal(stmt.param, param)
-        assert_equal(stmt.ip, ip)
+        assert stmt.param == param
+        assert stmt.ip == ip
 
 
 def test_IPParamStmt_dump():
     """ Test IPParamStmt to_gerber()
     """
-    stmt = {'param': 'IP', 'ip': 'POS'}
+    stmt = {"param": "IP", "ip": "POS"}
     ip = IPParamStmt.from_dict(stmt)
-    assert_equal(ip.to_gerber(), '%IPPOS*%')
+    assert ip.to_gerber() == "%IPPOS*%"
 
-    stmt = {'param': 'IP', 'ip': 'NEG'}
+    stmt = {"param": "IP", "ip": "NEG"}
     ip = IPParamStmt.from_dict(stmt)
-    assert_equal(ip.to_gerber(), '%IPNEG*%')
+    assert ip.to_gerber() == "%IPNEG*%"
 
 
 def test_IPParamStmt_string():
-    stmt = {'param': 'IP', 'ip': 'POS'}
+    stmt = {"param": "IP", "ip": "POS"}
     ip = IPParamStmt.from_dict(stmt)
-    assert_equal(str(ip), '<Image Polarity: positive>')
+    assert str(ip) == "<Image Polarity: positive>"
 
-    stmt = {'param': 'IP', 'ip': 'NEG'}
+    stmt = {"param": "IP", "ip": "NEG"}
     ip = IPParamStmt.from_dict(stmt)
-    assert_equal(str(ip), '<Image Polarity: negative>')
+    assert str(ip) == "<Image Polarity: negative>"
 
 
 def test_IRParamStmt_factory():
-    stmt = {'param': 'IR', 'angle': '45'}
+    stmt = {"param": "IR", "angle": "45"}
     ir = IRParamStmt.from_dict(stmt)
-    assert_equal(ir.param, 'IR')
-    assert_equal(ir.angle, 45)
+    assert ir.param == "IR"
+    assert ir.angle == 45
 
 
 def test_IRParamStmt_dump():
-    stmt = {'param': 'IR', 'angle': '45'}
+    stmt = {"param": "IR", "angle": "45"}
     ir = IRParamStmt.from_dict(stmt)
-    assert_equal(ir.to_gerber(), '%IR45*%')
+    assert ir.to_gerber() == "%IR45*%"
 
 
 def test_IRParamStmt_string():
-    stmt = {'param': 'IR', 'angle': '45'}
+    stmt = {"param": "IR", "angle": "45"}
     ir = IRParamStmt.from_dict(stmt)
-    assert_equal(str(ir), '<Image Angle: 45>')
+    assert str(ir) == "<Image Angle: 45>"
 
 
 def test_OFParamStmt_factory():
     """ Test OFParamStmt factory
     """
-    stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'}
+    stmt = {"param": "OF", "a": "0.1234567", "b": "0.1234567"}
     of = OFParamStmt.from_dict(stmt)
-    assert_equal(of.a, 0.1234567)
-    assert_equal(of.b, 0.1234567)
+    assert of.a == 0.1234567
+    assert of.b == 0.1234567
 
 
 def test_OFParamStmt():
     """ Test IPParamStmt initialization
     """
-    param = 'OF'
+    param = "OF"
     for val in [0.0, -3.4567]:
         stmt = OFParamStmt(param, val, val)
-        assert_equal(stmt.param, param)
-        assert_equal(stmt.a, val)
-        assert_equal(stmt.b, val)
+        assert stmt.param == param
+        assert stmt.a == val
+        assert stmt.b == val
 
 
 def test_OFParamStmt_dump():
     """ Test OFParamStmt to_gerber()
     """
-    stmt = {'param': 'OF', 'a': '0.123456', 'b': '0.123456'}
+    stmt = {"param": "OF", "a": "0.123456", "b": "0.123456"}
     of = OFParamStmt.from_dict(stmt)
-    assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%')
+    assert of.to_gerber() == "%OFA0.12345B0.12345*%"
 
 
 def test_OFParamStmt_conversion():
-    stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'}
+    stmt = {"param": "OF", "a": "2.54", "b": "25.4"}
     of = OFParamStmt.from_dict(stmt)
-    of.units = 'metric'
+    of.units = "metric"
 
     # No effect
     of.to_metric()
-    assert_equal(of.a, 2.54)
-    assert_equal(of.b, 25.4)
+    assert of.a == 2.54
+    assert of.b == 25.4
 
     of.to_inch()
-    assert_equal(of.units, 'inch')
-    assert_equal(of.a, 0.1)
-    assert_equal(of.b, 1.0)
+    assert of.units == "inch"
+    assert of.a == 0.1
+    assert of.b == 1.0
 
     # No effect
     of.to_inch()
-    assert_equal(of.a, 0.1)
-    assert_equal(of.b, 1.0)
+    assert of.a == 0.1
+    assert of.b == 1.0
 
-    stmt = {'param': 'OF', 'a': '0.1', 'b': '1.0'}
+    stmt = {"param": "OF", "a": "0.1", "b": "1.0"}
     of = OFParamStmt.from_dict(stmt)
-    of.units = 'inch'
+    of.units = "inch"
 
     # No effect
     of.to_inch()
-    assert_equal(of.a, 0.1)
-    assert_equal(of.b, 1.0)
+    assert of.a == 0.1
+    assert of.b == 1.0
 
     of.to_metric()
-    assert_equal(of.units, 'metric')
-    assert_equal(of.a, 2.54)
-    assert_equal(of.b, 25.4)
+    assert of.units == "metric"
+    assert of.a == 2.54
+    assert of.b == 25.4
 
     # No effect
     of.to_metric()
-    assert_equal(of.a, 2.54)
-    assert_equal(of.b, 25.4)
+    assert of.a == 2.54
+    assert of.b == 25.4
 
 
 def test_OFParamStmt_offset():
-    s = OFParamStmt('OF', 0, 0)
+    s = OFParamStmt("OF", 0, 0)
     s.offset(1, 0)
-    assert_equal(s.a, 1.)
-    assert_equal(s.b, 0.)
+    assert s.a == 1.0
+    assert s.b == 0.0
     s.offset(0, 1)
-    assert_equal(s.a, 1.)
-    assert_equal(s.b, 1.)
+    assert s.a == 1.0
+    assert s.b == 1.0
 
 
 def test_OFParamStmt_string():
     """ Test OFParamStmt __str__
     """
-    stmt = {'param': 'OF', 'a': '0.123456', 'b': '0.123456'}
+    stmt = {"param": "OF", "a": "0.123456", "b": "0.123456"}
     of = OFParamStmt.from_dict(stmt)
-    assert_equal(str(of), '<Offset: X: 0.123456 Y: 0.123456 >')
+    assert str(of) == "<Offset: X: 0.123456 Y: 0.123456 >"
 
 
 def test_SFParamStmt_factory():
-    stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'}
+    stmt = {"param": "SF", "a": "1.4", "b": "0.9"}
     sf = SFParamStmt.from_dict(stmt)
-    assert_equal(sf.param, 'SF')
-    assert_equal(sf.a, 1.4)
-    assert_equal(sf.b, 0.9)
+    assert sf.param == "SF"
+    assert sf.a == 1.4
+    assert sf.b == 0.9
 
 
 def test_SFParamStmt_dump():
-    stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'}
+    stmt = {"param": "SF", "a": "1.4", "b": "0.9"}
     sf = SFParamStmt.from_dict(stmt)
-    assert_equal(sf.to_gerber(), '%SFA1.4B0.9*%')
+    assert sf.to_gerber() == "%SFA1.4B0.9*%"
 
 
 def test_SFParamStmt_conversion():
-    stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'}
+    stmt = {"param": "OF", "a": "2.54", "b": "25.4"}
     of = SFParamStmt.from_dict(stmt)
-    of.units = 'metric'
+    of.units = "metric"
     of.to_metric()
 
     # No effect
-    assert_equal(of.a, 2.54)
-    assert_equal(of.b, 25.4)
+    assert of.a == 2.54
+    assert of.b == 25.4
 
     of.to_inch()
-    assert_equal(of.units, 'inch')
-    assert_equal(of.a, 0.1)
-    assert_equal(of.b, 1.0)
+    assert of.units == "inch"
+    assert of.a == 0.1
+    assert of.b == 1.0
 
     # No effect
     of.to_inch()
-    assert_equal(of.a, 0.1)
-    assert_equal(of.b, 1.0)
+    assert of.a == 0.1
+    assert of.b == 1.0
 
-    stmt = {'param': 'OF', 'a': '0.1', 'b': '1.0'}
+    stmt = {"param": "OF", "a": "0.1", "b": "1.0"}
     of = SFParamStmt.from_dict(stmt)
-    of.units = 'inch'
+    of.units = "inch"
 
     # No effect
     of.to_inch()
-    assert_equal(of.a, 0.1)
-    assert_equal(of.b, 1.0)
+    assert of.a == 0.1
+    assert of.b == 1.0
 
     of.to_metric()
-    assert_equal(of.units, 'metric')
-    assert_equal(of.a, 2.54)
-    assert_equal(of.b, 25.4)
+    assert of.units == "metric"
+    assert of.a == 2.54
+    assert of.b == 25.4
 
     # No effect
     of.to_metric()
-    assert_equal(of.a, 2.54)
-    assert_equal(of.b, 25.4)
+    assert of.a == 2.54
+    assert of.b == 25.4
 
 
 def test_SFParamStmt_offset():
-    s = SFParamStmt('OF', 0, 0)
+    s = SFParamStmt("OF", 0, 0)
     s.offset(1, 0)
-    assert_equal(s.a, 1.)
-    assert_equal(s.b, 0.)
+    assert s.a == 1.0
+    assert s.b == 0.0
     s.offset(0, 1)
-    assert_equal(s.a, 1.)
-    assert_equal(s.b, 1.)
+    assert s.a == 1.0
+    assert s.b == 1.0
 
 
 def test_SFParamStmt_string():
-    stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'}
+    stmt = {"param": "SF", "a": "1.4", "b": "0.9"}
     sf = SFParamStmt.from_dict(stmt)
-    assert_equal(str(sf), '<Scale Factor: X: 1.4 Y: 0.9>')
+    assert str(sf) == "<Scale Factor: X: 1.4 Y: 0.9>"
 
 
 def test_LPParamStmt_factory():
     """ Test LPParamStmt factory
     """
-    stmt = {'param': 'LP', 'lp': 'C'}
+    stmt = {"param": "LP", "lp": "C"}
     lp = LPParamStmt.from_dict(stmt)
-    assert_equal(lp.lp, 'clear')
+    assert lp.lp == "clear"
 
-    stmt = {'param': 'LP', 'lp': 'D'}
+    stmt = {"param": "LP", "lp": "D"}
     lp = LPParamStmt.from_dict(stmt)
-    assert_equal(lp.lp, 'dark')
+    assert lp.lp == "dark"
 
 
 def test_LPParamStmt_dump():
     """ Test LPParamStmt to_gerber()
     """
-    stmt = {'param': 'LP', 'lp': 'C'}
+    stmt = {"param": "LP", "lp": "C"}
     lp = LPParamStmt.from_dict(stmt)
-    assert_equal(lp.to_gerber(), '%LPC*%')
+    assert lp.to_gerber() == "%LPC*%"
 
-    stmt = {'param': 'LP', 'lp': 'D'}
+    stmt = {"param": "LP", "lp": "D"}
     lp = LPParamStmt.from_dict(stmt)
-    assert_equal(lp.to_gerber(), '%LPD*%')
+    assert lp.to_gerber() == "%LPD*%"
 
 
 def test_LPParamStmt_string():
     """ Test LPParamStmt.__str__()
     """
-    stmt = {'param': 'LP', 'lp': 'D'}
+    stmt = {"param": "LP", "lp": "D"}
     lp = LPParamStmt.from_dict(stmt)
-    assert_equal(str(lp), '<Level Polarity: dark>')
+    assert str(lp) == "<Level Polarity: dark>"
 
-    stmt = {'param': 'LP', 'lp': 'C'}
+    stmt = {"param": "LP", "lp": "C"}
     lp = LPParamStmt.from_dict(stmt)
-    assert_equal(str(lp), '<Level Polarity: clear>')
+    assert str(lp) == "<Level Polarity: clear>"
 
 
 def test_AMParamStmt_factory():
-    name = 'DONUTVAR'
-    macro = (
-'''0 Test Macro. *
+    name = "DONUTVAR"
+    macro = """0 Test Macro. *
 1,1,1.5,0,0*
 20,1,0.9,0,0.45,12,0.45,0*
 21,1,6.8,1.2,3.4,0.6,0*
@@ -420,533 +419,541 @@ def test_AMParamStmt_factory():
 6,0,0,5,0.5,0.5,2,0.1,6,0*
 7,0,0,7,6,0.2,0*
 8,THIS IS AN UNSUPPORTED PRIMITIVE*
-''')
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
+"""
+    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
     s.build()
-    assert_equal(len(s.primitives), 10)
-    assert_true(isinstance(s.primitives[0], AMCommentPrimitive))
-    assert_true(isinstance(s.primitives[1], AMCirclePrimitive))
-    assert_true(isinstance(s.primitives[2], AMVectorLinePrimitive))
-    assert_true(isinstance(s.primitives[3], AMCenterLinePrimitive))
-    assert_true(isinstance(s.primitives[4], AMLowerLeftLinePrimitive))
-    assert_true(isinstance(s.primitives[5], AMOutlinePrimitive))
-    assert_true(isinstance(s.primitives[6], AMPolygonPrimitive))
-    assert_true(isinstance(s.primitives[7], AMMoirePrimitive))
-    assert_true(isinstance(s.primitives[8], AMThermalPrimitive))
-    assert_true(isinstance(s.primitives[9], AMUnsupportPrimitive))
+    assert len(s.primitives) == 10
+    assert isinstance(s.primitives[0], AMCommentPrimitive)
+    assert isinstance(s.primitives[1], AMCirclePrimitive)
+    assert isinstance(s.primitives[2], AMVectorLinePrimitive)
+    assert isinstance(s.primitives[3], AMCenterLinePrimitive)
+    assert isinstance(s.primitives[4], AMLowerLeftLinePrimitive)
+    assert isinstance(s.primitives[5], AMOutlinePrimitive)
+    assert isinstance(s.primitives[6], AMPolygonPrimitive)
+    assert isinstance(s.primitives[7], AMMoirePrimitive)
+    assert isinstance(s.primitives[8], AMThermalPrimitive)
+    assert isinstance(s.primitives[9], AMUnsupportPrimitive)
 
 
 def testAMParamStmt_conversion():
-    name = 'POLYGON'
-    macro = '5,1,8,25.4,25.4,25.4,0*'
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
+    name = "POLYGON"
+    macro = "5,1,8,25.4,25.4,25.4,0*"
+    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
 
     s.build()
-    s.units = 'metric'
+    s.units = "metric"
 
     # No effect
     s.to_metric()
-    assert_equal(s.primitives[0].position, (25.4, 25.4))
-    assert_equal(s.primitives[0].diameter, 25.4)
+    assert s.primitives[0].position == (25.4, 25.4)
+    assert s.primitives[0].diameter == 25.4
 
     s.to_inch()
-    assert_equal(s.units, 'inch')
-    assert_equal(s.primitives[0].position, (1., 1.))
-    assert_equal(s.primitives[0].diameter, 1.)
+    assert s.units == "inch"
+    assert s.primitives[0].position == (1.0, 1.0)
+    assert s.primitives[0].diameter == 1.0
 
     # No effect
     s.to_inch()
-    assert_equal(s.primitives[0].position, (1., 1.))
-    assert_equal(s.primitives[0].diameter, 1.)
+    assert s.primitives[0].position == (1.0, 1.0)
+    assert s.primitives[0].diameter == 1.0
 
-    macro = '5,1,8,1,1,1,0*'
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
+    macro = "5,1,8,1,1,1,0*"
+    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
     s.build()
-    s.units = 'inch'
+    s.units = "inch"
 
     # No effect
     s.to_inch()
-    assert_equal(s.primitives[0].position, (1., 1.))
-    assert_equal(s.primitives[0].diameter, 1.)
+    assert s.primitives[0].position == (1.0, 1.0)
+    assert s.primitives[0].diameter == 1.0
 
     s.to_metric()
-    assert_equal(s.units, 'metric')
-    assert_equal(s.primitives[0].position, (25.4, 25.4))
-    assert_equal(s.primitives[0].diameter, 25.4)
+    assert s.units == "metric"
+    assert s.primitives[0].position == (25.4, 25.4)
+    assert s.primitives[0].diameter == 25.4
 
     # No effect
     s.to_metric()
-    assert_equal(s.primitives[0].position, (25.4, 25.4))
-    assert_equal(s.primitives[0].diameter, 25.4)
+    assert s.primitives[0].position == (25.4, 25.4)
+    assert s.primitives[0].diameter == 25.4
 
 
 def test_AMParamStmt_dump():
-    name = 'POLYGON'
-    macro = '5,1,8,25.4,25.4,25.4,0.0'
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
+    name = "POLYGON"
+    macro = "5,1,8,25.4,25.4,25.4,0.0"
+    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
     s.build()
-    assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%')
+    assert s.to_gerber() == "%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%"
 
-    #TODO - Store Equations and update on unit change...
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': 'OC8', 'macro': '5,1,8,0,0,1.08239X$1,22.5'})
+    # TODO - Store Equations and update on unit change...
+    s = AMParamStmt.from_dict(
+        {"param": "AM", "name": "OC8", "macro": "5,1,8,0,0,1.08239X$1,22.5"}
+    )
     s.build()
-    #assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,22.5*%')
-    assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,0,22.5*%')
+    # assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,22.5*%')
+    assert s.to_gerber() == "%AMOC8*5,1,8,0,0,0,22.5*%"
 
 
 def test_AMParamStmt_string():
-    name = 'POLYGON'
-    macro = '5,1,8,25.4,25.4,25.4,0*'
-    s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
+    name = "POLYGON"
+    macro = "5,1,8,25.4,25.4,25.4,0*"
+    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro})
     s.build()
-    assert_equal(str(s), '<Aperture Macro POLYGON: 5,1,8,25.4,25.4,25.4,0*>')
+    assert str(s) == "<Aperture Macro POLYGON: 5,1,8,25.4,25.4,25.4,0*>"
 
 
 def test_ASParamStmt_factory():
-    stmt = {'param': 'AS', 'mode': 'AXBY'}
+    stmt = {"param": "AS", "mode": "AXBY"}
     s = ASParamStmt.from_dict(stmt)
-    assert_equal(s.param, 'AS')
-    assert_equal(s.mode, 'AXBY')
+    assert s.param == "AS"
+    assert s.mode == "AXBY"
 
 
 def test_ASParamStmt_dump():
-    stmt = {'param': 'AS', 'mode': 'AXBY'}
+    stmt = {"param": "AS", "mode": "AXBY"}
     s = ASParamStmt.from_dict(stmt)
-    assert_equal(s.to_gerber(), '%ASAXBY*%')
+    assert s.to_gerber() == "%ASAXBY*%"
 
 
 def test_ASParamStmt_string():
-    stmt = {'param': 'AS', 'mode': 'AXBY'}
+    stmt = {"param": "AS", "mode": "AXBY"}
     s = ASParamStmt.from_dict(stmt)
-    assert_equal(str(s), '<Axis Select: AXBY>')
+    assert str(s) == "<Axis Select: AXBY>"
 
 
 def test_INParamStmt_factory():
     """ Test INParamStmt factory
     """
-    stmt = {'param': 'IN', 'name': 'test'}
+    stmt = {"param": "IN", "name": "test"}
     inp = INParamStmt.from_dict(stmt)
-    assert_equal(inp.name, 'test')
+    assert inp.name == "test"
 
 
 def test_INParamStmt_dump():
     """ Test INParamStmt to_gerber()
     """
-    stmt = {'param': 'IN', 'name': 'test'}
+    stmt = {"param": "IN", "name": "test"}
     inp = INParamStmt.from_dict(stmt)
-    assert_equal(inp.to_gerber(), '%INtest*%')
+    assert inp.to_gerber() == "%INtest*%"
 
 
 def test_INParamStmt_string():
-    stmt = {'param': 'IN', 'name': 'test'}
+    stmt = {"param": "IN", "name": "test"}
     inp = INParamStmt.from_dict(stmt)
-    assert_equal(str(inp), '<Image Name: test>')
+    assert str(inp) == "<Image Name: test>"
 
 
 def test_LNParamStmt_factory():
     """ Test LNParamStmt factory
     """
-    stmt = {'param': 'LN', 'name': 'test'}
+    stmt = {"param": "LN", "name": "test"}
     lnp = LNParamStmt.from_dict(stmt)
-    assert_equal(lnp.name, 'test')
+    assert lnp.name == "test"
 
 
 def test_LNParamStmt_dump():
     """ Test LNParamStmt to_gerber()
     """
-    stmt = {'param': 'LN', 'name': 'test'}
+    stmt = {"param": "LN", "name": "test"}
     lnp = LNParamStmt.from_dict(stmt)
-    assert_equal(lnp.to_gerber(), '%LNtest*%')
+    assert lnp.to_gerber() == "%LNtest*%"
 
 
 def test_LNParamStmt_string():
-    stmt = {'param': 'LN', 'name': 'test'}
+    stmt = {"param": "LN", "name": "test"}
     lnp = LNParamStmt.from_dict(stmt)
-    assert_equal(str(lnp), '<Level Name: test>')
+    assert str(lnp) == "<Level Name: test>"
 
 
 def test_comment_stmt():
     """ Test comment statement
     """
-    stmt = CommentStmt('A comment')
-    assert_equal(stmt.type, 'COMMENT')
-    assert_equal(stmt.comment, 'A comment')
+    stmt = CommentStmt("A comment")
+    assert stmt.type == "COMMENT"
+    assert stmt.comment == "A comment"
 
 
 def test_comment_stmt_dump():
     """ Test CommentStmt to_gerber()
     """
-    stmt = CommentStmt('A comment')
-    assert_equal(stmt.to_gerber(), 'G04A comment*')
+    stmt = CommentStmt("A comment")
+    assert stmt.to_gerber() == "G04A comment*"
 
 
 def test_comment_stmt_string():
-    stmt = CommentStmt('A comment')
-    assert_equal(str(stmt), '<Comment: A comment>')
+    stmt = CommentStmt("A comment")
+    assert str(stmt) == "<Comment: A comment>"
 
 
 def test_eofstmt():
     """ Test EofStmt
     """
     stmt = EofStmt()
-    assert_equal(stmt.type, 'EOF')
+    assert stmt.type == "EOF"
 
 
 def test_eofstmt_dump():
     """ Test EofStmt to_gerber()
     """
     stmt = EofStmt()
-    assert_equal(stmt.to_gerber(), 'M02*')
+    assert stmt.to_gerber() == "M02*"
 
 
 def test_eofstmt_string():
-    assert_equal(str(EofStmt()), '<EOF Statement>')
+    assert str(EofStmt()) == "<EOF Statement>"
 
 
 def test_quadmodestmt_factory():
     """ Test QuadrantModeStmt.from_gerber()
     """
-    line = 'G74*'
+    line = "G74*"
     stmt = QuadrantModeStmt.from_gerber(line)
-    assert_equal(stmt.type, 'QuadrantMode')
-    assert_equal(stmt.mode, 'single-quadrant')
+    assert stmt.type == "QuadrantMode"
+    assert stmt.mode == "single-quadrant"
 
-    line = 'G75*'
+    line = "G75*"
     stmt = QuadrantModeStmt.from_gerber(line)
-    assert_equal(stmt.mode, 'multi-quadrant')
+    assert stmt.mode == "multi-quadrant"
 
 
 def test_quadmodestmt_validation():
     """ Test QuadrantModeStmt input validation
     """
-    line = 'G76*'
-    assert_raises(ValueError, QuadrantModeStmt.from_gerber, line)
-    assert_raises(ValueError, QuadrantModeStmt, 'quadrant-ful')
+    line = "G76*"
+    pytest.raises(ValueError, QuadrantModeStmt.from_gerber, line)
+    pytest.raises(ValueError, QuadrantModeStmt, "quadrant-ful")
 
 
 def test_quadmodestmt_dump():
     """ Test QuadrantModeStmt.to_gerber()
     """
-    for line in ('G74*', 'G75*',):
+    for line in ("G74*", "G75*"):
         stmt = QuadrantModeStmt.from_gerber(line)
-        assert_equal(stmt.to_gerber(), line)
+        assert stmt.to_gerber() == line
 
 
 def test_regionmodestmt_factory():
     """ Test RegionModeStmt.from_gerber()
     """
-    line = 'G36*'
+    line = "G36*"
     stmt = RegionModeStmt.from_gerber(line)
-    assert_equal(stmt.type, 'RegionMode')
-    assert_equal(stmt.mode, 'on')
+    assert stmt.type == "RegionMode"
+    assert stmt.mode == "on"
 
-    line = 'G37*'
+    line = "G37*"
     stmt = RegionModeStmt.from_gerber(line)
-    assert_equal(stmt.mode, 'off')
+    assert stmt.mode == "off"
 
 
 def test_regionmodestmt_validation():
     """ Test RegionModeStmt input validation
     """
-    line = 'G38*'
-    assert_raises(ValueError, RegionModeStmt.from_gerber, line)
-    assert_raises(ValueError, RegionModeStmt, 'off-ish')
+    line = "G38*"
+    pytest.raises(ValueError, RegionModeStmt.from_gerber, line)
+    pytest.raises(ValueError, RegionModeStmt, "off-ish")
 
 
 def test_regionmodestmt_dump():
     """ Test RegionModeStmt.to_gerber()
     """
-    for line in ('G36*', 'G37*',):
+    for line in ("G36*", "G37*"):
         stmt = RegionModeStmt.from_gerber(line)
-        assert_equal(stmt.to_gerber(), line)
+        assert stmt.to_gerber() == line
 
 
 def test_unknownstmt():
     """ Test UnknownStmt
     """
-    line = 'G696969*'
+    line = "G696969*"
     stmt = UnknownStmt(line)
-    assert_equal(stmt.type, 'UNKNOWN')
-    assert_equal(stmt.line, line)
+    assert stmt.type == "UNKNOWN"
+    assert stmt.line == line
 
 
 def test_unknownstmt_dump():
     """ Test UnknownStmt.to_gerber()
     """
-    lines = ('G696969*', 'M03*',)
+    lines = ("G696969*", "M03*")
     for line in lines:
         stmt = UnknownStmt(line)
-        assert_equal(stmt.to_gerber(), line)
+        assert stmt.to_gerber() == line
 
 
 def test_statement_string():
     """ Test Statement.__str__()
     """
-    stmt = Statement('PARAM')
-    assert_in('type=PARAM', str(stmt))
-    stmt.test = 'PASS'
-    assert_in('test=PASS', str(stmt))
-    assert_in('type=PARAM', str(stmt))
+    stmt = Statement("PARAM")
+    assert "type=PARAM" in str(stmt)
+    stmt.test = "PASS"
+    assert "test=PASS" in str(stmt)
+    assert "type=PARAM" in str(stmt)
 
 
 def test_ADParamStmt_factory():
     """ Test ADParamStmt factory
     """
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'C'}
+    stmt = {"param": "AD", "d": 0, "shape": "C"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(ad.d, 0)
-    assert_equal(ad.shape, 'C')
+    assert ad.d == 0
+    assert ad.shape == "C"
 
-    stmt = {'param': 'AD', 'd': 1, 'shape': 'R'}
+    stmt = {"param": "AD", "d": 1, "shape": "R"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(ad.d, 1)
-    assert_equal(ad.shape, 'R')
+    assert ad.d == 1
+    assert ad.shape == "R"
 
-    stmt = {'param': 'AD', 'd': 1, 'shape': 'C', "modifiers": "1.42"}
+    stmt = {"param": "AD", "d": 1, "shape": "C", "modifiers": "1.42"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(ad.d, 1)
-    assert_equal(ad.shape, 'C')
-    assert_equal(ad.modifiers, [(1.42,)])
+    assert ad.d == 1
+    assert ad.shape == "C"
+    assert ad.modifiers == [(1.42,)]
 
-    stmt = {'param': 'AD', 'd': 1, 'shape': 'C', "modifiers": "1.42X"}
+    stmt = {"param": "AD", "d": 1, "shape": "C", "modifiers": "1.42X"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(ad.d, 1)
-    assert_equal(ad.shape, 'C')
-    assert_equal(ad.modifiers, [(1.42,)])
+    assert ad.d == 1
+    assert ad.shape == "C"
+    assert ad.modifiers == [(1.42,)]
 
-    stmt = {'param': 'AD', 'd': 1, 'shape': 'R', "modifiers": "1.42X1.24"}
+    stmt = {"param": "AD", "d": 1, "shape": "R", "modifiers": "1.42X1.24"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(ad.d, 1)
-    assert_equal(ad.shape, 'R')
-    assert_equal(ad.modifiers, [(1.42, 1.24)])
+    assert ad.d == 1
+    assert ad.shape == "R"
+    assert ad.modifiers == [(1.42, 1.24)]
 
 
 def test_ADParamStmt_conversion():
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'C',
-            'modifiers': '25.4X25.4,25.4X25.4'}
+    stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "25.4X25.4,25.4X25.4"}
     ad = ADParamStmt.from_dict(stmt)
-    ad.units = 'metric'
+    ad.units = "metric"
 
     # No effect
     ad.to_metric()
-    assert_equal(ad.modifiers[0], (25.4, 25.4))
-    assert_equal(ad.modifiers[1], (25.4, 25.4))
+    assert ad.modifiers[0] == (25.4, 25.4)
+    assert ad.modifiers[1] == (25.4, 25.4)
 
     ad.to_inch()
-    assert_equal(ad.units, 'inch')
-    assert_equal(ad.modifiers[0], (1., 1.))
-    assert_equal(ad.modifiers[1], (1., 1.))
+    assert ad.units == "inch"
+    assert ad.modifiers[0] == (1.0, 1.0)
+    assert ad.modifiers[1] == (1.0, 1.0)
 
     # No effect
     ad.to_inch()
-    assert_equal(ad.modifiers[0], (1., 1.))
-    assert_equal(ad.modifiers[1], (1., 1.))
+    assert ad.modifiers[0] == (1.0, 1.0)
+    assert ad.modifiers[1] == (1.0, 1.0)
 
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '1X1,1X1'}
+    stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "1X1,1X1"}
     ad = ADParamStmt.from_dict(stmt)
-    ad.units = 'inch'
+    ad.units = "inch"
 
     # No effect
     ad.to_inch()
-    assert_equal(ad.modifiers[0], (1., 1.))
-    assert_equal(ad.modifiers[1], (1., 1.))
+    assert ad.modifiers[0] == (1.0, 1.0)
+    assert ad.modifiers[1] == (1.0, 1.0)
 
     ad.to_metric()
-    assert_equal(ad.modifiers[0], (25.4, 25.4))
-    assert_equal(ad.modifiers[1], (25.4, 25.4))
+    assert ad.modifiers[0] == (25.4, 25.4)
+    assert ad.modifiers[1] == (25.4, 25.4)
 
     # No effect
     ad.to_metric()
-    assert_equal(ad.modifiers[0], (25.4, 25.4))
-    assert_equal(ad.modifiers[1], (25.4, 25.4))
+    assert ad.modifiers[0] == (25.4, 25.4)
+    assert ad.modifiers[1] == (25.4, 25.4)
 
 
 def test_ADParamStmt_dump():
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'C'}
+    stmt = {"param": "AD", "d": 0, "shape": "C"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(ad.to_gerber(), '%ADD0C*%')
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '1X1,1X1'}
+    assert ad.to_gerber() == "%ADD0C*%"
+    stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "1X1,1X1"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(ad.to_gerber(), '%ADD0C,1X1,1X1*%')
+    assert ad.to_gerber() == "%ADD0C,1X1,1X1*%"
 
 
 def test_ADPamramStmt_string():
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'C'}
+    stmt = {"param": "AD", "d": 0, "shape": "C"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(str(ad), '<Aperture Definition: 0: circle>')
+    assert str(ad) == "<Aperture Definition: 0: circle>"
 
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'R'}
+    stmt = {"param": "AD", "d": 0, "shape": "R"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(str(ad), '<Aperture Definition: 0: rectangle>')
+    assert str(ad) == "<Aperture Definition: 0: rectangle>"
 
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'O'}
+    stmt = {"param": "AD", "d": 0, "shape": "O"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(str(ad), '<Aperture Definition: 0: obround>')
+    assert str(ad) == "<Aperture Definition: 0: obround>"
 
-    stmt = {'param': 'AD', 'd': 0, 'shape': 'test'}
+    stmt = {"param": "AD", "d": 0, "shape": "test"}
     ad = ADParamStmt.from_dict(stmt)
-    assert_equal(str(ad), '<Aperture Definition: 0: test>')
+    assert str(ad) == "<Aperture Definition: 0: test>"
 
 
 def test_MIParamStmt_factory():
-    stmt = {'param': 'MI', 'a': 1, 'b': 1}
+    stmt = {"param": "MI", "a": 1, "b": 1}
     mi = MIParamStmt.from_dict(stmt)
-    assert_equal(mi.a, 1)
-    assert_equal(mi.b, 1)
+    assert mi.a == 1
+    assert mi.b == 1
 
 
 def test_MIParamStmt_dump():
-    stmt = {'param': 'MI', 'a': 1, 'b': 1}
+    stmt = {"param": "MI", "a": 1, "b": 1}
     mi = MIParamStmt.from_dict(stmt)
-    assert_equal(mi.to_gerber(), '%MIA1B1*%')
-    stmt = {'param': 'MI', 'a': 1}
+    assert mi.to_gerber() == "%MIA1B1*%"
+    stmt = {"param": "MI", "a": 1}
     mi = MIParamStmt.from_dict(stmt)
-    assert_equal(mi.to_gerber(), '%MIA1B0*%')
-    stmt = {'param': 'MI', 'b': 1}
+    assert mi.to_gerber() == "%MIA1B0*%"
+    stmt = {"param": "MI", "b": 1}
     mi = MIParamStmt.from_dict(stmt)
-    assert_equal(mi.to_gerber(), '%MIA0B1*%')
+    assert mi.to_gerber() == "%MIA0B1*%"
 
 
 def test_MIParamStmt_string():
-    stmt = {'param': 'MI', 'a': 1, 'b': 1}
+    stmt = {"param": "MI", "a": 1, "b": 1}
     mi = MIParamStmt.from_dict(stmt)
-    assert_equal(str(mi), '<Image Mirror: A=1 B=1>')
+    assert str(mi) == "<Image Mirror: A=1 B=1>"
 
-    stmt = {'param': 'MI', 'b': 1}
+    stmt = {"param": "MI", "b": 1}
     mi = MIParamStmt.from_dict(stmt)
-    assert_equal(str(mi), '<Image Mirror: A=0 B=1>')
+    assert str(mi) == "<Image Mirror: A=0 B=1>"
 
-    stmt = {'param': 'MI', 'a': 1}
+    stmt = {"param": "MI", "a": 1}
     mi = MIParamStmt.from_dict(stmt)
-    assert_equal(str(mi), '<Image Mirror: A=1 B=0>')
+    assert str(mi) == "<Image Mirror: A=1 B=0>"
 
 
 def test_coordstmt_ctor():
-    cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings())
-    assert_equal(cs.function, 'G04')
-    assert_equal(cs.x, 0.0)
-    assert_equal(cs.y, 0.1)
-    assert_equal(cs.i, 0.2)
-    assert_equal(cs.j, 0.3)
-    assert_equal(cs.op, 'D01')
+    cs = CoordStmt("G04", 0.0, 0.1, 0.2, 0.3, "D01", FileSettings())
+    assert cs.function == "G04"
+    assert cs.x == 0.0
+    assert cs.y == 0.1
+    assert cs.i == 0.2
+    assert cs.j == 0.3
+    assert cs.op == "D01"
 
 
 def test_coordstmt_factory():
-    stmt = {'function': 'G04', 'x': '0', 'y': '001',
-            'i': '002', 'j': '003', 'op': 'D01'}
+    stmt = {
+        "function": "G04",
+        "x": "0",
+        "y": "001",
+        "i": "002",
+        "j": "003",
+        "op": "D01",
+    }
     cs = CoordStmt.from_dict(stmt, FileSettings())
-    assert_equal(cs.function, 'G04')
-    assert_equal(cs.x, 0.0)
-    assert_equal(cs.y, 0.1)
-    assert_equal(cs.i, 0.2)
-    assert_equal(cs.j, 0.3)
-    assert_equal(cs.op, 'D01')
+    assert cs.function == "G04"
+    assert cs.x == 0.0
+    assert cs.y == 0.1
+    assert cs.i == 0.2
+    assert cs.j == 0.3
+    assert cs.op == "D01"
 
 
 def test_coordstmt_dump():
-    cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings())
-    assert_equal(cs.to_gerber(FileSettings()), 'G04X0Y001I002J003D01*')
+    cs = CoordStmt("G04", 0.0, 0.1, 0.2, 0.3, "D01", FileSettings())
+    assert cs.to_gerber(FileSettings()) == "G04X0Y001I002J003D01*"
 
 
 def test_coordstmt_conversion():
-    cs = CoordStmt('G71', 25.4, 25.4, 25.4, 25.4, 'D01', FileSettings())
-    cs.units = 'metric'
+    cs = CoordStmt("G71", 25.4, 25.4, 25.4, 25.4, "D01", FileSettings())
+    cs.units = "metric"
 
     # No effect
     cs.to_metric()
-    assert_equal(cs.x, 25.4)
-    assert_equal(cs.y, 25.4)
-    assert_equal(cs.i, 25.4)
-    assert_equal(cs.j, 25.4)
-    assert_equal(cs.function, 'G71')
+    assert cs.x == 25.4
+    assert cs.y == 25.4
+    assert cs.i == 25.4
+    assert cs.j == 25.4
+    assert cs.function == "G71"
 
     cs.to_inch()
-    assert_equal(cs.units, 'inch')
-    assert_equal(cs.x, 1.)
-    assert_equal(cs.y, 1.)
-    assert_equal(cs.i, 1.)
-    assert_equal(cs.j, 1.)
-    assert_equal(cs.function, 'G70')
+    assert cs.units == "inch"
+    assert cs.x == 1.0
+    assert cs.y == 1.0
+    assert cs.i == 1.0
+    assert cs.j == 1.0
+    assert cs.function == "G70"
 
     # No effect
     cs.to_inch()
-    assert_equal(cs.x, 1.)
-    assert_equal(cs.y, 1.)
-    assert_equal(cs.i, 1.)
-    assert_equal(cs.j, 1.)
-    assert_equal(cs.function, 'G70')
+    assert cs.x == 1.0
+    assert cs.y == 1.0
+    assert cs.i == 1.0
+    assert cs.j == 1.0
+    assert cs.function == "G70"
 
-    cs = CoordStmt('G70', 1., 1., 1., 1., 'D01', FileSettings())
-    cs.units = 'inch'
+    cs = CoordStmt("G70", 1.0, 1.0, 1.0, 1.0, "D01", FileSettings())
+    cs.units = "inch"
 
     # No effect
     cs.to_inch()
-    assert_equal(cs.x, 1.)
-    assert_equal(cs.y, 1.)
-    assert_equal(cs.i, 1.)
-    assert_equal(cs.j, 1.)
-    assert_equal(cs.function, 'G70')
+    assert cs.x == 1.0
+    assert cs.y == 1.0
+    assert cs.i == 1.0
+    assert cs.j == 1.0
+    assert cs.function == "G70"
 
     cs.to_metric()
-    assert_equal(cs.x, 25.4)
-    assert_equal(cs.y, 25.4)
-    assert_equal(cs.i, 25.4)
-    assert_equal(cs.j, 25.4)
-    assert_equal(cs.function, 'G71')
+    assert cs.x == 25.4
+    assert cs.y == 25.4
+    assert cs.i == 25.4
+    assert cs.j == 25.4
+    assert cs.function == "G71"
 
     # No effect
     cs.to_metric()
-    assert_equal(cs.x, 25.4)
-    assert_equal(cs.y, 25.4)
-    assert_equal(cs.i, 25.4)
-    assert_equal(cs.j, 25.4)
-    assert_equal(cs.function, 'G71')
+    assert cs.x == 25.4
+    assert cs.y == 25.4
+    assert cs.i == 25.4
+    assert cs.j == 25.4
+    assert cs.function == "G71"
 
 
 def test_coordstmt_offset():
-    c = CoordStmt('G71', 0, 0, 0, 0, 'D01', FileSettings())
+    c = CoordStmt("G71", 0, 0, 0, 0, "D01", FileSettings())
     c.offset(1, 0)
-    assert_equal(c.x, 1.)
-    assert_equal(c.y, 0.)
-    assert_equal(c.i, 1.)
-    assert_equal(c.j, 0.)
+    assert c.x == 1.0
+    assert c.y == 0.0
+    assert c.i == 1.0
+    assert c.j == 0.0
     c.offset(0, 1)
-    assert_equal(c.x, 1.)
-    assert_equal(c.y, 1.)
-    assert_equal(c.i, 1.)
-    assert_equal(c.j, 1.)
+    assert c.x == 1.0
+    assert c.y == 1.0
+    assert c.i == 1.0
+    assert c.j == 1.0
 
 
 def test_coordstmt_string():
-    cs = CoordStmt('G04', 0, 1, 2, 3, 'D01', FileSettings())
-    assert_equal(str(cs),
-                 '<Coordinate Statement: Fn: G04 X: 0 Y: 1 I: 2 J: 3 Op: Lights On>')
-    cs = CoordStmt('G04', None, None, None, None, 'D02', FileSettings())
-    assert_equal(str(cs), '<Coordinate Statement: Fn: G04 Op: Lights Off>')
-    cs = CoordStmt('G04', None, None, None, None, 'D03', FileSettings())
-    assert_equal(str(cs), '<Coordinate Statement: Fn: G04 Op: Flash>')
-    cs = CoordStmt('G04', None, None, None, None, 'TEST', FileSettings())
-    assert_equal(str(cs), '<Coordinate Statement: Fn: G04 Op: TEST>')
+    cs = CoordStmt("G04", 0, 1, 2, 3, "D01", FileSettings())
+    assert (
+        str(cs) == "<Coordinate Statement: Fn: G04 X: 0 Y: 1 I: 2 J: 3 Op: Lights On>"
+    )
+    cs = CoordStmt("G04", None, None, None, None, "D02", FileSettings())
+    assert str(cs) == "<Coordinate Statement: Fn: G04 Op: Lights Off>"
+    cs = CoordStmt("G04", None, None, None, None, "D03", FileSettings())
+    assert str(cs) == "<Coordinate Statement: Fn: G04 Op: Flash>"
+    cs = CoordStmt("G04", None, None, None, None, "TEST", FileSettings())
+    assert str(cs) == "<Coordinate Statement: Fn: G04 Op: TEST>"
 
 
 def test_aperturestmt_ctor():
     ast = ApertureStmt(3, False)
-    assert_equal(ast.d, 3)
-    assert_equal(ast.deprecated, False)
+    assert ast.d == 3
+    assert ast.deprecated == False
     ast = ApertureStmt(4, True)
-    assert_equal(ast.d, 4)
-    assert_equal(ast.deprecated, True)
+    assert ast.d == 4
+    assert ast.deprecated == True
     ast = ApertureStmt(4, 1)
-    assert_equal(ast.d, 4)
-    assert_equal(ast.deprecated, True)
+    assert ast.d == 4
+    assert ast.deprecated == True
     ast = ApertureStmt(3)
-    assert_equal(ast.d, 3)
-    assert_equal(ast.deprecated, False)
+    assert ast.d == 3
+    assert ast.deprecated == False
 
 
 def test_aperturestmt_dump():
     ast = ApertureStmt(3, False)
-    assert_equal(ast.to_gerber(), 'D3*')
+    assert ast.to_gerber() == "D3*"
     ast = ApertureStmt(3, True)
-    assert_equal(ast.to_gerber(), 'G54D3*')
-    assert_equal(str(ast), '<Aperture: 3>')
+    assert ast.to_gerber() == "G54D3*"
+    assert str(ast) == "<Aperture: 3>"
diff --git a/gerber/tests/test_ipc356.py b/gerber/tests/test_ipc356.py
index ae2772a..77f0782 100644
--- a/gerber/tests/test_ipc356.py
+++ b/gerber/tests/test_ipc356.py
@@ -2,139 +2,147 @@
 # -*- coding: utf-8 -*-
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
+import pytest
 from ..ipc356 import *
 from ..cam import FileSettings
-from .tests import *
 
 import os
 
-IPC_D_356_FILE = os.path.join(os.path.dirname(__file__),
-                              'resources/ipc-d-356.ipc')
+IPC_D_356_FILE = os.path.join(os.path.dirname(__file__), "resources/ipc-d-356.ipc")
 
 
 def test_read():
     ipcfile = read(IPC_D_356_FILE)
-    assert(isinstance(ipcfile, IPCNetlist))
-
+    assert isinstance(ipcfile, IPCNetlist)
 
 
 def test_parser():
     ipcfile = read(IPC_D_356_FILE)
-    assert_equal(ipcfile.settings.units, 'inch')
-    assert_equal(ipcfile.settings.angle_units, 'degrees')
-    assert_equal(len(ipcfile.comments), 3)
-    assert_equal(len(ipcfile.parameters), 4)
-    assert_equal(len(ipcfile.test_records), 105)
-    assert_equal(len(ipcfile.components), 21)
-    assert_equal(len(ipcfile.vias), 14)
-    assert_equal(ipcfile.test_records[-1].net_name, 'A_REALLY_LONG_NET_NAME')
-    assert_equal(ipcfile.outlines[0].type, 'BOARD_EDGE')
-    assert_equal(set(ipcfile.outlines[0].points),
-                 {(0., 0.), (2.25, 0.), (2.25, 1.5), (0., 1.5), (0.13, 0.024)})
+    assert ipcfile.settings.units == "inch"
+    assert ipcfile.settings.angle_units == "degrees"
+    assert len(ipcfile.comments) == 3
+    assert len(ipcfile.parameters) == 4
+    assert len(ipcfile.test_records) == 105
+    assert len(ipcfile.components) == 21
+    assert len(ipcfile.vias) == 14
+    assert ipcfile.test_records[-1].net_name == "A_REALLY_LONG_NET_NAME"
+    assert ipcfile.outlines[0].type == "BOARD_EDGE"
+    assert set(ipcfile.outlines[0].points) == {
+        (0.0, 0.0),
+        (2.25, 0.0),
+        (2.25, 1.5),
+        (0.0, 1.5),
+        (0.13, 0.024),
+    }
 
 
 def test_comment():
-    c = IPC356_Comment('Layer Stackup:')
-    assert_equal(c.comment, 'Layer Stackup:')
-    c = IPC356_Comment.from_line('C  Layer Stackup:   ')
-    assert_equal(c.comment, 'Layer Stackup:')
-    assert_raises(ValueError, IPC356_Comment.from_line, 'P  JOB')
-    assert_equal(str(c), '<IPC-D-356 Comment: Layer Stackup:>')
+    c = IPC356_Comment("Layer Stackup:")
+    assert c.comment == "Layer Stackup:"
+    c = IPC356_Comment.from_line("C  Layer Stackup:   ")
+    assert c.comment == "Layer Stackup:"
+    pytest.raises(ValueError, IPC356_Comment.from_line, "P  JOB")
+    assert str(c) == "<IPC-D-356 Comment: Layer Stackup:>"
 
 
 def test_parameter():
-    p = IPC356_Parameter('VER', 'IPC-D-356A')
-    assert_equal(p.parameter, 'VER')
-    assert_equal(p.value, 'IPC-D-356A')
-    p = IPC356_Parameter.from_line('P  VER IPC-D-356A    ')
-    assert_equal(p.parameter, 'VER')
-    assert_equal(p.value, 'IPC-D-356A')
-    assert_raises(ValueError, IPC356_Parameter.from_line,
-                  'C  Layer Stackup:   ')
-    assert_equal(str(p), '<IPC-D-356 Parameter: VER=IPC-D-356A>')
+    p = IPC356_Parameter("VER", "IPC-D-356A")
+    assert p.parameter == "VER"
+    assert p.value == "IPC-D-356A"
+    p = IPC356_Parameter.from_line("P  VER IPC-D-356A    ")
+    assert p.parameter == "VER"
+    assert p.value == "IPC-D-356A"
+    pytest.raises(ValueError, IPC356_Parameter.from_line, "C  Layer Stackup:   ")
+    assert str(p) == "<IPC-D-356 Parameter: VER=IPC-D-356A>"
 
 
 def test_eof():
     e = IPC356_EndOfFile()
-    assert_equal(e.to_netlist(), '999')
-    assert_equal(str(e), '<IPC-D-356 EOF>')
+    assert e.to_netlist() == "999"
+    assert str(e) == "<IPC-D-356 EOF>"
 
 
 def test_outline():
-    type = 'BOARD_EDGE'
-    points = [(0.01, 0.01), (2., 2.), (4., 2.), (4., 6.)]
+    type = "BOARD_EDGE"
+    points = [(0.01, 0.01), (2.0, 2.0), (4.0, 2.0), (4.0, 6.0)]
     b = IPC356_Outline(type, points)
-    assert_equal(b.type, type)
-    assert_equal(b.points, points)
-    b = IPC356_Outline.from_line('389BOARD_EDGE         X100Y100 X20000Y20000 X40000 Y60000',
-                                 FileSettings(units='inch'))
-    assert_equal(b.type, 'BOARD_EDGE')
-    assert_equal(b.points, points)
+    assert b.type == type
+    assert b.points == points
+    b = IPC356_Outline.from_line(
+        "389BOARD_EDGE         X100Y100 X20000Y20000 X40000 Y60000",
+        FileSettings(units="inch"),
+    )
+    assert b.type == "BOARD_EDGE"
+    assert b.points == points
 
 
 def test_test_record():
-    assert_raises(ValueError, IPC356_TestRecord.from_line,
-                  'P  JOB', FileSettings())
-    record_string = '317+5VDC            VIA   -     D0150PA00X 006647Y 012900X0000          S3'
-    r = IPC356_TestRecord.from_line(record_string, FileSettings(units='inch'))
-    assert_equal(r.feature_type, 'through-hole')
-    assert_equal(r.net_name, '+5VDC')
-    assert_equal(r.id, 'VIA')
-    assert_almost_equal(r.hole_diameter, 0.015)
-    assert_true(r.plated)
-    assert_equal(r.access, 'both')
-    assert_almost_equal(r.x_coord, 0.6647)
-    assert_almost_equal(r.y_coord, 1.29)
-    assert_equal(r.rect_x, 0.)
-    assert_equal(r.soldermask_info, 'both')
-    r = IPC356_TestRecord.from_line(record_string, FileSettings(units='metric'))
-    assert_almost_equal(r.hole_diameter, 0.15)
-    assert_almost_equal(r.x_coord, 6.647)
-    assert_almost_equal(r.y_coord, 12.9)
-    assert_equal(r.rect_x, 0.)
-    assert_equal(str(r), '<IPC-D-356 +5VDC Test Record: through-hole>')
-
-    record_string = '327+3.3VDC          R40   -1         PA01X 032100Y 007124X0236Y0315R180 S0'
-    r = IPC356_TestRecord.from_line(record_string, FileSettings(units='inch'))
-    assert_equal(r.feature_type, 'smt')
-    assert_equal(r.net_name, '+3.3VDC')
-    assert_equal(r.id, 'R40')
-    assert_equal(r.pin, '1')
-    assert_true(r.plated)
-    assert_equal(r.access, 'top')
-    assert_almost_equal(r.x_coord, 3.21)
-    assert_almost_equal(r.y_coord, 0.7124)
-    assert_almost_equal(r.rect_x, 0.0236)
-    assert_almost_equal(r.rect_y, 0.0315)
-    assert_equal(r.rect_rotation, 180)
-    assert_equal(r.soldermask_info, 'none')
-    r = IPC356_TestRecord.from_line(
-        record_string, FileSettings(units='metric'))
-    assert_almost_equal(r.x_coord, 32.1)
-    assert_almost_equal(r.y_coord, 7.124)
-    assert_almost_equal(r.rect_x, 0.236)
-    assert_almost_equal(r.rect_y, 0.315)
-
-    record_string = '317                 J4    -M2   D0330PA00X 012447Y 008030X0000          S1'
-    r = IPC356_TestRecord.from_line(record_string, FileSettings(units='inch'))
-    assert_equal(r.feature_type, 'through-hole')
-    assert_equal(r.id, 'J4')
-    assert_equal(r.pin, 'M2')
-    assert_almost_equal(r.hole_diameter, 0.033)
-    assert_true(r.plated)
-    assert_equal(r.access, 'both')
-    assert_almost_equal(r.x_coord, 1.2447)
-    assert_almost_equal(r.y_coord, 0.8030)
-    assert_almost_equal(r.rect_x, 0.)
-    assert_equal(r.soldermask_info, 'primary side')
-
-    record_string = '317SCL              COMMUNICATION-1    D  40PA00X  34000Y  20000X 600Y1200R270 '
-    r = IPC356_TestRecord.from_line(record_string, FileSettings(units='inch'))
-    assert_equal(r.feature_type, 'through-hole')
-    assert_equal(r.net_name, 'SCL')
-    assert_equal(r.id, 'COMMUNICATION')
-    assert_equal(r.pin, '1')
-    assert_almost_equal(r.hole_diameter, 0.004)
-    assert_true(r.plated)
-    assert_almost_equal(r.x_coord, 3.4)
-    assert_almost_equal(r.y_coord, 2.0)
+    pytest.raises(ValueError, IPC356_TestRecord.from_line, "P  JOB", FileSettings())
+    record_string = (
+        "317+5VDC            VIA   -     D0150PA00X 006647Y 012900X0000          S3"
+    )
+    r = IPC356_TestRecord.from_line(record_string, FileSettings(units="inch"))
+    assert r.feature_type == "through-hole"
+    assert r.net_name == "+5VDC"
+    assert r.id == "VIA"
+    pytest.approx(r.hole_diameter, 0.015)
+    assert r.plated
+    assert r.access == "both"
+    pytest.approx(r.x_coord, 0.6647)
+    pytest.approx(r.y_coord, 1.29)
+    assert r.rect_x == 0.0
+    assert r.soldermask_info == "both"
+    r = IPC356_TestRecord.from_line(record_string, FileSettings(units="metric"))
+    pytest.approx(r.hole_diameter, 0.15)
+    pytest.approx(r.x_coord, 6.647)
+    pytest.approx(r.y_coord, 12.9)
+    assert r.rect_x == 0.0
+    assert str(r) == "<IPC-D-356 +5VDC Test Record: through-hole>"
+
+    record_string = (
+        "327+3.3VDC          R40   -1         PA01X 032100Y 007124X0236Y0315R180 S0"
+    )
+    r = IPC356_TestRecord.from_line(record_string, FileSettings(units="inch"))
+    assert r.feature_type == "smt"
+    assert r.net_name == "+3.3VDC"
+    assert r.id == "R40"
+    assert r.pin == "1"
+    assert r.plated
+    assert r.access == "top"
+    pytest.approx(r.x_coord, 3.21)
+    pytest.approx(r.y_coord, 0.7124)
+    pytest.approx(r.rect_x, 0.0236)
+    pytest.approx(r.rect_y, 0.0315)
+    assert r.rect_rotation == 180
+    assert r.soldermask_info == "none"
+    r = IPC356_TestRecord.from_line(record_string, FileSettings(units="metric"))
+    pytest.approx(r.x_coord, 32.1)
+    pytest.approx(r.y_coord, 7.124)
+    pytest.approx(r.rect_x, 0.236)
+    pytest.approx(r.rect_y, 0.315)
+
+    record_string = (
+        "317                 J4    -M2   D0330PA00X 012447Y 008030X0000          S1"
+    )
+    r = IPC356_TestRecord.from_line(record_string, FileSettings(units="inch"))
+    assert r.feature_type == "through-hole"
+    assert r.id == "J4"
+    assert r.pin == "M2"
+    pytest.approx(r.hole_diameter, 0.033)
+    assert r.plated
+    assert r.access == "both"
+    pytest.approx(r.x_coord, 1.2447)
+    pytest.approx(r.y_coord, 0.8030)
+    pytest.approx(r.rect_x, 0.0)
+    assert r.soldermask_info == "primary side"
+
+    record_string = "317SCL              COMMUNICATION-1    D  40PA00X  34000Y  20000X 600Y1200R270 "
+    r = IPC356_TestRecord.from_line(record_string, FileSettings(units="inch"))
+    assert r.feature_type == "through-hole"
+    assert r.net_name == "SCL"
+    assert r.id == "COMMUNICATION"
+    assert r.pin == "1"
+    pytest.approx(r.hole_diameter, 0.004)
+    assert r.plated
+    pytest.approx(r.x_coord, 3.4)
+    pytest.approx(r.y_coord, 2.0)
diff --git a/gerber/tests/test_layers.py b/gerber/tests/test_layers.py
index 3a21a2c..2178787 100644
--- a/gerber/tests/test_layers.py
+++ b/gerber/tests/test_layers.py
@@ -18,128 +18,141 @@
 
 import os
 
-from .tests import *
 from ..layers import *
 from ..common import read
 
-NCDRILL_FILE = os.path.join(os.path.dirname(__file__),
-                            'resources/ncdrill.DRD')
-NETLIST_FILE = os.path.join(os.path.dirname(__file__),
-                            'resources/ipc-d-356.ipc')
-COPPER_FILE = os.path.join(os.path.dirname(__file__),
-                           'resources/top_copper.GTL')
+NCDRILL_FILE = os.path.join(os.path.dirname(__file__), "resources/ncdrill.DRD")
+NETLIST_FILE = os.path.join(os.path.dirname(__file__), "resources/ipc-d-356.ipc")
+COPPER_FILE = os.path.join(os.path.dirname(__file__), "resources/top_copper.GTL")
+
 
 def test_guess_layer_class():
     """ Test layer type inferred correctly from filename
     """
 
     # Add any specific test cases here (filename, layer_class)
-    test_vectors = [(None, 'unknown'), ('NCDRILL.TXT', 'unknown'),
-                    ('example_board.gtl', 'top'),
-                    ('exampmle_board.sst', 'topsilk'),
-                    ('ipc-d-356.ipc', 'ipc_netlist'), ]
+    test_vectors = [
+        (None, "unknown"),
+        ("NCDRILL.TXT", "unknown"),
+        ("example_board.gtl", "top"),
+        ("exampmle_board.sst", "topsilk"),
+        ("ipc-d-356.ipc", "ipc_netlist"),
+    ]
 
     for hint in hints:
         for ext in hint.ext:
-            assert_equal(hint.layer, guess_layer_class('board.{}'.format(ext)))
+            assert hint.layer == guess_layer_class("board.{}".format(ext))
         for name in hint.name:
-            assert_equal(hint.layer, guess_layer_class('{}.pho'.format(name)))
+            assert hint.layer == guess_layer_class("{}.pho".format(name))
 
     for filename, layer_class in test_vectors:
-        assert_equal(layer_class, guess_layer_class(filename))
+        assert layer_class == guess_layer_class(filename)
+
 
 def test_guess_layer_class_regex():
     """ Test regular expressions for layer matching
     """
 
     # Add any specific test case (filename, layer_class)
-    test_vectors = [('test - top copper.gbr', 'top'),
-                    ('test - copper top.gbr', 'top'), ]
+    test_vectors = [("test - top copper.gbr", "top"), ("test - copper top.gbr", "top")]
 
     # Add custom regular expressions
     layer_hints = [
-        Hint(layer='top',
-                ext=[],
-                name=[],
-                regex=r'(.*)(\scopper top|\stop copper).gbr',
-                content=[]
-            ),
+        Hint(
+            layer="top",
+            ext=[],
+            name=[],
+            regex=r"(.*)(\scopper top|\stop copper).gbr",
+            content=[],
+        )
     ]
     hints.extend(layer_hints)
 
     for filename, layer_class in test_vectors:
-        assert_equal(layer_class, guess_layer_class(filename))
+        assert layer_class == guess_layer_class(filename)
 
 
 def test_guess_layer_class_by_content():
     """ Test layer class by checking content
     """
 
-    expected_layer_class = 'bottom'
-    filename = os.path.join(os.path.dirname(__file__),
-                               'resources/example_guess_by_content.g0')
+    expected_layer_class = "bottom"
+    filename = os.path.join(
+        os.path.dirname(__file__), "resources/example_guess_by_content.g0"
+    )
 
     layer_hints = [
-        Hint(layer='bottom',
-                ext=[],
-                name=[],
-                regex='',
-                content=['G04 Layer name: Bottom']
-            )
+        Hint(
+            layer="bottom",
+            ext=[],
+            name=[],
+            regex="",
+            content=["G04 Layer name: Bottom"],
+        )
     ]
     hints.extend(layer_hints)
 
-    assert_equal(expected_layer_class, guess_layer_class_by_content(filename))
+    assert expected_layer_class == guess_layer_class_by_content(filename)
 
 
 def test_sort_layers():
     """ Test layer ordering
     """
     layers = [
-        PCBLayer(layer_class='drawing'),
-        PCBLayer(layer_class='drill'),
-        PCBLayer(layer_class='bottompaste'),
-        PCBLayer(layer_class='bottomsilk'),
-        PCBLayer(layer_class='bottommask'),
-        PCBLayer(layer_class='bottom'),
-        PCBLayer(layer_class='internal'),
-        PCBLayer(layer_class='top'),
-        PCBLayer(layer_class='topmask'),
-        PCBLayer(layer_class='topsilk'),
-        PCBLayer(layer_class='toppaste'),
-        PCBLayer(layer_class='outline'),
+        PCBLayer(layer_class="drawing"),
+        PCBLayer(layer_class="drill"),
+        PCBLayer(layer_class="bottompaste"),
+        PCBLayer(layer_class="bottomsilk"),
+        PCBLayer(layer_class="bottommask"),
+        PCBLayer(layer_class="bottom"),
+        PCBLayer(layer_class="internal"),
+        PCBLayer(layer_class="top"),
+        PCBLayer(layer_class="topmask"),
+        PCBLayer(layer_class="topsilk"),
+        PCBLayer(layer_class="toppaste"),
+        PCBLayer(layer_class="outline"),
     ]
 
-    layer_order = ['outline', 'toppaste', 'topsilk', 'topmask', 'top',
-                   'internal', 'bottom', 'bottommask', 'bottomsilk',
-                   'bottompaste', 'drill', 'drawing']
+    layer_order = [
+        "outline",
+        "toppaste",
+        "topsilk",
+        "topmask",
+        "top",
+        "internal",
+        "bottom",
+        "bottommask",
+        "bottomsilk",
+        "bottompaste",
+        "drill",
+        "drawing",
+    ]
     bottom_order = list(reversed(layer_order[:10])) + layer_order[10:]
-    assert_equal([l.layer_class for l in sort_layers(layers)], layer_order)
-    assert_equal([l.layer_class for l in sort_layers(layers, from_top=False)],
-                 bottom_order)
+    assert [l.layer_class for l in sort_layers(layers)] == layer_order
+    assert [l.layer_class for l in sort_layers(layers, from_top=False)] == bottom_order
 
 
 def test_PCBLayer_from_file():
     layer = PCBLayer.from_cam(read(COPPER_FILE))
-    assert_true(isinstance(layer, PCBLayer))
+    assert isinstance(layer, PCBLayer)
     layer = PCBLayer.from_cam(read(NCDRILL_FILE))
-    assert_true(isinstance(layer, DrillLayer))
+    assert isinstance(layer, DrillLayer)
     layer = PCBLayer.from_cam(read(NETLIST_FILE))
-    assert_true(isinstance(layer, PCBLayer))
-    assert_equal(layer.layer_class, 'ipc_netlist')
+    assert isinstance(layer, PCBLayer)
+    assert layer.layer_class == "ipc_netlist"
 
 
 def test_PCBLayer_bounds():
     source = read(COPPER_FILE)
     layer = PCBLayer.from_cam(source)
-    assert_equal(source.bounds, layer.bounds)
+    assert source.bounds == layer.bounds
 
 
 def test_DrillLayer_from_cam():
     no_exceptions = True
     try:
         layer = DrillLayer.from_cam(read(NCDRILL_FILE))
-        assert_true(isinstance(layer, DrillLayer))
+        assert isinstance(layer, DrillLayer)
     except:
         no_exceptions = False
-    assert_true(no_exceptions)
+    assert no_exceptions
diff --git a/gerber/tests/test_primitives.py b/gerber/tests/test_primitives.py
index b932297..ad5b34f 100644
--- a/gerber/tests/test_primitives.py
+++ b/gerber/tests/test_primitives.py
@@ -2,467 +2,478 @@
 # -*- coding: utf-8 -*-
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
-from operator import add
 
+import pytest
+from operator import add
 from ..primitives import *
-from .tests import *
 
 
 def test_primitive_smoketest():
     p = Primitive()
     try:
         p.bounding_box
-        assert_false(True, 'should have thrown the exception')
+        assert not True, "should have thrown the exception"
     except NotImplementedError:
         pass
-    #assert_raises(NotImplementedError, p.bounding_box)
+    # pytest.raises(NotImplementedError, p.bounding_box)
 
     p.to_metric()
     p.to_inch()
-    #try:
+    # try:
     #    p.offset(1, 1)
     #    assert_false(True, 'should have thrown the exception')
-    #except NotImplementedError:
+    # 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)), ]
+    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)
-        assert_almost_equal(line_angle, expected)
+        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))), ]
+    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_equal(l.bounding_box, expected)
+            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))), ]
+    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_equal(l.bounding_box, expected)
+        assert l.bounding_box == expected
 
 
 def test_line_vertices():
     c = Circle((0, 0), 2)
     l = Line((0, 0), (1, 1), c)
-    assert_equal(l.vertices, None)
+    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))), ]
+    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_equal(set(vertices), set(l.vertices))
+        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')
+    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_equal(l.start, (2.54, 25.4))
-    assert_equal(l.end, (254.0, 2540.0))
-    assert_equal(l.aperture.diameter, 25.4)
+    assert l.start == (2.54, 25.4)
+    assert l.end == (254.0, 2540.0)
+    assert l.aperture.diameter == 25.4
 
     l.to_inch()
-    assert_equal(l.start, (0.1, 1.0))
-    assert_equal(l.end, (10.0, 100.0))
-    assert_equal(l.aperture.diameter, 1.0)
+    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_equal(l.start, (0.1, 1.0))
-    assert_equal(l.end, (10.0, 100.0))
-    assert_equal(l.aperture.diameter, 1.0)
+    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')
+    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_equal(l.start, (0.1, 1.0))
-    assert_equal(l.end, (10.0, 100.0))
-    assert_equal(l.aperture.diameter, 1.0)
+    assert l.start == (0.1, 1.0)
+    assert l.end == (10.0, 100.0)
+    assert l.aperture.diameter == 1.0
 
     l.to_metric()
-    assert_equal(l.start, (2.54, 25.4))
-    assert_equal(l.end, (254.0, 2540.0))
-    assert_equal(l.aperture.diameter, 25.4)
+    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_equal(l.start, (2.54, 25.4))
-    assert_equal(l.end, (254.0, 2540.0))
-    assert_equal(l.aperture.diameter, 25.4)
+    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')
+    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_equal(l.start, (0.1, 1.0))
-    assert_equal(l.end, (10.0, 100.0))
-    assert_equal(l.aperture.width, 1.0)
-    assert_equal(l.aperture.height, 10.0)
+    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')
+    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_equal(l.start, (2.54, 25.4))
-    assert_equal(l.end, (254.0, 2540.0))
-    assert_equal(l.aperture.width, 25.4)
-    assert_equal(l.aperture.height, 254.0)
+    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_equal(l.start, (1., 0.))
-    assert_equal(l.end, (2., 1.))
+    assert l.start == (1.0, 0.0)
+    assert l.end == (2.0, 1.0)
     l.offset(0, 1)
-    assert_equal(l.start, (1., 1.))
-    assert_equal(l.end, (2., 2.))
+    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), ]
+    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_equal(a.radius, radius)
+        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)), ]
+    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_equal(a.sweep_angle, sweep)
+        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))),
-
+        ((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))),
+        ((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_equal(a.bounding_box, bounds)
+        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))),
-
+        ((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))),
+        ((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_equal(a.bounding_box_no_aperture, bounds)
+        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')
+    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_equal(a.start, (2.54, 25.4))
-    assert_equal(a.end, (254.0, 2540.0))
-    assert_equal(a.center, (25400.0, 254000.0))
-    assert_equal(a.aperture.diameter, 25.4)
+    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_equal(a.start, (0.1, 1.0))
-    assert_equal(a.end, (10.0, 100.0))
-    assert_equal(a.center, (1000.0, 10000.0))
-    assert_equal(a.aperture.diameter, 1.0)
+    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_equal(a.start, (0.1, 1.0))
-    assert_equal(a.end, (10.0, 100.0))
-    assert_equal(a.center, (1000.0, 10000.0))
-    assert_equal(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')
+    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_equal(a.start, (2.54, 25.4))
-    assert_equal(a.end, (254.0, 2540.0))
-    assert_equal(a.center, (25400.0, 254000.0))
-    assert_equal(a.aperture.diameter, 25.4)
+    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 = Arc((0, 0), (1, 1), (2, 2), "clockwise", c, "single-quadrant")
     a.offset(1, 0)
-    assert_equal(a.start, (1., 0.))
-    assert_equal(a.end, (2., 1.))
-    assert_equal(a.center, (3., 2.))
+    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_equal(a.start, (1., 1.))
-    assert_equal(a.end, (2., 2.))
-    assert_equal(a.center, (3., 3.))
+    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_equal(c.radius, 1)
+    assert c.radius == 1
 
 
 def test_circle_hole_radius():
     """ Test Circle primitive hole radius calculation
     """
     c = Circle((1, 1), 4, 2)
-    assert_equal(c.hole_radius, 1)
+    assert c.hole_radius == 1
 
 
 def test_circle_bounds():
     """ Test Circle bounding box calculation
     """
     c = Circle((1, 1), 2)
-    assert_equal(c.bounding_box, ((0, 2), (0, 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 = Circle((2.54, 25.4), 254.0, units="metric")
 
     c.to_metric()  # shouldn't do antyhing
-    assert_equal(c.position, (2.54, 25.4))
-    assert_equal(c.diameter, 254.)
-    assert_equal(c.hole_diameter, None)
+    assert c.position == (2.54, 25.4)
+    assert c.diameter == 254.0
+    assert c.hole_diameter == None
 
     c.to_inch()
-    assert_equal(c.position, (0.1, 1.))
-    assert_equal(c.diameter, 10.)
-    assert_equal(c.hole_diameter, None)
+    assert c.position == (0.1, 1.0)
+    assert c.diameter == 10.0
+    assert c.hole_diameter == None
 
     # no effect
     c.to_inch()
-    assert_equal(c.position, (0.1, 1.))
-    assert_equal(c.diameter, 10.)
-    assert_equal(c.hole_diameter, None)
+    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 = Circle((2.54, 25.4), 254.0, 127.0, units="metric")
 
-    c.to_metric()   #shouldn't do antyhing
-    assert_equal(c.position, (2.54, 25.4))
-    assert_equal(c.diameter, 254.)
-    assert_equal(c.hole_diameter, 127.)
+    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_equal(c.position, (0.1, 1.))
-    assert_equal(c.diameter, 10.)
-    assert_equal(c.hole_diameter, 5.)
+    assert c.position == (0.1, 1.0)
+    assert c.diameter == 10.0
+    assert c.hole_diameter == 5.0
 
     # no effect
     c.to_inch()
-    assert_equal(c.position, (0.1, 1.))
-    assert_equal(c.diameter, 10.)
-    assert_equal(c.hole_diameter, 5.)
+    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')
+    c = Circle((0.1, 1.0), 10.0, units="inch")
     # No effect
     c.to_inch()
-    assert_equal(c.position, (0.1, 1.))
-    assert_equal(c.diameter, 10.)
-    assert_equal(c.hole_diameter, None)
+    assert c.position == (0.1, 1.0)
+    assert c.diameter == 10.0
+    assert c.hole_diameter == None
 
     c.to_metric()
-    assert_equal(c.position, (2.54, 25.4))
-    assert_equal(c.diameter, 254.)
-    assert_equal(c.hole_diameter, None)
+    assert c.position == (2.54, 25.4)
+    assert c.diameter == 254.0
+    assert c.hole_diameter == None
 
     # no effect
     c.to_metric()
-    assert_equal(c.position, (2.54, 25.4))
-    assert_equal(c.diameter, 254.)
-    assert_equal(c.hole_diameter, None)
+    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 = Circle((0.1, 1.0), 10.0, 5.0, units="inch")
+    # No effect
     c.to_inch()
-    assert_equal(c.position, (0.1, 1.))
-    assert_equal(c.diameter, 10.)
-    assert_equal(c.hole_diameter, 5.)
+    assert c.position == (0.1, 1.0)
+    assert c.diameter == 10.0
+    assert c.hole_diameter == 5.0
 
     c.to_metric()
-    assert_equal(c.position, (2.54, 25.4))
-    assert_equal(c.diameter, 254.)
-    assert_equal(c.hole_diameter, 127.)
+    assert c.position == (2.54, 25.4)
+    assert c.diameter == 254.0
+    assert c.hole_diameter == 127.0
 
     # no effect
     c.to_metric()
-    assert_equal(c.position, (2.54, 25.4))
-    assert_equal(c.diameter, 254.)
-    assert_equal(c.hole_diameter, 127.)
+    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_equal(c.position, (1., 0.))
+    assert c.position == (1.0, 0.0)
     c.offset(0, 1)
-    assert_equal(c.position, (1., 1.))
+    assert c.position == (1.0, 1.0)
 
 
 def test_ellipse_ctor():
     """ Test ellipse creation
     """
     e = Ellipse((2, 2), 3, 2)
-    assert_equal(e.position, (2, 2))
-    assert_equal(e.width, 3)
-    assert_equal(e.height, 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_equal(e.bounding_box, ((0, 4), (1, 3)))
+    assert e.bounding_box == ((0, 4), (1, 3))
     e = Ellipse((2, 2), 4, 2, rotation=90)
-    assert_equal(e.bounding_box, ((1, 3), (0, 4)))
+    assert e.bounding_box == ((1, 3), (0, 4))
     e = Ellipse((2, 2), 4, 2, rotation=180)
-    assert_equal(e.bounding_box, ((0, 4), (1, 3)))
+    assert e.bounding_box == ((0, 4), (1, 3))
     e = Ellipse((2, 2), 4, 2, rotation=270)
-    assert_equal(e.bounding_box, ((1, 3), (0, 4)))
+    assert e.bounding_box == ((1, 3), (0, 4))
 
 
 def test_ellipse_conversion():
-    e = Ellipse((2.54, 25.4), 254.0, 2540., units='metric')
+    e = Ellipse((2.54, 25.4), 254.0, 2540.0, units="metric")
 
     # No effect
     e.to_metric()
-    assert_equal(e.position, (2.54, 25.4))
-    assert_equal(e.width, 254.)
-    assert_equal(e.height, 2540.)
+    assert e.position == (2.54, 25.4)
+    assert e.width == 254.0
+    assert e.height == 2540.0
 
     e.to_inch()
-    assert_equal(e.position, (0.1, 1.))
-    assert_equal(e.width, 10.)
-    assert_equal(e.height, 100.)
+    assert e.position == (0.1, 1.0)
+    assert e.width == 10.0
+    assert e.height == 100.0
 
     # No effect
     e.to_inch()
-    assert_equal(e.position, (0.1, 1.))
-    assert_equal(e.width, 10.)
-    assert_equal(e.height, 100.)
+    assert e.position == (0.1, 1.0)
+    assert e.width == 10.0
+    assert e.height == 100.0
 
-    e = Ellipse((0.1, 1.), 10.0, 100., units='inch')
+    e = Ellipse((0.1, 1.0), 10.0, 100.0, units="inch")
 
     # no effect
     e.to_inch()
-    assert_equal(e.position, (0.1, 1.))
-    assert_equal(e.width, 10.)
-    assert_equal(e.height, 100.)
+    assert e.position == (0.1, 1.0)
+    assert e.width == 10.0
+    assert e.height == 100.0
 
     e.to_metric()
-    assert_equal(e.position, (2.54, 25.4))
-    assert_equal(e.width, 254.)
-    assert_equal(e.height, 2540.)
+    assert e.position == (2.54, 25.4)
+    assert e.width == 254.0
+    assert e.height == 2540.0
 
     # No effect
     e.to_metric()
-    assert_equal(e.position, (2.54, 25.4))
-    assert_equal(e.width, 254.)
-    assert_equal(e.height, 2540.)
+    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_equal(e.position, (1., 0.))
+    assert e.position == (1.0, 0.0)
     e.offset(0, 1)
-    assert_equal(e.position, (1., 1.))
+    assert e.position == (1.0, 1.0)
 
 
 def test_rectangle_ctor():
@@ -471,19 +482,19 @@ def test_rectangle_ctor():
     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_equal(r.position, pos)
-        assert_equal(r.width, width)
-        assert_equal(r.height, 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_equal(0, r.hole_radius)
+    r = Rectangle((0, 0), 2, 2)
+    assert 0 == r.hole_radius
 
-    r = Rectangle((0,0), 2, 2, 1)
-    assert_equal(0.5, r.hole_radius)
+    r = Rectangle((0, 0), 2, 2, 1)
+    assert 0.5 == r.hole_radius
 
 
 def test_rectangle_bounds():
@@ -491,126 +502,137 @@ def test_rectangle_bounds():
     """
     r = Rectangle((0, 0), 2, 2)
     xbounds, ybounds = r.bounding_box
-    assert_array_almost_equal(xbounds, (-1, 1))
-    assert_array_almost_equal(ybounds, (-1, 1))
+    pytest.approx(xbounds, (-1, 1))
+    pytest.approx(ybounds, (-1, 1))
     r = Rectangle((0, 0), 2, 2, rotation=45)
     xbounds, ybounds = r.bounding_box
-    assert_array_almost_equal(xbounds, (-math.sqrt(2), math.sqrt(2)))
-    assert_array_almost_equal(ybounds, (-math.sqrt(2), math.sqrt(2)))
+    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))),
+        ((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)):
-            assert_array_almost_equal(test, expect)
+            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)))):
-        assert_array_almost_equal(test, expect)
+    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_in(vertex, expected)
+        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 = Rectangle((2.54, 25.4), 254.0, 2540.0, units="metric")
 
     r.to_metric()
-    assert_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
+    assert r.position == (2.54, 25.4)
+    assert r.width == 254.0
+    assert r.height == 2540.0
 
     r.to_inch()
-    assert_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
+    assert r.position == (0.1, 1.0)
+    assert r.width == 10.0
+    assert r.height == 100.0
 
     r.to_inch()
-    assert_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
+    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 = Rectangle((2.54, 25.4), 254.0, 2540.0, 127.0, units="metric")
 
     r.to_metric()
-    assert_equal(r.position, (2.54,25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.hole_diameter, 127.0)
+    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_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.hole_diameter, 5.0)
+    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_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.hole_diameter, 5.0)
+    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 = Rectangle((0.1, 1.0), 10.0, 100.0, units="inch")
     r.to_inch()
-    assert_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
+    assert r.position == (0.1, 1.0)
+    assert r.width == 10.0
+    assert r.height == 100.0
 
     r.to_metric()
-    assert_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
+    assert r.position == (2.54, 25.4)
+    assert r.width == 254.0
+    assert r.height == 2540.0
 
     r.to_metric()
-    assert_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
+    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 = Rectangle((0.1, 1.0), 10.0, 100.0, 5.0, units="inch")
     r.to_inch()
-    assert_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.hole_diameter, 5.0)
+    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_equal(r.position, (2.54,25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.hole_diameter, 127.0)
+    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_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.hole_diameter, 127.0)
+    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_equal(r.position, (1., 0.))
+    assert r.position == (1.0, 0.0)
     r.offset(0, 1)
-    assert_equal(r.position, (1., 1.))
+    assert r.position == (1.0, 1.0)
 
 
 def test_diamond_ctor():
@@ -619,9 +641,9 @@ def test_diamond_ctor():
     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_equal(d.position, pos)
-        assert_equal(d.width, width)
-        assert_equal(d.height, height)
+        assert d.position == pos
+        assert d.width == width
+        assert d.height == height
 
 
 def test_diamond_bounds():
@@ -629,71 +651,73 @@ def test_diamond_bounds():
     """
     d = Diamond((0, 0), 2, 2)
     xbounds, ybounds = d.bounding_box
-    assert_array_almost_equal(xbounds, (-1, 1))
-    assert_array_almost_equal(ybounds, (-1, 1))
+    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
-    assert_array_almost_equal(xbounds, (-1, 1))
-    assert_array_almost_equal(ybounds, (-1, 1))
+    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 = Diamond((2.54, 25.4), 254.0, 2540.0, units="metric")
 
     d.to_metric()
-    assert_equal(d.position, (2.54, 25.4))
-    assert_equal(d.width, 254.0)
-    assert_equal(d.height, 2540.0)
+    assert d.position == (2.54, 25.4)
+    assert d.width == 254.0
+    assert d.height == 2540.0
 
     d.to_inch()
-    assert_equal(d.position, (0.1, 1.0))
-    assert_equal(d.width, 10.0)
-    assert_equal(d.height, 100.0)
+    assert d.position == (0.1, 1.0)
+    assert d.width == 10.0
+    assert d.height == 100.0
 
     d.to_inch()
-    assert_equal(d.position, (0.1, 1.0))
-    assert_equal(d.width, 10.0)
-    assert_equal(d.height, 100.0)
+    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 = Diamond((0.1, 1.0), 10.0, 100.0, units="inch")
 
     d.to_inch()
-    assert_equal(d.position, (0.1, 1.0))
-    assert_equal(d.width, 10.0)
-    assert_equal(d.height, 100.0)
+    assert d.position == (0.1, 1.0)
+    assert d.width == 10.0
+    assert d.height == 100.0
 
     d.to_metric()
-    assert_equal(d.position, (2.54, 25.4))
-    assert_equal(d.width, 254.0)
-    assert_equal(d.height, 2540.0)
+    assert d.position == (2.54, 25.4)
+    assert d.width == 254.0
+    assert d.height == 2540.0
 
     d.to_metric()
-    assert_equal(d.position, (2.54, 25.4))
-    assert_equal(d.width, 254.0)
-    assert_equal(d.height, 2540.0)
+    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_equal(d.position, (1., 0.))
+    assert d.position == (1.0, 0.0)
     d.offset(0, 1)
-    assert_equal(d.position, (1., 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)))
+    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_equal(r.position, pos)
-        assert_equal(r.width, width)
-        assert_equal(r.height, height)
-        assert_equal(r.chamfer, chamfer)
-        assert_array_almost_equal(r.corners, 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():
@@ -701,91 +725,124 @@ def test_chamfer_rectangle_bounds():
     """
     r = ChamferRectangle((0, 0), 2, 2, 0.2, (True, True, False, False))
     xbounds, ybounds = r.bounding_box
-    assert_array_almost_equal(xbounds, (-1, 1))
-    assert_array_almost_equal(ybounds, (-1, 1))
-    r = ChamferRectangle(
-        (0, 0), 2, 2, 0.2, (True, True, False, False), rotation=45)
+    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
-    assert_array_almost_equal(xbounds, (-math.sqrt(2), math.sqrt(2)))
-    assert_array_almost_equal(ybounds, (-math.sqrt(2), math.sqrt(2)))
+    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 = ChamferRectangle(
+        (2.54, 25.4), 254.0, 2540.0, 0.254, (True, True, False, False), units="metric"
+    )
 
     r.to_metric()
-    assert_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.chamfer, 0.254)
+    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_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.chamfer, 0.01)
+    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_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.chamfer, 0.01)
+    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 = ChamferRectangle(
+        (0.1, 1.0), 10.0, 100.0, 0.01, (True, True, False, False), units="inch"
+    )
     r.to_inch()
-    assert_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.chamfer, 0.01)
+    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_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.chamfer, 0.254)
+    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_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.chamfer, 0.254)
+    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_equal(r.position, (1., 0.))
+    assert r.position == (1.0, 0.0)
     r.offset(0, 1)
-    assert_equal(r.position, (1., 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))),
+        (
+            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_equal(set(r.vertices), set(expected))
+        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)))
+    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_equal(r.position, pos)
-        assert_equal(r.width, width)
-        assert_equal(r.height, height)
-        assert_equal(r.radius, radius)
-        assert_array_almost_equal(r.corners, 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():
@@ -793,78 +850,77 @@ def test_round_rectangle_bounds():
     """
     r = RoundRectangle((0, 0), 2, 2, 0.2, (True, True, False, False))
     xbounds, ybounds = r.bounding_box
-    assert_array_almost_equal(xbounds, (-1, 1))
-    assert_array_almost_equal(ybounds, (-1, 1))
-    r = RoundRectangle((0, 0), 2, 2, 0.2,
-                       (True, True, False, False), rotation=45)
+    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
-    assert_array_almost_equal(xbounds, (-math.sqrt(2), math.sqrt(2)))
-    assert_array_almost_equal(ybounds, (-math.sqrt(2), math.sqrt(2)))
+    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 = RoundRectangle(
+        (2.54, 25.4), 254.0, 2540.0, 0.254, (True, True, False, False), units="metric"
+    )
 
     r.to_metric()
-    assert_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.radius, 0.254)
+    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_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.radius, 0.01)
+    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_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.radius, 0.01)
+    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 = RoundRectangle(
+        (0.1, 1.0), 10.0, 100.0, 0.01, (True, True, False, False), units="inch"
+    )
 
     r.to_inch()
-    assert_equal(r.position, (0.1, 1.0))
-    assert_equal(r.width, 10.0)
-    assert_equal(r.height, 100.0)
-    assert_equal(r.radius, 0.01)
+    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_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.radius, 0.254)
+    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_equal(r.position, (2.54, 25.4))
-    assert_equal(r.width, 254.0)
-    assert_equal(r.height, 2540.0)
-    assert_equal(r.radius, 0.254)
+    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_equal(r.position, (1., 0.))
+    assert r.position == (1.0, 0.0)
     r.offset(0, 1)
-    assert_equal(r.position, (1., 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))
+    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_equal(o.position, pos)
-        assert_equal(o.width, width)
-        assert_equal(o.height, height)
+        assert o.position == pos
+        assert o.width == width
+        assert o.height == height
 
 
 def test_obround_bounds():
@@ -872,94 +928,92 @@ def test_obround_bounds():
     """
     o = Obround((2, 2), 2, 4)
     xbounds, ybounds = o.bounding_box
-    assert_array_almost_equal(xbounds, (1, 3))
-    assert_array_almost_equal(ybounds, (0, 4))
+    pytest.approx(xbounds, (1, 3))
+    pytest.approx(ybounds, (0, 4))
     o = Obround((2, 2), 4, 2)
     xbounds, ybounds = o.bounding_box
-    assert_array_almost_equal(xbounds, (0, 4))
-    assert_array_almost_equal(ybounds, (1, 3))
+    pytest.approx(xbounds, (0, 4))
+    pytest.approx(ybounds, (1, 3))
 
 
 def test_obround_orientation():
     o = Obround((0, 0), 2, 1)
-    assert_equal(o.orientation, 'horizontal')
+    assert o.orientation == "horizontal"
     o = Obround((0, 0), 1, 2)
-    assert_equal(o.orientation, 'vertical')
+    assert o.orientation == "vertical"
 
 
 def test_obround_subshapes():
     o = Obround((0, 0), 1, 4)
     ss = o.subshapes
-    assert_array_almost_equal(ss['rectangle'].position, (0, 0))
-    assert_array_almost_equal(ss['circle1'].position, (0, 1.5))
-    assert_array_almost_equal(ss['circle2'].position, (0, -1.5))
+    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
-    assert_array_almost_equal(ss['rectangle'].position, (0, 0))
-    assert_array_almost_equal(ss['circle1'].position, (1.5, 0))
-    assert_array_almost_equal(ss['circle2'].position, (-1.5, 0))
+    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')
+    o = Obround((2.54, 25.4), 254.0, 2540.0, units="metric")
 
     # No effect
     o.to_metric()
-    assert_equal(o.position, (2.54, 25.4))
-    assert_equal(o.width, 254.0)
-    assert_equal(o.height, 2540.0)
+    assert o.position == (2.54, 25.4)
+    assert o.width == 254.0
+    assert o.height == 2540.0
 
     o.to_inch()
-    assert_equal(o.position, (0.1, 1.0))
-    assert_equal(o.width, 10.0)
-    assert_equal(o.height, 100.0)
+    assert o.position == (0.1, 1.0)
+    assert o.width == 10.0
+    assert o.height == 100.0
 
     # No effect
     o.to_inch()
-    assert_equal(o.position, (0.1, 1.0))
-    assert_equal(o.width, 10.0)
-    assert_equal(o.height, 100.0)
+    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')
+    o = Obround((0.1, 1.0), 10.0, 100.0, units="inch")
 
     # No effect
     o.to_inch()
-    assert_equal(o.position, (0.1, 1.0))
-    assert_equal(o.width, 10.0)
-    assert_equal(o.height, 100.0)
+    assert o.position == (0.1, 1.0)
+    assert o.width == 10.0
+    assert o.height == 100.0
 
     o.to_metric()
-    assert_equal(o.position, (2.54, 25.4))
-    assert_equal(o.width, 254.0)
-    assert_equal(o.height, 2540.0)
+    assert o.position == (2.54, 25.4)
+    assert o.width == 254.0
+    assert o.height == 2540.0
 
     # No effect
     o.to_metric()
-    assert_equal(o.position, (2.54, 25.4))
-    assert_equal(o.width, 254.0)
-    assert_equal(o.height, 2540.0)
+    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_equal(o.position, (1., 0.))
+    assert o.position == (1.0, 0.0)
     o.offset(0, 1)
-    assert_equal(o.position, (1., 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))
+    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_equal(p.position, pos)
-        assert_equal(p.sides, sides)
-        assert_equal(p.radius, radius)
-        assert_equal(p.hole_diameter, hole_diameter)
+        assert p.position == pos
+        assert p.sides == sides
+        assert p.radius == radius
+        assert p.hole_diameter == hole_diameter
 
 
 def test_polygon_bounds():
@@ -967,90 +1021,102 @@ def test_polygon_bounds():
     """
     p = Polygon((2, 2), 3, 2, 0)
     xbounds, ybounds = p.bounding_box
-    assert_array_almost_equal(xbounds, (0, 4))
-    assert_array_almost_equal(ybounds, (0, 4))
+    pytest.approx(xbounds, (0, 4))
+    pytest.approx(ybounds, (0, 4))
     p = Polygon((2, 2), 3, 4, 0)
     xbounds, ybounds = p.bounding_box
-    assert_array_almost_equal(xbounds, (-2, 6))
-    assert_array_almost_equal(ybounds, (-2, 6))
+    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')
+    p = Polygon((2.54, 25.4), 3, 254.0, 0, units="metric")
 
     # No effect
     p.to_metric()
-    assert_equal(p.position, (2.54, 25.4))
-    assert_equal(p.radius, 254.0)
+    assert p.position == (2.54, 25.4)
+    assert p.radius == 254.0
 
     p.to_inch()
-    assert_equal(p.position, (0.1, 1.0))
-    assert_equal(p.radius, 10.0)
+    assert p.position == (0.1, 1.0)
+    assert p.radius == 10.0
 
     # No effect
     p.to_inch()
-    assert_equal(p.position, (0.1, 1.0))
-    assert_equal(p.radius, 10.0)
+    assert p.position == (0.1, 1.0)
+    assert p.radius == 10.0
 
-    p = Polygon((0.1, 1.0), 3, 10.0, 0, units='inch')
+    p = Polygon((0.1, 1.0), 3, 10.0, 0, units="inch")
 
     # No effect
     p.to_inch()
-    assert_equal(p.position, (0.1, 1.0))
-    assert_equal(p.radius, 10.0)
+    assert p.position == (0.1, 1.0)
+    assert p.radius == 10.0
 
     p.to_metric()
-    assert_equal(p.position, (2.54, 25.4))
-    assert_equal(p.radius, 254.0)
+    assert p.position == (2.54, 25.4)
+    assert p.radius == 254.0
 
     # No effect
     p.to_metric()
-    assert_equal(p.position, (2.54, 25.4))
-    assert_equal(p.radius, 254.0)
+    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_equal(p.position, (1., 0.))
+    assert p.position == (1.0, 0.0)
     p.offset(0, 1)
-    assert_equal(p.position, (1., 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))
+    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_equal(r.primitives[i], p)
+        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))
+    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
-    assert_array_almost_equal(xbounds, (0, 1))
-    assert_array_almost_equal(ybounds, (0, 1))
+    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))
+    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
-    assert_array_almost_equal(new_xlim, xlim)
-    assert_array_almost_equal(new_ylim, tuple([y + 1 for y in ylim]))
+    pytest.approx(new_xlim, xlim)
+    pytest.approx(new_ylim, tuple([y + 1 for y in ylim]))
 
 
 def test_round_butterfly_ctor():
@@ -1059,58 +1125,58 @@ def test_round_butterfly_ctor():
     test_cases = (((0, 0), 3), ((0, 0), 5), ((1, 1), 7))
     for pos, diameter in test_cases:
         b = RoundButterfly(pos, diameter)
-        assert_equal(b.position, pos)
-        assert_equal(b.diameter, diameter)
-        assert_equal(b.radius, diameter / 2.)
+        assert b.position == pos
+        assert b.diameter == diameter
+        assert b.radius == diameter / 2.0
 
 
 def test_round_butterfly_ctor_validation():
     """ Test RoundButterfly argument validation
     """
-    assert_raises(TypeError, RoundButterfly, 3, 5)
-    assert_raises(TypeError, RoundButterfly, (3, 4, 5), 5)
+    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')
+    b = RoundButterfly((2.54, 25.4), 254.0, units="metric")
 
     # No Effect
     b.to_metric()
-    assert_equal(b.position, (2.54, 25.4))
-    assert_equal(b.diameter, (254.0))
+    assert b.position == (2.54, 25.4)
+    assert b.diameter == (254.0)
 
     b.to_inch()
-    assert_equal(b.position, (0.1, 1.0))
-    assert_equal(b.diameter, 10.0)
+    assert b.position == (0.1, 1.0)
+    assert b.diameter == 10.0
 
     # No effect
     b.to_inch()
-    assert_equal(b.position, (0.1, 1.0))
-    assert_equal(b.diameter, 10.0)
+    assert b.position == (0.1, 1.0)
+    assert b.diameter == 10.0
 
-    b = RoundButterfly((0.1, 1.0), 10.0, units='inch')
+    b = RoundButterfly((0.1, 1.0), 10.0, units="inch")
 
     # No effect
     b.to_inch()
-    assert_equal(b.position, (0.1, 1.0))
-    assert_equal(b.diameter, 10.0)
+    assert b.position == (0.1, 1.0)
+    assert b.diameter == 10.0
 
     b.to_metric()
-    assert_equal(b.position, (2.54, 25.4))
-    assert_equal(b.diameter, (254.0))
+    assert b.position == (2.54, 25.4)
+    assert b.diameter == (254.0)
 
     # No Effect
     b.to_metric()
-    assert_equal(b.position, (2.54, 25.4))
-    assert_equal(b.diameter, (254.0))
+    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_equal(b.position, (1., 0.))
+    assert b.position == (1.0, 0.0)
     b.offset(0, 1)
-    assert_equal(b.position, (1., 1.))
+    assert b.position == (1.0, 1.0)
 
 
 def test_round_butterfly_bounds():
@@ -1118,8 +1184,8 @@ def test_round_butterfly_bounds():
     """
     b = RoundButterfly((0, 0), 2)
     xbounds, ybounds = b.bounding_box
-    assert_array_almost_equal(xbounds, (-1, 1))
-    assert_array_almost_equal(ybounds, (-1, 1))
+    pytest.approx(xbounds, (-1, 1))
+    pytest.approx(ybounds, (-1, 1))
 
 
 def test_square_butterfly_ctor():
@@ -1128,15 +1194,15 @@ def test_square_butterfly_ctor():
     test_cases = (((0, 0), 3), ((0, 0), 5), ((1, 1), 7))
     for pos, side in test_cases:
         b = SquareButterfly(pos, side)
-        assert_equal(b.position, pos)
-        assert_equal(b.side, side)
+        assert b.position == pos
+        assert b.side == side
 
 
 def test_square_butterfly_ctor_validation():
     """ Test SquareButterfly argument validation
     """
-    assert_raises(TypeError, SquareButterfly, 3, 5)
-    assert_raises(TypeError, SquareButterfly, (3, 4, 5), 5)
+    pytest.raises(TypeError, SquareButterfly, 3, 5)
+    pytest.raises(TypeError, SquareButterfly, (3, 4, 5), 5)
 
 
 def test_square_butterfly_bounds():
@@ -1144,125 +1210,129 @@ def test_square_butterfly_bounds():
     """
     b = SquareButterfly((0, 0), 2)
     xbounds, ybounds = b.bounding_box
-    assert_array_almost_equal(xbounds, (-1, 1))
-    assert_array_almost_equal(ybounds, (-1, 1))
+    pytest.approx(xbounds, (-1, 1))
+    pytest.approx(ybounds, (-1, 1))
 
 
 def test_squarebutterfly_conversion():
-    b = SquareButterfly((2.54, 25.4), 254.0, units='metric')
+    b = SquareButterfly((2.54, 25.4), 254.0, units="metric")
 
     # No effect
     b.to_metric()
-    assert_equal(b.position, (2.54, 25.4))
-    assert_equal(b.side, (254.0))
+    assert b.position == (2.54, 25.4)
+    assert b.side == (254.0)
 
     b.to_inch()
-    assert_equal(b.position, (0.1, 1.0))
-    assert_equal(b.side, 10.0)
+    assert b.position == (0.1, 1.0)
+    assert b.side == 10.0
 
     # No effect
     b.to_inch()
-    assert_equal(b.position, (0.1, 1.0))
-    assert_equal(b.side, 10.0)
+    assert b.position == (0.1, 1.0)
+    assert b.side == 10.0
 
-    b = SquareButterfly((0.1, 1.0), 10.0, units='inch')
+    b = SquareButterfly((0.1, 1.0), 10.0, units="inch")
 
     # No effect
     b.to_inch()
-    assert_equal(b.position, (0.1, 1.0))
-    assert_equal(b.side, 10.0)
+    assert b.position == (0.1, 1.0)
+    assert b.side == 10.0
 
     b.to_metric()
-    assert_equal(b.position, (2.54, 25.4))
-    assert_equal(b.side, (254.0))
+    assert b.position == (2.54, 25.4)
+    assert b.side == (254.0)
 
     # No effect
     b.to_metric()
-    assert_equal(b.position, (2.54, 25.4))
-    assert_equal(b.side, (254.0))
+    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_equal(b.position, (1., 0.))
+    assert b.position == (1.0, 0.0)
     b.offset(0, 1)
-    assert_equal(b.position, (1., 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))
+    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_equal(d.position, pos)
-        assert_equal(d.shape, shape)
-        assert_equal(d.inner_diameter, in_d)
-        assert_equal(d.outer_diameter, 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():
-    assert_raises(TypeError, Donut, 3, 'round', 5, 7)
-    assert_raises(TypeError, Donut, (3, 4, 5), 'round', 5, 7)
-    assert_raises(ValueError, Donut, (0, 0), 'triangle', 3, 5)
-    assert_raises(ValueError, Donut, (0, 0), 'round', 5, 3)
+    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)
+    d = Donut((0, 0), "round", 0.0, 2.0)
     xbounds, ybounds = d.bounding_box
-    assert_equal(xbounds, (-1., 1.))
-    assert_equal(ybounds, (-1., 1.))
+    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')
+    d = Donut((2.54, 25.4), "round", 254.0, 2540.0, units="metric")
 
     # No effect
     d.to_metric()
-    assert_equal(d.position, (2.54, 25.4))
-    assert_equal(d.inner_diameter, 254.0)
-    assert_equal(d.outer_diameter, 2540.0)
+    assert d.position == (2.54, 25.4)
+    assert d.inner_diameter == 254.0
+    assert d.outer_diameter == 2540.0
 
     d.to_inch()
-    assert_equal(d.position, (0.1, 1.0))
-    assert_equal(d.inner_diameter, 10.0)
-    assert_equal(d.outer_diameter, 100.0)
+    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_equal(d.position, (0.1, 1.0))
-    assert_equal(d.inner_diameter, 10.0)
-    assert_equal(d.outer_diameter, 100.0)
+    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')
+    d = Donut((0.1, 1.0), "round", 10.0, 100.0, units="inch")
 
     # No effect
     d.to_inch()
-    assert_equal(d.position, (0.1, 1.0))
-    assert_equal(d.inner_diameter, 10.0)
-    assert_equal(d.outer_diameter, 100.0)
+    assert d.position == (0.1, 1.0)
+    assert d.inner_diameter == 10.0
+    assert d.outer_diameter == 100.0
 
     d.to_metric()
-    assert_equal(d.position, (2.54, 25.4))
-    assert_equal(d.inner_diameter, 254.0)
-    assert_equal(d.outer_diameter, 2540.0)
+    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_equal(d.position, (2.54, 25.4))
-    assert_equal(d.inner_diameter, 254.0)
-    assert_equal(d.outer_diameter, 2540.0)
+    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 = Donut((0, 0), "round", 1, 10)
     d.offset(1, 0)
-    assert_equal(d.position, (1., 0.))
+    assert d.position == (1.0, 0.0)
     d.offset(0, 1)
-    assert_equal(d.position, (1., 1.))
+    assert d.position == (1.0, 1.0)
 
 
 def test_drill_ctor():
@@ -1271,89 +1341,89 @@ def test_drill_ctor():
     test_cases = (((0, 0), 2), ((1, 1), 3), ((2, 2), 5))
     for position, diameter in test_cases:
         d = Drill(position, diameter)
-        assert_equal(d.position, position)
-        assert_equal(d.diameter, diameter)
-        assert_equal(d.radius, diameter / 2.)
+        assert d.position == position
+        assert d.diameter == diameter
+        assert d.radius == diameter / 2.0
 
 
 def test_drill_ctor_validation():
     """ Test drill argument validation
     """
-    assert_raises(TypeError, Drill, 3, 5)
-    assert_raises(TypeError, Drill, (3,4,5), 5)
-
+    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
-    assert_array_almost_equal(xbounds, (-1, 1))
-    assert_array_almost_equal(ybounds, (-1, 1))
+    pytest.approx(xbounds, (-1, 1))
+    pytest.approx(ybounds, (-1, 1))
     d = Drill((1, 2), 2)
     xbounds, ybounds = d.bounding_box
-    assert_array_almost_equal(xbounds, (0, 2))
-    assert_array_almost_equal(ybounds, (1, 3))
+    pytest.approx(xbounds, (0, 2))
+    pytest.approx(ybounds, (1, 3))
 
 
 def test_drill_conversion():
-    d = Drill((2.54, 25.4), 254., units='metric')
+    d = Drill((2.54, 25.4), 254.0, units="metric")
 
-    #No effect
+    # No effect
     d.to_metric()
-    assert_equal(d.position, (2.54, 25.4))
-    assert_equal(d.diameter, 254.0)
+    assert d.position == (2.54, 25.4)
+    assert d.diameter == 254.0
 
     d.to_inch()
-    assert_equal(d.position, (0.1, 1.0))
-    assert_equal(d.diameter, 10.0)
+    assert d.position == (0.1, 1.0)
+    assert d.diameter == 10.0
 
-    #No effect
+    # No effect
     d.to_inch()
-    assert_equal(d.position, (0.1, 1.0))
-    assert_equal(d.diameter, 10.0)
+    assert d.position == (0.1, 1.0)
+    assert d.diameter == 10.0
 
-    d = Drill((0.1, 1.0), 10., units='inch')
+    d = Drill((0.1, 1.0), 10.0, units="inch")
 
     # No effect
     d.to_inch()
-    assert_equal(d.position, (0.1, 1.0))
-    assert_equal(d.diameter, 10.0)
+    assert d.position == (0.1, 1.0)
+    assert d.diameter == 10.0
 
     d.to_metric()
-    assert_equal(d.position, (2.54, 25.4))
-    assert_equal(d.diameter, 254.0)
+    assert d.position == (2.54, 25.4)
+    assert d.diameter == 254.0
 
     # No effect
     d.to_metric()
-    assert_equal(d.position, (2.54, 25.4))
-    assert_equal(d.diameter, 254.0)
+    assert d.position == (2.54, 25.4)
+    assert d.diameter == 254.0
 
 
 def test_drill_offset():
-    d = Drill((0, 0), 1.)
+    d = Drill((0, 0), 1.0)
     d.offset(1, 0)
-    assert_equal(d.position, (1., 0.))
+    assert d.position == (1.0, 0.0)
     d.offset(0, 1)
-    assert_equal(d.position, (1., 1.))
+    assert d.position == (1.0, 1.0)
 
 
 def test_drill_equality():
-    d = Drill((2.54, 25.4), 254.)
-    d1 = Drill((2.54, 25.4), 254.)
-    assert_equal(d, d1)
+    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_not_equal(d, d1)
+    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))), ]
+    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_equal(s.bounding_box, expected)
-
+        assert s.bounding_box == expected
diff --git a/gerber/tests/test_rs274x.py b/gerber/tests/test_rs274x.py
index 4c69446..e7baf11 100644
--- a/gerber/tests/test_rs274x.py
+++ b/gerber/tests/test_rs274x.py
@@ -3,53 +3,53 @@
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
 import os
+import pytest
 
 from ..rs274x import read, GerberFile
-from .tests import *
 
 
-TOP_COPPER_FILE = os.path.join(os.path.dirname(__file__),
-                               'resources/top_copper.GTL')
+TOP_COPPER_FILE = os.path.join(os.path.dirname(__file__), "resources/top_copper.GTL")
 
-MULTILINE_READ_FILE = os.path.join(os.path.dirname(__file__),
-                                   'resources/multiline_read.ger')
+MULTILINE_READ_FILE = os.path.join(
+    os.path.dirname(__file__), "resources/multiline_read.ger"
+)
 
 
 def test_read():
     top_copper = read(TOP_COPPER_FILE)
-    assert(isinstance(top_copper, GerberFile))
+    assert isinstance(top_copper, GerberFile)
 
 
 def test_multiline_read():
     multiline = read(MULTILINE_READ_FILE)
-    assert(isinstance(multiline, GerberFile))
-    assert_equal(10, len(multiline.statements))
+    assert isinstance(multiline, GerberFile)
+    assert 10 == len(multiline.statements)
 
 
 def test_comments_parameter():
     top_copper = read(TOP_COPPER_FILE)
-    assert_equal(top_copper.comments[0], 'This is a comment,:')
+    assert top_copper.comments[0] == "This is a comment,:"
 
 
 def test_size_parameter():
     top_copper = read(TOP_COPPER_FILE)
     size = top_copper.size
-    assert_almost_equal(size[0], 2.256900, 6)
-    assert_almost_equal(size[1], 1.500000, 6)
+    pytest.approx(size[0], 2.256900, 6)
+    pytest.approx(size[1], 1.500000, 6)
 
 
 def test_conversion():
     top_copper = read(TOP_COPPER_FILE)
-    assert_equal(top_copper.units, 'inch')
+    assert top_copper.units == "inch"
     top_copper_inch = read(TOP_COPPER_FILE)
     top_copper.to_metric()
     for statement in top_copper_inch.statements:
         statement.to_metric()
     for primitive in top_copper_inch.primitives:
         primitive.to_metric()
-    assert_equal(top_copper.units, 'metric')
+    assert top_copper.units == "metric"
     for i, m in zip(top_copper.statements, top_copper_inch.statements):
-        assert_equal(i, m)
+        assert i == m
 
     for i, m in zip(top_copper.primitives, top_copper_inch.primitives):
-        assert_equal(i, m)
+        assert i == m
diff --git a/gerber/tests/test_rs274x_backend.py b/gerber/tests/test_rs274x_backend.py
index e128841..13347c5 100644
--- a/gerber/tests/test_rs274x_backend.py
+++ b/gerber/tests/test_rs274x_backend.py
@@ -7,62 +7,86 @@ import os
 
 from ..render.rs274x_backend import Rs274xContext
 from ..rs274x import read
-from .tests import *
+
 
 def test_render_two_boxes():
     """Umaco exapmle of two boxes"""
-    _test_render('resources/example_two_square_boxes.gbr', 'golden/example_two_square_boxes.gbr')
+    _test_render(
+        "resources/example_two_square_boxes.gbr", "golden/example_two_square_boxes.gbr"
+    )
 
 
 def _test_render_single_quadrant():
     """Umaco exapmle of a single quadrant arc"""
 
     # TODO there is probably a bug here
-    _test_render('resources/example_single_quadrant.gbr', 'golden/example_single_quadrant.gbr')
+    _test_render(
+        "resources/example_single_quadrant.gbr", "golden/example_single_quadrant.gbr"
+    )
 
 
 def _test_render_simple_contour():
     """Umaco exapmle of a simple arrow-shaped contour"""
-    _test_render('resources/example_simple_contour.gbr', 'golden/example_simple_contour.gbr')
+    _test_render(
+        "resources/example_simple_contour.gbr", "golden/example_simple_contour.gbr"
+    )
 
 
 def _test_render_single_contour_1():
     """Umaco example of a single contour
 
     The resulting image for this test is used by other tests because they must generate the same output."""
-    _test_render('resources/example_single_contour_1.gbr', 'golden/example_single_contour.gbr')
+    _test_render(
+        "resources/example_single_contour_1.gbr", "golden/example_single_contour.gbr"
+    )
 
 
 def _test_render_single_contour_2():
     """Umaco exapmle of a single contour, alternate contour end order
 
     The resulting image for this test is used by other tests because they must generate the same output."""
-    _test_render('resources/example_single_contour_2.gbr', 'golden/example_single_contour.gbr')
+    _test_render(
+        "resources/example_single_contour_2.gbr", "golden/example_single_contour.gbr"
+    )
 
 
 def _test_render_single_contour_3():
     """Umaco exapmle of a single contour with extra line"""
-    _test_render('resources/example_single_contour_3.gbr', 'golden/example_single_contour_3.gbr')
+    _test_render(
+        "resources/example_single_contour_3.gbr", "golden/example_single_contour_3.gbr"
+    )
 
 
 def _test_render_not_overlapping_contour():
     """Umaco example of D02 staring a second contour"""
-    _test_render('resources/example_not_overlapping_contour.gbr', 'golden/example_not_overlapping_contour.gbr')
+    _test_render(
+        "resources/example_not_overlapping_contour.gbr",
+        "golden/example_not_overlapping_contour.gbr",
+    )
 
 
 def _test_render_not_overlapping_touching():
     """Umaco example of D02 staring a second contour"""
-    _test_render('resources/example_not_overlapping_touching.gbr', 'golden/example_not_overlapping_touching.gbr')
+    _test_render(
+        "resources/example_not_overlapping_touching.gbr",
+        "golden/example_not_overlapping_touching.gbr",
+    )
 
 
 def _test_render_overlapping_touching():
     """Umaco example of D02 staring a second contour"""
-    _test_render('resources/example_overlapping_touching.gbr', 'golden/example_overlapping_touching.gbr')
+    _test_render(
+        "resources/example_overlapping_touching.gbr",
+        "golden/example_overlapping_touching.gbr",
+    )
 
 
 def _test_render_overlapping_contour():
     """Umaco example of D02 staring a second contour"""
-    _test_render('resources/example_overlapping_contour.gbr', 'golden/example_overlapping_contour.gbr')
+    _test_render(
+        "resources/example_overlapping_contour.gbr",
+        "golden/example_overlapping_contour.gbr",
+    )
 
 
 def _DISABLED_test_render_level_holes():
@@ -70,76 +94,96 @@ def _DISABLED_test_render_level_holes():
 
     # TODO This is clearly rendering wrong. I'm temporarily checking this in because there are more
     # rendering fixes in the related repository that may resolve these.
-    _test_render('resources/example_level_holes.gbr', 'golden/example_overlapping_contour.gbr')
+    _test_render(
+        "resources/example_level_holes.gbr", "golden/example_overlapping_contour.gbr"
+    )
 
 
 def _DISABLED_test_render_cutin():
     """Umaco example of using a cutin"""
 
     # TODO This is clearly rendering wrong.
-    _test_render('resources/example_cutin.gbr', 'golden/example_cutin.gbr')
+    _test_render("resources/example_cutin.gbr", "golden/example_cutin.gbr")
 
 
 def _test_render_fully_coincident():
     """Umaco example of coincident lines rendering two contours"""
 
-    _test_render('resources/example_fully_coincident.gbr', 'golden/example_fully_coincident.gbr')
+    _test_render(
+        "resources/example_fully_coincident.gbr", "golden/example_fully_coincident.gbr"
+    )
 
 
 def _test_render_coincident_hole():
     """Umaco example of coincident lines rendering a hole in the contour"""
 
-    _test_render('resources/example_coincident_hole.gbr', 'golden/example_coincident_hole.gbr')
+    _test_render(
+        "resources/example_coincident_hole.gbr", "golden/example_coincident_hole.gbr"
+    )
 
 
 def _test_render_cutin_multiple():
     """Umaco example of a region with multiple cutins"""
 
-    _test_render('resources/example_cutin_multiple.gbr', 'golden/example_cutin_multiple.gbr')
+    _test_render(
+        "resources/example_cutin_multiple.gbr", "golden/example_cutin_multiple.gbr"
+    )
 
 
 def _test_flash_circle():
     """Umaco example a simple circular flash with and without a hole"""
 
-    _test_render('resources/example_flash_circle.gbr', 'golden/example_flash_circle.gbr')
+    _test_render(
+        "resources/example_flash_circle.gbr", "golden/example_flash_circle.gbr"
+    )
 
 
 def _test_flash_rectangle():
     """Umaco example a simple rectangular flash with and without a hole"""
 
-    _test_render('resources/example_flash_rectangle.gbr', 'golden/example_flash_rectangle.gbr')
+    _test_render(
+        "resources/example_flash_rectangle.gbr", "golden/example_flash_rectangle.gbr"
+    )
 
 
 def _test_flash_obround():
     """Umaco example a simple obround flash with and without a hole"""
 
-    _test_render('resources/example_flash_obround.gbr', 'golden/example_flash_obround.gbr')
+    _test_render(
+        "resources/example_flash_obround.gbr", "golden/example_flash_obround.gbr"
+    )
 
 
 def _test_flash_polygon():
     """Umaco example a simple polygon flash with and without a hole"""
 
-    _test_render('resources/example_flash_polygon.gbr', 'golden/example_flash_polygon.gbr')
+    _test_render(
+        "resources/example_flash_polygon.gbr", "golden/example_flash_polygon.gbr"
+    )
 
 
 def _test_holes_dont_clear():
     """Umaco example that an aperture with a hole does not clear the area"""
 
-    _test_render('resources/example_holes_dont_clear.gbr', 'golden/example_holes_dont_clear.gbr')
+    _test_render(
+        "resources/example_holes_dont_clear.gbr", "golden/example_holes_dont_clear.gbr"
+    )
 
 
 def _test_render_am_exposure_modifier():
     """Umaco example that an aperture macro with a hole does not clear the area"""
 
-    _test_render('resources/example_am_exposure_modifier.gbr', 'golden/example_am_exposure_modifier.gbr')
+    _test_render(
+        "resources/example_am_exposure_modifier.gbr",
+        "golden/example_am_exposure_modifier.gbr",
+    )
 
 
 def _resolve_path(path):
-    return os.path.join(os.path.dirname(__file__),
-                                path)
+    return os.path.join(os.path.dirname(__file__), path)
 
 
-def _test_render(gerber_path, png_expected_path, create_output_path = None):
+def _test_render(gerber_path, png_expected_path, create_output_path=None):
     """Render the gerber file and compare to the expected PNG output.
 
     Parameters
@@ -168,18 +212,21 @@ def _test_render(gerber_path, png_expected_path, create_output_path = None):
 
     # If we want to write the file bytes, do it now. This happens
     if create_output_path:
-        with open(create_output_path, 'wb') as out_file:
+        with open(create_output_path, "wb") as out_file:
             out_file.write(actual_contents.getvalue())
         # Creating the output is dangerous - it could overwrite the expected result.
         # So if we are creating the output, we make the test fail on purpose so you
         # won't forget to disable this
-        assert_false(True, 'Test created the output %s. This needs to be disabled to make sure the test behaves correctly' % (create_output_path,))
+        assert not True, (
+            "Test created the output %s. This needs to be disabled to make sure the test behaves correctly"
+            % (create_output_path,)
+        )
 
     # Read the expected PNG file
 
-    with open(png_expected_path, 'r') as expected_file:
+    with open(png_expected_path, "r") as expected_file:
         expected_contents = expected_file.read()
 
-    assert_equal(expected_contents, actual_contents.getvalue())
+    assert expected_contents == actual_contents.getvalue()
 
     return gerber
diff --git a/gerber/tests/test_utils.py b/gerber/tests/test_utils.py
index 35f6f47..68484d1 100644
--- a/gerber/tests/test_utils.py
+++ b/gerber/tests/test_utils.py
@@ -3,7 +3,7 @@
 
 # Author: Hamilton Kibbe <ham@hamiltonkib.be>
 
-from .tests import assert_equal, assert_raises
+import pytest
 from ..utils import *
 
 
@@ -14,60 +14,99 @@ def test_zero_suppression():
     fmt = (2, 5)
 
     # Test leading zero suppression
-    zero_suppression = 'leading'
-    test_cases = [('1', 0.00001), ('10', 0.0001), ('100', 0.001),
-                  ('1000', 0.01), ('10000', 0.1), ('100000', 1.0),
-                  ('1000000', 10.0), ('-1', -0.00001), ('-10', -0.0001),
-                  ('-100', -0.001), ('-1000', -0.01), ('-10000', -0.1),
-                  ('-100000', -1.0), ('-1000000', -10.0),
-                  ('0', 0.0)]
+    zero_suppression = "leading"
+    test_cases = [
+        ("1", 0.00001),
+        ("10", 0.0001),
+        ("100", 0.001),
+        ("1000", 0.01),
+        ("10000", 0.1),
+        ("100000", 1.0),
+        ("1000000", 10.0),
+        ("-1", -0.00001),
+        ("-10", -0.0001),
+        ("-100", -0.001),
+        ("-1000", -0.01),
+        ("-10000", -0.1),
+        ("-100000", -1.0),
+        ("-1000000", -10.0),
+        ("0", 0.0),
+    ]
     for string, value in test_cases:
-        assert_equal(value, parse_gerber_value(string, fmt, zero_suppression))
-        assert_equal(string, write_gerber_value(value, fmt, zero_suppression))
+        assert value == parse_gerber_value(string, fmt, zero_suppression)
+        assert string == write_gerber_value(value, fmt, zero_suppression)
 
     # Test trailing zero suppression
-    zero_suppression = 'trailing'
-    test_cases = [('1', 10.0), ('01', 1.0), ('001', 0.1), ('0001', 0.01),
-                  ('00001', 0.001), ('000001', 0.0001),
-                  ('0000001', 0.00001), ('-1', -10.0), ('-01', -1.0),
-                  ('-001', -0.1), ('-0001', -0.01), ('-00001', -0.001),
-                  ('-000001', -0.0001), ('-0000001', -0.00001),
-                  ('0', 0.0)]
+    zero_suppression = "trailing"
+    test_cases = [
+        ("1", 10.0),
+        ("01", 1.0),
+        ("001", 0.1),
+        ("0001", 0.01),
+        ("00001", 0.001),
+        ("000001", 0.0001),
+        ("0000001", 0.00001),
+        ("-1", -10.0),
+        ("-01", -1.0),
+        ("-001", -0.1),
+        ("-0001", -0.01),
+        ("-00001", -0.001),
+        ("-000001", -0.0001),
+        ("-0000001", -0.00001),
+        ("0", 0.0),
+    ]
     for string, value in test_cases:
-        assert_equal(value, parse_gerber_value(string, fmt, zero_suppression))
-        assert_equal(string, write_gerber_value(value, fmt, zero_suppression))
+        assert value == parse_gerber_value(string, fmt, zero_suppression)
+        assert string == write_gerber_value(value, fmt, zero_suppression)
 
-    assert_equal(write_gerber_value(0.000000001, fmt, 'leading'), '0')
-    assert_equal(write_gerber_value(0.000000001, fmt, 'trailing'), '0')
+    assert write_gerber_value(0.000000001, fmt, "leading") == "0"
+    assert write_gerber_value(0.000000001, fmt, "trailing") == "0"
 
 
 def test_format():
     """ Test gerber value parser and writer handle format correctly
     """
-    zero_suppression = 'leading'
-    test_cases = [((2, 7), '1', 0.0000001), ((2, 6), '1', 0.000001),
-                  ((2, 5), '1', 0.00001), ((2, 4), '1', 0.0001),
-                  ((2, 3), '1', 0.001), ((2, 2), '1', 0.01),
-                  ((2, 1), '1', 0.1), ((2, 7), '-1', -0.0000001),
-                  ((2, 6), '-1', -0.000001), ((2, 5), '-1', -0.00001),
-                  ((2, 4), '-1', -0.0001), ((2, 3), '-1', -0.001),
-                  ((2, 2), '-1', -0.01), ((2, 1), '-1', -0.1),
-                  ((2, 6), '0', 0)]
+    zero_suppression = "leading"
+    test_cases = [
+        ((2, 7), "1", 0.0000001),
+        ((2, 6), "1", 0.000001),
+        ((2, 5), "1", 0.00001),
+        ((2, 4), "1", 0.0001),
+        ((2, 3), "1", 0.001),
+        ((2, 2), "1", 0.01),
+        ((2, 1), "1", 0.1),
+        ((2, 7), "-1", -0.0000001),
+        ((2, 6), "-1", -0.000001),
+        ((2, 5), "-1", -0.00001),
+        ((2, 4), "-1", -0.0001),
+        ((2, 3), "-1", -0.001),
+        ((2, 2), "-1", -0.01),
+        ((2, 1), "-1", -0.1),
+        ((2, 6), "0", 0),
+    ]
     for fmt, string, value in test_cases:
-        assert_equal(value, parse_gerber_value(string, fmt, zero_suppression))
-        assert_equal(string, write_gerber_value(value, fmt, zero_suppression))
-
-    zero_suppression = 'trailing'
-    test_cases = [((6, 5), '1', 100000.0), ((5, 5), '1', 10000.0),
-                  ((4, 5), '1', 1000.0), ((3, 5), '1', 100.0),
-                  ((2, 5), '1', 10.0), ((1, 5), '1', 1.0),
-                  ((6, 5), '-1', -100000.0), ((5, 5), '-1', -10000.0),
-                  ((4, 5), '-1', -1000.0), ((3, 5), '-1', -100.0),
-                  ((2, 5), '-1', -10.0), ((1, 5), '-1', -1.0),
-                  ((2, 5), '0', 0)]
+        assert value == parse_gerber_value(string, fmt, zero_suppression)
+        assert string == write_gerber_value(value, fmt, zero_suppression)
+
+    zero_suppression = "trailing"
+    test_cases = [
+        ((6, 5), "1", 100000.0),
+        ((5, 5), "1", 10000.0),
+        ((4, 5), "1", 1000.0),
+        ((3, 5), "1", 100.0),
+        ((2, 5), "1", 10.0),
+        ((1, 5), "1", 1.0),
+        ((6, 5), "-1", -100000.0),
+        ((5, 5), "-1", -10000.0),
+        ((4, 5), "-1", -1000.0),
+        ((3, 5), "-1", -100.0),
+        ((2, 5), "-1", -10.0),
+        ((1, 5), "-1", -1.0),
+        ((2, 5), "0", 0),
+    ]
     for fmt, string, value in test_cases:
-        assert_equal(value, parse_gerber_value(string, fmt, zero_suppression))
-        assert_equal(string, write_gerber_value(value, fmt, zero_suppression))
+        assert value == parse_gerber_value(string, fmt, zero_suppression)
+        assert string == write_gerber_value(value, fmt, zero_suppression)
 
 
 def test_decimal_truncation():
@@ -76,54 +115,53 @@ def test_decimal_truncation():
     value = 1.123456789
     for x in range(10):
         result = decimal_string(value, precision=x)
-        calculated = '1.' + ''.join(str(y) for y in range(1, x + 1))
-        assert_equal(result, calculated)
+        calculated = "1." + "".join(str(y) for y in range(1, x + 1))
+        assert result == calculated
 
 
 def test_decimal_padding():
     """ Test decimal_string padding
     """
     value = 1.123
-    assert_equal(decimal_string(value, precision=3, padding=True), '1.123')
-    assert_equal(decimal_string(value, precision=4, padding=True), '1.1230')
-    assert_equal(decimal_string(value, precision=5, padding=True), '1.12300')
-    assert_equal(decimal_string(value, precision=6, padding=True), '1.123000')
-    assert_equal(decimal_string(0, precision=6, padding=True), '0.000000')
+    assert decimal_string(value, precision=3, padding=True) == "1.123"
+    assert decimal_string(value, precision=4, padding=True) == "1.1230"
+    assert decimal_string(value, precision=5, padding=True) == "1.12300"
+    assert decimal_string(value, precision=6, padding=True) == "1.123000"
+    assert decimal_string(0, precision=6, padding=True) == "0.000000"
 
 
 def test_parse_format_validation():
     """ Test parse_gerber_value() format validation
     """
-    assert_raises(ValueError, parse_gerber_value, '00001111', (7, 5))
-    assert_raises(ValueError, parse_gerber_value, '00001111', (5, 8))
-    assert_raises(ValueError, parse_gerber_value, '00001111', (13, 1))
+    pytest.raises(ValueError, parse_gerber_value, "00001111", (7, 5))
+    pytest.raises(ValueError, parse_gerber_value, "00001111", (5, 8))
+    pytest.raises(ValueError, parse_gerber_value, "00001111", (13, 1))
 
 
 def test_write_format_validation():
     """ Test write_gerber_value() format validation
     """
-    assert_raises(ValueError, write_gerber_value, 69.0, (7, 5))
-    assert_raises(ValueError, write_gerber_value, 69.0, (5, 8))
-    assert_raises(ValueError, write_gerber_value, 69.0, (13, 1))
+    pytest.raises(ValueError, write_gerber_value, 69.0, (7, 5))
+    pytest.raises(ValueError, write_gerber_value, 69.0, (5, 8))
+    pytest.raises(ValueError, write_gerber_value, 69.0, (13, 1))
 
 
 def test_detect_format_with_short_file():
     """ Verify file format detection works with short files
     """
-    assert_equal('unknown', detect_file_format('gerber/tests/__init__.py'))
+    assert "unknown" == detect_file_format("gerber/tests/__init__.py")
 
 
 def test_validate_coordinates():
-    assert_raises(TypeError, validate_coordinates, 3)
-    assert_raises(TypeError, validate_coordinates, 3.1)
-    assert_raises(TypeError, validate_coordinates, '14')
-    assert_raises(TypeError, validate_coordinates, (0,))
-    assert_raises(TypeError, validate_coordinates, (0, 1, 2))
-    assert_raises(TypeError, validate_coordinates, (0, 'string'))
+    pytest.raises(TypeError, validate_coordinates, 3)
+    pytest.raises(TypeError, validate_coordinates, 3.1)
+    pytest.raises(TypeError, validate_coordinates, "14")
+    pytest.raises(TypeError, validate_coordinates, (0,))
+    pytest.raises(TypeError, validate_coordinates, (0, 1, 2))
+    pytest.raises(TypeError, validate_coordinates, (0, "string"))
 
 
 def test_convex_hull():
     points = [(0, 0), (1, 0), (1, 1), (0.5, 0.5), (0, 1), (0, 0)]
     expected = [(0, 0), (1, 0), (1, 1), (0, 1), (0, 0)]
-    assert_equal(set(convex_hull(points)), set(expected))
-    
\ No newline at end of file
+    assert set(convex_hull(points)) == set(expected)
diff --git a/gerber/tests/tests.py b/gerber/tests/tests.py
deleted file mode 100644
index ac08208..0000000
--- a/gerber/tests/tests.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Author: Hamilton Kibbe <ham@hamiltonkib.be>
-
-from nose.tools import assert_in
-from nose.tools import assert_not_in
-from nose.tools import assert_equal
-from nose.tools import assert_not_equal
-from nose.tools import assert_almost_equal
-from nose.tools import assert_true
-from nose.tools import assert_false
-from nose.tools import assert_raises
-from nose.tools import raises
-from nose import with_setup
-
-__all__ = ['assert_in', 'assert_not_in', 'assert_equal', 'assert_not_equal',
-           'assert_almost_equal', 'assert_array_almost_equal', 'assert_true',
-           'assert_false', 'assert_raises', 'raises', 'with_setup']
-
-
-def assert_array_almost_equal(arr1, arr2, decimal=6):
-    assert_equal(len(arr1), len(arr2))
-    for i in range(len(arr1)):
-        assert_almost_equal(arr1[i], arr2[i], decimal)