d3b19efb48
PCBmodE uses a standard but probably undefined behaviour issue on Gerber where it defines circle apertures with a single modifier but leaves a trilling 'X' after it. 'X' is modifiers separator but when there is only one modifier the behaviour is undefined. For parsing we are just ignoring blank modifiers. Test updated to catch this case.
870 lines
25 KiB
Python
870 lines
25 KiB
Python
#! /usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# Author: Hamilton Kibbe <ham@hamiltonkib.be>
|
|
|
|
from .tests import *
|
|
from ..gerber_statements import *
|
|
from ..cam import FileSettings
|
|
|
|
def test_Statement_smoketest():
|
|
stmt = Statement('Test')
|
|
assert_equal(stmt.type, 'Test')
|
|
stmt.to_metric()
|
|
assert_in('units=metric', str(stmt))
|
|
stmt.to_inch()
|
|
assert_in('units=inch', str(stmt))
|
|
stmt.to_metric()
|
|
stmt.offset(1, 1)
|
|
assert_in('type=Test',str(stmt))
|
|
|
|
def test_FSParamStmt_factory():
|
|
""" Test FSParamStruct factory
|
|
"""
|
|
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))
|
|
|
|
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))
|
|
|
|
def test_FSParamStmt():
|
|
""" Test FSParamStmt initialization
|
|
"""
|
|
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)
|
|
|
|
def test_FSParamStmt_dump():
|
|
""" Test FSParamStmt to_gerber()
|
|
"""
|
|
stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'}
|
|
fs = FSParamStmt.from_dict(stmt)
|
|
assert_equal(fs.to_gerber(), '%FSLAX27Y27*%')
|
|
|
|
stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'}
|
|
fs = FSParamStmt.from_dict(stmt)
|
|
assert_equal(fs.to_gerber(), '%FSTIX25Y25*%')
|
|
|
|
settings = FileSettings(zero_suppression='leading', notation='absolute')
|
|
assert_equal(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_equal(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_equal(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_equal(mo.param, 'MO')
|
|
assert_equal(mo.mode, 'inch')
|
|
|
|
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')
|
|
|
|
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)
|
|
|
|
def test_MOParamStmt():
|
|
""" Test MOParamStmt initialization
|
|
"""
|
|
param = 'MO'
|
|
mode = 'inch'
|
|
stmt = MOParamStmt(param, mode)
|
|
assert_equal(stmt.param, param)
|
|
|
|
for mode in ['inch', 'metric']:
|
|
stmt = MOParamStmt(param, mode)
|
|
assert_equal(stmt.mode, mode)
|
|
|
|
def test_MOParamStmt_dump():
|
|
""" Test MOParamStmt to_gerber()
|
|
"""
|
|
stmt = {'param': 'MO', 'mo': 'IN'}
|
|
mo = MOParamStmt.from_dict(stmt)
|
|
assert_equal(mo.to_gerber(), '%MOIN*%')
|
|
|
|
stmt = {'param': 'MO', 'mo': 'MM'}
|
|
mo = MOParamStmt.from_dict(stmt)
|
|
assert_equal(mo.to_gerber(), '%MOMM*%')
|
|
|
|
def test_MOParamStmt_conversion():
|
|
stmt = {'param': 'MO', 'mo': 'MM'}
|
|
mo = MOParamStmt.from_dict(stmt)
|
|
mo.to_inch()
|
|
assert_equal(mo.mode, 'inch')
|
|
|
|
stmt = {'param': 'MO', 'mo': 'IN'}
|
|
mo = MOParamStmt.from_dict(stmt)
|
|
mo.to_metric()
|
|
assert_equal(mo.mode, 'metric')
|
|
|
|
def test_MOParamStmt_string():
|
|
""" Test MOParamStmt.__str__()
|
|
"""
|
|
stmt = {'param': 'MO', 'mo': 'IN'}
|
|
mo = MOParamStmt.from_dict(stmt)
|
|
assert_equal(str(mo), '<Mode: inches>')
|
|
|
|
stmt = {'param': 'MO', 'mo': 'MM'}
|
|
mo = MOParamStmt.from_dict(stmt)
|
|
assert_equal(str(mo), '<Mode: millimeters>')
|
|
|
|
def test_IPParamStmt_factory():
|
|
""" Test IPParamStruct factory
|
|
"""
|
|
stmt = {'param': 'IP', 'ip': 'POS'}
|
|
ip = IPParamStmt.from_dict(stmt)
|
|
assert_equal(ip.ip, 'positive')
|
|
|
|
stmt = {'param': 'IP', 'ip': 'NEG'}
|
|
ip = IPParamStmt.from_dict(stmt)
|
|
assert_equal(ip.ip, 'negative')
|
|
|
|
def test_IPParamStmt():
|
|
""" Test IPParamStmt initialization
|
|
"""
|
|
param = 'IP'
|
|
for ip in ['positive', 'negative']:
|
|
stmt = IPParamStmt(param, ip)
|
|
assert_equal(stmt.param, param)
|
|
assert_equal(stmt.ip, ip)
|
|
|
|
def test_IPParamStmt_dump():
|
|
""" Test IPParamStmt to_gerber()
|
|
"""
|
|
stmt = {'param': 'IP', 'ip': 'POS'}
|
|
ip = IPParamStmt.from_dict(stmt)
|
|
assert_equal(ip.to_gerber(), '%IPPOS*%')
|
|
|
|
stmt = {'param': 'IP', 'ip': 'NEG'}
|
|
ip = IPParamStmt.from_dict(stmt)
|
|
assert_equal(ip.to_gerber(), '%IPNEG*%')
|
|
|
|
def test_IPParamStmt_string():
|
|
stmt = {'param': 'IP', 'ip': 'POS'}
|
|
ip = IPParamStmt.from_dict(stmt)
|
|
assert_equal(str(ip), '<Image Polarity: positive>')
|
|
|
|
stmt = {'param': 'IP', 'ip': 'NEG'}
|
|
ip = IPParamStmt.from_dict(stmt)
|
|
assert_equal(str(ip), '<Image Polarity: negative>')
|
|
|
|
def test_IRParamStmt_factory():
|
|
stmt = {'param': 'IR', 'angle': '45'}
|
|
ir = IRParamStmt.from_dict(stmt)
|
|
assert_equal(ir.param, 'IR')
|
|
assert_equal(ir.angle, 45)
|
|
|
|
def test_IRParamStmt_dump():
|
|
stmt = {'param': 'IR', 'angle': '45'}
|
|
ir = IRParamStmt.from_dict(stmt)
|
|
assert_equal(ir.to_gerber(), '%IR45*%')
|
|
|
|
def test_IRParamStmt_string():
|
|
stmt = {'param': 'IR', 'angle': '45'}
|
|
ir = IRParamStmt.from_dict(stmt)
|
|
assert_equal(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_equal(of.a, 0.1234567)
|
|
assert_equal(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_equal(stmt.param, param)
|
|
assert_equal(stmt.a, val)
|
|
assert_equal(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_equal(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_equal(of.a, 2.54)
|
|
assert_equal(of.b, 25.4)
|
|
|
|
of.to_inch()
|
|
assert_equal(of.units, 'inch')
|
|
assert_equal(of.a, 0.1)
|
|
assert_equal(of.b, 1.0)
|
|
|
|
#No effect
|
|
of.to_inch()
|
|
assert_equal(of.a, 0.1)
|
|
assert_equal(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_equal(of.a, 0.1)
|
|
assert_equal(of.b, 1.0)
|
|
|
|
of.to_metric()
|
|
assert_equal(of.units, 'metric')
|
|
assert_equal(of.a, 2.54)
|
|
assert_equal(of.b, 25.4)
|
|
|
|
#No effect
|
|
of.to_metric()
|
|
assert_equal(of.a, 2.54)
|
|
assert_equal(of.b, 25.4)
|
|
|
|
def test_OFParamStmt_offset():
|
|
s = OFParamStmt('OF', 0, 0)
|
|
s.offset(1, 0)
|
|
assert_equal(s.a, 1.)
|
|
assert_equal(s.b, 0.)
|
|
s.offset(0, 1)
|
|
assert_equal(s.a, 1.)
|
|
assert_equal(s.b, 1.)
|
|
|
|
def test_OFParamStmt_string():
|
|
""" Test OFParamStmt __str__
|
|
"""
|
|
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 >')
|
|
|
|
def test_SFParamStmt_factory():
|
|
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)
|
|
|
|
def test_SFParamStmt_dump():
|
|
stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'}
|
|
sf = SFParamStmt.from_dict(stmt)
|
|
assert_equal(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_equal(of.a, 2.54)
|
|
assert_equal(of.b, 25.4)
|
|
|
|
of.to_inch()
|
|
assert_equal(of.units, 'inch')
|
|
assert_equal(of.a, 0.1)
|
|
assert_equal(of.b, 1.0)
|
|
|
|
#No effect
|
|
of.to_inch()
|
|
assert_equal(of.a, 0.1)
|
|
assert_equal(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_equal(of.a, 0.1)
|
|
assert_equal(of.b, 1.0)
|
|
|
|
of.to_metric()
|
|
assert_equal(of.units, 'metric')
|
|
assert_equal(of.a, 2.54)
|
|
assert_equal(of.b, 25.4)
|
|
|
|
#No effect
|
|
of.to_metric()
|
|
assert_equal(of.a, 2.54)
|
|
assert_equal(of.b, 25.4)
|
|
|
|
def test_SFParamStmt_offset():
|
|
s = SFParamStmt('OF', 0, 0)
|
|
s.offset(1, 0)
|
|
assert_equal(s.a, 1.)
|
|
assert_equal(s.b, 0.)
|
|
s.offset(0, 1)
|
|
assert_equal(s.a, 1.)
|
|
assert_equal(s.b, 1.)
|
|
|
|
def test_SFParamStmt_string():
|
|
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>')
|
|
|
|
def test_LPParamStmt_factory():
|
|
""" Test LPParamStmt factory
|
|
"""
|
|
stmt = {'param': 'LP', 'lp': 'C'}
|
|
lp = LPParamStmt.from_dict(stmt)
|
|
assert_equal(lp.lp, 'clear')
|
|
|
|
stmt = {'param': 'LP', 'lp': 'D'}
|
|
lp = LPParamStmt.from_dict(stmt)
|
|
assert_equal(lp.lp, 'dark')
|
|
|
|
def test_LPParamStmt_dump():
|
|
""" Test LPParamStmt to_gerber()
|
|
"""
|
|
stmt = {'param': 'LP', 'lp': 'C'}
|
|
lp = LPParamStmt.from_dict(stmt)
|
|
assert_equal(lp.to_gerber(), '%LPC*%')
|
|
|
|
stmt = {'param': 'LP', 'lp': 'D'}
|
|
lp = LPParamStmt.from_dict(stmt)
|
|
assert_equal(lp.to_gerber(), '%LPD*%')
|
|
|
|
def test_LPParamStmt_string():
|
|
""" Test LPParamStmt.__str__()
|
|
"""
|
|
stmt = {'param': 'LP', 'lp': 'D'}
|
|
lp = LPParamStmt.from_dict(stmt)
|
|
assert_equal(str(lp), '<Level Polarity: dark>')
|
|
|
|
stmt = {'param': 'LP', 'lp': 'C'}
|
|
lp = LPParamStmt.from_dict(stmt)
|
|
assert_equal(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_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))
|
|
|
|
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_equal(s.primitives[0].position, (25.4, 25.4))
|
|
assert_equal(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.)
|
|
|
|
#No effect
|
|
s.to_inch()
|
|
assert_equal(s.primitives[0].position, (1., 1.))
|
|
assert_equal(s.primitives[0].diameter, 1.)
|
|
|
|
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_equal(s.primitives[0].position, (1., 1.))
|
|
assert_equal(s.primitives[0].diameter, 1.)
|
|
|
|
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)
|
|
|
|
#No effect
|
|
s.to_metric()
|
|
assert_equal(s.primitives[0].position, (25.4, 25.4))
|
|
assert_equal(s.primitives[0].diameter, 25.4)
|
|
|
|
def test_AMParamStmt_dump():
|
|
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(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0*%')
|
|
|
|
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_equal(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_equal(s.param, 'AS')
|
|
assert_equal(s.mode, 'AXBY')
|
|
|
|
def test_ASParamStmt_dump():
|
|
stmt = {'param': 'AS', 'mode': 'AXBY'}
|
|
s = ASParamStmt.from_dict(stmt)
|
|
assert_equal(s.to_gerber(), '%ASAXBY*%')
|
|
|
|
def test_ASParamStmt_string():
|
|
stmt = {'param': 'AS', 'mode': 'AXBY'}
|
|
s = ASParamStmt.from_dict(stmt)
|
|
assert_equal(str(s), '<Axis Select: AXBY>')
|
|
|
|
def test_INParamStmt_factory():
|
|
""" Test INParamStmt factory
|
|
"""
|
|
stmt = {'param': 'IN', 'name': 'test'}
|
|
inp = INParamStmt.from_dict(stmt)
|
|
assert_equal(inp.name, 'test')
|
|
|
|
def test_INParamStmt_dump():
|
|
""" Test INParamStmt to_gerber()
|
|
"""
|
|
stmt = {'param': 'IN', 'name': 'test'}
|
|
inp = INParamStmt.from_dict(stmt)
|
|
assert_equal(inp.to_gerber(), '%INtest*%')
|
|
|
|
def test_INParamStmt_string():
|
|
stmt = {'param': 'IN', 'name': 'test'}
|
|
inp = INParamStmt.from_dict(stmt)
|
|
assert_equal(str(inp), '<Image Name: test>')
|
|
|
|
def test_LNParamStmt_factory():
|
|
""" Test LNParamStmt factory
|
|
"""
|
|
stmt = {'param': 'LN', 'name': 'test'}
|
|
lnp = LNParamStmt.from_dict(stmt)
|
|
assert_equal(lnp.name, 'test')
|
|
|
|
def test_LNParamStmt_dump():
|
|
""" Test LNParamStmt to_gerber()
|
|
"""
|
|
stmt = {'param': 'LN', 'name': 'test'}
|
|
lnp = LNParamStmt.from_dict(stmt)
|
|
assert_equal(lnp.to_gerber(), '%LNtest*%')
|
|
|
|
def test_LNParamStmt_string():
|
|
stmt = {'param': 'LN', 'name': 'test'}
|
|
lnp = LNParamStmt.from_dict(stmt)
|
|
assert_equal(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')
|
|
|
|
def test_comment_stmt_dump():
|
|
""" Test CommentStmt to_gerber()
|
|
"""
|
|
stmt = CommentStmt('A comment')
|
|
assert_equal(stmt.to_gerber(), 'G04A comment*')
|
|
|
|
def test_comment_stmt_string():
|
|
stmt = CommentStmt('A comment')
|
|
assert_equal(str(stmt), '<Comment: A comment>')
|
|
|
|
def test_eofstmt():
|
|
""" Test EofStmt
|
|
"""
|
|
stmt = EofStmt()
|
|
assert_equal(stmt.type, 'EOF')
|
|
|
|
def test_eofstmt_dump():
|
|
""" Test EofStmt to_gerber()
|
|
"""
|
|
stmt = EofStmt()
|
|
assert_equal(stmt.to_gerber(), 'M02*')
|
|
|
|
def test_eofstmt_string():
|
|
assert_equal(str(EofStmt()), '<EOF Statement>')
|
|
|
|
def test_quadmodestmt_factory():
|
|
""" Test QuadrantModeStmt.from_gerber()
|
|
"""
|
|
line = 'G74*'
|
|
stmt = QuadrantModeStmt.from_gerber(line)
|
|
assert_equal(stmt.type, 'QuadrantMode')
|
|
assert_equal(stmt.mode, 'single-quadrant')
|
|
|
|
line = 'G75*'
|
|
stmt = QuadrantModeStmt.from_gerber(line)
|
|
assert_equal(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')
|
|
|
|
def test_quadmodestmt_dump():
|
|
""" Test QuadrantModeStmt.to_gerber()
|
|
"""
|
|
for line in ('G74*', 'G75*',):
|
|
stmt = QuadrantModeStmt.from_gerber(line)
|
|
assert_equal(stmt.to_gerber(), line)
|
|
|
|
def test_regionmodestmt_factory():
|
|
""" Test RegionModeStmt.from_gerber()
|
|
"""
|
|
line = 'G36*'
|
|
stmt = RegionModeStmt.from_gerber(line)
|
|
assert_equal(stmt.type, 'RegionMode')
|
|
assert_equal(stmt.mode, 'on')
|
|
|
|
line = 'G37*'
|
|
stmt = RegionModeStmt.from_gerber(line)
|
|
assert_equal(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')
|
|
|
|
def test_regionmodestmt_dump():
|
|
""" Test RegionModeStmt.to_gerber()
|
|
"""
|
|
for line in ('G36*', 'G37*',):
|
|
stmt = RegionModeStmt.from_gerber(line)
|
|
assert_equal(stmt.to_gerber(), line)
|
|
|
|
def test_unknownstmt():
|
|
""" Test UnknownStmt
|
|
"""
|
|
line = 'G696969*'
|
|
stmt = UnknownStmt(line)
|
|
assert_equal(stmt.type, 'UNKNOWN')
|
|
assert_equal(stmt.line, line)
|
|
|
|
def test_unknownstmt_dump():
|
|
""" Test UnknownStmt.to_gerber()
|
|
"""
|
|
lines = ('G696969*', 'M03*',)
|
|
for line in lines:
|
|
stmt = UnknownStmt(line)
|
|
assert_equal(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))
|
|
|
|
def test_ADParamStmt_factory():
|
|
""" Test ADParamStmt factory
|
|
"""
|
|
stmt = {'param': 'AD', 'd': 0, 'shape': 'C'}
|
|
ad = ADParamStmt.from_dict(stmt)
|
|
assert_equal(ad.d, 0)
|
|
assert_equal(ad.shape, 'C')
|
|
|
|
stmt = {'param': 'AD', 'd': 1, 'shape': 'R'}
|
|
ad = ADParamStmt.from_dict(stmt)
|
|
assert_equal(ad.d, 1)
|
|
assert_equal(ad.shape, 'R')
|
|
|
|
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,)])
|
|
|
|
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,)])
|
|
|
|
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)])
|
|
|
|
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_equal(ad.modifiers[0], (25.4, 25.4))
|
|
assert_equal(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.))
|
|
|
|
#No effect
|
|
ad.to_inch()
|
|
assert_equal(ad.modifiers[0], (1., 1.))
|
|
assert_equal(ad.modifiers[1], (1., 1.))
|
|
|
|
stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '1X1,1X1'}
|
|
ad = ADParamStmt.from_dict(stmt)
|
|
ad.units = 'inch'
|
|
|
|
#No effect
|
|
ad.to_inch()
|
|
assert_equal(ad.modifiers[0], (1., 1.))
|
|
assert_equal(ad.modifiers[1], (1., 1.))
|
|
|
|
ad.to_metric()
|
|
assert_equal(ad.modifiers[0], (25.4, 25.4))
|
|
assert_equal(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))
|
|
|
|
def test_ADParamStmt_dump():
|
|
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'}
|
|
ad = ADParamStmt.from_dict(stmt)
|
|
assert_equal(ad.to_gerber(), '%ADD0C,1X1,1X1*%')
|
|
|
|
def test_ADPamramStmt_string():
|
|
stmt = {'param': 'AD', 'd': 0, 'shape': 'C'}
|
|
ad = ADParamStmt.from_dict(stmt)
|
|
assert_equal(str(ad), '<Aperture Definition: 0: circle>')
|
|
|
|
stmt = {'param': 'AD', 'd': 0, 'shape': 'R'}
|
|
ad = ADParamStmt.from_dict(stmt)
|
|
assert_equal(str(ad), '<Aperture Definition: 0: rectangle>')
|
|
|
|
stmt = {'param': 'AD', 'd': 0, 'shape': 'O'}
|
|
ad = ADParamStmt.from_dict(stmt)
|
|
assert_equal(str(ad), '<Aperture Definition: 0: obround>')
|
|
|
|
stmt = {'param': 'AD', 'd': 0, 'shape': 'test'}
|
|
ad = ADParamStmt.from_dict(stmt)
|
|
assert_equal(str(ad), '<Aperture Definition: 0: test>')
|
|
|
|
def test_MIParamStmt_factory():
|
|
stmt = {'param': 'MI', 'a': 1, 'b': 1}
|
|
mi = MIParamStmt.from_dict(stmt)
|
|
assert_equal(mi.a, 1)
|
|
assert_equal(mi.b, 1)
|
|
|
|
def test_MIParamStmt_dump():
|
|
stmt = {'param': 'MI', 'a': 1, 'b': 1}
|
|
mi = MIParamStmt.from_dict(stmt)
|
|
assert_equal(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}
|
|
mi = MIParamStmt.from_dict(stmt)
|
|
assert_equal(mi.to_gerber(), '%MIA0B1*%')
|
|
|
|
def test_MIParamStmt_string():
|
|
stmt = {'param': 'MI', 'a': 1, 'b': 1}
|
|
mi = MIParamStmt.from_dict(stmt)
|
|
assert_equal(str(mi), '<Image Mirror: A=1 B=1>')
|
|
|
|
stmt = {'param': 'MI', 'b': 1}
|
|
mi = MIParamStmt.from_dict(stmt)
|
|
assert_equal(str(mi), '<Image Mirror: A=0 B=1>')
|
|
|
|
stmt = {'param': 'MI', 'a': 1}
|
|
mi = MIParamStmt.from_dict(stmt)
|
|
assert_equal(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')
|
|
|
|
def test_coordstmt_factory():
|
|
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')
|
|
|
|
def test_coordstmt_dump():
|
|
cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings())
|
|
assert_equal(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_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')
|
|
|
|
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')
|
|
|
|
#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')
|
|
|
|
cs = CoordStmt('G70', 1., 1., 1., 1., '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')
|
|
|
|
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')
|
|
|
|
#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')
|
|
|
|
def test_coordstmt_offset():
|
|
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.)
|
|
c.offset(0, 1)
|
|
assert_equal(c.x, 1.)
|
|
assert_equal(c.y, 1.)
|
|
assert_equal(c.i, 1.)
|
|
assert_equal(c.j, 1.)
|
|
|
|
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>')
|
|
|
|
def test_aperturestmt_ctor():
|
|
ast = ApertureStmt(3, False)
|
|
assert_equal(ast.d, 3)
|
|
assert_equal(ast.deprecated, False)
|
|
ast = ApertureStmt(4, True)
|
|
assert_equal(ast.d, 4)
|
|
assert_equal(ast.deprecated, True)
|
|
ast = ApertureStmt(4, 1)
|
|
assert_equal(ast.d, 4)
|
|
assert_equal(ast.deprecated, True)
|
|
ast = ApertureStmt(3)
|
|
assert_equal(ast.d, 3)
|
|
assert_equal(ast.deprecated, False)
|
|
|
|
def test_aperturestmt_dump():
|
|
ast = ApertureStmt(3, False)
|
|
assert_equal(ast.to_gerber(), 'D3*')
|
|
ast = ApertureStmt(3, True)
|
|
assert_equal(ast.to_gerber(), 'G54D3*')
|
|
assert_equal(str(ast), '<Aperture: 3>')
|
|
|
|
|