summaryrefslogtreecommitdiff
path: root/gerber/tests/test_gerber_statements.py
diff options
context:
space:
mode:
Diffstat (limited to 'gerber/tests/test_gerber_statements.py')
-rw-r--r--gerber/tests/test_gerber_statements.py145
1 files changed, 111 insertions, 34 deletions
diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py
index 79ce76b..c1985e6 100644
--- a/gerber/tests/test_gerber_statements.py
+++ b/gerber/tests/test_gerber_statements.py
@@ -7,6 +7,7 @@ from .tests import *
from ..gerber_statements import *
from ..cam import FileSettings
+
def test_Statement_smoketest():
stmt = Statement('Test')
assert_equal(stmt.type, 'Test')
@@ -16,7 +17,8 @@ def test_Statement_smoketest():
assert_in('units=inch', str(stmt))
stmt.to_metric()
stmt.offset(1, 1)
- assert_in('type=Test',str(stmt))
+ assert_in('type=Test', str(stmt))
+
def test_FSParamStmt_factory():
""" Test FSParamStruct factory
@@ -35,6 +37,7 @@ def test_FSParamStmt_factory():
assert_equal(fs.notation, 'incremental')
assert_equal(fs.format, (2, 7))
+
def test_FSParamStmt():
""" Test FSParamStmt initialization
"""
@@ -48,6 +51,7 @@ def test_FSParamStmt():
assert_equal(stmt.notation, notation)
assert_equal(stmt.format, fmt)
+
def test_FSParamStmt_dump():
""" Test FSParamStmt to_gerber()
"""
@@ -62,16 +66,20 @@ def test_FSParamStmt_dump():
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>')
+ 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>')
+ assert_equal(str(fs),
+ '<Format Spec: 2:5 trailing zero suppression incremental notation>')
+
def test_MOParamStmt_factory():
""" Test MOParamStruct factory
@@ -94,6 +102,7 @@ def test_MOParamStmt_factory():
stmt = {'param': 'MO', 'mo': 'degrees kelvin'}
assert_raises(ValueError, MOParamStmt.from_dict, stmt)
+
def test_MOParamStmt():
""" Test MOParamStmt initialization
"""
@@ -106,6 +115,7 @@ def test_MOParamStmt():
stmt = MOParamStmt(param, mode)
assert_equal(stmt.mode, mode)
+
def test_MOParamStmt_dump():
""" Test MOParamStmt to_gerber()
"""
@@ -117,6 +127,7 @@ def test_MOParamStmt_dump():
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)
@@ -128,6 +139,7 @@ def test_MOParamStmt_conversion():
mo.to_metric()
assert_equal(mo.mode, 'metric')
+
def test_MOParamStmt_string():
""" Test MOParamStmt.__str__()
"""
@@ -139,6 +151,7 @@ def test_MOParamStmt_string():
mo = MOParamStmt.from_dict(stmt)
assert_equal(str(mo), '<Mode: millimeters>')
+
def test_IPParamStmt_factory():
""" Test IPParamStruct factory
"""
@@ -150,6 +163,7 @@ def test_IPParamStmt_factory():
ip = IPParamStmt.from_dict(stmt)
assert_equal(ip.ip, 'negative')
+
def test_IPParamStmt():
""" Test IPParamStmt initialization
"""
@@ -159,6 +173,7 @@ def test_IPParamStmt():
assert_equal(stmt.param, param)
assert_equal(stmt.ip, ip)
+
def test_IPParamStmt_dump():
""" Test IPParamStmt to_gerber()
"""
@@ -170,6 +185,7 @@ def test_IPParamStmt_dump():
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)
@@ -179,22 +195,26 @@ def test_IPParamStmt_string():
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
"""
@@ -203,6 +223,7 @@ def test_OFParamStmt_factory():
assert_equal(of.a, 0.1234567)
assert_equal(of.b, 0.1234567)
+
def test_OFParamStmt():
""" Test IPParamStmt initialization
"""
@@ -213,6 +234,7 @@ def test_OFParamStmt():
assert_equal(stmt.a, val)
assert_equal(stmt.b, val)
+
def test_OFParamStmt_dump():
""" Test OFParamStmt to_gerber()
"""
@@ -220,10 +242,11 @@ def test_OFParamStmt_dump():
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'
+ of.units = 'metric'
# No effect
of.to_metric()
@@ -235,7 +258,7 @@ def test_OFParamStmt_conversion():
assert_equal(of.a, 0.1)
assert_equal(of.b, 1.0)
- #No effect
+ # No effect
of.to_inch()
assert_equal(of.a, 0.1)
assert_equal(of.b, 1.0)
@@ -244,7 +267,7 @@ def test_OFParamStmt_conversion():
of = OFParamStmt.from_dict(stmt)
of.units = 'inch'
- #No effect
+ # No effect
of.to_inch()
assert_equal(of.a, 0.1)
assert_equal(of.b, 1.0)
@@ -254,11 +277,12 @@ def test_OFParamStmt_conversion():
assert_equal(of.a, 2.54)
assert_equal(of.b, 25.4)
- #No effect
+ # 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)
@@ -268,6 +292,7 @@ def test_OFParamStmt_offset():
assert_equal(s.a, 1.)
assert_equal(s.b, 1.)
+
def test_OFParamStmt_string():
""" Test OFParamStmt __str__
"""
@@ -275,6 +300,7 @@ def test_OFParamStmt_string():
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)
@@ -282,18 +308,20 @@ def test_SFParamStmt_factory():
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
+ # No effect
assert_equal(of.a, 2.54)
assert_equal(of.b, 25.4)
@@ -302,7 +330,7 @@ def test_SFParamStmt_conversion():
assert_equal(of.a, 0.1)
assert_equal(of.b, 1.0)
- #No effect
+ # No effect
of.to_inch()
assert_equal(of.a, 0.1)
assert_equal(of.b, 1.0)
@@ -311,7 +339,7 @@ def test_SFParamStmt_conversion():
of = SFParamStmt.from_dict(stmt)
of.units = 'inch'
- #No effect
+ # No effect
of.to_inch()
assert_equal(of.a, 0.1)
assert_equal(of.b, 1.0)
@@ -321,11 +349,12 @@ def test_SFParamStmt_conversion():
assert_equal(of.a, 2.54)
assert_equal(of.b, 25.4)
- #No effect
+ # 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)
@@ -335,11 +364,13 @@ def test_SFParamStmt_offset():
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
"""
@@ -351,6 +382,7 @@ def test_LPParamStmt_factory():
lp = LPParamStmt.from_dict(stmt)
assert_equal(lp.lp, 'dark')
+
def test_LPParamStmt_dump():
""" Test LPParamStmt to_gerber()
"""
@@ -362,6 +394,7 @@ def test_LPParamStmt_dump():
lp = LPParamStmt.from_dict(stmt)
assert_equal(lp.to_gerber(), '%LPD*%')
+
def test_LPParamStmt_string():
""" Test LPParamStmt.__str__()
"""
@@ -373,6 +406,7 @@ def test_LPParamStmt_string():
lp = LPParamStmt.from_dict(stmt)
assert_equal(str(lp), '<Level Polarity: clear>')
+
def test_AMParamStmt_factory():
name = 'DONUTVAR'
macro = (
@@ -387,7 +421,7 @@ def test_AMParamStmt_factory():
7,0,0,7,6,0.2,0*
8,THIS IS AN UNSUPPORTED PRIMITIVE*
''')
- s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro })
+ s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
s.build()
assert_equal(len(s.primitives), 10)
assert_true(isinstance(s.primitives[0], AMCommentPrimitive))
@@ -401,15 +435,16 @@ def test_AMParamStmt_factory():
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 = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
s.build()
s.units = 'metric'
- #No effect
+ # No effect
s.to_metric()
assert_equal(s.primitives[0].position, (25.4, 25.4))
assert_equal(s.primitives[0].diameter, 25.4)
@@ -419,17 +454,17 @@ def testAMParamStmt_conversion():
assert_equal(s.primitives[0].position, (1., 1.))
assert_equal(s.primitives[0].diameter, 1.)
- #No effect
+ # 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 = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro})
s.build()
s.units = 'inch'
- #No effect
+ # No effect
s.to_inch()
assert_equal(s.primitives[0].position, (1., 1.))
assert_equal(s.primitives[0].diameter, 1.)
@@ -439,42 +474,48 @@ def testAMParamStmt_conversion():
assert_equal(s.primitives[0].position, (25.4, 25.4))
assert_equal(s.primitives[0].diameter, 25.4)
- #No effect
+ # 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 = 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 = 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
"""
@@ -482,6 +523,7 @@ def test_INParamStmt_factory():
inp = INParamStmt.from_dict(stmt)
assert_equal(inp.name, 'test')
+
def test_INParamStmt_dump():
""" Test INParamStmt to_gerber()
"""
@@ -489,11 +531,13 @@ def test_INParamStmt_dump():
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
"""
@@ -501,6 +545,7 @@ def test_LNParamStmt_factory():
lnp = LNParamStmt.from_dict(stmt)
assert_equal(lnp.name, 'test')
+
def test_LNParamStmt_dump():
""" Test LNParamStmt to_gerber()
"""
@@ -508,11 +553,13 @@ def test_LNParamStmt_dump():
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
"""
@@ -520,31 +567,37 @@ def test_comment_stmt():
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()
"""
@@ -557,6 +610,7 @@ def test_quadmodestmt_factory():
stmt = QuadrantModeStmt.from_gerber(line)
assert_equal(stmt.mode, 'multi-quadrant')
+
def test_quadmodestmt_validation():
""" Test QuadrantModeStmt input validation
"""
@@ -564,6 +618,7 @@ def test_quadmodestmt_validation():
assert_raises(ValueError, QuadrantModeStmt.from_gerber, line)
assert_raises(ValueError, QuadrantModeStmt, 'quadrant-ful')
+
def test_quadmodestmt_dump():
""" Test QuadrantModeStmt.to_gerber()
"""
@@ -571,6 +626,7 @@ def test_quadmodestmt_dump():
stmt = QuadrantModeStmt.from_gerber(line)
assert_equal(stmt.to_gerber(), line)
+
def test_regionmodestmt_factory():
""" Test RegionModeStmt.from_gerber()
"""
@@ -583,6 +639,7 @@ def test_regionmodestmt_factory():
stmt = RegionModeStmt.from_gerber(line)
assert_equal(stmt.mode, 'off')
+
def test_regionmodestmt_validation():
""" Test RegionModeStmt input validation
"""
@@ -590,6 +647,7 @@ def test_regionmodestmt_validation():
assert_raises(ValueError, RegionModeStmt.from_gerber, line)
assert_raises(ValueError, RegionModeStmt, 'off-ish')
+
def test_regionmodestmt_dump():
""" Test RegionModeStmt.to_gerber()
"""
@@ -597,6 +655,7 @@ def test_regionmodestmt_dump():
stmt = RegionModeStmt.from_gerber(line)
assert_equal(stmt.to_gerber(), line)
+
def test_unknownstmt():
""" Test UnknownStmt
"""
@@ -605,6 +664,7 @@ def test_unknownstmt():
assert_equal(stmt.type, 'UNKNOWN')
assert_equal(stmt.line, line)
+
def test_unknownstmt_dump():
""" Test UnknownStmt.to_gerber()
"""
@@ -613,15 +673,17 @@ def test_unknownstmt_dump():
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'
+ stmt.test = 'PASS'
assert_in('test=PASS', str(stmt))
assert_in('type=PARAM', str(stmt))
+
def test_ADParamStmt_factory():
""" Test ADParamStmt factory
"""
@@ -653,12 +715,14 @@ def test_ADParamStmt_factory():
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'}
+ stmt = {'param': 'AD', 'd': 0, 'shape': 'C',
+ 'modifiers': '25.4X25.4,25.4X25.4'}
ad = ADParamStmt.from_dict(stmt)
ad.units = 'metric'
- #No effect
+ # No effect
ad.to_metric()
assert_equal(ad.modifiers[0], (25.4, 25.4))
assert_equal(ad.modifiers[1], (25.4, 25.4))
@@ -668,7 +732,7 @@ def test_ADParamStmt_conversion():
assert_equal(ad.modifiers[0], (1., 1.))
assert_equal(ad.modifiers[1], (1., 1.))
- #No effect
+ # No effect
ad.to_inch()
assert_equal(ad.modifiers[0], (1., 1.))
assert_equal(ad.modifiers[1], (1., 1.))
@@ -677,7 +741,7 @@ def test_ADParamStmt_conversion():
ad = ADParamStmt.from_dict(stmt)
ad.units = 'inch'
- #No effect
+ # No effect
ad.to_inch()
assert_equal(ad.modifiers[0], (1., 1.))
assert_equal(ad.modifiers[1], (1., 1.))
@@ -686,11 +750,12 @@ def test_ADParamStmt_conversion():
assert_equal(ad.modifiers[0], (25.4, 25.4))
assert_equal(ad.modifiers[1], (25.4, 25.4))
- #No effect
+ # 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)
@@ -699,6 +764,7 @@ def test_ADParamStmt_dump():
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)
@@ -716,12 +782,14 @@ def test_ADPamramStmt_string():
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)
@@ -733,6 +801,7 @@ def test_MIParamStmt_dump():
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)
@@ -746,6 +815,7 @@ def test_MIParamStmt_string():
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')
@@ -755,8 +825,10 @@ def test_coordstmt_ctor():
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'}
+ 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)
@@ -765,15 +837,17 @@ def test_coordstmt_factory():
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
+ # No effect
cs.to_metric()
assert_equal(cs.x, 25.4)
assert_equal(cs.y, 25.4)
@@ -789,7 +863,7 @@ def test_coordstmt_conversion():
assert_equal(cs.j, 1.)
assert_equal(cs.function, 'G70')
- #No effect
+ # No effect
cs.to_inch()
assert_equal(cs.x, 1.)
assert_equal(cs.y, 1.)
@@ -800,7 +874,7 @@ def test_coordstmt_conversion():
cs = CoordStmt('G70', 1., 1., 1., 1., 'D01', FileSettings())
cs.units = 'inch'
- #No effect
+ # No effect
cs.to_inch()
assert_equal(cs.x, 1.)
assert_equal(cs.y, 1.)
@@ -815,7 +889,7 @@ def test_coordstmt_conversion():
assert_equal(cs.j, 25.4)
assert_equal(cs.function, 'G71')
- #No effect
+ # No effect
cs.to_metric()
assert_equal(cs.x, 25.4)
assert_equal(cs.y, 25.4)
@@ -823,6 +897,7 @@ def test_coordstmt_conversion():
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)
@@ -836,9 +911,11 @@ def test_coordstmt_offset():
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>')
+ 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())
@@ -846,6 +923,7 @@ def test_coordstmt_string():
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)
@@ -860,11 +938,10 @@ def test_aperturestmt_ctor():
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>')
-
-