Add obsolete test cases

1 files changed, 0 insertions, 903 deletions

diff --git a/gerbonara/gerber/tests/test_gerber_statements.py b/gerbonara/gerber/tests/test_gerber_statements.py
deleted file mode 100644
index 17e2591..0000000
--- a/gerbonara/gerber/tests/test_gerber_statements.py
+++ /dev/null
@@ -1,903 +0,0 @@
-#! /usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Author: Hamilton Kibbe <ham@hamiltonkib.be>
-
-import pytest
-from ..gerber_statements import *
-from ..cam import FileSettings
-
-
-def test_Statement_smoketest():
-    stmt = Statement("Test")
-    assert stmt.type == "Test"
-    stmt.to_metric()
-    assert "units=metric" in str(stmt)
-    stmt.to_inch()
-    assert "units=inch" in str(stmt)
-    stmt.to_metric()
-    stmt.offset(1, 1)
-    assert "type=Test" in str(stmt)
-
-
-def test_FSParamStmt_factory():
-    """ Test FSParamStruct factory
-    """
-    stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"}
-    fs = FSParamStmt.from_dict(stmt)
-    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"}
-    fs = FSParamStmt.from_dict(stmt)
-    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"
-    fmt = (2, 5)
-    stmt = FSParamStmt(param, zeros, notation, 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"}
-    fs = FSParamStmt.from_dict(stmt)
-    assert fs.to_gerber() == "%FSLAX27Y27*%"
-
-    stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "25"}
-    fs = FSParamStmt.from_dict(stmt)
-    assert fs.to_gerber() == "%FSTIX25Y25*%"
-
-    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"}
-    fs = FSParamStmt.from_dict(stmt)
-    assert str(fs) == "<Format Spec: 2:7 leading zero suppression absolute notation>"
-
-    stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "25"}
-    fs = FSParamStmt.from_dict(stmt)
-    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"}]
-    for stmt in stmts:
-        mo = MOParamStmt.from_dict(stmt)
-        assert mo.param == "MO"
-        assert mo.mode == "inch"
-
-    stmts = [{"param": "MO", "mo": "MM"}, {"param": "MO", "mo": "mm"}]
-    for stmt in stmts:
-        mo = MOParamStmt.from_dict(stmt)
-        assert mo.param == "MO"
-        assert mo.mode == "metric"
-
-    stmt = {"param": "MO"}
-    mo = 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"
-    stmt = MOParamStmt(param, mode)
-    assert stmt.param == param
-
-    for mode in ["inch", "metric"]:
-        stmt = MOParamStmt(param, mode)
-        assert stmt.mode == mode
-
-
-def test_MOParamStmt_dump():
-    """ Test MOParamStmt to_gerber()
-    """
-    stmt = {"param": "MO", "mo": "IN"}
-    mo = MOParamStmt.from_dict(stmt)
-    assert mo.to_gerber() == "%MOIN*%"
-
-    stmt = {"param": "MO", "mo": "MM"}
-    mo = MOParamStmt.from_dict(stmt)
-    assert mo.to_gerber() == "%MOMM*%"
-
-
-def test_MOParamStmt_conversion():
-    stmt = {"param": "MO", "mo": "MM"}
-    mo = MOParamStmt.from_dict(stmt)
-    mo.to_inch()
-    assert mo.mode == "inch"
-
-    stmt = {"param": "MO", "mo": "IN"}
-    mo = MOParamStmt.from_dict(stmt)
-    mo.to_metric()
-    assert mo.mode == "metric"
-
-
-def test_MOParamStmt_string():
-    """ Test MOParamStmt.__str__()
-    """
-    stmt = {"param": "MO", "mo": "IN"}
-    mo = MOParamStmt.from_dict(stmt)
-    assert str(mo) == "<Mode: inches>"
-
-    stmt = {"param": "MO", "mo": "MM"}
-    mo = MOParamStmt.from_dict(stmt)
-    assert str(mo) == "<Mode: millimeters>"
-
-
-def test_IPParamStmt_factory():
-    """ Test IPParamStruct factory
-    """
-    stmt = {"param": "IP", "ip": "POS"}
-    ip = IPParamStmt.from_dict(stmt)
-    assert ip.ip == "positive"
-
-    stmt = {"param": "IP", "ip": "NEG"}
-    ip = IPParamStmt.from_dict(stmt)
-    assert ip.ip == "negative"
-
-
-def test_IPParamStmt():
-    """ Test IPParamStmt initialization
-    """
-    param = "IP"
-    for ip in ["positive", "negative"]:
-        stmt = IPParamStmt(param, ip)
-        assert stmt.param == param
-        assert stmt.ip == ip
-
-
-def test_IPParamStmt_dump():
-    """ Test IPParamStmt to_gerber()
-    """
-    stmt = {"param": "IP", "ip": "POS"}
-    ip = IPParamStmt.from_dict(stmt)
-    assert ip.to_gerber() == "%IPPOS*%"
-
-    stmt = {"param": "IP", "ip": "NEG"}
-    ip = IPParamStmt.from_dict(stmt)
-    assert ip.to_gerber() == "%IPNEG*%"
-
-
-def test_IPParamStmt_string():
-    stmt = {"param": "IP", "ip": "POS"}
-    ip = IPParamStmt.from_dict(stmt)
-    assert str(ip) == "<Image Polarity: positive>"
-
-    stmt = {"param": "IP", "ip": "NEG"}
-    ip = IPParamStmt.from_dict(stmt)
-    assert str(ip) == "<Image Polarity: negative>"
-
-
-def test_IRParamStmt_factory():
-    stmt = {"param": "IR", "angle": "45"}
-    ir = IRParamStmt.from_dict(stmt)
-    assert ir.param == "IR"
-    assert ir.angle == 45
-
-
-def test_IRParamStmt_dump():
-    stmt = {"param": "IR", "angle": "45"}
-    ir = IRParamStmt.from_dict(stmt)
-    assert ir.to_gerber() == "%IR45*%"
-
-
-def test_IRParamStmt_string():
-    stmt = {"param": "IR", "angle": "45"}
-    ir = IRParamStmt.from_dict(stmt)
-    assert str(ir) == "<Image Angle: 45>"
-
-
-def test_OFParamStmt_factory():
-    """ Test OFParamStmt factory
-    """
-    stmt = {"param": "OF", "a": "0.1234567", "b": "0.1234567"}
-    of = OFParamStmt.from_dict(stmt)
-    assert of.a == 0.1234567
-    assert of.b == 0.1234567
-
-
-def test_OFParamStmt():
-    """ Test IPParamStmt initialization
-    """
-    param = "OF"
-    for val in [0.0, -3.4567]:
-        stmt = OFParamStmt(param, val, 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"}
-    of = OFParamStmt.from_dict(stmt)
-    assert of.to_gerber() == "%OFA0.12345B0.12345*%"
-
-
-def test_OFParamStmt_conversion():
-    stmt = {"param": "OF", "a": "2.54", "b": "25.4"}
-    of = OFParamStmt.from_dict(stmt)
-    of.units = "metric"
-
-    # No effect
-    of.to_metric()
-    assert of.a == 2.54
-    assert of.b == 25.4
-
-    of.to_inch()
-    assert of.units == "inch"
-    assert of.a == 0.1
-    assert of.b == 1.0
-
-    # No effect
-    of.to_inch()
-    assert of.a == 0.1
-    assert of.b == 1.0
-
-    stmt = {"param": "OF", "a": "0.1", "b": "1.0"}
-    of = OFParamStmt.from_dict(stmt)
-    of.units = "inch"
-
-    # No effect
-    of.to_inch()
-    assert of.a == 0.1
-    assert of.b == 1.0
-
-    of.to_metric()
-    assert of.units == "metric"
-    assert of.a == 2.54
-    assert of.b == 25.4
-
-    # No effect
-    of.to_metric()
-    assert of.a == 2.54
-    assert of.b == 25.4
-
-
-def test_OFParamStmt_offset():
-    s = OFParamStmt("OF", 0, 0)
-    s.offset(1, 0)
-    assert s.a == 1.0
-    assert s.b == 0.0
-    s.offset(0, 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"}
-    of = OFParamStmt.from_dict(stmt)
-    assert str(of) == "<Offset: X: 0.123456 Y: 0.123456 >"
-
-
-def test_SFParamStmt_factory():
-    stmt = {"param": "SF", "a": "1.4", "b": "0.9"}
-    sf = SFParamStmt.from_dict(stmt)
-    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"}
-    sf = SFParamStmt.from_dict(stmt)
-    assert sf.to_gerber() == "%SFA1.4B0.9*%"
-
-
-def test_SFParamStmt_conversion():
-    stmt = {"param": "OF", "a": "2.54", "b": "25.4"}
-    of = SFParamStmt.from_dict(stmt)
-    of.units = "metric"
-    of.to_metric()
-
-    # No effect
-    assert of.a == 2.54
-    assert of.b == 25.4
-
-    of.to_inch()
-    assert of.units == "inch"
-    assert of.a == 0.1
-    assert of.b == 1.0
-
-    # No effect
-    of.to_inch()
-    assert of.a == 0.1
-    assert of.b == 1.0
-
-    stmt = {"param": "OF", "a": "0.1", "b": "1.0"}
-    of = SFParamStmt.from_dict(stmt)
-    of.units = "inch"
-
-    # No effect
-    of.to_inch()
-    assert of.a == 0.1
-    assert of.b == 1.0
-
-    of.to_metric()
-    assert of.units == "metric"
-    assert of.a == 2.54
-    assert of.b == 25.4
-
-    # No effect
-    of.to_metric()
-    assert of.a == 2.54
-    assert of.b == 25.4
-
-
-def test_SFParamStmt_offset():
-    s = SFParamStmt("OF", 0, 0)
-    s.offset(1, 0)
-    assert s.a == 1.0
-    assert s.b == 0.0
-    s.offset(0, 1)
-    assert s.a == 1.0
-    assert s.b == 1.0
-
-
-def test_SFParamStmt_string():
-    stmt = {"param": "SF", "a": "1.4", "b": "0.9"}
-    sf = SFParamStmt.from_dict(stmt)
-    assert str(sf) == "<Scale Factor: X: 1.4 Y: 0.9>"
-
-
-def test_LPParamStmt_factory():
-    """ Test LPParamStmt factory
-    """
-    stmt = {"param": "LP", "lp": "C"}
-    lp = LPParamStmt.from_dict(stmt)
-    assert lp.lp == "clear"
-
-    stmt = {"param": "LP", "lp": "D"}
-    lp = LPParamStmt.from_dict(stmt)
-    assert lp.lp == "dark"
-
-
-def test_LPParamStmt_dump():
-    """ Test LPParamStmt to_gerber()
-    """
-    stmt = {"param": "LP", "lp": "C"}
-    lp = LPParamStmt.from_dict(stmt)
-    assert lp.to_gerber() == "%LPC*%"
-
-    stmt = {"param": "LP", "lp": "D"}
-    lp = LPParamStmt.from_dict(stmt)
-    assert lp.to_gerber() == "%LPD*%"
-
-
-def test_LPParamStmt_string():
-    """ Test LPParamStmt.__str__()
-    """
-    stmt = {"param": "LP", "lp": "D"}
-    lp = LPParamStmt.from_dict(stmt)
-    assert str(lp) == "<Level Polarity: dark>"
-
-    stmt = {"param": "LP", "lp": "C"}
-    lp = LPParamStmt.from_dict(stmt)
-    assert str(lp) == "<Level Polarity: clear>"
-
-
-def test_AMParamStmt_factory():
-    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*
-4,1,4,0.1,0.1,0.5,0.1,0.5,0.5,0.1,0.5,0.1,0.1,0*
-5,1,8,0,0,8,0*
-7,0,0,7,6,0.2,0*
-"""
-    s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm')
-    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[5], AMOutlinePrimitive)
-    assert isinstance(s.primitives[6], AMPolygonPrimitive)
-    assert isinstance(s.primitives[8], AMThermalPrimitive)
-
-
-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}, units='mm')
-    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"}, units='mm')
-    # 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}, units='mm')
-    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"}
-    s = ASParamStmt.from_dict(stmt)
-    assert s.param == "AS"
-    assert s.mode == "AXBY"
-
-
-def test_ASParamStmt_dump():
-    stmt = {"param": "AS", "mode": "AXBY"}
-    s = ASParamStmt.from_dict(stmt)
-    assert s.to_gerber() == "%ASAXBY*%"
-
-
-def test_ASParamStmt_string():
-    stmt = {"param": "AS", "mode": "AXBY"}
-    s = ASParamStmt.from_dict(stmt)
-    assert str(s) == "<Axis Select: AXBY>"
-
-
-def test_INParamStmt_factory():
-    """ Test INParamStmt factory
-    """
-    stmt = {"param": "IN", "name": "test"}
-    inp = INParamStmt.from_dict(stmt)
-    assert inp.name == "test"
-
-
-def test_INParamStmt_dump():
-    """ Test INParamStmt to_gerber()
-    """
-    stmt = {"param": "IN", "name": "test"}
-    inp = INParamStmt.from_dict(stmt)
-    assert inp.to_gerber() == "%INtest*%"
-
-
-def test_INParamStmt_string():
-    stmt = {"param": "IN", "name": "test"}
-    inp = INParamStmt.from_dict(stmt)
-    assert str(inp) == "<Image Name: test>"
-
-
-def test_LNParamStmt_factory():
-    """ Test LNParamStmt factory
-    """
-    stmt = {"param": "LN", "name": "test"}
-    lnp = LNParamStmt.from_dict(stmt)
-    assert lnp.name == "test"
-
-
-def test_LNParamStmt_dump():
-    """ Test LNParamStmt to_gerber()
-    """
-    stmt = {"param": "LN", "name": "test"}
-    lnp = LNParamStmt.from_dict(stmt)
-    assert lnp.to_gerber() == "%LNtest*%"
-
-
-def test_LNParamStmt_string():
-    stmt = {"param": "LN", "name": "test"}
-    lnp = LNParamStmt.from_dict(stmt)
-    assert str(lnp) == "<Level Name: test>"
-
-
-def test_comment_stmt():
-    """ Test comment statement
-    """
-    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 stmt.to_gerber() == "G04A comment*"
-
-
-def test_comment_stmt_string():
-    stmt = CommentStmt("A comment")
-    assert str(stmt) == "<Comment: A comment>"
-
-
-def test_eofstmt():
-    """ Test EofStmt
-    """
-    stmt = EofStmt()
-    assert stmt.type == "EOF"
-
-
-def test_eofstmt_dump():
-    """ Test EofStmt to_gerber()
-    """
-    stmt = EofStmt()
-    assert stmt.to_gerber() == "M02*"
-
-
-def test_eofstmt_string():
-    assert str(EofStmt()) == "<EOF Statement>"
-
-
-def test_quadmodestmt_factory():
-    """ Test QuadrantModeStmt.from_gerber()
-    """
-    line = "G74*"
-    stmt = QuadrantModeStmt.from_gerber(line)
-    assert stmt.type == "QuadrantMode"
-    assert stmt.mode == "single-quadrant"
-
-    line = "G75*"
-    stmt = QuadrantModeStmt.from_gerber(line)
-    assert stmt.mode == "multi-quadrant"
-
-
-def test_quadmodestmt_validation():
-    """ Test QuadrantModeStmt input validation
-    """
-    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*"):
-        stmt = QuadrantModeStmt.from_gerber(line)
-        assert stmt.to_gerber() == line
-
-
-def test_regionmodestmt_factory():
-    """ Test RegionModeStmt.from_gerber()
-    """
-    line = "G36*"
-    stmt = RegionModeStmt.from_gerber(line)
-    assert stmt.type == "RegionMode"
-    assert stmt.mode == "on"
-
-    line = "G37*"
-    stmt = RegionModeStmt.from_gerber(line)
-    assert stmt.mode == "off"
-
-
-def test_regionmodestmt_validation():
-    """ Test RegionModeStmt input validation
-    """
-    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*"):
-        stmt = RegionModeStmt.from_gerber(line)
-        assert stmt.to_gerber() == line
-
-
-def test_unknownstmt():
-    """ Test UnknownStmt
-    """
-    line = "G696969*"
-    stmt = UnknownStmt(line)
-    assert stmt.type == "UNKNOWN"
-    assert stmt.line == line
-
-
-def test_unknownstmt_dump():
-    """ Test UnknownStmt.to_gerber()
-    """
-    lines = ("G696969*", "M03*")
-    for line in lines:
-        stmt = UnknownStmt(line)
-        assert stmt.to_gerber() == line
-
-
-def test_statement_string():
-    """ Test Statement.__str__()
-    """
-    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"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert ad.d == 0
-    assert ad.shape == "C"
-
-    stmt = {"param": "AD", "d": 1, "shape": "R"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert ad.d == 1
-    assert ad.shape == "R"
-
-    stmt = {"param": "AD", "d": 1, "shape": "C", "modifiers": "1.42"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert ad.d == 1
-    assert ad.shape == "C"
-    assert ad.modifiers == [(1.42,)]
-
-    stmt = {"param": "AD", "d": 1, "shape": "C", "modifiers": "1.42X"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert ad.d == 1
-    assert ad.shape == "C"
-    assert ad.modifiers == [(1.42,)]
-
-    stmt = {"param": "AD", "d": 1, "shape": "R", "modifiers": "1.42X1.24"}
-    ad = ADParamStmt.from_dict(stmt)
-    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"}
-    ad = ADParamStmt.from_dict(stmt)
-    ad.units = "metric"
-
-    # No effect
-    ad.to_metric()
-    assert ad.modifiers[0] == (25.4, 25.4)
-    assert ad.modifiers[1] == (25.4, 25.4)
-
-    ad.to_inch()
-    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 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"}
-    ad = ADParamStmt.from_dict(stmt)
-    ad.units = "inch"
-
-    # No effect
-    ad.to_inch()
-    assert ad.modifiers[0] == (1.0, 1.0)
-    assert ad.modifiers[1] == (1.0, 1.0)
-
-    ad.to_metric()
-    assert ad.modifiers[0] == (25.4, 25.4)
-    assert ad.modifiers[1] == (25.4, 25.4)
-
-    # No effect
-    ad.to_metric()
-    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"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert ad.to_gerber() == "%ADD0C*%"
-    stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "1X1,1X1"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert ad.to_gerber() == "%ADD0C,1X1,1X1*%"
-
-
-def test_ADPamramStmt_string():
-    stmt = {"param": "AD", "d": 0, "shape": "C"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert str(ad) == "<Aperture Definition: 0: circle>"
-
-    stmt = {"param": "AD", "d": 0, "shape": "R"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert str(ad) == "<Aperture Definition: 0: rectangle>"
-
-    stmt = {"param": "AD", "d": 0, "shape": "O"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert str(ad) == "<Aperture Definition: 0: obround>"
-
-    stmt = {"param": "AD", "d": 0, "shape": "test"}
-    ad = ADParamStmt.from_dict(stmt)
-    assert str(ad) == "<Aperture Definition: 0: test>"
-
-
-def test_MIParamStmt_factory():
-    stmt = {"param": "MI", "a": 1, "b": 1}
-    mi = MIParamStmt.from_dict(stmt)
-    assert mi.a == 1
-    assert mi.b == 1
-
-
-def test_MIParamStmt_dump():
-    stmt = {"param": "MI", "a": 1, "b": 1}
-    mi = MIParamStmt.from_dict(stmt)
-    assert mi.to_gerber() == "%MIA1B1*%"
-    stmt = {"param": "MI", "a": 1}
-    mi = MIParamStmt.from_dict(stmt)
-    assert mi.to_gerber() == "%MIA1B0*%"
-    stmt = {"param": "MI", "b": 1}
-    mi = MIParamStmt.from_dict(stmt)
-    assert mi.to_gerber() == "%MIA0B1*%"
-
-
-def test_MIParamStmt_string():
-    stmt = {"param": "MI", "a": 1, "b": 1}
-    mi = MIParamStmt.from_dict(stmt)
-    assert str(mi) == "<Image Mirror: A=1 B=1>"
-
-    stmt = {"param": "MI", "b": 1}
-    mi = MIParamStmt.from_dict(stmt)
-    assert str(mi) == "<Image Mirror: A=0 B=1>"
-
-    stmt = {"param": "MI", "a": 1}
-    mi = MIParamStmt.from_dict(stmt)
-    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 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",
-    }
-    cs = CoordStmt.from_dict(stmt, 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_dump():
-    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"
-
-    # No effect
-    cs.to_metric()
-    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 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 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.0, 1.0, 1.0, 1.0, "D01", FileSettings())
-    cs.units = "inch"
-
-    # No effect
-    cs.to_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"
-
-    cs.to_metric()
-    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 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.offset(1, 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 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 (
-        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 ast.d == 3
-    assert ast.deprecated == False
-    ast = ApertureStmt(4, True)
-    assert ast.d == 4
-    assert ast.deprecated == True
-    ast = ApertureStmt(4, 1)
-    assert ast.d == 4
-    assert ast.deprecated == True
-    ast = ApertureStmt(3)
-    assert ast.d == 3
-    assert ast.deprecated == False
-
-
-def test_aperturestmt_dump():
-    ast = ApertureStmt(3, False)
-    assert ast.to_gerber() == "D3*"
-    ast = ApertureStmt(3, True)
-    assert ast.to_gerber() == "G54D3*"
-    assert str(ast) == "<Aperture: 3>"