diff options
Diffstat (limited to 'gerbonara/gerber')
| -rw-r--r-- | gerbonara/gerber/tests/test_cam.py | 151 | ||||
| -rw-r--r-- | gerbonara/gerber/tests/test_common.py | 38 | ||||
| -rw-r--r-- | gerbonara/gerber/tests/test_excellon_statements.py | 734 | ||||
| -rw-r--r-- | gerbonara/gerber/tests/test_gerber_statements.py | 903 | ||||
| -rw-r--r-- | gerbonara/gerber/tests/test_primitives.py | 897 |
5 files changed, 0 insertions, 2723 deletions
diff --git a/gerbonara/gerber/tests/test_cam.py b/gerbonara/gerber/tests/test_cam.py deleted file mode 100644 index 8a71a32..0000000 --- a/gerbonara/gerber/tests/test_cam.py +++ /dev/null @@ -1,151 +0,0 @@ -#! /usr/bin/env python -# -*- coding: utf-8 -*- - -# Author: Hamilton Kibbe <ham@hamiltonkib.be> - -import pytest - -from ..cam import CamFile, FileSettings - - -def test_filesettings_defaults(): - """ Test FileSettings default values - """ - fs = FileSettings() - assert fs.format == (2, 5) - assert fs.notation == "absolute" - assert fs.zero_suppression == "trailing" - assert fs.units == "inch" - - -def test_filesettings_dict(): - """ Test FileSettings Dict - """ - fs = FileSettings() - assert fs["format"] == (2, 5) - assert fs["notation"] == "absolute" - assert fs["zero_suppression"] == "trailing" - assert fs["units"] == "inch" - - -def test_filesettings_assign(): - """ Test FileSettings attribute assignment - """ - fs = FileSettings() - fs.units = "test1" - fs.notation = "test2" - fs.zero_suppression = "test3" - fs.format = "test4" - assert fs.units == "test1" - assert fs.notation == "test2" - assert fs.zero_suppression == "test3" - assert fs.format == "test4" - - -def test_filesettings_dict_assign(): - """ Test FileSettings dict-style attribute assignment - """ - fs = FileSettings() - fs["units"] = "metric" - fs["notation"] = "incremental" - fs["zero_suppression"] = "leading" - fs["format"] = (1, 2) - assert fs.units == "metric" - assert fs.notation == "incremental" - assert fs.zero_suppression == "leading" - assert fs.format == (1, 2) - - -def test_camfile_init(): - """ Smoke test CamFile test - """ - cf = CamFile() - - -def test_camfile_settings(): - """ Test CamFile Default Settings - """ - cf = CamFile() - assert cf.settings == FileSettings() - - -def test_bounds_override_smoketest(): - cf = CamFile() - cf.bounds - - -def test_zeros(): - """ Test zero/zero_suppression interaction - """ - fs = FileSettings() - assert fs.zero_suppression == "trailing" - assert fs.zeros == "leading" - - fs["zero_suppression"] = "leading" - assert fs.zero_suppression == "leading" - assert fs.zeros == "trailing" - - fs.zero_suppression = "trailing" - assert fs.zero_suppression == "trailing" - assert fs.zeros == "leading" - - fs["zeros"] = "trailing" - assert fs.zeros == "trailing" - assert fs.zero_suppression == "leading" - - fs.zeros = "leading" - assert fs.zeros == "leading" - assert fs.zero_suppression == "trailing" - - fs = FileSettings(zeros="leading") - assert fs.zeros == "leading" - assert fs.zero_suppression == "trailing" - - fs = FileSettings(zero_suppression="leading") - assert fs.zeros == "trailing" - assert fs.zero_suppression == "leading" - - fs = FileSettings(zeros="leading", zero_suppression="trailing") - assert fs.zeros == "leading" - assert fs.zero_suppression == "trailing" - - fs = FileSettings(zeros="trailing", zero_suppression="leading") - assert fs.zeros == "trailing" - assert fs.zero_suppression == "leading" - - -def test_filesettings_validation(): - """ Test FileSettings constructor argument validation - """ - # absolute-ish is not a valid notation - pytest.raises(ValueError, FileSettings, "absolute-ish", "inch", None, (2, 5), None) - - # degrees kelvin isn't a valid unit for a CAM file - pytest.raises( - ValueError, FileSettings, "absolute", "degrees kelvin", None, (2, 5), None - ) - - pytest.raises( - ValueError, FileSettings, "absolute", "inch", "leading", (2, 5), "leading" - ) - - # Technnically this should be an error, but Eangle files often do this incorrectly so we - # allow it - # pytest.raises(ValueError, FileSettings, 'absolute', - # 'inch', 'following', (2, 5), None) - - pytest.raises( - ValueError, FileSettings, "absolute", "inch", None, (2, 5), "following" - ) - pytest.raises(ValueError, FileSettings, "absolute", "inch", None, (2, 5, 6), None) - - -def test_key_validation(): - fs = FileSettings() - pytest.raises(KeyError, fs.__getitem__, "octopus") - pytest.raises(KeyError, fs.__setitem__, "octopus", "do not care") - pytest.raises(ValueError, fs.__setitem__, "notation", "absolute-ish") - pytest.raises(ValueError, fs.__setitem__, "units", "degrees kelvin") - pytest.raises(ValueError, fs.__setitem__, "zero_suppression", "following") - pytest.raises(ValueError, fs.__setitem__, "zeros", "following") - pytest.raises(ValueError, fs.__setitem__, "format", (2, 5, 6)) diff --git a/gerbonara/gerber/tests/test_common.py b/gerbonara/gerber/tests/test_common.py deleted file mode 100644 index e4c023c..0000000 --- a/gerbonara/gerber/tests/test_common.py +++ /dev/null @@ -1,38 +0,0 @@ -#! /usr/bin/env python -# -*- coding: utf-8 -*- - -# Author: Hamilton Kibbe <ham@hamiltonkib.be> -from ..exceptions import ParseError -from ..common import read, loads -from ..excellon import ExcellonFile -from ..rs274x import GerberFile -import os -import pytest - - -NCDRILL_FILE = os.path.join(os.path.dirname(__file__), "resources/ncdrill.DRD") -TOP_COPPER_FILE = os.path.join(os.path.dirname(__file__), "resources/top_copper.GTL") - - -def test_file_type_detection(): - """ Test file type detection - """ - ncdrill = read(NCDRILL_FILE) - top_copper = read(TOP_COPPER_FILE) - assert isinstance(ncdrill, ExcellonFile) - assert isinstance(top_copper, GerberFile) - - -def test_load_from_string(): - with open(NCDRILL_FILE, "r") as f: - ncdrill = loads(f.read()) - with open(TOP_COPPER_FILE, "r") as f: - top_copper = loads(f.read()) - assert isinstance(ncdrill, ExcellonFile) - assert isinstance(top_copper, GerberFile) - - -def test_file_type_validation(): - """ Test file format validation - """ - pytest.raises(ParseError, read, __file__) diff --git a/gerbonara/gerber/tests/test_excellon_statements.py b/gerbonara/gerber/tests/test_excellon_statements.py deleted file mode 100644 index 41fe294..0000000 --- a/gerbonara/gerber/tests/test_excellon_statements.py +++ /dev/null @@ -1,734 +0,0 @@ -#! /usr/bin/env python -# -*- coding: utf-8 -*- - -# Author: Hamilton Kibbe <ham@hamiltonkib.be> - -import pytest -from ..excellon_statements import * -from ..cam import FileSettings - - -def test_excellon_statement_implementation(): - stmt = ExcellonStatement() - pytest.raises(NotImplementedError, stmt.from_excellon, None) - pytest.raises(NotImplementedError, stmt.to_excellon) - - -def test_excellontstmt(): - """ Smoke test ExcellonStatement - """ - stmt = ExcellonStatement() - stmt.to_inch() - stmt.to_metric() - stmt.offset() - - -def test_excellontool_factory(): - """ Test ExcellonTool factory methods - """ - exc_line = "T8F01B02S00003H04Z05C0.12500" - settings = FileSettings( - format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute" - ) - tool = ExcellonTool.from_excellon(exc_line, settings) - 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 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" - ) - for line in exc_lines: - tool = ExcellonTool.from_excellon(line, settings) - assert tool.to_excellon() == line - - -def test_excellontool_order(): - settings = FileSettings( - format=(2, 5), zero_suppression="trailing", units="inch", notation="absolute" - ) - line = "T8F00S00C0.12500" - tool1 = ExcellonTool.from_excellon(line, settings) - line = "T8C0.12500F00S00" - tool2 = ExcellonTool.from_excellon(line, settings) - 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.to_inch() - assert tool.diameter == 1.0 - tool = ExcellonTool.from_dict( - FileSettings(units="inch"), {"number": 8, "diameter": 1.0} - ) - tool.to_metric() - 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.to_inch() - assert tool.diameter == 25.4 - tool = ExcellonTool.from_dict( - FileSettings(units="metric"), {"number": 8, "diameter": 1.0} - ) - tool.to_metric() - assert tool.diameter == 1.0 - - -def test_excellontool_repr(): - 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}) - t1 = ExcellonTool.from_dict(FileSettings(), {"number": 8, "diameter": 0.125}) - assert t == t1 - t1 = ExcellonTool.from_dict( - 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 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"] - for line in lines: - stmt = ToolSelectionStmt.from_excellon(line) - assert stmt.to_excellon() == line - - -def test_z_axis_infeed_rate_factory(): - """ Test ZAxisInfeedRateStmt factory method - """ - 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")] - for input_rate, expected_output in inputs: - stmt = ZAxisInfeedRateStmt.from_excellon(input_rate) - 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" - ) - - line = "X0278207Y0065293" - stmt = CoordinateStmt.from_excellon(line, settings) - assert stmt.x == 2.78207 - assert stmt.y == 0.65293 - - # line = 'X02945' - # stmt = CoordinateStmt.from_excellon(line) - # assert_equal(stmt.x, 2.945) - - # line = 'Y00575' - # stmt = CoordinateStmt.from_excellon(line) - # assert_equal(stmt.y, 0.575) - - settings = FileSettings( - format=(2, 4), zero_suppression="leading", units="inch", notation="absolute" - ) - - line = "X9660Y4639" - stmt = CoordinateStmt.from_excellon(line, settings) - assert stmt.x == 0.9660 - assert stmt.y == 0.4639 - assert stmt.to_excellon(settings) == "X9660Y4639" - assert stmt.units == "inch" - - settings.units = "metric" - stmt = CoordinateStmt.from_excellon(line, settings) - 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" - ) - for line in lines: - stmt = CoordinateStmt.from_excellon(line, settings) - assert stmt.to_excellon(settings) == line - - -def test_coordinatestmt_conversion(): - - settings = FileSettings() - settings.units = "metric" - stmt = CoordinateStmt.from_excellon("X254Y254", settings) - - # No effect - stmt.to_metric() - assert stmt.x == 25.4 - assert stmt.y == 25.4 - - stmt.to_inch() - assert stmt.units == "inch" - assert stmt.x == 1.0 - assert stmt.y == 1.0 - - # No effect - stmt.to_inch() - assert stmt.x == 1.0 - assert stmt.y == 1.0 - - settings.units = "inch" - stmt = CoordinateStmt.from_excellon("X01Y01", settings) - - # No effect - stmt.to_inch() - assert stmt.x == 1.0 - assert stmt.y == 1.0 - - stmt.to_metric() - assert stmt.units == "metric" - assert stmt.x == 25.4 - assert stmt.y == 25.4 - - # No effect - stmt.to_metric() - assert stmt.x == 25.4 - assert stmt.y == 25.4 - - -def test_coordinatestmt_offset(): - stmt = CoordinateStmt.from_excellon("X01Y01", FileSettings()) - stmt.offset() - assert stmt.x == 1 - assert stmt.y == 1 - stmt.offset(1, 0) - assert stmt.x == 2.0 - assert stmt.y == 1.0 - stmt.offset(0, 1) - 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 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 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 stmt.units == "metric" - - -def test_repeatholestmt_dump(): - line = "R4X015Y32" - stmt = RepeatHoleStmt.from_excellon(line, FileSettings()) - assert stmt.to_excellon(FileSettings()) == line - - -def test_repeatholestmt_conversion(): - line = "R4X0254Y254" - settings = FileSettings() - settings.units = "metric" - stmt = RepeatHoleStmt.from_excellon(line, settings) - - # No effect - stmt.to_metric() - assert stmt.xdelta == 2.54 - assert stmt.ydelta == 25.4 - - stmt.to_inch() - assert stmt.units == "inch" - assert stmt.xdelta == 0.1 - assert stmt.ydelta == 1.0 - - # no effect - stmt.to_inch() - assert stmt.xdelta == 0.1 - assert stmt.ydelta == 1.0 - - line = "R4X01Y1" - settings.units = "inch" - stmt = RepeatHoleStmt.from_excellon(line, settings) - - # no effect - stmt.to_inch() - assert stmt.xdelta == 1.0 - assert stmt.ydelta == 10.0 - - stmt.to_metric() - assert stmt.units == "metric" - assert stmt.xdelta == 25.4 - assert stmt.ydelta == 254.0 - - # No effect - stmt.to_metric() - assert stmt.xdelta == 25.4 - assert stmt.ydelta == 254.0 - - -def test_repeathole_str(): - 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" - stmt = CommentStmt.from_excellon(line) - assert stmt.comment == line[1:] - - line = ";FILE_FORMAT=2:5" - stmt = CommentStmt.from_excellon(line) - assert stmt.comment == line[1:] - - line = ";TYPE=PLATED" - stmt = CommentStmt.from_excellon(line) - assert stmt.comment == line[1:] - - -def test_commentstmt_dump(): - """ Test CommentStmt to_excellon() - """ - lines = [";Layer_Color=9474304", ";FILE_FORMAT=2:5", ";TYPE=PLATED"] - for line in lines: - stmt = CommentStmt.from_excellon(line) - assert stmt.to_excellon() == line - - -def test_header_begin_stmt(): - stmt = HeaderBeginStmt() - assert stmt.to_excellon(None) == "M48" - - -def test_header_end_stmt(): - stmt = HeaderEndStmt() - assert stmt.to_excellon(None) == "M95" - - -def test_rewindstop_stmt(): - stmt = RewindStopStmt() - assert stmt.to_excellon(None) == "%" - - -def test_z_axis_rout_position_stmt(): - stmt = ZAxisRoutPositionStmt() - assert stmt.to_excellon(None) == "M15" - - -def test_retract_with_clamping_stmt(): - stmt = RetractWithClampingStmt() - assert stmt.to_excellon(None) == "M16" - - -def test_retract_without_clamping_stmt(): - stmt = RetractWithoutClampingStmt() - assert stmt.to_excellon(None) == "M17" - - -def test_cutter_compensation_off_stmt(): - stmt = CutterCompensationOffStmt() - assert stmt.to_excellon(None) == "G40" - - -def test_cutter_compensation_left_stmt(): - stmt = CutterCompensationLeftStmt() - assert stmt.to_excellon(None) == "G41" - - -def test_cutter_compensation_right_stmt(): - stmt = CutterCompensationRightStmt() - assert stmt.to_excellon(None) == "G42" - - -def test_endofprogramstmt_factory(): - 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"] - for line in lines: - stmt = EndOfProgramStmt.from_excellon(line, FileSettings()) - assert stmt.to_excellon(FileSettings()) == line - - -def test_endofprogramstmt_conversion(): - settings = FileSettings() - settings.units = "metric" - stmt = EndOfProgramStmt.from_excellon("M30X0254Y254", settings) - # No effect - stmt.to_metric() - assert stmt.x == 2.54 - assert stmt.y == 25.4 - - stmt.to_inch() - assert stmt.units == "inch" - assert stmt.x == 0.1 - assert stmt.y == 1.0 - - # No effect - stmt.to_inch() - assert stmt.x == 0.1 - assert stmt.y == 1.0 - - settings.units = "inch" - stmt = EndOfProgramStmt.from_excellon("M30X01Y1", settings) - - # No effect - stmt.to_inch() - assert stmt.x == 1.0 - assert stmt.y == 10.0 - - stmt.to_metric() - assert stmt.units == "metric" - assert stmt.x == 25.4 - assert stmt.y == 254.0 - - # No effect - stmt.to_metric() - assert stmt.x == 25.4 - assert stmt.y == 254.0 - - -def test_endofprogramstmt_offset(): - stmt = EndOfProgramStmt(1, 1) - stmt.offset() - assert stmt.x == 1 - assert stmt.y == 1 - stmt.offset(1, 0) - assert stmt.x == 2.0 - assert stmt.y == 1.0 - stmt.offset(0, 1) - assert stmt.x == 2.0 - assert stmt.y == 2.0 - - -def test_unitstmt_factory(): - """ Test UnitStmt factory method - """ - line = "INCH,LZ" - stmt = UnitStmt.from_excellon(line) - assert stmt.units == "inch" - assert stmt.zeros == "leading" - - line = "INCH,TZ" - stmt = UnitStmt.from_excellon(line) - assert stmt.units == "inch" - assert stmt.zeros == "trailing" - - line = "METRIC,LZ" - stmt = UnitStmt.from_excellon(line) - assert stmt.units == "metric" - assert stmt.zeros == "leading" - - line = "METRIC,TZ" - stmt = UnitStmt.from_excellon(line) - 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"] - for line in lines: - stmt = UnitStmt.from_excellon(line) - assert stmt.to_excellon() == line - - -def test_unitstmt_conversion(): - stmt = UnitStmt.from_excellon("METRIC,TZ") - stmt.to_inch() - assert stmt.units == "inch" - - stmt = UnitStmt.from_excellon("INCH,TZ") - stmt.to_metric() - assert stmt.units == "metric" - - -def test_incrementalmode_factory(): - """ Test IncrementalModeStmt factory method - """ - line = "ICI,ON" - stmt = IncrementalModeStmt.from_excellon(line) - assert stmt.mode == "on" - - line = "ICI,OFF" - stmt = IncrementalModeStmt.from_excellon(line) - assert stmt.mode == "off" - - -def test_incrementalmode_dump(): - """ Test IncrementalModeStmt to_excellon() - """ - lines = ["ICI,ON", "ICI,OFF"] - for line in lines: - stmt = IncrementalModeStmt.from_excellon(line) - assert stmt.to_excellon() == line - - -def test_incrementalmode_validation(): - """ Test IncrementalModeStmt input validation - """ - pytest.raises(ValueError, IncrementalModeStmt, "OFF-ISH") - - -def test_versionstmt_factory(): - """ Test VersionStmt factory method - """ - line = "VER,1" - stmt = VersionStmt.from_excellon(line) - assert stmt.version == 1 - - line = "VER,2" - stmt = VersionStmt.from_excellon(line) - assert stmt.version == 2 - - -def test_versionstmt_dump(): - """ Test VersionStmt to_excellon() - """ - lines = ["VER,1", "VER,2"] - for line in lines: - stmt = VersionStmt.from_excellon(line) - assert stmt.to_excellon() == line - - -def test_versionstmt_validation(): - """ Test VersionStmt input validation - """ - pytest.raises(ValueError, VersionStmt, 3) - - -def test_formatstmt_factory(): - """ Test FormatStmt factory method - """ - line = "FMAT,1" - stmt = FormatStmt.from_excellon(line) - assert stmt.format == 1 - - line = "FMAT,2" - stmt = FormatStmt.from_excellon(line) - assert stmt.format == 2 - - -def test_formatstmt_dump(): - """ Test FormatStmt to_excellon() - """ - lines = ["FMAT,1", "FMAT,2"] - for line in lines: - stmt = FormatStmt.from_excellon(line) - assert stmt.to_excellon() == line - - -def test_formatstmt_validation(): - """ Test FormatStmt input validation - """ - pytest.raises(ValueError, FormatStmt, 3) - - -def test_linktoolstmt_factory(): - """ Test LinkToolStmt factory method - """ - line = "1/2/3/4" - stmt = LinkToolStmt.from_excellon(line) - assert stmt.linked_tools == [1, 2, 3, 4] - - line = "01/02/03/04" - stmt = LinkToolStmt.from_excellon(line) - assert stmt.linked_tools == [1, 2, 3, 4] - - -def test_linktoolstmt_dump(): - """ Test LinkToolStmt to_excellon() - """ - lines = ["1/2/3/4", "5/6/7"] - for line in lines: - stmt = LinkToolStmt.from_excellon(line) - assert stmt.to_excellon() == line - - -def test_measmodestmt_factory(): - """ Test MeasuringModeStmt factory method - """ - line = "M72" - stmt = MeasuringModeStmt.from_excellon(line) - assert stmt.units == "inch" - - line = "M71" - stmt = MeasuringModeStmt.from_excellon(line) - assert stmt.units == "metric" - - -def test_measmodestmt_dump(): - """ Test MeasuringModeStmt to_excellon() - """ - lines = ["M71", "M72"] - for line in lines: - stmt = MeasuringModeStmt.from_excellon(line) - assert stmt.to_excellon() == line - - -def test_measmodestmt_validation(): - """ Test MeasuringModeStmt input validation - """ - pytest.raises(ValueError, MeasuringModeStmt.from_excellon, "M70") - pytest.raises(ValueError, MeasuringModeStmt, "millimeters") - - -def test_measmodestmt_conversion(): - line = "M72" - stmt = MeasuringModeStmt.from_excellon(line) - assert stmt.units == "inch" - stmt.to_metric() - assert stmt.units == "metric" - - line = "M71" - stmt = MeasuringModeStmt.from_excellon(line) - assert stmt.units == "metric" - stmt.to_inch() - assert stmt.units == "inch" - - -def test_routemode_stmt(): - stmt = RouteModeStmt() - assert stmt.to_excellon(FileSettings()) == "G00" - - -def test_linearmode_stmt(): - stmt = LinearModeStmt() - assert stmt.to_excellon(FileSettings()) == "G01" - - -def test_drillmode_stmt(): - stmt = DrillModeStmt() - assert stmt.to_excellon(FileSettings()) == "G05" - - -def test_absolutemode_stmt(): - stmt = AbsoluteModeStmt() - assert stmt.to_excellon(FileSettings()) == "G90" - - -def test_unknownstmt(): - stmt = UnknownStmt("TEST") - assert stmt.stmt == "TEST" - assert str(stmt) == "<Unknown Statement: TEST>" - - -def test_unknownstmt_dump(): - stmt = UnknownStmt("TEST") - assert stmt.to_excellon(FileSettings()) == "TEST" diff --git a/gerbonara/gerber/tests/test_gerber_statements.py b/gerbonara/gerber/tests/test_gerber_statements.py deleted file mode 100644 index 17e2591..0000000 --- a/gerbonara/gerber/tests/test_gerber_statements.py +++ /dev/null @@ -1,903 +0,0 @@ -#! /usr/bin/env python -# -*- coding: utf-8 -*- - -# Author: Hamilton Kibbe <ham@hamiltonkib.be> - -import pytest -from ..gerber_statements import * -from ..cam import FileSettings - - -def test_Statement_smoketest(): - stmt = Statement("Test") - assert stmt.type == "Test" - stmt.to_metric() - assert "units=metric" in str(stmt) - stmt.to_inch() - assert "units=inch" in str(stmt) - stmt.to_metric() - stmt.offset(1, 1) - assert "type=Test" in str(stmt) - - -def test_FSParamStmt_factory(): - """ Test FSParamStruct factory - """ - stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"} - fs = FSParamStmt.from_dict(stmt) - assert fs.param == "FS" - assert fs.zero_suppression == "leading" - assert fs.notation == "absolute" - assert fs.format == (2, 7) - - stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "27"} - fs = FSParamStmt.from_dict(stmt) - assert fs.param == "FS" - assert fs.zero_suppression == "trailing" - assert fs.notation == "incremental" - assert fs.format == (2, 7) - - -def test_FSParamStmt(): - """ Test FSParamStmt initialization - """ - param = "FS" - zeros = "trailing" - notation = "absolute" - fmt = (2, 5) - stmt = FSParamStmt(param, zeros, notation, fmt) - assert stmt.param == param - assert stmt.zero_suppression == zeros - assert stmt.notation == notation - assert stmt.format == fmt - - -def test_FSParamStmt_dump(): - """ Test FSParamStmt to_gerber() - """ - stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"} - fs = FSParamStmt.from_dict(stmt) - assert fs.to_gerber() == "%FSLAX27Y27*%" - - stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "25"} - fs = FSParamStmt.from_dict(stmt) - assert fs.to_gerber() == "%FSTIX25Y25*%" - - settings = FileSettings(zero_suppression="leading", notation="absolute") - assert fs.to_gerber(settings) == "%FSLAX25Y25*%" - - -def test_FSParamStmt_string(): - """ Test FSParamStmt.__str__() - """ - stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"} - fs = FSParamStmt.from_dict(stmt) - assert str(fs) == "<Format Spec: 2:7 leading zero suppression absolute notation>" - - stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "25"} - fs = FSParamStmt.from_dict(stmt) - assert ( - str(fs) == "<Format Spec: 2:5 trailing zero suppression incremental notation>" - ) - - -def test_MOParamStmt_factory(): - """ Test MOParamStruct factory - """ - stmts = [{"param": "MO", "mo": "IN"}, {"param": "MO", "mo": "in"}] - for stmt in stmts: - mo = MOParamStmt.from_dict(stmt) - assert mo.param == "MO" - assert mo.mode == "inch" - - stmts = [{"param": "MO", "mo": "MM"}, {"param": "MO", "mo": "mm"}] - for stmt in stmts: - mo = MOParamStmt.from_dict(stmt) - assert mo.param == "MO" - assert mo.mode == "metric" - - stmt = {"param": "MO"} - mo = MOParamStmt.from_dict(stmt) - assert mo.mode == None - stmt = {"param": "MO", "mo": "degrees kelvin"} - pytest.raises(ValueError, MOParamStmt.from_dict, stmt) - - -def test_MOParamStmt(): - """ Test MOParamStmt initialization - """ - param = "MO" - mode = "inch" - stmt = MOParamStmt(param, mode) - assert stmt.param == param - - for mode in ["inch", "metric"]: - stmt = MOParamStmt(param, mode) - assert stmt.mode == mode - - -def test_MOParamStmt_dump(): - """ Test MOParamStmt to_gerber() - """ - stmt = {"param": "MO", "mo": "IN"} - mo = MOParamStmt.from_dict(stmt) - assert mo.to_gerber() == "%MOIN*%" - - stmt = {"param": "MO", "mo": "MM"} - mo = MOParamStmt.from_dict(stmt) - assert mo.to_gerber() == "%MOMM*%" - - -def test_MOParamStmt_conversion(): - stmt = {"param": "MO", "mo": "MM"} - mo = MOParamStmt.from_dict(stmt) - mo.to_inch() - assert mo.mode == "inch" - - stmt = {"param": "MO", "mo": "IN"} - mo = MOParamStmt.from_dict(stmt) - mo.to_metric() - assert mo.mode == "metric" - - -def test_MOParamStmt_string(): - """ Test MOParamStmt.__str__() - """ - stmt = {"param": "MO", "mo": "IN"} - mo = MOParamStmt.from_dict(stmt) - assert str(mo) == "<Mode: inches>" - - stmt = {"param": "MO", "mo": "MM"} - mo = MOParamStmt.from_dict(stmt) - assert str(mo) == "<Mode: millimeters>" - - -def test_IPParamStmt_factory(): - """ Test IPParamStruct factory - """ - stmt = {"param": "IP", "ip": "POS"} - ip = IPParamStmt.from_dict(stmt) - assert ip.ip == "positive" - - stmt = {"param": "IP", "ip": "NEG"} - ip = IPParamStmt.from_dict(stmt) - assert ip.ip == "negative" - - -def test_IPParamStmt(): - """ Test IPParamStmt initialization - """ - param = "IP" - for ip in ["positive", "negative"]: - stmt = IPParamStmt(param, ip) - assert stmt.param == param - assert stmt.ip == ip - - -def test_IPParamStmt_dump(): - """ Test IPParamStmt to_gerber() - """ - stmt = {"param": "IP", "ip": "POS"} - ip = IPParamStmt.from_dict(stmt) - assert ip.to_gerber() == "%IPPOS*%" - - stmt = {"param": "IP", "ip": "NEG"} - ip = IPParamStmt.from_dict(stmt) - assert ip.to_gerber() == "%IPNEG*%" - - -def test_IPParamStmt_string(): - stmt = {"param": "IP", "ip": "POS"} - ip = IPParamStmt.from_dict(stmt) - assert str(ip) == "<Image Polarity: positive>" - - stmt = {"param": "IP", "ip": "NEG"} - ip = IPParamStmt.from_dict(stmt) - assert str(ip) == "<Image Polarity: negative>" - - -def test_IRParamStmt_factory(): - stmt = {"param": "IR", "angle": "45"} - ir = IRParamStmt.from_dict(stmt) - assert ir.param == "IR" - assert ir.angle == 45 - - -def test_IRParamStmt_dump(): - stmt = {"param": "IR", "angle": "45"} - ir = IRParamStmt.from_dict(stmt) - assert ir.to_gerber() == "%IR45*%" - - -def test_IRParamStmt_string(): - stmt = {"param": "IR", "angle": "45"} - ir = IRParamStmt.from_dict(stmt) - assert str(ir) == "<Image Angle: 45>" - - -def test_OFParamStmt_factory(): - """ Test OFParamStmt factory - """ - stmt = {"param": "OF", "a": "0.1234567", "b": "0.1234567"} - of = OFParamStmt.from_dict(stmt) - assert of.a == 0.1234567 - assert of.b == 0.1234567 - - -def test_OFParamStmt(): - """ Test IPParamStmt initialization - """ - param = "OF" - for val in [0.0, -3.4567]: - stmt = OFParamStmt(param, val, val) - assert stmt.param == param - assert stmt.a == val - assert stmt.b == val - - -def test_OFParamStmt_dump(): - """ Test OFParamStmt to_gerber() - """ - stmt = {"param": "OF", "a": "0.123456", "b": "0.123456"} - of = OFParamStmt.from_dict(stmt) - assert of.to_gerber() == "%OFA0.12345B0.12345*%" - - -def test_OFParamStmt_conversion(): - stmt = {"param": "OF", "a": "2.54", "b": "25.4"} - of = OFParamStmt.from_dict(stmt) - of.units = "metric" - - # No effect - of.to_metric() - assert of.a == 2.54 - assert of.b == 25.4 - - of.to_inch() - assert of.units == "inch" - assert of.a == 0.1 - assert of.b == 1.0 - - # No effect - of.to_inch() - assert of.a == 0.1 - assert of.b == 1.0 - - stmt = {"param": "OF", "a": "0.1", "b": "1.0"} - of = OFParamStmt.from_dict(stmt) - of.units = "inch" - - # No effect - of.to_inch() - assert of.a == 0.1 - assert of.b == 1.0 - - of.to_metric() - assert of.units == "metric" - assert of.a == 2.54 - assert of.b == 25.4 - - # No effect - of.to_metric() - assert of.a == 2.54 - assert of.b == 25.4 - - -def test_OFParamStmt_offset(): - s = OFParamStmt("OF", 0, 0) - s.offset(1, 0) - assert s.a == 1.0 - assert s.b == 0.0 - s.offset(0, 1) - assert s.a == 1.0 - assert s.b == 1.0 - - -def test_OFParamStmt_string(): - """ Test OFParamStmt __str__ - """ - stmt = {"param": "OF", "a": "0.123456", "b": "0.123456"} - of = OFParamStmt.from_dict(stmt) - assert str(of) == "<Offset: X: 0.123456 Y: 0.123456 >" - - -def test_SFParamStmt_factory(): - stmt = {"param": "SF", "a": "1.4", "b": "0.9"} - sf = SFParamStmt.from_dict(stmt) - assert sf.param == "SF" - assert sf.a == 1.4 - assert sf.b == 0.9 - - -def test_SFParamStmt_dump(): - stmt = {"param": "SF", "a": "1.4", "b": "0.9"} - sf = SFParamStmt.from_dict(stmt) - assert sf.to_gerber() == "%SFA1.4B0.9*%" - - -def test_SFParamStmt_conversion(): - stmt = {"param": "OF", "a": "2.54", "b": "25.4"} - of = SFParamStmt.from_dict(stmt) - of.units = "metric" - of.to_metric() - - # No effect - assert of.a == 2.54 - assert of.b == 25.4 - - of.to_inch() - assert of.units == "inch" - assert of.a == 0.1 - assert of.b == 1.0 - - # No effect - of.to_inch() - assert of.a == 0.1 - assert of.b == 1.0 - - stmt = {"param": "OF", "a": "0.1", "b": "1.0"} - of = SFParamStmt.from_dict(stmt) - of.units = "inch" - - # No effect - of.to_inch() - assert of.a == 0.1 - assert of.b == 1.0 - - of.to_metric() - assert of.units == "metric" - assert of.a == 2.54 - assert of.b == 25.4 - - # No effect - of.to_metric() - assert of.a == 2.54 - assert of.b == 25.4 - - -def test_SFParamStmt_offset(): - s = SFParamStmt("OF", 0, 0) - s.offset(1, 0) - assert s.a == 1.0 - assert s.b == 0.0 - s.offset(0, 1) - assert s.a == 1.0 - assert s.b == 1.0 - - -def test_SFParamStmt_string(): - stmt = {"param": "SF", "a": "1.4", "b": "0.9"} - sf = SFParamStmt.from_dict(stmt) - assert str(sf) == "<Scale Factor: X: 1.4 Y: 0.9>" - - -def test_LPParamStmt_factory(): - """ Test LPParamStmt factory - """ - stmt = {"param": "LP", "lp": "C"} - lp = LPParamStmt.from_dict(stmt) - assert lp.lp == "clear" - - stmt = {"param": "LP", "lp": "D"} - lp = LPParamStmt.from_dict(stmt) - assert lp.lp == "dark" - - -def test_LPParamStmt_dump(): - """ Test LPParamStmt to_gerber() - """ - stmt = {"param": "LP", "lp": "C"} - lp = LPParamStmt.from_dict(stmt) - assert lp.to_gerber() == "%LPC*%" - - stmt = {"param": "LP", "lp": "D"} - lp = LPParamStmt.from_dict(stmt) - assert lp.to_gerber() == "%LPD*%" - - -def test_LPParamStmt_string(): - """ Test LPParamStmt.__str__() - """ - stmt = {"param": "LP", "lp": "D"} - lp = LPParamStmt.from_dict(stmt) - assert str(lp) == "<Level Polarity: dark>" - - stmt = {"param": "LP", "lp": "C"} - lp = LPParamStmt.from_dict(stmt) - assert str(lp) == "<Level Polarity: clear>" - - -def test_AMParamStmt_factory(): - name = "DONUTVAR" - macro = """0 Test Macro. * -1,1,1.5,0,0* -20,1,0.9,0,0.45,12,0.45,0* -21,1,6.8,1.2,3.4,0.6,0* -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* -7,0,0,7,6,0.2,0* -""" - s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm') - assert len(s.primitives) == 10 - assert isinstance(s.primitives[0], AMCommentPrimitive) - assert isinstance(s.primitives[1], AMCirclePrimitive) - assert isinstance(s.primitives[2], AMVectorLinePrimitive) - assert isinstance(s.primitives[3], AMCenterLinePrimitive) - assert isinstance(s.primitives[5], AMOutlinePrimitive) - assert isinstance(s.primitives[6], AMPolygonPrimitive) - assert isinstance(s.primitives[8], AMThermalPrimitive) - - -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}, units='mm') - assert s.to_gerber() == "%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%" - - # TODO - Store Equations and update on unit change... - s = AMParamStmt.from_dict({"param": "AM", "name": "OC8", "macro": "5,1,8,0,0,1.08239X$1,22.5"}, units='mm') - # assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,22.5*%') - assert s.to_gerber() == "%AMOC8*5,1,8,0,0,0,22.5*%" - - -def test_AMParamStmt_string(): - name = "POLYGON" - macro = "5,1,8,25.4,25.4,25.4,0*" - s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}, units='mm') - assert str(s) == "<Aperture Macro POLYGON: 5,1,8,25.4,25.4,25.4,0*>" - - -def test_ASParamStmt_factory(): - stmt = {"param": "AS", "mode": "AXBY"} - s = ASParamStmt.from_dict(stmt) - assert s.param == "AS" - assert s.mode == "AXBY" - - -def test_ASParamStmt_dump(): - stmt = {"param": "AS", "mode": "AXBY"} - s = ASParamStmt.from_dict(stmt) - assert s.to_gerber() == "%ASAXBY*%" - - -def test_ASParamStmt_string(): - stmt = {"param": "AS", "mode": "AXBY"} - s = ASParamStmt.from_dict(stmt) - assert str(s) == "<Axis Select: AXBY>" - - -def test_INParamStmt_factory(): - """ Test INParamStmt factory - """ - stmt = {"param": "IN", "name": "test"} - inp = INParamStmt.from_dict(stmt) - assert inp.name == "test" - - -def test_INParamStmt_dump(): - """ Test INParamStmt to_gerber() - """ - stmt = {"param": "IN", "name": "test"} - inp = INParamStmt.from_dict(stmt) - assert inp.to_gerber() == "%INtest*%" - - -def test_INParamStmt_string(): - stmt = {"param": "IN", "name": "test"} - inp = INParamStmt.from_dict(stmt) - assert str(inp) == "<Image Name: test>" - - -def test_LNParamStmt_factory(): - """ Test LNParamStmt factory - """ - stmt = {"param": "LN", "name": "test"} - lnp = LNParamStmt.from_dict(stmt) - assert lnp.name == "test" - - -def test_LNParamStmt_dump(): - """ Test LNParamStmt to_gerber() - """ - stmt = {"param": "LN", "name": "test"} - lnp = LNParamStmt.from_dict(stmt) - assert lnp.to_gerber() == "%LNtest*%" - - -def test_LNParamStmt_string(): - stmt = {"param": "LN", "name": "test"} - lnp = LNParamStmt.from_dict(stmt) - assert str(lnp) == "<Level Name: test>" - - -def test_comment_stmt(): - """ Test comment statement - """ - stmt = CommentStmt("A comment") - assert stmt.type == "COMMENT" - assert stmt.comment == "A comment" - - -def test_comment_stmt_dump(): - """ Test CommentStmt to_gerber() - """ - stmt = CommentStmt("A comment") - assert stmt.to_gerber() == "G04A comment*" - - -def test_comment_stmt_string(): - stmt = CommentStmt("A comment") - assert str(stmt) == "<Comment: A comment>" - - -def test_eofstmt(): - """ Test EofStmt - """ - stmt = EofStmt() - assert stmt.type == "EOF" - - -def test_eofstmt_dump(): - """ Test EofStmt to_gerber() - """ - stmt = EofStmt() - assert stmt.to_gerber() == "M02*" - - -def test_eofstmt_string(): - assert str(EofStmt()) == "<EOF Statement>" - - -def test_quadmodestmt_factory(): - """ Test QuadrantModeStmt.from_gerber() - """ - line = "G74*" - stmt = QuadrantModeStmt.from_gerber(line) - assert stmt.type == "QuadrantMode" - assert stmt.mode == "single-quadrant" - - line = "G75*" - stmt = QuadrantModeStmt.from_gerber(line) - assert stmt.mode == "multi-quadrant" - - -def test_quadmodestmt_validation(): - """ Test QuadrantModeStmt input validation - """ - line = "G76*" - pytest.raises(ValueError, QuadrantModeStmt.from_gerber, line) - pytest.raises(ValueError, QuadrantModeStmt, "quadrant-ful") - - -def test_quadmodestmt_dump(): - """ Test QuadrantModeStmt.to_gerber() - """ - for line in ("G74*", "G75*"): - stmt = QuadrantModeStmt.from_gerber(line) - assert stmt.to_gerber() == line - - -def test_regionmodestmt_factory(): - """ Test RegionModeStmt.from_gerber() - """ - line = "G36*" - stmt = RegionModeStmt.from_gerber(line) - assert stmt.type == "RegionMode" - assert stmt.mode == "on" - - line = "G37*" - stmt = RegionModeStmt.from_gerber(line) - assert stmt.mode == "off" - - -def test_regionmodestmt_validation(): - """ Test RegionModeStmt input validation - """ - line = "G38*" - pytest.raises(ValueError, RegionModeStmt.from_gerber, line) - pytest.raises(ValueError, RegionModeStmt, "off-ish") - - -def test_regionmodestmt_dump(): - """ Test RegionModeStmt.to_gerber() - """ - for line in ("G36*", "G37*"): - stmt = RegionModeStmt.from_gerber(line) - assert stmt.to_gerber() == line - - -def test_unknownstmt(): - """ Test UnknownStmt - """ - line = "G696969*" - stmt = UnknownStmt(line) - assert stmt.type == "UNKNOWN" - assert stmt.line == line - - -def test_unknownstmt_dump(): - """ Test UnknownStmt.to_gerber() - """ - lines = ("G696969*", "M03*") - for line in lines: - stmt = UnknownStmt(line) - assert stmt.to_gerber() == line - - -def test_statement_string(): - """ Test Statement.__str__() - """ - stmt = Statement("PARAM") - assert "type=PARAM" in str(stmt) - stmt.test = "PASS" - assert "test=PASS" in str(stmt) - assert "type=PARAM" in str(stmt) - - -def test_ADParamStmt_factory(): - """ Test ADParamStmt factory - """ - stmt = {"param": "AD", "d": 0, "shape": "C"} - ad = ADParamStmt.from_dict(stmt) - assert ad.d == 0 - assert ad.shape == "C" - - stmt = {"param": "AD", "d": 1, "shape": "R"} - ad = ADParamStmt.from_dict(stmt) - assert ad.d == 1 - assert ad.shape == "R" - - stmt = {"param": "AD", "d": 1, "shape": "C", "modifiers": "1.42"} - ad = ADParamStmt.from_dict(stmt) - assert ad.d == 1 - assert ad.shape == "C" - assert ad.modifiers == [(1.42,)] - - stmt = {"param": "AD", "d": 1, "shape": "C", "modifiers": "1.42X"} - ad = ADParamStmt.from_dict(stmt) - assert ad.d == 1 - assert ad.shape == "C" - assert ad.modifiers == [(1.42,)] - - stmt = {"param": "AD", "d": 1, "shape": "R", "modifiers": "1.42X1.24"} - ad = ADParamStmt.from_dict(stmt) - assert ad.d == 1 - assert ad.shape == "R" - assert ad.modifiers == [(1.42, 1.24)] - - -def test_ADParamStmt_conversion(): - stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "25.4X25.4,25.4X25.4"} - ad = ADParamStmt.from_dict(stmt) - ad.units = "metric" - - # No effect - ad.to_metric() - assert ad.modifiers[0] == (25.4, 25.4) - assert ad.modifiers[1] == (25.4, 25.4) - - ad.to_inch() - assert ad.units == "inch" - assert ad.modifiers[0] == (1.0, 1.0) - assert ad.modifiers[1] == (1.0, 1.0) - - # No effect - ad.to_inch() - assert ad.modifiers[0] == (1.0, 1.0) - assert ad.modifiers[1] == (1.0, 1.0) - - stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "1X1,1X1"} - ad = ADParamStmt.from_dict(stmt) - ad.units = "inch" - - # No effect - ad.to_inch() - assert ad.modifiers[0] == (1.0, 1.0) - assert ad.modifiers[1] == (1.0, 1.0) - - ad.to_metric() - assert ad.modifiers[0] == (25.4, 25.4) - assert ad.modifiers[1] == (25.4, 25.4) - - # No effect - ad.to_metric() - assert ad.modifiers[0] == (25.4, 25.4) - assert ad.modifiers[1] == (25.4, 25.4) - - -def test_ADParamStmt_dump(): - stmt = {"param": "AD", "d": 0, "shape": "C"} - ad = ADParamStmt.from_dict(stmt) - assert ad.to_gerber() == "%ADD0C*%" - stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "1X1,1X1"} - ad = ADParamStmt.from_dict(stmt) - assert ad.to_gerber() == "%ADD0C,1X1,1X1*%" - - -def test_ADPamramStmt_string(): - stmt = {"param": "AD", "d": 0, "shape": "C"} - ad = ADParamStmt.from_dict(stmt) - assert str(ad) == "<Aperture Definition: 0: circle>" - - stmt = {"param": "AD", "d": 0, "shape": "R"} - ad = ADParamStmt.from_dict(stmt) - assert str(ad) == "<Aperture Definition: 0: rectangle>" - - stmt = {"param": "AD", "d": 0, "shape": "O"} - ad = ADParamStmt.from_dict(stmt) - assert str(ad) == "<Aperture Definition: 0: obround>" - - stmt = {"param": "AD", "d": 0, "shape": "test"} - ad = ADParamStmt.from_dict(stmt) - assert str(ad) == "<Aperture Definition: 0: test>" - - -def test_MIParamStmt_factory(): - stmt = {"param": "MI", "a": 1, "b": 1} - mi = MIParamStmt.from_dict(stmt) - assert mi.a == 1 - assert mi.b == 1 - - -def test_MIParamStmt_dump(): - stmt = {"param": "MI", "a": 1, "b": 1} - mi = MIParamStmt.from_dict(stmt) - assert mi.to_gerber() == "%MIA1B1*%" - stmt = {"param": "MI", "a": 1} - mi = MIParamStmt.from_dict(stmt) - assert mi.to_gerber() == "%MIA1B0*%" - stmt = {"param": "MI", "b": 1} - mi = MIParamStmt.from_dict(stmt) - assert mi.to_gerber() == "%MIA0B1*%" - - -def test_MIParamStmt_string(): - stmt = {"param": "MI", "a": 1, "b": 1} - mi = MIParamStmt.from_dict(stmt) - assert str(mi) == "<Image Mirror: A=1 B=1>" - - stmt = {"param": "MI", "b": 1} - mi = MIParamStmt.from_dict(stmt) - assert str(mi) == "<Image Mirror: A=0 B=1>" - - stmt = {"param": "MI", "a": 1} - mi = MIParamStmt.from_dict(stmt) - assert str(mi) == "<Image Mirror: A=1 B=0>" - - -def test_coordstmt_ctor(): - cs = CoordStmt("G04", 0.0, 0.1, 0.2, 0.3, "D01", FileSettings()) - assert cs.function == "G04" - assert cs.x == 0.0 - assert cs.y == 0.1 - assert cs.i == 0.2 - assert cs.j == 0.3 - assert cs.op == "D01" - - -def test_coordstmt_factory(): - stmt = { - "function": "G04", - "x": "0", - "y": "001", - "i": "002", - "j": "003", - "op": "D01", - } - cs = CoordStmt.from_dict(stmt, FileSettings()) - assert cs.function == "G04" - assert cs.x == 0.0 - assert cs.y == 0.1 - assert cs.i == 0.2 - assert cs.j == 0.3 - assert cs.op == "D01" - - -def test_coordstmt_dump(): - cs = CoordStmt("G04", 0.0, 0.1, 0.2, 0.3, "D01", FileSettings()) - assert cs.to_gerber(FileSettings()) == "G04X0Y001I002J003D01*" - - -def test_coordstmt_conversion(): - cs = CoordStmt("G71", 25.4, 25.4, 25.4, 25.4, "D01", FileSettings()) - cs.units = "metric" - - # No effect - cs.to_metric() - assert cs.x == 25.4 - assert cs.y == 25.4 - assert cs.i == 25.4 - assert cs.j == 25.4 - assert cs.function == "G71" - - cs.to_inch() - assert cs.units == "inch" - assert cs.x == 1.0 - assert cs.y == 1.0 - assert cs.i == 1.0 - assert cs.j == 1.0 - assert cs.function == "G70" - - # No effect - cs.to_inch() - assert cs.x == 1.0 - assert cs.y == 1.0 - assert cs.i == 1.0 - assert cs.j == 1.0 - assert cs.function == "G70" - - cs = CoordStmt("G70", 1.0, 1.0, 1.0, 1.0, "D01", FileSettings()) - cs.units = "inch" - - # No effect - cs.to_inch() - assert cs.x == 1.0 - assert cs.y == 1.0 - assert cs.i == 1.0 - assert cs.j == 1.0 - assert cs.function == "G70" - - cs.to_metric() - assert cs.x == 25.4 - assert cs.y == 25.4 - assert cs.i == 25.4 - assert cs.j == 25.4 - assert cs.function == "G71" - - # No effect - cs.to_metric() - assert cs.x == 25.4 - assert cs.y == 25.4 - assert cs.i == 25.4 - assert cs.j == 25.4 - assert cs.function == "G71" - - -def test_coordstmt_offset(): - c = CoordStmt("G71", 0, 0, 0, 0, "D01", FileSettings()) - c.offset(1, 0) - assert c.x == 1.0 - assert c.y == 0.0 - assert c.i == 1.0 - assert c.j == 0.0 - c.offset(0, 1) - assert c.x == 1.0 - assert c.y == 1.0 - assert c.i == 1.0 - assert c.j == 1.0 - - -def test_coordstmt_string(): - cs = CoordStmt("G04", 0, 1, 2, 3, "D01", FileSettings()) - assert ( - str(cs) == "<Coordinate Statement: Fn: G04 X: 0 Y: 1 I: 2 J: 3 Op: Lights On>" - ) - cs = CoordStmt("G04", None, None, None, None, "D02", FileSettings()) - assert str(cs) == "<Coordinate Statement: Fn: G04 Op: Lights Off>" - cs = CoordStmt("G04", None, None, None, None, "D03", FileSettings()) - assert str(cs) == "<Coordinate Statement: Fn: G04 Op: Flash>" - cs = CoordStmt("G04", None, None, None, None, "TEST", FileSettings()) - assert str(cs) == "<Coordinate Statement: Fn: G04 Op: TEST>" - - -def test_aperturestmt_ctor(): - ast = ApertureStmt(3, False) - assert ast.d == 3 - assert ast.deprecated == False - ast = ApertureStmt(4, True) - assert ast.d == 4 - assert ast.deprecated == True - ast = ApertureStmt(4, 1) - assert ast.d == 4 - assert ast.deprecated == True - ast = ApertureStmt(3) - assert ast.d == 3 - assert ast.deprecated == False - - -def test_aperturestmt_dump(): - ast = ApertureStmt(3, False) - assert ast.to_gerber() == "D3*" - ast = ApertureStmt(3, True) - assert ast.to_gerber() == "G54D3*" - assert str(ast) == "<Aperture: 3>" diff --git a/gerbonara/gerber/tests/test_primitives.py b/gerbonara/gerber/tests/test_primitives.py deleted file mode 100644 index 3f8df51..0000000 --- a/gerbonara/gerber/tests/test_primitives.py +++ /dev/null @@ -1,897 +0,0 @@ -#! /usr/bin/env python -# -*- coding: utf-8 -*- - -# Author: Hamilton Kibbe <ham@hamiltonkib.be> - -import pytest -from operator import add -from ..primitives import * - - -def test_primitive_smoketest(): - p = Primitive() - try: - p.bounding_box - assert not True, "should have thrown the exception" - except NotImplementedError: - pass - # pytest.raises(NotImplementedError, p.bounding_box) - - p.to_metric() - p.to_inch() - # try: - # p.offset(1, 1) - # assert_false(True, 'should have thrown the exception') - # except NotImplementedError: - # pass - - -def test_line_angle(): - """ Test Line primitive angle calculation - """ - cases = [ - ((0, 0), (1, 0), math.radians(0)), - ((0, 0), (1, 1), math.radians(45)), - ((0, 0), (0, 1), math.radians(90)), - ((0, 0), (-1, 1), math.radians(135)), - ((0, 0), (-1, 0), math.radians(180)), - ((0, 0), (-1, -1), math.radians(225)), - ((0, 0), (0, -1), math.radians(270)), - ((0, 0), (1, -1), math.radians(315)), - ] - for start, end, expected in cases: - l = Line(start, end, 0) - line_angle = (l.angle + 2 * math.pi) % (2 * math.pi) - pytest.approx(line_angle, expected) - - -def test_line_bounds(): - """ Test Line primitive bounding box calculation - """ - cases = [ - ((0, 0), (1, 1), ((-1, -1), (2, 2))), - ((-1, -1), (1, 1), ((-2, -2), (2, 2))), - ((1, 1), (-1, -1), ((-2, -2), (2, 2))), - ((-1, 1), (1, -1), ((-2, -2), (2, 2))), - ] - - c = Circle((0, 0), 2) - r = Rectangle((0, 0), 2, 2) - for shape in (c, r): - for start, end, expected in cases: - l = Line(start, end, shape) - assert l.bounding_box == expected - # Test a non-square rectangle - r = Rectangle((0, 0), 3, 2) - cases = [ - ((0, 0), (1, 1), ((-1.5, -1), (2.5, 2))), - ((-1, -1), (1, 1), ((-2.5, -2), (2.5, 2))), - ((1, 1), (-1, -1), ((-2.5, -2), (2.5, 2))), - ((-1, 1), (1, -1), ((-2.5, -2), (2.5, 2))), - ] - for start, end, expected in cases: - l = Line(start, end, r) - assert l.bounding_box == expected - - -def test_line_vertices(): - c = Circle((0, 0), 2) - l = Line((0, 0), (1, 1), c) - assert l.vertices == None - - # All 4 compass points, all 4 quadrants and the case where start == end - test_cases = [ - ((0, 0), (1, 0), ((-1, -1), (-1, 1), (2, 1), (2, -1))), - ((0, 0), (1, 1), ((-1, -1), (-1, 1), (0, 2), (2, 2), (2, 0), (1, -1))), - ((0, 0), (0, 1), ((-1, -1), (-1, 2), (1, 2), (1, -1))), - ((0, 0), (-1, 1), ((-1, -1), (-2, 0), (-2, 2), (0, 2), (1, 1), (1, -1))), - ((0, 0), (-1, 0), ((-2, -1), (-2, 1), (1, 1), (1, -1))), - ((0, 0), (-1, -1), ((-2, -2), (1, -1), (1, 1), (-1, 1), (-2, 0), (0, -2))), - ((0, 0), (0, -1), ((-1, -2), (-1, 1), (1, 1), (1, -2))), - ((0, 0), (1, -1), ((-1, -1), (0, -2), (2, -2), (2, 0), (1, 1), (-1, 1))), - ((0, 0), (0, 0), ((-1, -1), (-1, 1), (1, 1), (1, -1))), - ] - r = Rectangle((0, 0), 2, 2) - - for start, end, vertices in test_cases: - l = Line(start, end, r) - assert set(vertices) == set(l.vertices) - - -def test_line_conversion(): - c = Circle((0, 0), 25.4, units="metric") - l = Line((2.54, 25.4), (254.0, 2540.0), c, units="metric") - - # No effect - l.to_metric() - assert l.start == (2.54, 25.4) - assert l.end == (254.0, 2540.0) - assert l.aperture.diameter == 25.4 - - l.to_inch() - assert l.start == (0.1, 1.0) - assert l.end == (10.0, 100.0) - assert l.aperture.diameter == 1.0 - - # No effect - l.to_inch() - assert l.start == (0.1, 1.0) - assert l.end == (10.0, 100.0) - assert l.aperture.diameter == 1.0 - - c = Circle((0, 0), 1.0, units="inch") - l = Line((0.1, 1.0), (10.0, 100.0), c, units="inch") - - # No effect - l.to_inch() - assert l.start == (0.1, 1.0) - assert l.end == (10.0, 100.0) - assert l.aperture.diameter == 1.0 - - l.to_metric() - assert l.start == (2.54, 25.4) - assert l.end == (254.0, 2540.0) - assert l.aperture.diameter == 25.4 - - # No effect - l.to_metric() - assert l.start == (2.54, 25.4) - assert l.end == (254.0, 2540.0) - assert l.aperture.diameter == 25.4 - - r = Rectangle((0, 0), 25.4, 254.0, units="metric") - l = Line((2.54, 25.4), (254.0, 2540.0), r, units="metric") - l.to_inch() - assert l.start == (0.1, 1.0) - assert l.end == (10.0, 100.0) - assert l.aperture.width == 1.0 - assert l.aperture.height == 10.0 - - r = Rectangle((0, 0), 1.0, 10.0, units="inch") - l = Line((0.1, 1.0), (10.0, 100.0), r, units="inch") - l.to_metric() - assert l.start == (2.54, 25.4) - assert l.end == (254.0, 2540.0) - assert l.aperture.width == 25.4 - assert l.aperture.height == 254.0 - - -def test_line_offset(): - c = Circle((0, 0), 1) - l = Line((0, 0), (1, 1), c) - l.offset(1, 0) - assert l.start == (1.0, 0.0) - assert l.end == (2.0, 1.0) - l.offset(0, 1) - assert l.start == (1.0, 1.0) - assert l.end == (2.0, 2.0) - - -def test_arc_radius(): - """ Test Arc primitive radius calculation - """ - cases = [((-3, 4), (5, 0), (0, 0), 5), ((0, 1), (1, 0), (0, 0), 1)] - - for start, end, center, radius in cases: - a = Arc(start, end, center, "clockwise", 0, "single-quadrant") - assert a.radius == radius - - -def test_arc_sweep_angle(): - """ Test Arc primitive sweep angle calculation - """ - cases = [ - ((1, 0), (0, 1), (0, 0), "counterclockwise", math.radians(90)), - ((1, 0), (0, 1), (0, 0), "clockwise", math.radians(270)), - ((1, 0), (-1, 0), (0, 0), "clockwise", math.radians(180)), - ((1, 0), (-1, 0), (0, 0), "counterclockwise", math.radians(180)), - ] - - for start, end, center, direction, sweep in cases: - c = Circle((0, 0), 1) - a = Arc(start, end, center, direction, c, "single-quadrant") - assert a.sweep_angle == sweep - - -def test_arc_bounds(): - """ Test Arc primitive bounding box calculation - """ - cases = [ - (( 1, 0), ( 0, 1), (0, 0), "clockwise", ((-1.5, -1.5), (1.5, 1.5))), - (( 1, 0), ( 0, 1), (0, 0), "counterclockwise", ((-0.5, -0.5), (1.5, 1.5))), - (( 0, 1), (-1, 0), (0, 0), "clockwise", ((-1.5, -1.5), (1.5, 1.5))), - (( 0, 1), (-1, 0), (0, 0), "counterclockwise", ((-1.5, -0.5), (0.5, 1.5))), - ((-1, 0), ( 0, -1), (0, 0), "clockwise", ((-1.5, -1.5), (1.5, 1.5))), - ((-1, 0), ( 0, -1), (0, 0), "counterclockwise", ((-1.5, -1.5), (0.5, 0.5))), - (( 0, -1), ( 1, 0), (0, 0), "clockwise", ((-1.5, -1.5), (1.5, 1.5))), - (( 0, -1), ( 1, 0), (0, 0), "counterclockwise", ((-0.5, -1.5), (1.5, 0.5))), - # Arcs with the same start and end point render a full circle - (( 1, 0), ( 1, 0), (0, 0), "clockwise", ((-1.5, -1.5), (1.5, 1.5))), - (( 1, 0), ( 1, 0), (0, 0), "counterclockwise", ((-1.5, -1.5), (1.5, 1.5))), - ] - for start, end, center, direction, bounds in cases: - c = Circle((0, 0), 1) - a = Arc(start, end, center, direction, c, "multi-quadrant") - assert a.bounding_box == bounds - - -def test_arc_bounds_no_aperture(): - """ Test Arc primitive bounding box calculation ignoring aperture - """ - cases = [ - ((1, 0), (0, 1), (0, 0), "clockwise", ((-1.0, -1.0), (1.0, 1.0))), - ((1, 0), (0, 1), (0, 0), "counterclockwise", ((0.0, 0.0), (1.0, 1.0))), - ((0, 1), (-1, 0), (0, 0), "clockwise", ((-1.0, -1.0), (1.0, 1.0))), - ((0, 1), (-1, 0), (0, 0), "counterclockwise", ((-1.0, 0.0), (0.0, 1.0))), - ((-1, 0), (0, -1), (0, 0), "clockwise", ((-1.0, -1.0), (1.0, 1.0))), - ((-1, 0), (0, -1), (0, 0), "counterclockwise", ((-1.0, -1.0), (0.0, 0.0))), - ((0, -1), (1, 0), (0, 0), "clockwise", ((-1.0, -1.0), (1.0, 1.0))), - ((0, -1), (1, 0), (0, 0), "counterclockwise", ((-0.0, -1.0), (1.0, 0.0))), - # Arcs with the same start and end point render a full circle - ((1, 0), (1, 0), (0, 0), "clockwise", ((-1.0, -1.0), (1.0, 1.0))), - ((1, 0), (1, 0), (0, 0), "counterclockwise", ((-1.0, -1.0), (1.0, 1.0))), - ] - for start, end, center, direction, bounds in cases: - c = Circle((0, 0), 1) - a = Arc(start, end, center, direction, c, "multi-quadrant") - assert a.bounding_box_no_aperture == bounds - - -def test_arc_conversion(): - c = Circle((0, 0), 25.4, units="metric") - a = Arc( - (2.54, 25.4), - (254.0, 2540.0), - (25400.0, 254000.0), - "clockwise", - c, - "single-quadrant", - units="metric", - ) - - # No effect - a.to_metric() - assert a.start == (2.54, 25.4) - assert a.end == (254.0, 2540.0) - assert a.center == (25400.0, 254000.0) - assert a.aperture.diameter == 25.4 - - a.to_inch() - assert a.start == (0.1, 1.0) - assert a.end == (10.0, 100.0) - assert a.center == (1000.0, 10000.0) - assert a.aperture.diameter == 1.0 - - # no effect - a.to_inch() - assert a.start == (0.1, 1.0) - assert a.end == (10.0, 100.0) - assert a.center == (1000.0, 10000.0) - assert a.aperture.diameter == 1.0 - - c = Circle((0, 0), 1.0, units="inch") - a = Arc( - (0.1, 1.0), - (10.0, 100.0), - (1000.0, 10000.0), - "clockwise", - c, - "single-quadrant", - units="inch", - ) - a.to_metric() - assert a.start == (2.54, 25.4) - assert a.end == (254.0, 2540.0) - assert a.center == (25400.0, 254000.0) - assert a.aperture.diameter == 25.4 - - -def test_arc_offset(): - c = Circle((0, 0), 1) - a = Arc((0, 0), (1, 1), (2, 2), "clockwise", c, "single-quadrant") - a.offset(1, 0) - assert a.start == (1.0, 0.0) - assert a.end == (2.0, 1.0) - assert a.center == (3.0, 2.0) - a.offset(0, 1) - assert a.start == (1.0, 1.0) - assert a.end == (2.0, 2.0) - assert a.center == (3.0, 3.0) - - -def test_circle_radius(): - """ Test Circle primitive radius calculation - """ - c = Circle((1, 1), 2) - assert c.radius == 1 - - -def test_circle_hole_radius(): - """ Test Circle primitive hole radius calculation - """ - c = Circle((1, 1), 4, 2) - assert c.hole_radius == 1 - - -def test_circle_bounds(): - """ Test Circle bounding box calculation - """ - c = Circle((1, 1), 2) - assert c.bounding_box == ((0, 0), (2, 2)) - - -def test_circle_conversion(): - """Circle conversion of units""" - # Circle initially metric, no hole - c = Circle((2.54, 25.4), 254.0, units="metric") - - c.to_metric() # shouldn't do antyhing - assert c.position == (2.54, 25.4) - assert c.diameter == 254.0 - assert c.hole_diameter == None - - c.to_inch() - assert c.position == (0.1, 1.0) - assert c.diameter == 10.0 - assert c.hole_diameter == None - - # no effect - c.to_inch() - assert c.position == (0.1, 1.0) - assert c.diameter == 10.0 - assert c.hole_diameter == None - - # Circle initially metric, with hole - c = Circle((2.54, 25.4), 254.0, 127.0, units="metric") - - c.to_metric() # shouldn't do antyhing - assert c.position == (2.54, 25.4) - assert c.diameter == 254.0 - assert c.hole_diameter == 127.0 - - c.to_inch() - assert c.position == (0.1, 1.0) - assert c.diameter == 10.0 - assert c.hole_diameter == 5.0 - - # no effect - c.to_inch() - assert c.position == (0.1, 1.0) - assert c.diameter == 10.0 - assert c.hole_diameter == 5.0 - - # Circle initially inch, no hole - c = Circle((0.1, 1.0), 10.0, units="inch") - # No effect - c.to_inch() - assert c.position == (0.1, 1.0) - assert c.diameter == 10.0 - assert c.hole_diameter == None - - c.to_metric() - assert c.position == (2.54, 25.4) - assert c.diameter == 254.0 - assert c.hole_diameter == None - - # no effect - c.to_metric() - assert c.position == (2.54, 25.4) - assert c.diameter == 254.0 - assert c.hole_diameter == None - - c = Circle((0.1, 1.0), 10.0, 5.0, units="inch") - # No effect - c.to_inch() - assert c.position == (0.1, 1.0) - assert c.diameter == 10.0 - assert c.hole_diameter == 5.0 - - c.to_metric() - assert c.position == (2.54, 25.4) - assert c.diameter == 254.0 - assert c.hole_diameter == 127.0 - - # no effect - c.to_metric() - assert c.position == (2.54, 25.4) - assert c.diameter == 254.0 - assert c.hole_diameter == 127.0 - - -def test_circle_offset(): - c = Circle((0, 0), 1) - c.offset(1, 0) - assert c.position == (1.0, 0.0) - c.offset(0, 1) - assert c.position == (1.0, 1.0) - - -def test_rectangle_ctor(): - """ Test rectangle creation - """ - test_cases = (((0, 0), 1, 1), ((0, 0), 1, 2), ((1, 1), 1, 2)) - for pos, width, height in test_cases: - r = Rectangle(pos, width, height) - assert r.position == pos - assert r.width == width - assert r.height == height - - -def test_rectangle_hole_radius(): - """ Test rectangle hole diameter calculation - """ - r = Rectangle((0, 0), 2, 2) - assert 0 == r.hole_radius - - r = Rectangle((0, 0), 2, 2, 1) - assert 0.5 == r.hole_radius - - -def test_rectangle_bounds(): - """ Test rectangle bounding box calculation - """ - r = Rectangle((0, 0), 2, 2) - bounds = r.bounding_box - pytest.approx(bounds[0], (-1, -1)) - pytest.approx(bounds[1], (1, 1)) - r = Rectangle((0, 0), 2, 2, rotation=45) - bounds = r.bounding_box - pytest.approx(bounds[0], (-math.sqrt(2), -math.sqrt(2))) - pytest.approx(bounds[1], (math.sqrt(2), math.sqrt(2))) - - -def test_rectangle_vertices(): - sqrt2 = math.sqrt(2.0) - TEST_VECTORS = [ - ((0, 0), 2.0, 2.0, 0.0, ((-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0))), - ((0, 0), 2.0, 3.0, 0.0, ((-1.0, -1.5), (-1.0, 1.5), (1.0, 1.5), (1.0, -1.5))), - ((0, 0), 2.0, 2.0, 90.0, ((-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0))), - ((0, 0), 3.0, 2.0, 90.0, ((-1.0, -1.5), (-1.0, 1.5), (1.0, 1.5), (1.0, -1.5))), - ( - (0, 0), - 2.0, - 2.0, - 45.0, - ((-sqrt2, 0.0), (0.0, sqrt2), (sqrt2, 0), (0, -sqrt2)), - ), - ] - for pos, width, height, rotation, expected in TEST_VECTORS: - r = Rectangle(pos, width, height, rotation=rotation) - for test, expect in zip(sorted(r.vertices), sorted(expected)): - pytest.approx(test, expect) - - r = Rectangle((0, 0), 2.0, 2.0, rotation=0.0) - r.rotation = 45.0 - for test, expect in zip( - sorted(r.vertices), - sorted(((-sqrt2, 0.0), (0.0, sqrt2), (sqrt2, 0), (0, -sqrt2))), - ): - pytest.approx(test, expect) - - -def test_rectangle_segments(): - - r = Rectangle((0, 0), 2.0, 2.0) - expected = [vtx for segment in r.segments for vtx in segment] - for vertex in r.vertices: - assert vertex in expected - - -def test_rectangle_conversion(): - """Test converting rectangles between units""" - - # Initially metric no hole - r = Rectangle((2.54, 25.4), 254.0, 2540.0, units="metric") - - r.to_metric() - assert r.position == (2.54, 25.4) - assert r.width == 254.0 - assert r.height == 2540.0 - - r.to_inch() - assert r.position == (0.1, 1.0) - assert r.width == 10.0 - assert r.height == 100.0 - - r.to_inch() - assert r.position == (0.1, 1.0) - assert r.width == 10.0 - assert r.height == 100.0 - - # Initially metric with hole - r = Rectangle((2.54, 25.4), 254.0, 2540.0, 127.0, units="metric") - - r.to_metric() - assert r.position == (2.54, 25.4) - assert r.width == 254.0 - assert r.height == 2540.0 - assert r.hole_diameter == 127.0 - - r.to_inch() - assert r.position == (0.1, 1.0) - assert r.width == 10.0 - assert r.height == 100.0 - assert r.hole_diameter == 5.0 - - r.to_inch() - assert r.position == (0.1, 1.0) - assert r.width == 10.0 - assert r.height == 100.0 - assert r.hole_diameter == 5.0 - - # Initially inch, no hole - r = Rectangle((0.1, 1.0), 10.0, 100.0, units="inch") - r.to_inch() - assert r.position == (0.1, 1.0) - assert r.width == 10.0 - assert r.height == 100.0 - - r.to_metric() - assert r.position == (2.54, 25.4) - assert r.width == 254.0 - assert r.height == 2540.0 - - r.to_metric() - assert r.position == (2.54, 25.4) - assert r.width == 254.0 - assert r.height == 2540.0 - - # Initially inch with hole - r = Rectangle((0.1, 1.0), 10.0, 100.0, 5.0, units="inch") - r.to_inch() - assert r.position == (0.1, 1.0) - assert r.width == 10.0 - assert r.height == 100.0 - assert r.hole_diameter == 5.0 - - r.to_metric() - assert r.position == (2.54, 25.4) - assert r.width == 254.0 - assert r.height == 2540.0 - assert r.hole_diameter == 127.0 - - r.to_metric() - assert r.position == (2.54, 25.4) - assert r.width == 254.0 - assert r.height == 2540.0 - assert r.hole_diameter == 127.0 - - -def test_rectangle_offset(): - r = Rectangle((0, 0), 1, 2) - r.offset(1, 0) - assert r.position == (1.0, 0.0) - r.offset(0, 1) - assert r.position == (1.0, 1.0) - - -def test_round_rectangle_ctor(): - """ Test round rectangle creation - """ - test_cases = ( - ((0, 0), 1, 1, 0.2, (True, True, False, False)), - ((0, 0), 1, 2, 0.3, (True, True, True, True)), - ((1, 1), 1, 2, 0.4, (False, False, False, False)), - ) - for pos, width, height, radius, corners in test_cases: - r = RoundRectangle(pos, width, height, radius, corners) - assert r.position == pos - assert r.width == width - assert r.height == height - assert r.radius == radius - pytest.approx(r.corners, corners) - - -def test_round_rectangle_bounds(): - """ Test round rectangle bounding box calculation - """ - r = RoundRectangle((0, 0), 2, 2, 0.2, (True, True, False, False)) - bounds = r.bounding_box - pytest.approx(bounds[0], (-1, -1)) - pytest.approx(bounds[1], (1, 1)) - r = RoundRectangle((0, 0), 2, 2, 0.2, (True, True, False, False), rotation=45) - bounds = r.bounding_box - pytest.approx(bounds[0], (-math.sqrt(2), -math.sqrt(2))) - pytest.approx(bounds[1], (math.sqrt(2), math.sqrt(2))) - - -def test_obround_ctor(): - """ Test obround creation - """ - test_cases = (((0, 0), 1, 1), ((0, 0), 1, 2), ((1, 1), 1, 2)) - for pos, width, height in test_cases: - o = Obround(pos, width, height) - assert o.position == pos - assert o.width == width - assert o.height == height - - -def test_obround_bounds(): - """ Test obround bounding box calculation - """ - o = Obround((2, 2), 2, 4) - bounds = o.bounding_box - pytest.approx(bounds[0], (1, 0)) - pytest.approx(bounds[1], (3, 4)) - o = Obround((2, 2), 4, 2) - bounds = o.bounding_box - pytest.approx(bounds[0], (0, 1)) - pytest.approx(bounds[1], (4, 3)) - - -def test_obround_orientation(): - o = Obround((0, 0), 2, 1) - assert o.orientation == "horizontal" - o = Obround((0, 0), 1, 2) - assert o.orientation == "vertical" - - -def test_obround_subshapes(): - o = Obround((0, 0), 1, 4) - ss = o.subshapes - pytest.approx(ss["rectangle"].position, (0, 0)) - pytest.approx(ss["circle1"].position, (0, 1.5)) - pytest.approx(ss["circle2"].position, (0, -1.5)) - o = Obround((0, 0), 4, 1) - ss = o.subshapes - pytest.approx(ss["rectangle"].position, (0, 0)) - pytest.approx(ss["circle1"].position, (1.5, 0)) - pytest.approx(ss["circle2"].position, (-1.5, 0)) - - -def test_obround_conversion(): - o = Obround((2.54, 25.4), 254.0, 2540.0, units="metric") - - # No effect - o.to_metric() - assert o.position == (2.54, 25.4) - assert o.width == 254.0 - assert o.height == 2540.0 - - o.to_inch() - assert o.position == (0.1, 1.0) - assert o.width == 10.0 - assert o.height == 100.0 - - # No effect - o.to_inch() - assert o.position == (0.1, 1.0) - assert o.width == 10.0 - assert o.height == 100.0 - - o = Obround((0.1, 1.0), 10.0, 100.0, units="inch") - - # No effect - o.to_inch() - assert o.position == (0.1, 1.0) - assert o.width == 10.0 - assert o.height == 100.0 - - o.to_metric() - assert o.position == (2.54, 25.4) - assert o.width == 254.0 - assert o.height == 2540.0 - - # No effect - o.to_metric() - assert o.position == (2.54, 25.4) - assert o.width == 254.0 - assert o.height == 2540.0 - - -def test_obround_offset(): - o = Obround((0, 0), 1, 2) - o.offset(1, 0) - assert o.position == (1.0, 0.0) - o.offset(0, 1) - assert o.position == (1.0, 1.0) - - -def test_polygon_ctor(): - """ Test polygon creation - """ - test_cases = (((0, 0), 3, 5, 0), ((0, 0), 5, 6, 0), ((1, 1), 7, 7, 45)) - for pos, sides, radius, hole_diameter in test_cases: - p = Polygon(pos, sides, radius, hole_diameter) - assert p.position == pos - assert p.sides == sides - assert p.radius == radius - assert p.hole_diameter == hole_diameter - - -def test_polygon_bounds(): - """ Test polygon bounding box calculation - """ - p = Polygon((2, 2), 3, 2, 0) - bounds = p.bounding_box - pytest.approx(bounds[0], (0, 0)) - pytest.approx(bounds[0], (4, 4)) - p = Polygon((2, 2), 3, 4, 0) - bounds = p.bounding_box - pytest.approx(bounds[0], (-2, -2)) - pytest.approx(bounds[1], (6, 6)) - - -def test_polygon_conversion(): - p = Polygon((2.54, 25.4), 3, 254.0, 0, units="metric") - - # No effect - p.to_metric() - assert p.position == (2.54, 25.4) - assert p.radius == 254.0 - - p.to_inch() - assert p.position == (0.1, 1.0) - assert p.radius == 10.0 - - # No effect - p.to_inch() - assert p.position == (0.1, 1.0) - assert p.radius == 10.0 - - p = Polygon((0.1, 1.0), 3, 10.0, 0, units="inch") - - # No effect - p.to_inch() - assert p.position == (0.1, 1.0) - assert p.radius == 10.0 - - p.to_metric() - assert p.position == (2.54, 25.4) - assert p.radius == 254.0 - - # No effect - p.to_metric() - assert p.position == (2.54, 25.4) - assert p.radius == 254.0 - - -def test_polygon_offset(): - p = Polygon((0, 0), 5, 10, 0) - p.offset(1, 0) - assert p.position == (1.0, 0.0) - p.offset(0, 1) - assert p.position == (1.0, 1.0) - - -def test_region_ctor(): - """ Test Region creation - """ - apt = Circle((0, 0), 0) - lines = ( - Line((0, 0), (1, 0), apt), - Line((1, 0), (1, 1), apt), - Line((1, 1), (0, 1), apt), - Line((0, 1), (0, 0), apt), - ) - points = ((0, 0), (1, 0), (1, 1), (0, 1)) - r = Region(lines) - for i, p in enumerate(lines): - assert r.primitives[i] == p - - -def test_region_bounds(): - """ Test region bounding box calculation - """ - apt = Circle((0, 0), 0) - lines = ( - Line((0, 0), (1, 0), apt), - Line((1, 0), (1, 1), apt), - Line((1, 1), (0, 1), apt), - Line((0, 1), (0, 0), apt), - ) - r = Region(lines) - bounds = r.bounding_box - pytest.approx(bounds[0], (0, 0)) - pytest.approx(bounds[1], (1, 1)) - - -def test_region_offset(): - apt = Circle((0, 0), 0) - lines = ( - Line((0, 0), (1, 0), apt), - Line((1, 0), (1, 1), apt), - Line((1, 1), (0, 1), apt), - Line((0, 1), (0, 0), apt), - ) - r = Region(lines) - xlim, ylim = r.bounding_box - r.offset(0, 1) - new_xlim, new_ylim = r.bounding_box - pytest.approx(new_xlim, xlim) - pytest.approx(new_ylim, tuple([y + 1 for y in ylim])) - - -def test_drill_ctor(): - """ Test drill primitive creation - """ - test_cases = (((0, 0), 2), ((1, 1), 3), ((2, 2), 5)) - for position, diameter in test_cases: - d = Drill(position, diameter) - assert d.position == position - assert d.diameter == diameter - assert d.radius == diameter / 2.0 - - -def test_drill_ctor_validation(): - """ Test drill argument validation - """ - pytest.raises(TypeError, Drill, 3, 5) - pytest.raises(TypeError, Drill, (3, 4, 5), 5) - - -def test_drill_bounds(): - d = Drill((0, 0), 2) - bounds = d.bounding_box - pytest.approx(bounds[0], (-1, -1)) - pytest.approx(bounds[1], (1, 1)) - d = Drill((1, 2), 2) - bounds = d.bounding_box - pytest.approx(bounds[0], (0, 1)) - pytest.approx(bounds[1], (2, 3)) - - -def test_drill_conversion(): - d = Drill((2.54, 25.4), 254.0, units="metric") - - # No effect - d.to_metric() - assert d.position == (2.54, 25.4) - assert d.diameter == 254.0 - - d.to_inch() - assert d.position == (0.1, 1.0) - assert d.diameter == 10.0 - - # No effect - d.to_inch() - assert d.position == (0.1, 1.0) - assert d.diameter == 10.0 - - d = Drill((0.1, 1.0), 10.0, units="inch") - - # No effect - d.to_inch() - assert d.position == (0.1, 1.0) - assert d.diameter == 10.0 - - d.to_metric() - assert d.position == (2.54, 25.4) - assert d.diameter == 254.0 - - # No effect - d.to_metric() - assert d.position == (2.54, 25.4) - assert d.diameter == 254.0 - - -def test_drill_offset(): - d = Drill((0, 0), 1.0) - d.offset(1, 0) - assert d.position == (1.0, 0.0) - d.offset(0, 1) - assert d.position == (1.0, 1.0) - - -def test_drill_equality(): - d = Drill((2.54, 25.4), 254.0) - d1 = Drill((2.54, 25.4), 254.0) - assert d == d1 - d1 = Drill((2.54, 25.4), 254.2) - assert d != d1 - - -def test_slot_bounds(): - """ Test Slot primitive bounding box calculation - """ - cases = [ - (( 0, 0), ( 1, 1), ((-1, -1), (2, 2))), - ((-1, -1), ( 1, 1), ((-2, -2), (2, 2))), - (( 1, 1), (-1, -1), ((-2, -2), (2, 2))), - ((-1, 1), ( 1, -1), ((-2, -2), (2, 2))), - ] - - for start, end, expected in cases: - s = Slot(start, end, 2.0) - assert s.bounding_box == expected - |