summaryrefslogtreecommitdiff
path: root/gerber/tests/test_excellon_statements.py
diff options
context:
space:
mode:
authorChintalagiri Shashank <shashank.chintalagiri@gmail.com>2019-11-27 15:11:27 +0530
committerChintalagiri Shashank <shashank.chintalagiri@gmail.com>2019-11-27 15:11:27 +0530
commit5288a8314b535d455e8635ee9a3a537cd795845b (patch)
tree4233452d40a23ab99d0aab5f977e63df632d3c70 /gerber/tests/test_excellon_statements.py
parent25b82c988578482fbb57f80d3d30bdf985a9a885 (diff)
parent0024c0b045a29621845f4f1b5ee1283e32e38887 (diff)
downloadgerbonara-5288a8314b535d455e8635ee9a3a537cd795845b.tar.gz
gerbonara-5288a8314b535d455e8635ee9a3a537cd795845b.tar.bz2
gerbonara-5288a8314b535d455e8635ee9a3a537cd795845b.zip
Manual merge resolution
Diffstat (limited to 'gerber/tests/test_excellon_statements.py')
-rw-r--r--gerber/tests/test_excellon_statements.py616
1 files changed, 325 insertions, 291 deletions
diff --git a/gerber/tests/test_excellon_statements.py b/gerber/tests/test_excellon_statements.py
index 8e6e06e..41fe294 100644
--- a/gerber/tests/test_excellon_statements.py
+++ b/gerber/tests/test_excellon_statements.py
@@ -3,15 +3,15 @@
# Author: Hamilton Kibbe <ham@hamiltonkib.be>
-from .tests import assert_equal, assert_not_equal, assert_raises
+import pytest
from ..excellon_statements import *
from ..cam import FileSettings
def test_excellon_statement_implementation():
stmt = ExcellonStatement()
- assert_raises(NotImplementedError, stmt.from_excellon, None)
- assert_raises(NotImplementedError, stmt.to_excellon)
+ pytest.raises(NotImplementedError, stmt.from_excellon, None)
+ pytest.raises(NotImplementedError, stmt.to_excellon)
def test_excellontstmt():
@@ -26,154 +26,173 @@ def test_excellontstmt():
def test_excellontool_factory():
""" Test ExcellonTool factory methods
"""
- exc_line = 'T8F01B02S00003H04Z05C0.12500'
- settings = FileSettings(format=(2, 5), zero_suppression='trailing',
- units='inch', notation='absolute')
+ exc_line = "T8F01B02S00003H04Z05C0.12500"
+ settings = FileSettings(
+ format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute"
+ )
tool = ExcellonTool.from_excellon(exc_line, settings)
- assert_equal(tool.number, 8)
- assert_equal(tool.diameter, 0.125)
- assert_equal(tool.feed_rate, 1)
- assert_equal(tool.retract_rate, 2)
- assert_equal(tool.rpm, 3)
- assert_equal(tool.max_hit_count, 4)
- assert_equal(tool.depth_offset, 5)
-
- stmt = {'number': 8, 'feed_rate': 1, 'retract_rate': 2, 'rpm': 3,
- 'diameter': 0.125, 'max_hit_count': 4, 'depth_offset': 5}
+ assert tool.number == 8
+ assert tool.diameter == 0.125
+ assert tool.feed_rate == 1
+ assert tool.retract_rate == 2
+ assert tool.rpm == 3
+ assert tool.max_hit_count == 4
+ assert tool.depth_offset == 5
+
+ stmt = {
+ "number": 8,
+ "feed_rate": 1,
+ "retract_rate": 2,
+ "rpm": 3,
+ "diameter": 0.125,
+ "max_hit_count": 4,
+ "depth_offset": 5,
+ }
tool = ExcellonTool.from_dict(settings, stmt)
- assert_equal(tool.number, 8)
- assert_equal(tool.diameter, 0.125)
- assert_equal(tool.feed_rate, 1)
- assert_equal(tool.retract_rate, 2)
- assert_equal(tool.rpm, 3)
- assert_equal(tool.max_hit_count, 4)
- assert_equal(tool.depth_offset, 5)
+ assert tool.number == 8
+ assert tool.diameter == 0.125
+ assert tool.feed_rate == 1
+ assert tool.retract_rate == 2
+ assert tool.rpm == 3
+ assert tool.max_hit_count == 4
+ assert tool.depth_offset == 5
def test_excellontool_dump():
""" Test ExcellonTool to_excellon()
"""
- exc_lines = ['T01F0S0C0.01200', 'T02F0S0C0.01500', 'T03F0S0C0.01968',
- 'T04F0S0C0.02800', 'T05F0S0C0.03300', 'T06F0S0C0.03800',
- 'T07F0S0C0.04300', 'T08F0S0C0.12500', 'T09F0S0C0.13000',
- 'T08B01F02H03S00003C0.12500Z04', 'T01F0S300.999C0.01200']
- settings = FileSettings(format=(2, 5), zero_suppression='trailing',
- units='inch', notation='absolute')
+ exc_lines = [
+ "T01F0S0C0.01200",
+ "T02F0S0C0.01500",
+ "T03F0S0C0.01968",
+ "T04F0S0C0.02800",
+ "T05F0S0C0.03300",
+ "T06F0S0C0.03800",
+ "T07F0S0C0.04300",
+ "T08F0S0C0.12500",
+ "T09F0S0C0.13000",
+ "T08B01F02H03S00003C0.12500Z04",
+ "T01F0S300.999C0.01200",
+ ]
+ settings = FileSettings(
+ format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute"
+ )
for line in exc_lines:
tool = ExcellonTool.from_excellon(line, settings)
- assert_equal(tool.to_excellon(), line)
+ assert tool.to_excellon() == line
def test_excellontool_order():
- settings = FileSettings(format=(2, 5), zero_suppression='trailing',
- units='inch', notation='absolute')
- line = 'T8F00S00C0.12500'
+ settings = FileSettings(
+ format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute"
+ )
+ line = "T8F00S00C0.12500"
tool1 = ExcellonTool.from_excellon(line, settings)
- line = 'T8C0.12500F00S00'
+ line = "T8C0.12500F00S00"
tool2 = ExcellonTool.from_excellon(line, settings)
- assert_equal(tool1.diameter, tool2.diameter)
- assert_equal(tool1.feed_rate, tool2.feed_rate)
- assert_equal(tool1.rpm, tool2.rpm)
+ assert tool1.diameter == tool2.diameter
+ assert tool1.feed_rate == tool2.feed_rate
+ assert tool1.rpm == tool2.rpm
def test_excellontool_conversion():
- tool = ExcellonTool.from_dict(FileSettings(units='metric'),
- {'number': 8, 'diameter': 25.4})
+ tool = ExcellonTool.from_dict(
+ FileSettings(units="metric"), {"number": 8, "diameter": 25.4}
+ )
tool.to_inch()
- assert_equal(tool.diameter, 1.)
- tool = ExcellonTool.from_dict(FileSettings(units='inch'),
- {'number': 8, 'diameter': 1.})
+ assert tool.diameter == 1.0
+ tool = ExcellonTool.from_dict(
+ FileSettings(units="inch"), {"number": 8, "diameter": 1.0}
+ )
tool.to_metric()
- assert_equal(tool.diameter, 25.4)
+ assert tool.diameter == 25.4
# Shouldn't change units if we're already using target units
- tool = ExcellonTool.from_dict(FileSettings(units='inch'),
- {'number': 8, 'diameter': 25.4})
+ tool = ExcellonTool.from_dict(
+ FileSettings(units="inch"), {"number": 8, "diameter": 25.4}
+ )
tool.to_inch()
- assert_equal(tool.diameter, 25.4)
- tool = ExcellonTool.from_dict(FileSettings(units='metric'),
- {'number': 8, 'diameter': 1.})
+ assert tool.diameter == 25.4
+ tool = ExcellonTool.from_dict(
+ FileSettings(units="metric"), {"number": 8, "diameter": 1.0}
+ )
tool.to_metric()
- assert_equal(tool.diameter, 1.)
+ assert tool.diameter == 1.0
def test_excellontool_repr():
- tool = ExcellonTool.from_dict(FileSettings(),
- {'number': 8, 'diameter': 0.125})
- assert_equal(str(tool), '<ExcellonTool 08: 0.125in. dia.>')
- tool = ExcellonTool.from_dict(FileSettings(units='metric'),
- {'number': 8, 'diameter': 0.125})
- assert_equal(str(tool), '<ExcellonTool 08: 0.125mm dia.>')
+ tool = ExcellonTool.from_dict(FileSettings(), {"number": 8, "diameter": 0.125})
+ assert str(tool) == "<ExcellonTool 08: 0.125in. dia.>"
+ tool = ExcellonTool.from_dict(
+ FileSettings(units="metric"), {"number": 8, "diameter": 0.125}
+ )
+ assert str(tool) == "<ExcellonTool 08: 0.125mm dia.>"
def test_excellontool_equality():
- t = ExcellonTool.from_dict(
- FileSettings(), {'number': 8, 'diameter': 0.125})
+ t = ExcellonTool.from_dict(FileSettings(), {"number": 8, "diameter": 0.125})
+ t1 = ExcellonTool.from_dict(FileSettings(), {"number": 8, "diameter": 0.125})
+ assert t == t1
t1 = ExcellonTool.from_dict(
- FileSettings(), {'number': 8, 'diameter': 0.125})
- assert_equal(t, t1)
- t1 = ExcellonTool.from_dict(FileSettings(units='metric'),
- {'number': 8, 'diameter': 0.125})
- assert_not_equal(t, t1)
+ FileSettings(units="metric"), {"number": 8, "diameter": 0.125}
+ )
+ assert t != t1
def test_toolselection_factory():
""" Test ToolSelectionStmt factory method
"""
- stmt = ToolSelectionStmt.from_excellon('T01')
- assert_equal(stmt.tool, 1)
- assert_equal(stmt.compensation_index, None)
- stmt = ToolSelectionStmt.from_excellon('T0223')
- assert_equal(stmt.tool, 2)
- assert_equal(stmt.compensation_index, 23)
- stmt = ToolSelectionStmt.from_excellon('T042')
- assert_equal(stmt.tool, 42)
- assert_equal(stmt.compensation_index, None)
+ stmt = ToolSelectionStmt.from_excellon("T01")
+ assert stmt.tool == 1
+ assert stmt.compensation_index == None
+ stmt = ToolSelectionStmt.from_excellon("T0223")
+ assert stmt.tool == 2
+ assert stmt.compensation_index == 23
+ stmt = ToolSelectionStmt.from_excellon("T042")
+ assert stmt.tool == 42
+ assert stmt.compensation_index == None
def test_toolselection_dump():
""" Test ToolSelectionStmt to_excellon()
"""
- lines = ['T01', 'T0223', 'T10', 'T09', 'T0000']
+ lines = ["T01", "T0223", "T10", "T09", "T0000"]
for line in lines:
stmt = ToolSelectionStmt.from_excellon(line)
- assert_equal(stmt.to_excellon(), line)
+ assert stmt.to_excellon() == line
def test_z_axis_infeed_rate_factory():
""" Test ZAxisInfeedRateStmt factory method
"""
- stmt = ZAxisInfeedRateStmt.from_excellon('F01')
- assert_equal(stmt.rate, 1)
- stmt = ZAxisInfeedRateStmt.from_excellon('F2')
- assert_equal(stmt.rate, 2)
- stmt = ZAxisInfeedRateStmt.from_excellon('F03')
- assert_equal(stmt.rate, 3)
+ stmt = ZAxisInfeedRateStmt.from_excellon("F01")
+ assert stmt.rate == 1
+ stmt = ZAxisInfeedRateStmt.from_excellon("F2")
+ assert stmt.rate == 2
+ stmt = ZAxisInfeedRateStmt.from_excellon("F03")
+ assert stmt.rate == 3
def test_z_axis_infeed_rate_dump():
""" Test ZAxisInfeedRateStmt to_excellon()
"""
- inputs = [
- ('F01', 'F01'),
- ('F2', 'F02'),
- ('F00003', 'F03')
- ]
+ inputs = [("F01", "F01"), ("F2", "F02"), ("F00003", "F03")]
for input_rate, expected_output in inputs:
stmt = ZAxisInfeedRateStmt.from_excellon(input_rate)
- assert_equal(stmt.to_excellon(), expected_output)
+ assert stmt.to_excellon() == expected_output
def test_coordinatestmt_factory():
""" Test CoordinateStmt factory method
"""
- settings = FileSettings(format=(2, 5), zero_suppression='trailing',
- units='inch', notation='absolute')
+ settings = FileSettings(
+ format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute"
+ )
- line = 'X0278207Y0065293'
+ line = "X0278207Y0065293"
stmt = CoordinateStmt.from_excellon(line, settings)
- assert_equal(stmt.x, 2.78207)
- assert_equal(stmt.y, 0.65293)
+ assert stmt.x == 2.78207
+ assert stmt.y == 0.65293
# line = 'X02945'
# stmt = CoordinateStmt.from_excellon(line)
@@ -183,518 +202,533 @@ def test_coordinatestmt_factory():
# stmt = CoordinateStmt.from_excellon(line)
# assert_equal(stmt.y, 0.575)
- settings = FileSettings(format=(2, 4), zero_suppression='leading',
- units='inch', notation='absolute')
+ settings = FileSettings(
+ format=(2, 4), zero_suppression="leading", units="inch", notation="absolute"
+ )
- line = 'X9660Y4639'
+ line = "X9660Y4639"
stmt = CoordinateStmt.from_excellon(line, settings)
- assert_equal(stmt.x, 0.9660)
- assert_equal(stmt.y, 0.4639)
- assert_equal(stmt.to_excellon(settings), "X9660Y4639")
- assert_equal(stmt.units, 'inch')
+ assert stmt.x == 0.9660
+ assert stmt.y == 0.4639
+ assert stmt.to_excellon(settings) == "X9660Y4639"
+ assert stmt.units == "inch"
- settings.units = 'metric'
+ settings.units = "metric"
stmt = CoordinateStmt.from_excellon(line, settings)
- assert_equal(stmt.units, 'metric')
+ assert stmt.units == "metric"
def test_coordinatestmt_dump():
""" Test CoordinateStmt to_excellon()
"""
- lines = ['X278207Y65293', 'X243795', 'Y82528', 'Y86028',
- 'X251295Y81528', 'X2525Y78', 'X255Y575', 'Y52',
- 'X2675', 'Y575', 'X2425', 'Y52', 'X23', ]
- settings = FileSettings(format=(2, 4), zero_suppression='leading',
- units='inch', notation='absolute')
+ lines = [
+ "X278207Y65293",
+ "X243795",
+ "Y82528",
+ "Y86028",
+ "X251295Y81528",
+ "X2525Y78",
+ "X255Y575",
+ "Y52",
+ "X2675",
+ "Y575",
+ "X2425",
+ "Y52",
+ "X23",
+ ]
+ settings = FileSettings(
+ format=(2, 4), zero_suppression="leading", units="inch", notation="absolute"
+ )
for line in lines:
stmt = CoordinateStmt.from_excellon(line, settings)
- assert_equal(stmt.to_excellon(settings), line)
+ assert stmt.to_excellon(settings) == line
def test_coordinatestmt_conversion():
settings = FileSettings()
- settings.units = 'metric'
- stmt = CoordinateStmt.from_excellon('X254Y254', settings)
+ settings.units = "metric"
+ stmt = CoordinateStmt.from_excellon("X254Y254", settings)
# No effect
stmt.to_metric()
- assert_equal(stmt.x, 25.4)
- assert_equal(stmt.y, 25.4)
+ assert stmt.x == 25.4
+ assert stmt.y == 25.4
stmt.to_inch()
- assert_equal(stmt.units, 'inch')
- assert_equal(stmt.x, 1.)
- assert_equal(stmt.y, 1.)
+ assert stmt.units == "inch"
+ assert stmt.x == 1.0
+ assert stmt.y == 1.0
# No effect
stmt.to_inch()
- assert_equal(stmt.x, 1.)
- assert_equal(stmt.y, 1.)
+ assert stmt.x == 1.0
+ assert stmt.y == 1.0
- settings.units = 'inch'
- stmt = CoordinateStmt.from_excellon('X01Y01', settings)
+ settings.units = "inch"
+ stmt = CoordinateStmt.from_excellon("X01Y01", settings)
# No effect
stmt.to_inch()
- assert_equal(stmt.x, 1.)
- assert_equal(stmt.y, 1.)
+ assert stmt.x == 1.0
+ assert stmt.y == 1.0
stmt.to_metric()
- assert_equal(stmt.units, 'metric')
- assert_equal(stmt.x, 25.4)
- assert_equal(stmt.y, 25.4)
+ assert stmt.units == "metric"
+ assert stmt.x == 25.4
+ assert stmt.y == 25.4
# No effect
stmt.to_metric()
- assert_equal(stmt.x, 25.4)
- assert_equal(stmt.y, 25.4)
+ assert stmt.x == 25.4
+ assert stmt.y == 25.4
def test_coordinatestmt_offset():
- stmt = CoordinateStmt.from_excellon('X01Y01', FileSettings())
+ stmt = CoordinateStmt.from_excellon("X01Y01", FileSettings())
stmt.offset()
- assert_equal(stmt.x, 1)
- assert_equal(stmt.y, 1)
+ assert stmt.x == 1
+ assert stmt.y == 1
stmt.offset(1, 0)
- assert_equal(stmt.x, 2.)
- assert_equal(stmt.y, 1.)
+ assert stmt.x == 2.0
+ assert stmt.y == 1.0
stmt.offset(0, 1)
- assert_equal(stmt.x, 2.)
- assert_equal(stmt.y, 2.)
+ assert stmt.x == 2.0
+ assert stmt.y == 2.0
def test_coordinatestmt_string():
- settings = FileSettings(format=(2, 4), zero_suppression='leading',
- units='inch', notation='absolute')
- stmt = CoordinateStmt.from_excellon('X9660Y4639', settings)
- assert_equal(str(stmt), '<Coordinate Statement: X: 0.966 Y: 0.4639 >')
+ settings = FileSettings(
+ format=(2, 4), zero_suppression="leading", units="inch", notation="absolute"
+ )
+ stmt = CoordinateStmt.from_excellon("X9660Y4639", settings)
+ assert str(stmt) == "<Coordinate Statement: X: 0.966 Y: 0.4639 >"
def test_repeathole_stmt_factory():
- stmt = RepeatHoleStmt.from_excellon('R0004X015Y32',
- FileSettings(zeros='leading',
- units='inch'))
- assert_equal(stmt.count, 4)
- assert_equal(stmt.xdelta, 1.5)
- assert_equal(stmt.ydelta, 32)
- assert_equal(stmt.units, 'inch')
+ stmt = RepeatHoleStmt.from_excellon(
+ "R0004X015Y32", FileSettings(zeros="leading", units="inch")
+ )
+ assert stmt.count == 4
+ assert stmt.xdelta == 1.5
+ assert stmt.ydelta == 32
+ assert stmt.units == "inch"
- stmt = RepeatHoleStmt.from_excellon('R0004X015Y32',
- FileSettings(zeros='leading',
- units='metric'))
- assert_equal(stmt.units, 'metric')
+ stmt = RepeatHoleStmt.from_excellon(
+ "R0004X015Y32", FileSettings(zeros="leading", units="metric")
+ )
+ assert stmt.units == "metric"
def test_repeatholestmt_dump():
- line = 'R4X015Y32'
+ line = "R4X015Y32"
stmt = RepeatHoleStmt.from_excellon(line, FileSettings())
- assert_equal(stmt.to_excellon(FileSettings()), line)
+ assert stmt.to_excellon(FileSettings()) == line
def test_repeatholestmt_conversion():
- line = 'R4X0254Y254'
+ line = "R4X0254Y254"
settings = FileSettings()
- settings.units = 'metric'
+ settings.units = "metric"
stmt = RepeatHoleStmt.from_excellon(line, settings)
# No effect
stmt.to_metric()
- assert_equal(stmt.xdelta, 2.54)
- assert_equal(stmt.ydelta, 25.4)
+ assert stmt.xdelta == 2.54
+ assert stmt.ydelta == 25.4
stmt.to_inch()
- assert_equal(stmt.units, 'inch')
- assert_equal(stmt.xdelta, 0.1)
- assert_equal(stmt.ydelta, 1.)
+ assert stmt.units == "inch"
+ assert stmt.xdelta == 0.1
+ assert stmt.ydelta == 1.0
# no effect
stmt.to_inch()
- assert_equal(stmt.xdelta, 0.1)
- assert_equal(stmt.ydelta, 1.)
+ assert stmt.xdelta == 0.1
+ assert stmt.ydelta == 1.0
- line = 'R4X01Y1'
- settings.units = 'inch'
+ line = "R4X01Y1"
+ settings.units = "inch"
stmt = RepeatHoleStmt.from_excellon(line, settings)
# no effect
stmt.to_inch()
- assert_equal(stmt.xdelta, 1.)
- assert_equal(stmt.ydelta, 10.)
+ assert stmt.xdelta == 1.0
+ assert stmt.ydelta == 10.0
stmt.to_metric()
- assert_equal(stmt.units, 'metric')
- assert_equal(stmt.xdelta, 25.4)
- assert_equal(stmt.ydelta, 254.)
+ assert stmt.units == "metric"
+ assert stmt.xdelta == 25.4
+ assert stmt.ydelta == 254.0
# No effect
stmt.to_metric()
- assert_equal(stmt.xdelta, 25.4)
- assert_equal(stmt.ydelta, 254.)
+ assert stmt.xdelta == 25.4
+ assert stmt.ydelta == 254.0
def test_repeathole_str():
- stmt = RepeatHoleStmt.from_excellon('R4X015Y32', FileSettings())
- assert_equal(str(stmt), '<Repeat Hole: 4 times, offset X: 1.5 Y: 32>')
+ stmt = RepeatHoleStmt.from_excellon("R4X015Y32", FileSettings())
+ assert str(stmt) == "<Repeat Hole: 4 times, offset X: 1.5 Y: 32>"
def test_commentstmt_factory():
""" Test CommentStmt factory method
"""
- line = ';Layer_Color=9474304'
+ line = ";Layer_Color=9474304"
stmt = CommentStmt.from_excellon(line)
- assert_equal(stmt.comment, line[1:])
+ assert stmt.comment == line[1:]
- line = ';FILE_FORMAT=2:5'
+ line = ";FILE_FORMAT=2:5"
stmt = CommentStmt.from_excellon(line)
- assert_equal(stmt.comment, line[1:])
+ assert stmt.comment == line[1:]
- line = ';TYPE=PLATED'
+ line = ";TYPE=PLATED"
stmt = CommentStmt.from_excellon(line)
- assert_equal(stmt.comment, line[1:])
+ assert stmt.comment == line[1:]
def test_commentstmt_dump():
""" Test CommentStmt to_excellon()
"""
- lines = [';Layer_Color=9474304', ';FILE_FORMAT=2:5', ';TYPE=PLATED', ]
+ lines = [";Layer_Color=9474304", ";FILE_FORMAT=2:5", ";TYPE=PLATED"]
for line in lines:
stmt = CommentStmt.from_excellon(line)
- assert_equal(stmt.to_excellon(), line)
+ assert stmt.to_excellon() == line
def test_header_begin_stmt():
stmt = HeaderBeginStmt()
- assert_equal(stmt.to_excellon(None), 'M48')
+ assert stmt.to_excellon(None) == "M48"
def test_header_end_stmt():
stmt = HeaderEndStmt()
- assert_equal(stmt.to_excellon(None), 'M95')
+ assert stmt.to_excellon(None) == "M95"
def test_rewindstop_stmt():
stmt = RewindStopStmt()
- assert_equal(stmt.to_excellon(None), '%')
+ assert stmt.to_excellon(None) == "%"
def test_z_axis_rout_position_stmt():
stmt = ZAxisRoutPositionStmt()
- assert_equal(stmt.to_excellon(None), 'M15')
+ assert stmt.to_excellon(None) == "M15"
def test_retract_with_clamping_stmt():
stmt = RetractWithClampingStmt()
- assert_equal(stmt.to_excellon(None), 'M16')
+ assert stmt.to_excellon(None) == "M16"
def test_retract_without_clamping_stmt():
stmt = RetractWithoutClampingStmt()
- assert_equal(stmt.to_excellon(None), 'M17')
+ assert stmt.to_excellon(None) == "M17"
def test_cutter_compensation_off_stmt():
stmt = CutterCompensationOffStmt()
- assert_equal(stmt.to_excellon(None), 'G40')
+ assert stmt.to_excellon(None) == "G40"
def test_cutter_compensation_left_stmt():
stmt = CutterCompensationLeftStmt()
- assert_equal(stmt.to_excellon(None), 'G41')
+ assert stmt.to_excellon(None) == "G41"
def test_cutter_compensation_right_stmt():
stmt = CutterCompensationRightStmt()
- assert_equal(stmt.to_excellon(None), 'G42')
+ assert stmt.to_excellon(None) == "G42"
def test_endofprogramstmt_factory():
- settings = FileSettings(units='inch')
- stmt = EndOfProgramStmt.from_excellon('M30X01Y02', settings)
- assert_equal(stmt.x, 1.)
- assert_equal(stmt.y, 2.)
- assert_equal(stmt.units, 'inch')
- settings.units = 'metric'
- stmt = EndOfProgramStmt.from_excellon('M30X01', settings)
- assert_equal(stmt.x, 1.)
- assert_equal(stmt.y, None)
- assert_equal(stmt.units, 'metric')
- stmt = EndOfProgramStmt.from_excellon('M30Y02', FileSettings())
- assert_equal(stmt.x, None)
- assert_equal(stmt.y, 2.)
+ settings = FileSettings(units="inch")
+ stmt = EndOfProgramStmt.from_excellon("M30X01Y02", settings)
+ assert stmt.x == 1.0
+ assert stmt.y == 2.0
+ assert stmt.units == "inch"
+ settings.units = "metric"
+ stmt = EndOfProgramStmt.from_excellon("M30X01", settings)
+ assert stmt.x == 1.0
+ assert stmt.y == None
+ assert stmt.units == "metric"
+ stmt = EndOfProgramStmt.from_excellon("M30Y02", FileSettings())
+ assert stmt.x == None
+ assert stmt.y == 2.0
def test_endofprogramStmt_dump():
- lines = ['M30X01Y02', ]
+ lines = ["M30X01Y02"]
for line in lines:
stmt = EndOfProgramStmt.from_excellon(line, FileSettings())
- assert_equal(stmt.to_excellon(FileSettings()), line)
+ assert stmt.to_excellon(FileSettings()) == line
def test_endofprogramstmt_conversion():
settings = FileSettings()
- settings.units = 'metric'
- stmt = EndOfProgramStmt.from_excellon('M30X0254Y254', settings)
+ settings.units = "metric"
+ stmt = EndOfProgramStmt.from_excellon("M30X0254Y254", settings)
# No effect
stmt.to_metric()
- assert_equal(stmt.x, 2.54)
- assert_equal(stmt.y, 25.4)
+ assert stmt.x == 2.54
+ assert stmt.y == 25.4
stmt.to_inch()
- assert_equal(stmt.units, 'inch')
- assert_equal(stmt.x, 0.1)
- assert_equal(stmt.y, 1.0)
+ assert stmt.units == "inch"
+ assert stmt.x == 0.1
+ assert stmt.y == 1.0
# No effect
stmt.to_inch()
- assert_equal(stmt.x, 0.1)
- assert_equal(stmt.y, 1.0)
+ assert stmt.x == 0.1
+ assert stmt.y == 1.0
- settings.units = 'inch'
- stmt = EndOfProgramStmt.from_excellon('M30X01Y1', settings)
+ settings.units = "inch"
+ stmt = EndOfProgramStmt.from_excellon("M30X01Y1", settings)
# No effect
stmt.to_inch()
- assert_equal(stmt.x, 1.)
- assert_equal(stmt.y, 10.0)
+ assert stmt.x == 1.0
+ assert stmt.y == 10.0
stmt.to_metric()
- assert_equal(stmt.units, 'metric')
- assert_equal(stmt.x, 25.4)
- assert_equal(stmt.y, 254.)
+ assert stmt.units == "metric"
+ assert stmt.x == 25.4
+ assert stmt.y == 254.0
# No effect
stmt.to_metric()
- assert_equal(stmt.x, 25.4)
- assert_equal(stmt.y, 254.)
+ assert stmt.x == 25.4
+ assert stmt.y == 254.0
def test_endofprogramstmt_offset():
stmt = EndOfProgramStmt(1, 1)
stmt.offset()
- assert_equal(stmt.x, 1)
- assert_equal(stmt.y, 1)
+ assert stmt.x == 1
+ assert stmt.y == 1
stmt.offset(1, 0)
- assert_equal(stmt.x, 2.)
- assert_equal(stmt.y, 1.)
+ assert stmt.x == 2.0
+ assert stmt.y == 1.0
stmt.offset(0, 1)
- assert_equal(stmt.x, 2.)
- assert_equal(stmt.y, 2.)
+ assert stmt.x == 2.0
+ assert stmt.y == 2.0
def test_unitstmt_factory():
""" Test UnitStmt factory method
"""
- line = 'INCH,LZ'
+ line = "INCH,LZ"
stmt = UnitStmt.from_excellon(line)
- assert_equal(stmt.units, 'inch')
- assert_equal(stmt.zeros, 'leading')
+ assert stmt.units == "inch"
+ assert stmt.zeros == "leading"
- line = 'INCH,TZ'
+ line = "INCH,TZ"
stmt = UnitStmt.from_excellon(line)
- assert_equal(stmt.units, 'inch')
- assert_equal(stmt.zeros, 'trailing')
+ assert stmt.units == "inch"
+ assert stmt.zeros == "trailing"
- line = 'METRIC,LZ'
+ line = "METRIC,LZ"
stmt = UnitStmt.from_excellon(line)
- assert_equal(stmt.units, 'metric')
- assert_equal(stmt.zeros, 'leading')
+ assert stmt.units == "metric"
+ assert stmt.zeros == "leading"
- line = 'METRIC,TZ'
+ line = "METRIC,TZ"
stmt = UnitStmt.from_excellon(line)
- assert_equal(stmt.units, 'metric')
- assert_equal(stmt.zeros, 'trailing')
+ assert stmt.units == "metric"
+ assert stmt.zeros == "trailing"
def test_unitstmt_dump():
""" Test UnitStmt to_excellon()
"""
- lines = ['INCH,LZ', 'INCH,TZ', 'METRIC,LZ', 'METRIC,TZ', ]
+ lines = ["INCH,LZ", "INCH,TZ", "METRIC,LZ", "METRIC,TZ"]
for line in lines:
stmt = UnitStmt.from_excellon(line)
- assert_equal(stmt.to_excellon(), line)
+ assert stmt.to_excellon() == line
def test_unitstmt_conversion():
- stmt = UnitStmt.from_excellon('METRIC,TZ')
+ stmt = UnitStmt.from_excellon("METRIC,TZ")
stmt.to_inch()
- assert_equal(stmt.units, 'inch')
+ assert stmt.units == "inch"
- stmt = UnitStmt.from_excellon('INCH,TZ')
+ stmt = UnitStmt.from_excellon("INCH,TZ")
stmt.to_metric()
- assert_equal(stmt.units, 'metric')
+ assert stmt.units == "metric"
def test_incrementalmode_factory():
""" Test IncrementalModeStmt factory method
"""
- line = 'ICI,ON'
+ line = "ICI,ON"
stmt = IncrementalModeStmt.from_excellon(line)
- assert_equal(stmt.mode, 'on')
+ assert stmt.mode == "on"
- line = 'ICI,OFF'
+ line = "ICI,OFF"
stmt = IncrementalModeStmt.from_excellon(line)
- assert_equal(stmt.mode, 'off')
+ assert stmt.mode == "off"
def test_incrementalmode_dump():
""" Test IncrementalModeStmt to_excellon()
"""
- lines = ['ICI,ON', 'ICI,OFF', ]
+ lines = ["ICI,ON", "ICI,OFF"]
for line in lines:
stmt = IncrementalModeStmt.from_excellon(line)
- assert_equal(stmt.to_excellon(), line)
+ assert stmt.to_excellon() == line
def test_incrementalmode_validation():
""" Test IncrementalModeStmt input validation
"""
- assert_raises(ValueError, IncrementalModeStmt, 'OFF-ISH')
+ pytest.raises(ValueError, IncrementalModeStmt, "OFF-ISH")
def test_versionstmt_factory():
""" Test VersionStmt factory method
"""
- line = 'VER,1'
+ line = "VER,1"
stmt = VersionStmt.from_excellon(line)
- assert_equal(stmt.version, 1)
+ assert stmt.version == 1
- line = 'VER,2'
+ line = "VER,2"
stmt = VersionStmt.from_excellon(line)
- assert_equal(stmt.version, 2)
+ assert stmt.version == 2
def test_versionstmt_dump():
""" Test VersionStmt to_excellon()
"""
- lines = ['VER,1', 'VER,2', ]
+ lines = ["VER,1", "VER,2"]
for line in lines:
stmt = VersionStmt.from_excellon(line)
- assert_equal(stmt.to_excellon(), line)
+ assert stmt.to_excellon() == line
def test_versionstmt_validation():
""" Test VersionStmt input validation
"""
- assert_raises(ValueError, VersionStmt, 3)
+ pytest.raises(ValueError, VersionStmt, 3)
def test_formatstmt_factory():
""" Test FormatStmt factory method
"""
- line = 'FMAT,1'
+ line = "FMAT,1"
stmt = FormatStmt.from_excellon(line)
- assert_equal(stmt.format, 1)
+ assert stmt.format == 1
- line = 'FMAT,2'
+ line = "FMAT,2"
stmt = FormatStmt.from_excellon(line)
- assert_equal(stmt.format, 2)
+ assert stmt.format == 2
def test_formatstmt_dump():
""" Test FormatStmt to_excellon()
"""
- lines = ['FMAT,1', 'FMAT,2', ]
+ lines = ["FMAT,1", "FMAT,2"]
for line in lines:
stmt = FormatStmt.from_excellon(line)
- assert_equal(stmt.to_excellon(), line)
+ assert stmt.to_excellon() == line
def test_formatstmt_validation():
""" Test FormatStmt input validation
"""
- assert_raises(ValueError, FormatStmt, 3)
+ pytest.raises(ValueError, FormatStmt, 3)
def test_linktoolstmt_factory():
""" Test LinkToolStmt factory method
"""
- line = '1/2/3/4'
+ line = "1/2/3/4"
stmt = LinkToolStmt.from_excellon(line)
- assert_equal(stmt.linked_tools, [1, 2, 3, 4])
+ assert stmt.linked_tools == [1, 2, 3, 4]
- line = '01/02/03/04'
+ line = "01/02/03/04"
stmt = LinkToolStmt.from_excellon(line)
- assert_equal(stmt.linked_tools, [1, 2, 3, 4])
+ assert stmt.linked_tools == [1, 2, 3, 4]
def test_linktoolstmt_dump():
""" Test LinkToolStmt to_excellon()
"""
- lines = ['1/2/3/4', '5/6/7', ]
+ lines = ["1/2/3/4", "5/6/7"]
for line in lines:
stmt = LinkToolStmt.from_excellon(line)
- assert_equal(stmt.to_excellon(), line)
+ assert stmt.to_excellon() == line
def test_measmodestmt_factory():
""" Test MeasuringModeStmt factory method
"""
- line = 'M72'
+ line = "M72"
stmt = MeasuringModeStmt.from_excellon(line)
- assert_equal(stmt.units, 'inch')
+ assert stmt.units == "inch"
- line = 'M71'
+ line = "M71"
stmt = MeasuringModeStmt.from_excellon(line)
- assert_equal(stmt.units, 'metric')
+ assert stmt.units == "metric"
def test_measmodestmt_dump():
""" Test MeasuringModeStmt to_excellon()
"""
- lines = ['M71', 'M72', ]
+ lines = ["M71", "M72"]
for line in lines:
stmt = MeasuringModeStmt.from_excellon(line)
- assert_equal(stmt.to_excellon(), line)
+ assert stmt.to_excellon() == line
def test_measmodestmt_validation():
""" Test MeasuringModeStmt input validation
"""
- assert_raises(ValueError, MeasuringModeStmt.from_excellon, 'M70')
- assert_raises(ValueError, MeasuringModeStmt, 'millimeters')
+ pytest.raises(ValueError, MeasuringModeStmt.from_excellon, "M70")
+ pytest.raises(ValueError, MeasuringModeStmt, "millimeters")
def test_measmodestmt_conversion():
- line = 'M72'
+ line = "M72"
stmt = MeasuringModeStmt.from_excellon(line)
- assert_equal(stmt.units, 'inch')
+ assert stmt.units == "inch"
stmt.to_metric()
- assert_equal(stmt.units, 'metric')
+ assert stmt.units == "metric"
- line = 'M71'
+ line = "M71"
stmt = MeasuringModeStmt.from_excellon(line)
- assert_equal(stmt.units, 'metric')
+ assert stmt.units == "metric"
stmt.to_inch()
- assert_equal(stmt.units, 'inch')
+ assert stmt.units == "inch"
def test_routemode_stmt():
stmt = RouteModeStmt()
- assert_equal(stmt.to_excellon(FileSettings()), 'G00')
+ assert stmt.to_excellon(FileSettings()) == "G00"
def test_linearmode_stmt():
stmt = LinearModeStmt()
- assert_equal(stmt.to_excellon(FileSettings()), 'G01')
+ assert stmt.to_excellon(FileSettings()) == "G01"
def test_drillmode_stmt():
stmt = DrillModeStmt()
- assert_equal(stmt.to_excellon(FileSettings()), 'G05')
+ assert stmt.to_excellon(FileSettings()) == "G05"
def test_absolutemode_stmt():
stmt = AbsoluteModeStmt()
- assert_equal(stmt.to_excellon(FileSettings()), 'G90')
+ assert stmt.to_excellon(FileSettings()) == "G90"
def test_unknownstmt():
- stmt = UnknownStmt('TEST')
- assert_equal(stmt.stmt, 'TEST')
- assert_equal(str(stmt), '<Unknown Statement: TEST>')
+ stmt = UnknownStmt("TEST")
+ assert stmt.stmt == "TEST"
+ assert str(stmt) == "<Unknown Statement: TEST>"
def test_unknownstmt_dump():
- stmt = UnknownStmt('TEST')
- assert_equal(stmt.to_excellon(FileSettings()), 'TEST')
+ stmt = UnknownStmt("TEST")
+ assert stmt.to_excellon(FileSettings()) == "TEST"