49dadd46ee
AMParamStmt was not calling to_gerber on each of its primitives on his own to_gerber method. That way primitives that changes after reading, such as when you call to_inch/to_metric was failing because it was writing only the original macro back.
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.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*%')
|
|
|
|
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>')
|
|
|
|
|