ef589a0640
* 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.
959 lines
24 KiB
Python
959 lines
24 KiB
Python
#! /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*
|
|
22,1,6.8,1.2,0,0,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*
|
|
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.build()
|
|
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})
|
|
|
|
s.build()
|
|
s.units = "metric"
|
|
|
|
# No effect
|
|
s.to_metric()
|
|
assert s.primitives[0].position == (25.4, 25.4)
|
|
assert s.primitives[0].diameter == 25.4
|
|
|
|
s.to_inch()
|
|
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 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})
|
|
s.build()
|
|
s.units = "inch"
|
|
|
|
# No effect
|
|
s.to_inch()
|
|
assert s.primitives[0].position == (1.0, 1.0)
|
|
assert s.primitives[0].diameter == 1.0
|
|
|
|
s.to_metric()
|
|
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 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})
|
|
s.build()
|
|
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"}
|
|
)
|
|
s.build()
|
|
# 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})
|
|
s.build()
|
|
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>"
|