From 597427d785d6f44348fe15631f2c184504195fb0 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Mon, 6 Oct 2014 08:33:53 -0400 Subject: add excellon statements --- gerber/tests/test_gerber_statements.py | 96 ++++++++++++++++++++++++++++++++++ 1 file changed, 96 insertions(+) create mode 100644 gerber/tests/test_gerber_statements.py (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py new file mode 100644 index 0000000..121aa42 --- /dev/null +++ b/gerber/tests/test_gerber_statements.py @@ -0,0 +1,96 @@ +#! /usr/bin/env python +# -*- coding: utf-8 -*- + +# Author: Hamilton Kibbe + +from .tests import * +from ..gerber_statements import * + + +def test_FSParamStmt_factory(): + """ Test FSParamStruct factory correctly handles parameters + """ + stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'} + fs = FSParamStmt.from_dict(stmt) + assert_equal(fs.param, 'FS') + assert_equal(fs.zero_suppression, 'leading') + assert_equal(fs.notation, 'absolute') + assert_equal(fs.format, (2, 7)) + + stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '27'} + fs = FSParamStmt.from_dict(stmt) + assert_equal(fs.param, 'FS') + assert_equal(fs.zero_suppression, 'trailing') + assert_equal(fs.notation, 'incremental') + assert_equal(fs.format, (2, 7)) + + +def test_FSParamStmt_dump(): + """ Test FSParamStmt to_gerber() + """ + stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'} + fs = FSParamStmt.from_dict(stmt) + assert_equal(fs.to_gerber(), '%FSLAX27Y27*%') + + stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'} + fs = FSParamStmt.from_dict(stmt) + assert_equal(fs.to_gerber(), '%FSTIX25Y25*%') + + +def test_MOParamStmt_factory(): + """ Test MOParamStruct factory correctly handles parameters + """ + stmt = {'param': 'MO', 'mo': 'IN'} + mo = MOParamStmt.from_dict(stmt) + assert_equal(mo.param, 'MO') + assert_equal(mo.mode, 'inch') + + stmt = {'param': 'MO', 'mo': 'MM'} + mo = MOParamStmt.from_dict(stmt) + assert_equal(mo.param, 'MO') + assert_equal(mo.mode, 'metric') + + +def test_MOParamStmt_dump(): + """ Test MOParamStmt to_gerber() + """ + stmt = {'param': 'MO', 'mo': 'IN'} + mo = MOParamStmt.from_dict(stmt) + assert_equal(mo.to_gerber(), '%MOIN*%') + + stmt = {'param': 'MO', 'mo': 'MM'} + mo = MOParamStmt.from_dict(stmt) + assert_equal(mo.to_gerber(), '%MOMM*%') + + +def test_IPParamStmt_factory(): + """ Test IPParamStruct factory correctly handles parameters + """ + stmt = {'param': 'IP', 'ip': 'POS'} + ip = IPParamStmt.from_dict(stmt) + assert_equal(ip.ip, 'positive') + + stmt = {'param': 'IP', 'ip': 'NEG'} + ip = IPParamStmt.from_dict(stmt) + assert_equal(ip.ip, 'negative') + + +def test_IPParamStmt_dump(): + """ Test IPParamStmt to_gerber() + """ + stmt = {'param': 'IP', 'ip': 'POS'} + ip = IPParamStmt.from_dict(stmt) + assert_equal(ip.to_gerber(), '%IPPOS*%') + + stmt = {'param': 'IP', 'ip': 'NEG'} + ip = IPParamStmt.from_dict(stmt) + assert_equal(ip.to_gerber(), '%IPNEG*%') + + +def test_OFParamStmt_dump(): + """ Test OFParamStmt to_gerber() + """ + stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'} + of = OFParamStmt.from_dict(stmt) + assert_equal(of.to_gerber(), '%OFA0.123456B0.123456*%') + -- cgit From 2abb7159be80beb0565d35e856f3279d2f1f693b Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Mon, 6 Oct 2014 23:52:57 -0400 Subject: add tests --- gerber/tests/test_gerber_statements.py | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 121aa42..7495ba7 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -87,6 +87,15 @@ def test_IPParamStmt_dump(): assert_equal(ip.to_gerber(), '%IPNEG*%') +def test_OFParamStmt_factory(): + """ Test OFParamStmt factory correctly handles parameters + """ + stmt = {'param': 'OF', 'a': '0.1234567', 'b':'0.1234567'} + of = OFParamStmt.from_dict(stmt) + assert_equal(of.a, 0.1234567) + assert_equal(of.b, 0.1234567) + + def test_OFParamStmt_dump(): """ Test OFParamStmt to_gerber() """ -- cgit From f7c19398730d95bd4f34834ebcf66d9a68273055 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Tue, 7 Oct 2014 00:16:39 -0400 Subject: add tests --- gerber/tests/test_gerber_statements.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 7495ba7..7c01130 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -90,7 +90,7 @@ def test_IPParamStmt_dump(): def test_OFParamStmt_factory(): """ Test OFParamStmt factory correctly handles parameters """ - stmt = {'param': 'OF', 'a': '0.1234567', 'b':'0.1234567'} + stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'} of = OFParamStmt.from_dict(stmt) assert_equal(of.a, 0.1234567) assert_equal(of.b, 0.1234567) @@ -102,4 +102,3 @@ def test_OFParamStmt_dump(): stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'} of = OFParamStmt.from_dict(stmt) assert_equal(of.to_gerber(), '%OFA0.123456B0.123456*%') - -- cgit From 1750c3c60aeffc813dad8191ceabcdb90dd2e0a6 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Fri, 10 Oct 2014 13:07:54 -0400 Subject: Add tests --- gerber/tests/test_gerber_statements.py | 155 +++++++++++++++++++++++++++++++++ 1 file changed, 155 insertions(+) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 7c01130..9e73fd4 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -102,3 +102,158 @@ def test_OFParamStmt_dump(): stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'} of = OFParamStmt.from_dict(stmt) assert_equal(of.to_gerber(), '%OFA0.123456B0.123456*%') + + +def test_LPParamStmt_factory(): + """ Test LPParamStmt factory correctly handles parameters + """ + stmt = {'param': 'LP', 'lp': 'C'} + lp = LPParamStmt.from_dict(stmt) + assert_equal(lp.lp, 'clear') + + stmt = {'param': 'LP', 'lp': 'D'} + lp = LPParamStmt.from_dict(stmt) + assert_equal(lp.lp, 'dark') + +def test_LPParamStmt_dump(): + """ Test LPParamStmt to_gerber() + """ + stmt = {'param': 'LP', 'lp': 'C'} + lp = LPParamStmt.from_dict(stmt) + assert_equal(lp.to_gerber(), '%LPC*%') + + stmt = {'param': 'LP', 'lp': 'D'} + lp = LPParamStmt.from_dict(stmt) + assert_equal(lp.to_gerber(), '%LPD*%') + + +def test_INParamStmt_factory(): + """ Test INParamStmt factory correctly handles parameters + """ + stmt = {'param': 'IN', 'name': 'test'} + inp = INParamStmt.from_dict(stmt) + assert_equal(inp.name, 'test') + +def test_INParamStmt_dump(): + """ Test INParamStmt to_gerber() + """ + stmt = {'param': 'IN', 'name': 'test'} + inp = INParamStmt.from_dict(stmt) + assert_equal(inp.to_gerber(), '%INtest*%') + + +def test_LNParamStmt_factory(): + """ Test LNParamStmt factory correctly handles parameters + """ + stmt = {'param': 'LN', 'name': 'test'} + lnp = LNParamStmt.from_dict(stmt) + assert_equal(lnp.name, 'test') + +def test_LNParamStmt_dump(): + """ Test LNParamStmt to_gerber() + """ + stmt = {'param': 'LN', 'name': 'test'} + lnp = LNParamStmt.from_dict(stmt) + assert_equal(lnp.to_gerber(), '%LNtest*%') + +def test_comment_stmt(): + """ Test comment statement + """ + stmt = CommentStmt('A comment') + assert_equal(stmt.type, 'COMMENT') + assert_equal(stmt.comment, 'A comment') + +def test_comment_stmt_dump(): + """ Test CommentStmt to_gerber() + """ + stmt = CommentStmt('A comment') + assert_equal(stmt.to_gerber(), 'G04A comment*') + + +def test_eofstmt(): + """ Test EofStmt + """ + stmt = EofStmt() + assert_equal(stmt.type, 'EOF') + +def test_eofstmt_dump(): + """ Test EofStmt to_gerber() + """ + stmt = EofStmt() + assert_equal(stmt.to_gerber(), 'M02*') + + +def test_quadmodestmt_factory(): + """ Test QuadrantModeStmt.from_gerber() + """ + line = 'G74*' + stmt = QuadrantModeStmt.from_gerber(line) + assert_equal(stmt.type, 'QuadrantMode') + assert_equal(stmt.mode, 'single-quadrant') + + line = 'G75*' + stmt = QuadrantModeStmt.from_gerber(line) + assert_equal(stmt.mode, 'multi-quadrant') + +def test_quadmodestmt_validation(): + """ Test QuadrantModeStmt input validation + """ + line = 'G76*' + assert_raises(ValueError, QuadrantModeStmt.from_gerber, line) + assert_raises(ValueError, QuadrantModeStmt, 'quadrant-ful') + + +def test_quadmodestmt_dump(): + """ Test QuadrantModeStmt.to_gerber() + """ + for line in ('G74*', 'G75*',): + stmt = QuadrantModeStmt.from_gerber(line) + assert_equal(stmt.to_gerber(), line) + + +def test_regionmodestmt_factory(): + """ Test RegionModeStmt.from_gerber() + """ + line = 'G36*' + stmt = RegionModeStmt.from_gerber(line) + assert_equal(stmt.type, 'RegionMode') + assert_equal(stmt.mode, 'on') + + line = 'G37*' + stmt = RegionModeStmt.from_gerber(line) + assert_equal(stmt.mode, 'off') + + +def test_regionmodestmt_validation(): + """ Test RegionModeStmt input validation + """ + line = 'G38*' + assert_raises(ValueError, RegionModeStmt.from_gerber, line) + assert_raises(ValueError, RegionModeStmt, 'off-ish') + + +def test_regionmodestmt_dump(): + """ Test RegionModeStmt.to_gerber() + """ + for line in ('G36*', 'G37*',): + stmt = RegionModeStmt.from_gerber(line) + assert_equal(stmt.to_gerber(), line) + + +def test_unknownstmt(): + """ Test UnknownStmt + """ + line = 'G696969*' + stmt = UnknownStmt(line) + assert_equal(stmt.type, 'UNKNOWN') + assert_equal(stmt.line, line) + + +def test_unknownstmt_dump(): + """ Test UnknownStmt.to_gerber() + """ + lines = ('G696969*', 'M03*',) + for line in lines: + stmt = UnknownStmt(line) + assert_equal(stmt.to_gerber(), line) + -- cgit From ae3bbff8b0849e0b49dc139396d7f8c57334a7b8 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Fri, 10 Oct 2014 23:07:51 -0400 Subject: Added excellon format detection --- gerber/tests/test_gerber_statements.py | 76 +++++++++++++++++++++++++++------- 1 file changed, 60 insertions(+), 16 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 9e73fd4..a463c9d 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -8,7 +8,7 @@ from ..gerber_statements import * def test_FSParamStmt_factory(): - """ Test FSParamStruct factory correctly handles parameters + """ Test FSParamStruct factory """ stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'} fs = FSParamStmt.from_dict(stmt) @@ -24,6 +24,18 @@ def test_FSParamStmt_factory(): assert_equal(fs.notation, 'incremental') assert_equal(fs.format, (2, 7)) +def test_FSParamStmt(): + """ Test FSParamStmt initialization + """ + param = 'FS' + zeros = 'trailing' + notation = 'absolute' + fmt = (2, 5) + stmt = FSParamStmt(param, zeros, notation, fmt) + assert_equal(stmt.param, param) + assert_equal(stmt.zero_suppression, zeros) + assert_equal(stmt.notation, notation) + assert_equal(stmt.format, fmt) def test_FSParamStmt_dump(): """ Test FSParamStmt to_gerber() @@ -38,17 +50,31 @@ def test_FSParamStmt_dump(): def test_MOParamStmt_factory(): - """ Test MOParamStruct factory correctly handles parameters + """ Test MOParamStruct factory """ - stmt = {'param': 'MO', 'mo': 'IN'} - mo = MOParamStmt.from_dict(stmt) - assert_equal(mo.param, 'MO') - assert_equal(mo.mode, 'inch') + stmts = [{'param': 'MO', 'mo': 'IN'}, {'param': 'MO', 'mo': 'in'}, ] + for stmt in stmts: + mo = MOParamStmt.from_dict(stmt) + assert_equal(mo.param, 'MO') + assert_equal(mo.mode, 'inch') + + stmts = [{'param': 'MO', 'mo': 'MM'}, {'param': 'MO', 'mo': 'mm'}, ] + for stmt in stmts: + mo = MOParamStmt.from_dict(stmt) + assert_equal(mo.param, 'MO') + assert_equal(mo.mode, 'metric') + +def test_MOParamStmt(): + """ Test MOParamStmt initialization + """ + param = 'MO' + mode = 'inch' + stmt = MOParamStmt(param, mode) + assert_equal(stmt.param, param) - stmt = {'param': 'MO', 'mo': 'MM'} - mo = MOParamStmt.from_dict(stmt) - assert_equal(mo.param, 'MO') - assert_equal(mo.mode, 'metric') + for mode in ['inch', 'metric']: + stmt = MOParamStmt(param, mode) + assert_equal(stmt.mode, mode) def test_MOParamStmt_dump(): @@ -64,7 +90,7 @@ def test_MOParamStmt_dump(): def test_IPParamStmt_factory(): - """ Test IPParamStruct factory correctly handles parameters + """ Test IPParamStruct factory """ stmt = {'param': 'IP', 'ip': 'POS'} ip = IPParamStmt.from_dict(stmt) @@ -74,6 +100,15 @@ def test_IPParamStmt_factory(): ip = IPParamStmt.from_dict(stmt) assert_equal(ip.ip, 'negative') +def test_IPParamStmt(): + """ Test IPParamStmt initialization + """ + param = 'IP' + for ip in ['positive', 'negative']: + stmt = IPParamStmt(param, ip) + assert_equal(stmt.param, param) + assert_equal(stmt.ip, ip) + def test_IPParamStmt_dump(): """ Test IPParamStmt to_gerber() @@ -88,14 +123,23 @@ def test_IPParamStmt_dump(): def test_OFParamStmt_factory(): - """ Test OFParamStmt factory correctly handles parameters + """ Test OFParamStmt factory """ stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'} of = OFParamStmt.from_dict(stmt) assert_equal(of.a, 0.1234567) assert_equal(of.b, 0.1234567) - +def test_OFParamStmt(): + """ Test IPParamStmt initialization + """ + param = 'OF' + for val in [0.0, -3.4567]: + stmt = OFParamStmt(param, val, val) + assert_equal(stmt.param, param) + assert_equal(stmt.a, val) + assert_equal(stmt.b, val) + def test_OFParamStmt_dump(): """ Test OFParamStmt to_gerber() """ @@ -105,7 +149,7 @@ def test_OFParamStmt_dump(): def test_LPParamStmt_factory(): - """ Test LPParamStmt factory correctly handles parameters + """ Test LPParamStmt factory """ stmt = {'param': 'LP', 'lp': 'C'} lp = LPParamStmt.from_dict(stmt) @@ -128,7 +172,7 @@ def test_LPParamStmt_dump(): def test_INParamStmt_factory(): - """ Test INParamStmt factory correctly handles parameters + """ Test INParamStmt factory """ stmt = {'param': 'IN', 'name': 'test'} inp = INParamStmt.from_dict(stmt) @@ -143,7 +187,7 @@ def test_INParamStmt_dump(): def test_LNParamStmt_factory(): - """ Test LNParamStmt factory correctly handles parameters + """ Test LNParamStmt factory """ stmt = {'param': 'LN', 'name': 'test'} lnp = LNParamStmt.from_dict(stmt) -- cgit From ab69ee0172353e64fbe5099a974341e88feaf24b Mon Sep 17 00:00:00 2001 From: Paulo Henrique Silva Date: Mon, 10 Nov 2014 12:24:09 -0200 Subject: Bunch of small fixes to improve Gerber read/write. --- gerber/tests/test_gerber_statements.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index a463c9d..62b99b4 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -123,7 +123,7 @@ def test_IPParamStmt_dump(): def test_OFParamStmt_factory(): - """ Test OFParamStmt factory + """ Test OFParamStmt factory """ stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'} of = OFParamStmt.from_dict(stmt) @@ -139,13 +139,13 @@ def test_OFParamStmt(): assert_equal(stmt.param, param) assert_equal(stmt.a, val) assert_equal(stmt.b, val) - + def test_OFParamStmt_dump(): """ Test OFParamStmt to_gerber() """ - stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'} + stmt = {'param': 'OF', 'a': '0.123456', 'b': '0.123456'} of = OFParamStmt.from_dict(stmt) - assert_equal(of.to_gerber(), '%OFA0.123456B0.123456*%') + assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%') def test_LPParamStmt_factory(): -- cgit From c054136a6531404e3b20aadbc7fba2ec25b50a4a Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Mon, 26 Jan 2015 22:16:00 -0500 Subject: Added some tests --- gerber/tests/test_gerber_statements.py | 111 +++++++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 62b99b4..c346ace 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -5,6 +5,7 @@ from .tests import * from ..gerber_statements import * +from ..cam import FileSettings def test_FSParamStmt_factory(): @@ -24,6 +25,7 @@ def test_FSParamStmt_factory(): assert_equal(fs.notation, 'incremental') assert_equal(fs.format, (2, 7)) + def test_FSParamStmt(): """ Test FSParamStmt initialization """ @@ -37,6 +39,7 @@ def test_FSParamStmt(): assert_equal(stmt.notation, notation) assert_equal(stmt.format, fmt) + def test_FSParamStmt_dump(): """ Test FSParamStmt to_gerber() """ @@ -48,6 +51,21 @@ def test_FSParamStmt_dump(): fs = FSParamStmt.from_dict(stmt) assert_equal(fs.to_gerber(), '%FSTIX25Y25*%') + settings = FileSettings(zero_suppression='leading', notation='absolute') + assert_equal(fs.to_gerber(settings), '%FSLAX25Y25*%') + + +def test_FSParamStmt_string(): + """ Test FSParamStmt.__str__() + """ + stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'} + fs = FSParamStmt.from_dict(stmt) + assert_equal(str(fs), '') + + stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'} + fs = FSParamStmt.from_dict(stmt) + assert_equal(str(fs), '') + def test_MOParamStmt_factory(): """ Test MOParamStruct factory @@ -64,6 +82,7 @@ def test_MOParamStmt_factory(): assert_equal(mo.param, 'MO') assert_equal(mo.mode, 'metric') + def test_MOParamStmt(): """ Test MOParamStmt initialization """ @@ -89,6 +108,18 @@ def test_MOParamStmt_dump(): assert_equal(mo.to_gerber(), '%MOMM*%') +def test_MOParamStmt_string(): + """ Test MOParamStmt.__str__() + """ + stmt = {'param': 'MO', 'mo': 'IN'} + mo = MOParamStmt.from_dict(stmt) + assert_equal(str(mo), '') + + stmt = {'param': 'MO', 'mo': 'MM'} + mo = MOParamStmt.from_dict(stmt) + assert_equal(str(mo), '') + + def test_IPParamStmt_factory(): """ Test IPParamStruct factory """ @@ -100,6 +131,7 @@ def test_IPParamStmt_factory(): ip = IPParamStmt.from_dict(stmt) assert_equal(ip.ip, 'negative') + def test_IPParamStmt(): """ Test IPParamStmt initialization """ @@ -130,6 +162,7 @@ def test_OFParamStmt_factory(): assert_equal(of.a, 0.1234567) assert_equal(of.b, 0.1234567) + def test_OFParamStmt(): """ Test IPParamStmt initialization """ @@ -140,6 +173,7 @@ def test_OFParamStmt(): assert_equal(stmt.a, val) assert_equal(stmt.b, val) + def test_OFParamStmt_dump(): """ Test OFParamStmt to_gerber() """ @@ -159,6 +193,7 @@ def test_LPParamStmt_factory(): lp = LPParamStmt.from_dict(stmt) assert_equal(lp.lp, 'dark') + def test_LPParamStmt_dump(): """ Test LPParamStmt to_gerber() """ @@ -171,6 +206,18 @@ def test_LPParamStmt_dump(): assert_equal(lp.to_gerber(), '%LPD*%') +def test_LPParamStmt_string(): + """ Test LPParamStmt.__str__() + """ + stmt = {'param': 'LP', 'lp': 'D'} + lp = LPParamStmt.from_dict(stmt) + assert_equal(str(lp), '') + + stmt = {'param': 'LP', 'lp': 'C'} + lp = LPParamStmt.from_dict(stmt) + assert_equal(str(lp), '') + + def test_INParamStmt_factory(): """ Test INParamStmt factory """ @@ -178,6 +225,7 @@ def test_INParamStmt_factory(): inp = INParamStmt.from_dict(stmt) assert_equal(inp.name, 'test') + def test_INParamStmt_dump(): """ Test INParamStmt to_gerber() """ @@ -193,6 +241,7 @@ def test_LNParamStmt_factory(): lnp = LNParamStmt.from_dict(stmt) assert_equal(lnp.name, 'test') + def test_LNParamStmt_dump(): """ Test LNParamStmt to_gerber() """ @@ -200,6 +249,7 @@ def test_LNParamStmt_dump(): lnp = LNParamStmt.from_dict(stmt) assert_equal(lnp.to_gerber(), '%LNtest*%') + def test_comment_stmt(): """ Test comment statement """ @@ -207,6 +257,7 @@ def test_comment_stmt(): assert_equal(stmt.type, 'COMMENT') assert_equal(stmt.comment, 'A comment') + def test_comment_stmt_dump(): """ Test CommentStmt to_gerber() """ @@ -220,6 +271,7 @@ def test_eofstmt(): stmt = EofStmt() assert_equal(stmt.type, 'EOF') + def test_eofstmt_dump(): """ Test EofStmt to_gerber() """ @@ -239,6 +291,7 @@ def test_quadmodestmt_factory(): stmt = QuadrantModeStmt.from_gerber(line) assert_equal(stmt.mode, 'multi-quadrant') + def test_quadmodestmt_validation(): """ Test QuadrantModeStmt input validation """ @@ -301,3 +354,61 @@ def test_unknownstmt_dump(): stmt = UnknownStmt(line) assert_equal(stmt.to_gerber(), line) + +def test_statement_string(): + """ Test Statement.__str__() + """ + stmt = Statement('PARAM') + assert_equal(str(stmt), '') + stmt.test='PASS' + assert_equal(str(stmt), '') + + +def test_ADParamStmt_factory(): + """ Test ADParamStmt factory + """ + stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.d, 0) + assert_equal(ad.shape, 'C') + + stmt = {'param': 'AD', 'd': 1, 'shape': 'R'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.d, 1) + assert_equal(ad.shape, 'R') + + stmt = {'param': 'AD', 'd': 2, 'shape': 'O'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.d, 2) + assert_equal(ad.shape, 'O') + + +def test_ADParamStmt_dump(): + """ Test ADParamStmt.to_gerber() + """ + stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.to_gerber(),'%ADD0C*%') + + stmt = {'param': 'AD', 'd': 1, 'shape': 'R'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.to_gerber(),'%ADD1R*%') + + stmt = {'param': 'AD', 'd': 2, 'shape': 'O'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.to_gerber(),'%ADD2O*%') + +def test_ADParamStmt_string(): + """ Test ADParamStmt.__str__() + """ + stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(str(ad), '') + + stmt = {'param': 'AD', 'd': 1, 'shape': 'R'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(str(ad), '') + + stmt = {'param': 'AD', 'd': 2, 'shape': 'O'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(str(ad), ' Date: Mon, 26 Jan 2015 22:24:45 -0500 Subject: merge upstream changes --- gerber/tests/test_gerber_statements.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index c346ace..ff967f9 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -411,4 +411,4 @@ def test_ADParamStmt_string(): stmt = {'param': 'AD', 'd': 2, 'shape': 'O'} ad = ADParamStmt.from_dict(stmt) - assert_equal(str(ad), '') -- cgit From 1cc20b351c10b1fa19817f29edd8c54a27aeee4b Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Mon, 2 Feb 2015 11:42:47 -0500 Subject: tests --- gerber/tests/test_gerber_statements.py | 92 +++++++++++++++++++++------------- 1 file changed, 57 insertions(+), 35 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index ff967f9..e797d5a 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -82,6 +82,12 @@ def test_MOParamStmt_factory(): assert_equal(mo.param, 'MO') assert_equal(mo.mode, 'metric') + stmt = {'param': 'MO'} + mo = MOParamStmt.from_dict(stmt) + assert_equal(mo.mode, None) + stmt = {'param': 'MO', 'mo': 'degrees kelvin'} + assert_raises(ValueError, MOParamStmt.from_dict, stmt) + def test_MOParamStmt(): """ Test MOParamStmt initialization @@ -182,6 +188,13 @@ def test_OFParamStmt_dump(): assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%') +def test_OFParamStmt_string(): + """ Test OFParamStmt __str__ + """ + stmt = {'param': 'OF', 'a': '0.123456', 'b': '0.123456'} + of = OFParamStmt.from_dict(stmt) + assert_equal(str(of), '') + def test_LPParamStmt_factory(): """ Test LPParamStmt factory """ @@ -377,38 +390,47 @@ def test_ADParamStmt_factory(): assert_equal(ad.d, 1) assert_equal(ad.shape, 'R') - stmt = {'param': 'AD', 'd': 2, 'shape': 'O'} - ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.d, 2) - assert_equal(ad.shape, 'O') - - -def test_ADParamStmt_dump(): - """ Test ADParamStmt.to_gerber() - """ - stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} - ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.to_gerber(),'%ADD0C*%') - - stmt = {'param': 'AD', 'd': 1, 'shape': 'R'} - ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.to_gerber(),'%ADD1R*%') - - stmt = {'param': 'AD', 'd': 2, 'shape': 'O'} - ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.to_gerber(),'%ADD2O*%') - -def test_ADParamStmt_string(): - """ Test ADParamStmt.__str__() - """ - stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} - ad = ADParamStmt.from_dict(stmt) - assert_equal(str(ad), '') - - stmt = {'param': 'AD', 'd': 1, 'shape': 'R'} - ad = ADParamStmt.from_dict(stmt) - assert_equal(str(ad), '') - - stmt = {'param': 'AD', 'd': 2, 'shape': 'O'} - ad = ADParamStmt.from_dict(stmt) - assert_equal(str(ad), '') +def test_MIParamStmt_factory(): + stmt = {'param': 'MI', 'a': 1, 'b': 1} + mi = MIParamStmt.from_dict(stmt) + assert_equal(mi.a, 1) + assert_equal(mi.b, 1) + +def test_MIParamStmt_dump(): + stmt = {'param': 'MI', 'a': 1, 'b': 1} + mi = MIParamStmt.from_dict(stmt) + assert_equal(mi.to_gerber(), '%MIA1B1*%') + stmt = {'param': 'MI', 'a': 1} + mi = MIParamStmt.from_dict(stmt) + assert_equal(mi.to_gerber(), '%MIA1B0*%') + stmt = {'param': 'MI', 'b': 1} + mi = MIParamStmt.from_dict(stmt) + assert_equal(mi.to_gerber(), '%MIA0B1*%') + +def test_MIParamStmt_string(): + stmt = {'param': 'MI', 'a': 1, 'b': 1} + mi = MIParamStmt.from_dict(stmt) + assert_equal(str(mi), '') + + stmt = {'param': 'MI', 'b': 1} + mi = MIParamStmt.from_dict(stmt) + assert_equal(str(mi), '') + + stmt = {'param': 'MI', 'a': 1} + mi = MIParamStmt.from_dict(stmt) + assert_equal(str(mi), '') + + + +def test_coordstmt_ctor(): + cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings()) + assert_equal(cs.function, 'G04') + assert_equal(cs.x, 0.0) + assert_equal(cs.y, 0.1) + assert_equal(cs.i, 0.2) + assert_equal(cs.j, 0.3) + assert_equal(cs.op, 'D01') + + + + \ No newline at end of file -- cgit From 41f9475b132001d52064392057e376c6423c33dc Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Mon, 9 Feb 2015 17:39:24 -0500 Subject: Tests and bugfixes --- gerber/tests/test_gerber_statements.py | 177 ++++++++++++++++++++++++++++++--- 1 file changed, 164 insertions(+), 13 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index e797d5a..0875b57 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -159,6 +159,31 @@ def test_IPParamStmt_dump(): ip = IPParamStmt.from_dict(stmt) assert_equal(ip.to_gerber(), '%IPNEG*%') +def test_IPParamStmt_string(): + stmt = {'param': 'IP', 'ip': 'POS'} + ip = IPParamStmt.from_dict(stmt) + assert_equal(str(ip), '') + + stmt = {'param': 'IP', 'ip': 'NEG'} + ip = IPParamStmt.from_dict(stmt) + assert_equal(str(ip), '') + +def test_IRParamStmt_factory(): + stmt = {'param': 'IR', 'angle': '45'} + ir = IRParamStmt.from_dict(stmt) + assert_equal(ir.param, 'IR') + assert_equal(ir.angle, 45) + +def test_IRParamStmt_dump(): + stmt = {'param': 'IR', 'angle': '45'} + ir = IRParamStmt.from_dict(stmt) + assert_equal(ir.to_gerber(), '%IR45*%') + +def test_IRParamStmt_string(): + stmt = {'param': 'IR', 'angle': '45'} + ir = IRParamStmt.from_dict(stmt) + assert_equal(str(ir), '') + def test_OFParamStmt_factory(): """ Test OFParamStmt factory @@ -195,6 +220,24 @@ def test_OFParamStmt_string(): of = OFParamStmt.from_dict(stmt) assert_equal(str(of), '') +def test_SFParamStmt_factory(): + stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} + sf = SFParamStmt.from_dict(stmt) + assert_equal(sf.param, 'SF') + assert_equal(sf.a, 1.4) + assert_equal(sf.b, 0.9) + +def test_SFParamStmt_dump(): + stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} + sf = SFParamStmt.from_dict(stmt) + assert_equal(sf.to_gerber(), '%SFA1.4B0.9*%') + +def test_SFParamStmt_string(): + stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} + sf = SFParamStmt.from_dict(stmt) + assert_equal(str(sf), '') + + def test_LPParamStmt_factory(): """ Test LPParamStmt factory """ @@ -231,6 +274,75 @@ def test_LPParamStmt_string(): assert_equal(str(lp), '') +def test_AMParamStmt_factory(): + name = 'DONUTVAR' + macro = ( +'''0 Test Macro. * +1,1,1.5,0,0* +20,1,0.9,0,0.45,12,0.45,0* +21,1,6.8,1.2,3.4,0.6,0* +22,1,6.8,1.2,0,0,0* +4,1,4,0.1,0.1,0.5,0.1,0.5,0.5,0.1,0.5,0.1,0.1,0* +5,1,8,0,0,8,0* +6,0,0,5,0.5,0.5,2,0.1,6,0* +7,0,0,7,6,0.2,0* +8,THIS IS AN UNSUPPORTED PRIMITIVE* +''') + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + assert_equal(len(s.primitives), 10) + assert_true(isinstance(s.primitives[0], AMCommentPrimitive)) + assert_true(isinstance(s.primitives[1], AMCirclePrimitive)) + assert_true(isinstance(s.primitives[2], AMVectorLinePrimitive)) + assert_true(isinstance(s.primitives[3], AMCenterLinePrimitive)) + assert_true(isinstance(s.primitives[4], AMLowerLeftLinePrimitive)) + assert_true(isinstance(s.primitives[5], AMOutlinePrimitive)) + assert_true(isinstance(s.primitives[6], AMPolygonPrimitive)) + assert_true(isinstance(s.primitives[7], AMMoirePrimitive)) + assert_true(isinstance(s.primitives[8], AMThermalPrimitive)) + assert_true(isinstance(s.primitives[9], AMUnsupportPrimitive)) + +def testAMParamStmt_conversion(): + name = 'POLYGON' + macro = '5,1,8,25.4,25.4,25.4,0*%' + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s.to_inch() + assert_equal(s.primitives[0].position, (1., 1.)) + assert_equal(s.primitives[0].diameter, 1.) + + macro = '5,1,8,1,1,1,0*%' + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s.to_metric() + assert_equal(s.primitives[0].position, (25.4, 25.4)) + assert_equal(s.primitives[0].diameter, 25.4) + +def test_AMParamStmt_dump(): + name = 'POLYGON' + macro = '5,1,8,25.4,25.4,25.4,0*%' + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%') + +def test_AMParamStmt_string(): + name = 'POLYGON' + macro = '5,1,8,25.4,25.4,25.4,0*%' + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + assert_equal(str(s), '') + +def test_ASParamStmt_factory(): + stmt = {'param': 'AS', 'mode': 'AXBY'} + s = ASParamStmt.from_dict(stmt) + assert_equal(s.param, 'AS') + assert_equal(s.mode, 'AXBY') + +def test_ASParamStmt_dump(): + stmt = {'param': 'AS', 'mode': 'AXBY'} + s = ASParamStmt.from_dict(stmt) + assert_equal(s.to_gerber(), '%ASAXBY*%') + +def test_ASParamStmt_string(): + stmt = {'param': 'AS', 'mode': 'AXBY'} + s = ASParamStmt.from_dict(stmt) + assert_equal(str(s), '') + def test_INParamStmt_factory(): """ Test INParamStmt factory """ @@ -238,7 +350,6 @@ def test_INParamStmt_factory(): inp = INParamStmt.from_dict(stmt) assert_equal(inp.name, 'test') - def test_INParamStmt_dump(): """ Test INParamStmt to_gerber() """ @@ -246,6 +357,10 @@ def test_INParamStmt_dump(): inp = INParamStmt.from_dict(stmt) assert_equal(inp.to_gerber(), '%INtest*%') +def test_INParamStmt_string(): + stmt = {'param': 'IN', 'name': 'test'} + inp = INParamStmt.from_dict(stmt) + assert_equal(str(inp), '') def test_LNParamStmt_factory(): """ Test LNParamStmt factory @@ -254,7 +369,6 @@ def test_LNParamStmt_factory(): lnp = LNParamStmt.from_dict(stmt) assert_equal(lnp.name, 'test') - def test_LNParamStmt_dump(): """ Test LNParamStmt to_gerber() """ @@ -262,6 +376,10 @@ def test_LNParamStmt_dump(): lnp = LNParamStmt.from_dict(stmt) assert_equal(lnp.to_gerber(), '%LNtest*%') +def test_LNParamStmt_string(): + stmt = {'param': 'LN', 'name': 'test'} + lnp = LNParamStmt.from_dict(stmt) + assert_equal(str(lnp), '') def test_comment_stmt(): """ Test comment statement @@ -270,28 +388,24 @@ def test_comment_stmt(): assert_equal(stmt.type, 'COMMENT') assert_equal(stmt.comment, 'A comment') - def test_comment_stmt_dump(): """ Test CommentStmt to_gerber() """ stmt = CommentStmt('A comment') assert_equal(stmt.to_gerber(), 'G04A comment*') - def test_eofstmt(): """ Test EofStmt """ stmt = EofStmt() assert_equal(stmt.type, 'EOF') - def test_eofstmt_dump(): """ Test EofStmt to_gerber() """ stmt = EofStmt() assert_equal(stmt.to_gerber(), 'M02*') - def test_quadmodestmt_factory(): """ Test QuadrantModeStmt.from_gerber() """ @@ -390,12 +504,50 @@ def test_ADParamStmt_factory(): assert_equal(ad.d, 1) assert_equal(ad.shape, 'R') +def test_ADParamStmt_conversion(): + stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '25.4X25.4,25.4X25.4'} + ad = ADParamStmt.from_dict(stmt) + ad.to_inch() + assert_equal(ad.modifiers[0], (1., 1.)) + assert_equal(ad.modifiers[1], (1., 1.)) + + stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '1X1,1X1'} + ad = ADParamStmt.from_dict(stmt) + ad.to_metric() + assert_equal(ad.modifiers[0], (25.4, 25.4)) + assert_equal(ad.modifiers[1], (25.4, 25.4)) + +def test_ADParamStmt_dump(): + stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.to_gerber(), '%ADD0C*%') + stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '1X1,1X1'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.to_gerber(), '%ADD0C,1X1,1X1*%') + +def test_ADPamramStmt_string(): + stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(str(ad), '') + + stmt = {'param': 'AD', 'd': 0, 'shape': 'R'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(str(ad), '') + + stmt = {'param': 'AD', 'd': 0, 'shape': 'O'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(str(ad), '') + + stmt = {'param': 'AD', 'd': 0, 'shape': 'test'} + ad = ADParamStmt.from_dict(stmt) + assert_equal(str(ad), '') + def test_MIParamStmt_factory(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) assert_equal(mi.a, 1) assert_equal(mi.b, 1) - + def test_MIParamStmt_dump(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) @@ -406,12 +558,12 @@ def test_MIParamStmt_dump(): stmt = {'param': 'MI', 'b': 1} mi = MIParamStmt.from_dict(stmt) assert_equal(mi.to_gerber(), '%MIA0B1*%') - + def test_MIParamStmt_string(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) assert_equal(str(mi), '') - + stmt = {'param': 'MI', 'b': 1} mi = MIParamStmt.from_dict(stmt) assert_equal(str(mi), '') @@ -430,7 +582,6 @@ def test_coordstmt_ctor(): assert_equal(cs.i, 0.2) assert_equal(cs.j, 0.3) assert_equal(cs.op, 'D01') - - - - \ No newline at end of file + + + -- cgit From 5cf1fa74b42eb8feaab23078bef6f31f6d647c33 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Sun, 15 Feb 2015 02:20:02 -0500 Subject: Tests and bugfixes --- gerber/tests/test_gerber_statements.py | 73 ++++++++++++++++++++++++++++++++-- 1 file changed, 70 insertions(+), 3 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 0875b57..c6040c0 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -394,6 +394,10 @@ def test_comment_stmt_dump(): stmt = CommentStmt('A comment') assert_equal(stmt.to_gerber(), 'G04A comment*') +def test_comment_stmt_string(): + stmt = CommentStmt('A comment') + assert_equal(str(stmt), '') + def test_eofstmt(): """ Test EofStmt """ @@ -406,6 +410,9 @@ def test_eofstmt_dump(): stmt = EofStmt() assert_equal(stmt.to_gerber(), 'M02*') +def test_eofstmt_string(): + assert_equal(str(EofStmt()), '') + def test_quadmodestmt_factory(): """ Test QuadrantModeStmt.from_gerber() """ @@ -572,8 +579,6 @@ def test_MIParamStmt_string(): mi = MIParamStmt.from_dict(stmt) assert_equal(str(mi), '') - - def test_coordstmt_ctor(): cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings()) assert_equal(cs.function, 'G04') @@ -583,5 +588,67 @@ def test_coordstmt_ctor(): assert_equal(cs.j, 0.3) assert_equal(cs.op, 'D01') +def test_coordstmt_factory(): + stmt = {'function': 'G04', 'x': '0', 'y': '001', 'i': '002', 'j': '003', 'op': 'D01'} + cs = CoordStmt.from_dict(stmt, FileSettings()) + assert_equal(cs.function, 'G04') + assert_equal(cs.x, 0.0) + assert_equal(cs.y, 0.1) + assert_equal(cs.i, 0.2) + assert_equal(cs.j, 0.3) + assert_equal(cs.op, 'D01') - +def test_coordstmt_dump(): + cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings()) + assert_equal(cs.to_gerber(FileSettings()), 'G04X0Y001I002J003D01*') + +def test_coordstmt_conversion(): + cs = CoordStmt('G71', 25.4, 25.4, 25.4, 25.4, 'D01', FileSettings()) + cs.to_inch() + assert_equal(cs.x, 1.) + assert_equal(cs.y, 1.) + assert_equal(cs.i, 1.) + assert_equal(cs.j, 1.) + assert_equal(cs.function, 'G70') + + cs = CoordStmt('G70', 1., 1., 1., 1., 'D01', FileSettings()) + cs.to_metric() + assert_equal(cs.x, 25.4) + assert_equal(cs.y, 25.4) + assert_equal(cs.i, 25.4) + assert_equal(cs.j, 25.4) + assert_equal(cs.function, 'G71') + +def test_coordstmt_string(): + cs = CoordStmt('G04', 0, 1, 2, 3, 'D01', FileSettings()) + assert_equal(str(cs), '') + cs = CoordStmt('G04', None, None, None, None, 'D02', FileSettings()) + assert_equal(str(cs), '') + cs = CoordStmt('G04', None, None, None, None, 'D03', FileSettings()) + assert_equal(str(cs), '') + cs = CoordStmt('G04', None, None, None, None, 'TEST', FileSettings()) + assert_equal(str(cs), '') + +def test_aperturestmt_ctor(): + ast = ApertureStmt(3, False) + assert_equal(ast.d, 3) + assert_equal(ast.deprecated, False) + ast = ApertureStmt(4, True) + assert_equal(ast.d, 4) + assert_equal(ast.deprecated, True) + ast = ApertureStmt(4, 1) + assert_equal(ast.d, 4) + assert_equal(ast.deprecated, True) + ast = ApertureStmt(3) + assert_equal(ast.d, 3) + assert_equal(ast.deprecated, False) + +def test_aperturestmt_dump(): + ast = ApertureStmt(3, False) + assert_equal(ast.to_gerber(), 'D3*') + ast = ApertureStmt(3, True) + assert_equal(ast.to_gerber(), 'G54D3*') + assert_equal(str(ast), '') + + + \ No newline at end of file -- cgit From 288ac27084b47166ac662402ea340d0aa25d8f56 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Wed, 18 Feb 2015 04:31:23 -0500 Subject: Get unit conversion working for Gerber/Excellon files Started operations module for file operations/transforms --- gerber/tests/test_gerber_statements.py | 45 +++++++++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index c6040c0..bf7035f 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -7,6 +7,12 @@ from .tests import * from ..gerber_statements import * from ..cam import FileSettings +def test_Statement_smoketest(): + stmt = Statement('Test') + assert_equal(stmt.type, 'Test') + stmt.to_inch() + stmt.to_metric() + assert_equal(str(stmt), '') def test_FSParamStmt_factory(): """ Test FSParamStruct factory @@ -114,6 +120,17 @@ def test_MOParamStmt_dump(): assert_equal(mo.to_gerber(), '%MOMM*%') +def test_MOParamStmt_conversion(): + stmt = {'param': 'MO', 'mo': 'MM'} + mo = MOParamStmt.from_dict(stmt) + mo.to_inch() + assert_equal(mo.mode, 'inch') + + stmt = {'param': 'MO', 'mo': 'IN'} + mo = MOParamStmt.from_dict(stmt) + mo.to_metric() + assert_equal(mo.mode, 'metric') + def test_MOParamStmt_string(): """ Test MOParamStmt.__str__() """ @@ -213,6 +230,20 @@ def test_OFParamStmt_dump(): assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%') +def test_OFParamStmt_conversion(): + stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} + of = OFParamStmt.from_dict(stmt) + of.to_inch() + assert_equal(of.a, 0.1) + assert_equal(of.b, 1.0) + + stmt = {'param': 'OF', 'a': '0.1', 'b': '1.0'} + of = OFParamStmt.from_dict(stmt) + of.to_metric() + assert_equal(of.a, 2.54) + assert_equal(of.b, 25.4) + + def test_OFParamStmt_string(): """ Test OFParamStmt __str__ """ @@ -232,6 +263,19 @@ def test_SFParamStmt_dump(): sf = SFParamStmt.from_dict(stmt) assert_equal(sf.to_gerber(), '%SFA1.4B0.9*%') +def test_SFParamStmt_conversion(): + stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} + of = SFParamStmt.from_dict(stmt) + of.to_inch() + assert_equal(of.a, 0.1) + assert_equal(of.b, 1.0) + + stmt = {'param': 'OF', 'a': '0.1', 'b': '1.0'} + of = SFParamStmt.from_dict(stmt) + of.to_metric() + assert_equal(of.a, 2.54) + assert_equal(of.b, 25.4) + def test_SFParamStmt_string(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) @@ -651,4 +695,3 @@ def test_aperturestmt_dump(): assert_equal(str(ast), '') - \ No newline at end of file -- cgit From e71d7a24b5be3e68d36494869595eec934db4bd2 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Wed, 18 Feb 2015 21:14:30 -0500 Subject: Python 3 tests passing --- gerber/tests/test_gerber_statements.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index bf7035f..b473cf9 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -539,7 +539,8 @@ def test_statement_string(): stmt = Statement('PARAM') assert_equal(str(stmt), '') stmt.test='PASS' - assert_equal(str(stmt), '') + assert_true('test=PASS' in str(stmt)) + assert_true('type=PARAM' in str(stmt)) def test_ADParamStmt_factory(): -- cgit From 5966d7830bda7f37ed5ddcc1bfccb93e7f780eaa Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Wed, 18 Feb 2015 23:13:23 -0500 Subject: Add offset operation --- gerber/tests/test_gerber_statements.py | 58 ++++++++++++++++++---------------- 1 file changed, 31 insertions(+), 27 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index b473cf9..04358eb 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -12,6 +12,7 @@ def test_Statement_smoketest(): assert_equal(stmt.type, 'Test') stmt.to_inch() stmt.to_metric() + stmt.offset(1, 1) assert_equal(str(stmt), '') def test_FSParamStmt_factory(): @@ -31,7 +32,6 @@ def test_FSParamStmt_factory(): assert_equal(fs.notation, 'incremental') assert_equal(fs.format, (2, 7)) - def test_FSParamStmt(): """ Test FSParamStmt initialization """ @@ -45,7 +45,6 @@ def test_FSParamStmt(): assert_equal(stmt.notation, notation) assert_equal(stmt.format, fmt) - def test_FSParamStmt_dump(): """ Test FSParamStmt to_gerber() """ @@ -60,7 +59,6 @@ def test_FSParamStmt_dump(): settings = FileSettings(zero_suppression='leading', notation='absolute') assert_equal(fs.to_gerber(settings), '%FSLAX25Y25*%') - def test_FSParamStmt_string(): """ Test FSParamStmt.__str__() """ @@ -72,7 +70,6 @@ def test_FSParamStmt_string(): fs = FSParamStmt.from_dict(stmt) assert_equal(str(fs), '') - def test_MOParamStmt_factory(): """ Test MOParamStruct factory """ @@ -94,7 +91,6 @@ def test_MOParamStmt_factory(): stmt = {'param': 'MO', 'mo': 'degrees kelvin'} assert_raises(ValueError, MOParamStmt.from_dict, stmt) - def test_MOParamStmt(): """ Test MOParamStmt initialization """ @@ -107,7 +103,6 @@ def test_MOParamStmt(): stmt = MOParamStmt(param, mode) assert_equal(stmt.mode, mode) - def test_MOParamStmt_dump(): """ Test MOParamStmt to_gerber() """ @@ -119,7 +114,6 @@ def test_MOParamStmt_dump(): mo = MOParamStmt.from_dict(stmt) assert_equal(mo.to_gerber(), '%MOMM*%') - def test_MOParamStmt_conversion(): stmt = {'param': 'MO', 'mo': 'MM'} mo = MOParamStmt.from_dict(stmt) @@ -142,7 +136,6 @@ def test_MOParamStmt_string(): mo = MOParamStmt.from_dict(stmt) assert_equal(str(mo), '') - def test_IPParamStmt_factory(): """ Test IPParamStruct factory """ @@ -154,7 +147,6 @@ def test_IPParamStmt_factory(): ip = IPParamStmt.from_dict(stmt) assert_equal(ip.ip, 'negative') - def test_IPParamStmt(): """ Test IPParamStmt initialization """ @@ -164,7 +156,6 @@ def test_IPParamStmt(): assert_equal(stmt.param, param) assert_equal(stmt.ip, ip) - def test_IPParamStmt_dump(): """ Test IPParamStmt to_gerber() """ @@ -201,7 +192,6 @@ def test_IRParamStmt_string(): ir = IRParamStmt.from_dict(stmt) assert_equal(str(ir), '') - def test_OFParamStmt_factory(): """ Test OFParamStmt factory """ @@ -210,7 +200,6 @@ def test_OFParamStmt_factory(): assert_equal(of.a, 0.1234567) assert_equal(of.b, 0.1234567) - def test_OFParamStmt(): """ Test IPParamStmt initialization """ @@ -221,7 +210,6 @@ def test_OFParamStmt(): assert_equal(stmt.a, val) assert_equal(stmt.b, val) - def test_OFParamStmt_dump(): """ Test OFParamStmt to_gerber() """ @@ -229,7 +217,6 @@ def test_OFParamStmt_dump(): of = OFParamStmt.from_dict(stmt) assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%') - def test_OFParamStmt_conversion(): stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} of = OFParamStmt.from_dict(stmt) @@ -243,6 +230,14 @@ def test_OFParamStmt_conversion(): assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) +def test_OFParamStmt_offset(): + s = OFParamStmt('OF', 0, 0) + s.offset(1, 0) + assert_equal(s.a, 1.) + assert_equal(s.b, 0.) + s.offset(0, 1) + assert_equal(s.a, 1.) + assert_equal(s.b, 1.) def test_OFParamStmt_string(): """ Test OFParamStmt __str__ @@ -276,12 +271,20 @@ def test_SFParamStmt_conversion(): assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) +def test_SFParamStmt_offset(): + s = SFParamStmt('OF', 0, 0) + s.offset(1, 0) + assert_equal(s.a, 1.) + assert_equal(s.b, 0.) + s.offset(0, 1) + assert_equal(s.a, 1.) + assert_equal(s.b, 1.) + def test_SFParamStmt_string(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) assert_equal(str(sf), '') - def test_LPParamStmt_factory(): """ Test LPParamStmt factory """ @@ -293,7 +296,6 @@ def test_LPParamStmt_factory(): lp = LPParamStmt.from_dict(stmt) assert_equal(lp.lp, 'dark') - def test_LPParamStmt_dump(): """ Test LPParamStmt to_gerber() """ @@ -305,7 +307,6 @@ def test_LPParamStmt_dump(): lp = LPParamStmt.from_dict(stmt) assert_equal(lp.to_gerber(), '%LPD*%') - def test_LPParamStmt_string(): """ Test LPParamStmt.__str__() """ @@ -317,7 +318,6 @@ def test_LPParamStmt_string(): lp = LPParamStmt.from_dict(stmt) assert_equal(str(lp), '') - def test_AMParamStmt_factory(): name = 'DONUTVAR' macro = ( @@ -469,7 +469,6 @@ def test_quadmodestmt_factory(): stmt = QuadrantModeStmt.from_gerber(line) assert_equal(stmt.mode, 'multi-quadrant') - def test_quadmodestmt_validation(): """ Test QuadrantModeStmt input validation """ @@ -477,7 +476,6 @@ def test_quadmodestmt_validation(): assert_raises(ValueError, QuadrantModeStmt.from_gerber, line) assert_raises(ValueError, QuadrantModeStmt, 'quadrant-ful') - def test_quadmodestmt_dump(): """ Test QuadrantModeStmt.to_gerber() """ @@ -485,7 +483,6 @@ def test_quadmodestmt_dump(): stmt = QuadrantModeStmt.from_gerber(line) assert_equal(stmt.to_gerber(), line) - def test_regionmodestmt_factory(): """ Test RegionModeStmt.from_gerber() """ @@ -498,7 +495,6 @@ def test_regionmodestmt_factory(): stmt = RegionModeStmt.from_gerber(line) assert_equal(stmt.mode, 'off') - def test_regionmodestmt_validation(): """ Test RegionModeStmt input validation """ @@ -506,7 +502,6 @@ def test_regionmodestmt_validation(): assert_raises(ValueError, RegionModeStmt.from_gerber, line) assert_raises(ValueError, RegionModeStmt, 'off-ish') - def test_regionmodestmt_dump(): """ Test RegionModeStmt.to_gerber() """ @@ -514,7 +509,6 @@ def test_regionmodestmt_dump(): stmt = RegionModeStmt.from_gerber(line) assert_equal(stmt.to_gerber(), line) - def test_unknownstmt(): """ Test UnknownStmt """ @@ -523,7 +517,6 @@ def test_unknownstmt(): assert_equal(stmt.type, 'UNKNOWN') assert_equal(stmt.line, line) - def test_unknownstmt_dump(): """ Test UnknownStmt.to_gerber() """ @@ -532,7 +525,6 @@ def test_unknownstmt_dump(): stmt = UnknownStmt(line) assert_equal(stmt.to_gerber(), line) - def test_statement_string(): """ Test Statement.__str__() """ @@ -542,7 +534,6 @@ def test_statement_string(): assert_true('test=PASS' in str(stmt)) assert_true('type=PARAM' in str(stmt)) - def test_ADParamStmt_factory(): """ Test ADParamStmt factory """ @@ -664,6 +655,19 @@ def test_coordstmt_conversion(): assert_equal(cs.j, 25.4) assert_equal(cs.function, 'G71') +def test_coordstmt_offset(): + c = CoordStmt('G71', 0, 0, 0, 0, 'D01', FileSettings()) + c.offset(1, 0) + assert_equal(c.x, 1.) + assert_equal(c.y, 0.) + assert_equal(c.i, 1.) + assert_equal(c.j, 0.) + c.offset(0, 1) + assert_equal(c.x, 1.) + assert_equal(c.y, 1.) + assert_equal(c.i, 1.) + assert_equal(c.j, 1.) + def test_coordstmt_string(): cs = CoordStmt('G04', 0, 1, 2, 3, 'D01', FileSettings()) assert_equal(str(cs), '') -- cgit From a13b981c1c2ea9ede39e9821d9ba818566f044de Mon Sep 17 00:00:00 2001 From: Paulo Henrique Silva Date: Thu, 5 Mar 2015 14:43:30 -0300 Subject: Fix tests for macros with no variables. All AM*Primitive classes now handles float for all but the code modifiers. This simplifies the reading/parsing. --- gerber/tests/test_gerber_statements.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 04358eb..9032268 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -333,6 +333,7 @@ def test_AMParamStmt_factory(): 8,THIS IS AN UNSUPPORTED PRIMITIVE* ''') s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s.build() assert_equal(len(s.primitives), 10) assert_true(isinstance(s.primitives[0], AMCommentPrimitive)) assert_true(isinstance(s.primitives[1], AMCirclePrimitive)) @@ -347,29 +348,34 @@ def test_AMParamStmt_factory(): def testAMParamStmt_conversion(): name = 'POLYGON' - macro = '5,1,8,25.4,25.4,25.4,0*%' + macro = '5,1,8,25.4,25.4,25.4,0*' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s.build() s.to_inch() assert_equal(s.primitives[0].position, (1., 1.)) assert_equal(s.primitives[0].diameter, 1.) - macro = '5,1,8,1,1,1,0*%' + macro = '5,1,8,1,1,1,0*' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s.build() s.to_metric() assert_equal(s.primitives[0].position, (25.4, 25.4)) assert_equal(s.primitives[0].diameter, 25.4) def test_AMParamStmt_dump(): name = 'POLYGON' - macro = '5,1,8,25.4,25.4,25.4,0*%' + macro = '5,1,8,25.4,25.4,25.4,0*' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s.build() + assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%') def test_AMParamStmt_string(): name = 'POLYGON' - macro = '5,1,8,25.4,25.4,25.4,0*%' + macro = '5,1,8,25.4,25.4,25.4,0*' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) - assert_equal(str(s), '') + s.build() + assert_equal(str(s), '') def test_ASParamStmt_factory(): stmt = {'param': 'AS', 'mode': 'AXBY'} -- cgit From bbfa66eb381f327b62994b60c321b61a72d25bfe Mon Sep 17 00:00:00 2001 From: Paulo Henrique Silva Date: Tue, 7 Apr 2015 18:25:44 -0300 Subject: Small change on __str__ for SF Statement --- gerber/tests/test_gerber_statements.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 9032268..831ff3a 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -283,7 +283,7 @@ def test_SFParamStmt_offset(): def test_SFParamStmt_string(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) - assert_equal(str(sf), '') + assert_equal(str(sf), '') def test_LPParamStmt_factory(): """ Test LPParamStmt factory -- cgit From 0c54a20263ea193b92674b8f74191bcf957f73fe Mon Sep 17 00:00:00 2001 From: Paulo Henrique Silva Date: Tue, 14 Apr 2015 23:31:15 -0300 Subject: Fix AM statement test --- gerber/tests/test_gerber_statements.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 831ff3a..a8a4a1a 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -364,11 +364,11 @@ def testAMParamStmt_conversion(): def test_AMParamStmt_dump(): name = 'POLYGON' - macro = '5,1,8,25.4,25.4,25.4,0*' + macro = '5,1,8,25.4,25.4,25.4,0' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) s.build() - assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%') + assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0*%') def test_AMParamStmt_string(): name = 'POLYGON' -- cgit From 8ec3077be988681bbbafcef18ea3a2f84dd61b2b Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Sat, 16 May 2015 09:45:34 -0400 Subject: Add checks to ensure statement unit conversions are idempotent --- gerber/tests/test_gerber_statements.py | 152 ++++++++++++++++++++++++++++++++- 1 file changed, 148 insertions(+), 4 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index a8a4a1a..f3249b1 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -10,10 +10,13 @@ from ..cam import FileSettings def test_Statement_smoketest(): stmt = Statement('Test') assert_equal(stmt.type, 'Test') + stmt.to_metric() + assert_in('units=metric', str(stmt)) stmt.to_inch() + assert_in('units=inch', str(stmt)) stmt.to_metric() stmt.offset(1, 1) - assert_equal(str(stmt), '') + assert_in('type=Test',str(stmt)) def test_FSParamStmt_factory(): """ Test FSParamStruct factory @@ -220,12 +223,38 @@ def test_OFParamStmt_dump(): def test_OFParamStmt_conversion(): stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} of = OFParamStmt.from_dict(stmt) + of.units='metric' + + # No effect + of.to_metric() + assert_equal(of.a, 2.54) + assert_equal(of.b, 25.4) + + of.to_inch() + assert_equal(of.units, 'inch') + assert_equal(of.a, 0.1) + assert_equal(of.b, 1.0) + + #No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) stmt = {'param': 'OF', 'a': '0.1', 'b': '1.0'} of = OFParamStmt.from_dict(stmt) + of.units = 'inch' + + #No effect + of.to_inch() + assert_equal(of.a, 0.1) + assert_equal(of.b, 1.0) + + of.to_metric() + assert_equal(of.units, 'metric') + assert_equal(of.a, 2.54) + assert_equal(of.b, 25.4) + + #No effect of.to_metric() assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) @@ -261,12 +290,38 @@ def test_SFParamStmt_dump(): def test_SFParamStmt_conversion(): stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} of = SFParamStmt.from_dict(stmt) + of.units = 'metric' + of.to_metric() + + #No effect + assert_equal(of.a, 2.54) + assert_equal(of.b, 25.4) + + of.to_inch() + assert_equal(of.units, 'inch') + assert_equal(of.a, 0.1) + assert_equal(of.b, 1.0) + + #No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) stmt = {'param': 'OF', 'a': '0.1', 'b': '1.0'} of = SFParamStmt.from_dict(stmt) + of.units = 'inch' + + #No effect + of.to_inch() + assert_equal(of.a, 0.1) + assert_equal(of.b, 1.0) + + of.to_metric() + assert_equal(of.units, 'metric') + assert_equal(of.a, 2.54) + assert_equal(of.b, 25.4) + + #No effect of.to_metric() assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) @@ -350,7 +405,21 @@ def testAMParamStmt_conversion(): name = 'POLYGON' macro = '5,1,8,25.4,25.4,25.4,0*' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s.build() + s.units = 'metric' + + #No effect + s.to_metric() + assert_equal(s.primitives[0].position, (25.4, 25.4)) + assert_equal(s.primitives[0].diameter, 25.4) + + s.to_inch() + assert_equal(s.units, 'inch') + assert_equal(s.primitives[0].position, (1., 1.)) + assert_equal(s.primitives[0].diameter, 1.) + + #No effect s.to_inch() assert_equal(s.primitives[0].position, (1., 1.)) assert_equal(s.primitives[0].diameter, 1.) @@ -358,6 +427,19 @@ def testAMParamStmt_conversion(): macro = '5,1,8,1,1,1,0*' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) s.build() + s.units = 'inch' + + #No effect + s.to_inch() + assert_equal(s.primitives[0].position, (1., 1.)) + assert_equal(s.primitives[0].diameter, 1.) + + s.to_metric() + assert_equal(s.units, 'metric') + assert_equal(s.primitives[0].position, (25.4, 25.4)) + assert_equal(s.primitives[0].diameter, 25.4) + + #No effect s.to_metric() assert_equal(s.primitives[0].position, (25.4, 25.4)) assert_equal(s.primitives[0].diameter, 25.4) @@ -535,10 +617,10 @@ def test_statement_string(): """ Test Statement.__str__() """ stmt = Statement('PARAM') - assert_equal(str(stmt), '') + assert_in('type=PARAM', str(stmt)) stmt.test='PASS' - assert_true('test=PASS' in str(stmt)) - assert_true('type=PARAM' in str(stmt)) + assert_in('test=PASS', str(stmt)) + assert_in('type=PARAM', str(stmt)) def test_ADParamStmt_factory(): """ Test ADParamStmt factory @@ -556,12 +638,37 @@ def test_ADParamStmt_factory(): def test_ADParamStmt_conversion(): stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '25.4X25.4,25.4X25.4'} ad = ADParamStmt.from_dict(stmt) + ad.units = 'metric' + + #No effect + ad.to_metric() + assert_equal(ad.modifiers[0], (25.4, 25.4)) + assert_equal(ad.modifiers[1], (25.4, 25.4)) + + ad.to_inch() + assert_equal(ad.units, 'inch') + assert_equal(ad.modifiers[0], (1., 1.)) + assert_equal(ad.modifiers[1], (1., 1.)) + + #No effect ad.to_inch() assert_equal(ad.modifiers[0], (1., 1.)) assert_equal(ad.modifiers[1], (1., 1.)) stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '1X1,1X1'} ad = ADParamStmt.from_dict(stmt) + ad.units = 'inch' + + #No effect + ad.to_inch() + assert_equal(ad.modifiers[0], (1., 1.)) + assert_equal(ad.modifiers[1], (1., 1.)) + + ad.to_metric() + assert_equal(ad.modifiers[0], (25.4, 25.4)) + assert_equal(ad.modifiers[1], (25.4, 25.4)) + + #No effect ad.to_metric() assert_equal(ad.modifiers[0], (25.4, 25.4)) assert_equal(ad.modifiers[1], (25.4, 25.4)) @@ -646,6 +753,25 @@ def test_coordstmt_dump(): def test_coordstmt_conversion(): cs = CoordStmt('G71', 25.4, 25.4, 25.4, 25.4, 'D01', FileSettings()) + cs.units = 'metric' + + #No effect + cs.to_metric() + assert_equal(cs.x, 25.4) + assert_equal(cs.y, 25.4) + assert_equal(cs.i, 25.4) + assert_equal(cs.j, 25.4) + assert_equal(cs.function, 'G71') + + cs.to_inch() + assert_equal(cs.units, 'inch') + assert_equal(cs.x, 1.) + assert_equal(cs.y, 1.) + assert_equal(cs.i, 1.) + assert_equal(cs.j, 1.) + assert_equal(cs.function, 'G70') + + #No effect cs.to_inch() assert_equal(cs.x, 1.) assert_equal(cs.y, 1.) @@ -654,6 +780,24 @@ def test_coordstmt_conversion(): assert_equal(cs.function, 'G70') cs = CoordStmt('G70', 1., 1., 1., 1., 'D01', FileSettings()) + cs.units = 'inch' + + #No effect + cs.to_inch() + assert_equal(cs.x, 1.) + assert_equal(cs.y, 1.) + assert_equal(cs.i, 1.) + assert_equal(cs.j, 1.) + assert_equal(cs.function, 'G70') + + cs.to_metric() + assert_equal(cs.x, 25.4) + assert_equal(cs.y, 25.4) + assert_equal(cs.i, 25.4) + assert_equal(cs.j, 25.4) + assert_equal(cs.function, 'G71') + + #No effect cs.to_metric() assert_equal(cs.x, 25.4) assert_equal(cs.y, 25.4) -- cgit From d3b19efb484941f9726b1ae805c8d39e767bbe15 Mon Sep 17 00:00:00 2001 From: Paulo Henrique Silva Date: Wed, 20 May 2015 16:20:02 -0300 Subject: Add support for PCBmodE generated files. PCBmodE uses a standard but probably undefined behaviour issue on Gerber where it defines circle apertures with a single modifier but leaves a trilling 'X' after it. 'X' is modifiers separator but when there is only one modifier the behaviour is undefined. For parsing we are just ignoring blank modifiers. Test updated to catch this case. --- gerber/tests/test_gerber_statements.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index f3249b1..b5c20b1 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -635,6 +635,24 @@ def test_ADParamStmt_factory(): assert_equal(ad.d, 1) assert_equal(ad.shape, 'R') + stmt = {'param': 'AD', 'd': 1, 'shape': 'C', "modifiers": "1.42"} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.d, 1) + assert_equal(ad.shape, 'C') + assert_equal(ad.modifiers, [(1.42,)]) + + stmt = {'param': 'AD', 'd': 1, 'shape': 'C', "modifiers": "1.42X"} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.d, 1) + assert_equal(ad.shape, 'C') + assert_equal(ad.modifiers, [(1.42,)]) + + stmt = {'param': 'AD', 'd': 1, 'shape': 'R', "modifiers": "1.42X1.24"} + ad = ADParamStmt.from_dict(stmt) + assert_equal(ad.d, 1) + assert_equal(ad.shape, 'R') + assert_equal(ad.modifiers, [(1.42, 1.24)]) + def test_ADParamStmt_conversion(): stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '25.4X25.4,25.4X25.4'} ad = ADParamStmt.from_dict(stmt) -- cgit From 2e2b4e49c3182cc7385f12d760222ecb57cc1356 Mon Sep 17 00:00:00 2001 From: Paulo Henrique Silva Date: Mon, 23 Nov 2015 16:02:16 -0200 Subject: Fix AMParamStmt to_gerber to write changes back. AMParamStmt was not calling to_gerber on each of its primitives on his own to_gerber method. That way primitives that changes after reading, such as when you call to_inch/to_metric was failing because it was writing only the original macro back. --- gerber/tests/test_gerber_statements.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index b5c20b1..79ce76b 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -446,11 +446,11 @@ def testAMParamStmt_conversion(): def test_AMParamStmt_dump(): name = 'POLYGON' - macro = '5,1,8,25.4,25.4,25.4,0' + macro = '5,1,8,25.4,25.4,25.4,0.0' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) s.build() - assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0*%') + assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%') def test_AMParamStmt_string(): name = 'POLYGON' -- cgit From 2fa585853beff6527ea71084640f91bad290fac2 Mon Sep 17 00:00:00 2001 From: Paulo Henrique Silva Date: Sun, 6 Dec 2015 21:44:09 -0200 Subject: Add test case to start working on a fix --- gerber/tests/test_gerber_statements.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 79ce76b..a89a283 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -449,9 +449,12 @@ def test_AMParamStmt_dump(): macro = '5,1,8,25.4,25.4,25.4,0.0' s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) s.build() - assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%') + s = AMParamStmt.from_dict({'param': 'AM', 'name': 'OC8', 'macro': '5,1,8,0,0,1.08239X$1,22.5'}) + s.build() + assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,22.5*%') + def test_AMParamStmt_string(): name = 'POLYGON' macro = '5,1,8,25.4,25.4,25.4,0*' -- cgit From 5476da8aa3f4ee424f56f4f2491e7af1c4b7b758 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Thu, 21 Jan 2016 03:57:44 -0500 Subject: Fix a bunch of rendering bugs. - 'clear' polarity primitives no longer erase background - Added aperture macro support for polygons - Added aperture macro rendring support - Renderer now creates a new surface for each layer and merges them instead of working directly on a single surface - Updated examples accordingly --- gerber/tests/test_gerber_statements.py | 145 +++++++++++++++++++++++++-------- 1 file changed, 111 insertions(+), 34 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 79ce76b..c1985e6 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -7,6 +7,7 @@ from .tests import * from ..gerber_statements import * from ..cam import FileSettings + def test_Statement_smoketest(): stmt = Statement('Test') assert_equal(stmt.type, 'Test') @@ -16,7 +17,8 @@ def test_Statement_smoketest(): assert_in('units=inch', str(stmt)) stmt.to_metric() stmt.offset(1, 1) - assert_in('type=Test',str(stmt)) + assert_in('type=Test', str(stmt)) + def test_FSParamStmt_factory(): """ Test FSParamStruct factory @@ -35,6 +37,7 @@ def test_FSParamStmt_factory(): assert_equal(fs.notation, 'incremental') assert_equal(fs.format, (2, 7)) + def test_FSParamStmt(): """ Test FSParamStmt initialization """ @@ -48,6 +51,7 @@ def test_FSParamStmt(): assert_equal(stmt.notation, notation) assert_equal(stmt.format, fmt) + def test_FSParamStmt_dump(): """ Test FSParamStmt to_gerber() """ @@ -62,16 +66,20 @@ def test_FSParamStmt_dump(): settings = FileSettings(zero_suppression='leading', notation='absolute') assert_equal(fs.to_gerber(settings), '%FSLAX25Y25*%') + def test_FSParamStmt_string(): """ Test FSParamStmt.__str__() """ stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'} fs = FSParamStmt.from_dict(stmt) - assert_equal(str(fs), '') + assert_equal(str(fs), + '') stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'} fs = FSParamStmt.from_dict(stmt) - assert_equal(str(fs), '') + assert_equal(str(fs), + '') + def test_MOParamStmt_factory(): """ Test MOParamStruct factory @@ -94,6 +102,7 @@ def test_MOParamStmt_factory(): stmt = {'param': 'MO', 'mo': 'degrees kelvin'} assert_raises(ValueError, MOParamStmt.from_dict, stmt) + def test_MOParamStmt(): """ Test MOParamStmt initialization """ @@ -106,6 +115,7 @@ def test_MOParamStmt(): stmt = MOParamStmt(param, mode) assert_equal(stmt.mode, mode) + def test_MOParamStmt_dump(): """ Test MOParamStmt to_gerber() """ @@ -117,6 +127,7 @@ def test_MOParamStmt_dump(): mo = MOParamStmt.from_dict(stmt) assert_equal(mo.to_gerber(), '%MOMM*%') + def test_MOParamStmt_conversion(): stmt = {'param': 'MO', 'mo': 'MM'} mo = MOParamStmt.from_dict(stmt) @@ -128,6 +139,7 @@ def test_MOParamStmt_conversion(): mo.to_metric() assert_equal(mo.mode, 'metric') + def test_MOParamStmt_string(): """ Test MOParamStmt.__str__() """ @@ -139,6 +151,7 @@ def test_MOParamStmt_string(): mo = MOParamStmt.from_dict(stmt) assert_equal(str(mo), '') + def test_IPParamStmt_factory(): """ Test IPParamStruct factory """ @@ -150,6 +163,7 @@ def test_IPParamStmt_factory(): ip = IPParamStmt.from_dict(stmt) assert_equal(ip.ip, 'negative') + def test_IPParamStmt(): """ Test IPParamStmt initialization """ @@ -159,6 +173,7 @@ def test_IPParamStmt(): assert_equal(stmt.param, param) assert_equal(stmt.ip, ip) + def test_IPParamStmt_dump(): """ Test IPParamStmt to_gerber() """ @@ -170,6 +185,7 @@ def test_IPParamStmt_dump(): ip = IPParamStmt.from_dict(stmt) assert_equal(ip.to_gerber(), '%IPNEG*%') + def test_IPParamStmt_string(): stmt = {'param': 'IP', 'ip': 'POS'} ip = IPParamStmt.from_dict(stmt) @@ -179,22 +195,26 @@ def test_IPParamStmt_string(): ip = IPParamStmt.from_dict(stmt) assert_equal(str(ip), '') + def test_IRParamStmt_factory(): stmt = {'param': 'IR', 'angle': '45'} ir = IRParamStmt.from_dict(stmt) assert_equal(ir.param, 'IR') assert_equal(ir.angle, 45) + def test_IRParamStmt_dump(): stmt = {'param': 'IR', 'angle': '45'} ir = IRParamStmt.from_dict(stmt) assert_equal(ir.to_gerber(), '%IR45*%') + def test_IRParamStmt_string(): stmt = {'param': 'IR', 'angle': '45'} ir = IRParamStmt.from_dict(stmt) assert_equal(str(ir), '') + def test_OFParamStmt_factory(): """ Test OFParamStmt factory """ @@ -203,6 +223,7 @@ def test_OFParamStmt_factory(): assert_equal(of.a, 0.1234567) assert_equal(of.b, 0.1234567) + def test_OFParamStmt(): """ Test IPParamStmt initialization """ @@ -213,6 +234,7 @@ def test_OFParamStmt(): assert_equal(stmt.a, val) assert_equal(stmt.b, val) + def test_OFParamStmt_dump(): """ Test OFParamStmt to_gerber() """ @@ -220,10 +242,11 @@ def test_OFParamStmt_dump(): of = OFParamStmt.from_dict(stmt) assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%') + def test_OFParamStmt_conversion(): stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} of = OFParamStmt.from_dict(stmt) - of.units='metric' + of.units = 'metric' # No effect of.to_metric() @@ -235,7 +258,7 @@ def test_OFParamStmt_conversion(): assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) - #No effect + # No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) @@ -244,7 +267,7 @@ def test_OFParamStmt_conversion(): of = OFParamStmt.from_dict(stmt) of.units = 'inch' - #No effect + # No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) @@ -254,11 +277,12 @@ def test_OFParamStmt_conversion(): assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) - #No effect + # No effect of.to_metric() assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) + def test_OFParamStmt_offset(): s = OFParamStmt('OF', 0, 0) s.offset(1, 0) @@ -268,6 +292,7 @@ def test_OFParamStmt_offset(): assert_equal(s.a, 1.) assert_equal(s.b, 1.) + def test_OFParamStmt_string(): """ Test OFParamStmt __str__ """ @@ -275,6 +300,7 @@ def test_OFParamStmt_string(): of = OFParamStmt.from_dict(stmt) assert_equal(str(of), '') + def test_SFParamStmt_factory(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) @@ -282,18 +308,20 @@ def test_SFParamStmt_factory(): assert_equal(sf.a, 1.4) assert_equal(sf.b, 0.9) + def test_SFParamStmt_dump(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) assert_equal(sf.to_gerber(), '%SFA1.4B0.9*%') + def test_SFParamStmt_conversion(): stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} of = SFParamStmt.from_dict(stmt) of.units = 'metric' of.to_metric() - #No effect + # No effect assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) @@ -302,7 +330,7 @@ def test_SFParamStmt_conversion(): assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) - #No effect + # No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) @@ -311,7 +339,7 @@ def test_SFParamStmt_conversion(): of = SFParamStmt.from_dict(stmt) of.units = 'inch' - #No effect + # No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) @@ -321,11 +349,12 @@ def test_SFParamStmt_conversion(): assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) - #No effect + # No effect of.to_metric() assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) + def test_SFParamStmt_offset(): s = SFParamStmt('OF', 0, 0) s.offset(1, 0) @@ -335,11 +364,13 @@ def test_SFParamStmt_offset(): assert_equal(s.a, 1.) assert_equal(s.b, 1.) + def test_SFParamStmt_string(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) assert_equal(str(sf), '') + def test_LPParamStmt_factory(): """ Test LPParamStmt factory """ @@ -351,6 +382,7 @@ def test_LPParamStmt_factory(): lp = LPParamStmt.from_dict(stmt) assert_equal(lp.lp, 'dark') + def test_LPParamStmt_dump(): """ Test LPParamStmt to_gerber() """ @@ -362,6 +394,7 @@ def test_LPParamStmt_dump(): lp = LPParamStmt.from_dict(stmt) assert_equal(lp.to_gerber(), '%LPD*%') + def test_LPParamStmt_string(): """ Test LPParamStmt.__str__() """ @@ -373,6 +406,7 @@ def test_LPParamStmt_string(): lp = LPParamStmt.from_dict(stmt) assert_equal(str(lp), '') + def test_AMParamStmt_factory(): name = 'DONUTVAR' macro = ( @@ -387,7 +421,7 @@ def test_AMParamStmt_factory(): 7,0,0,7,6,0.2,0* 8,THIS IS AN UNSUPPORTED PRIMITIVE* ''') - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() assert_equal(len(s.primitives), 10) assert_true(isinstance(s.primitives[0], AMCommentPrimitive)) @@ -401,15 +435,16 @@ def test_AMParamStmt_factory(): assert_true(isinstance(s.primitives[8], AMThermalPrimitive)) assert_true(isinstance(s.primitives[9], AMUnsupportPrimitive)) + def testAMParamStmt_conversion(): name = 'POLYGON' macro = '5,1,8,25.4,25.4,25.4,0*' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() s.units = 'metric' - #No effect + # No effect s.to_metric() assert_equal(s.primitives[0].position, (25.4, 25.4)) assert_equal(s.primitives[0].diameter, 25.4) @@ -419,17 +454,17 @@ def testAMParamStmt_conversion(): assert_equal(s.primitives[0].position, (1., 1.)) assert_equal(s.primitives[0].diameter, 1.) - #No effect + # No effect s.to_inch() assert_equal(s.primitives[0].position, (1., 1.)) assert_equal(s.primitives[0].diameter, 1.) macro = '5,1,8,1,1,1,0*' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() s.units = 'inch' - #No effect + # No effect s.to_inch() assert_equal(s.primitives[0].position, (1., 1.)) assert_equal(s.primitives[0].diameter, 1.) @@ -439,42 +474,48 @@ def testAMParamStmt_conversion(): assert_equal(s.primitives[0].position, (25.4, 25.4)) assert_equal(s.primitives[0].diameter, 25.4) - #No effect + # No effect s.to_metric() assert_equal(s.primitives[0].position, (25.4, 25.4)) assert_equal(s.primitives[0].diameter, 25.4) + def test_AMParamStmt_dump(): name = 'POLYGON' macro = '5,1,8,25.4,25.4,25.4,0.0' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%') + def test_AMParamStmt_string(): name = 'POLYGON' macro = '5,1,8,25.4,25.4,25.4,0*' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() assert_equal(str(s), '') + def test_ASParamStmt_factory(): stmt = {'param': 'AS', 'mode': 'AXBY'} s = ASParamStmt.from_dict(stmt) assert_equal(s.param, 'AS') assert_equal(s.mode, 'AXBY') + def test_ASParamStmt_dump(): stmt = {'param': 'AS', 'mode': 'AXBY'} s = ASParamStmt.from_dict(stmt) assert_equal(s.to_gerber(), '%ASAXBY*%') + def test_ASParamStmt_string(): stmt = {'param': 'AS', 'mode': 'AXBY'} s = ASParamStmt.from_dict(stmt) assert_equal(str(s), '') + def test_INParamStmt_factory(): """ Test INParamStmt factory """ @@ -482,6 +523,7 @@ def test_INParamStmt_factory(): inp = INParamStmt.from_dict(stmt) assert_equal(inp.name, 'test') + def test_INParamStmt_dump(): """ Test INParamStmt to_gerber() """ @@ -489,11 +531,13 @@ def test_INParamStmt_dump(): inp = INParamStmt.from_dict(stmt) assert_equal(inp.to_gerber(), '%INtest*%') + def test_INParamStmt_string(): stmt = {'param': 'IN', 'name': 'test'} inp = INParamStmt.from_dict(stmt) assert_equal(str(inp), '') + def test_LNParamStmt_factory(): """ Test LNParamStmt factory """ @@ -501,6 +545,7 @@ def test_LNParamStmt_factory(): lnp = LNParamStmt.from_dict(stmt) assert_equal(lnp.name, 'test') + def test_LNParamStmt_dump(): """ Test LNParamStmt to_gerber() """ @@ -508,11 +553,13 @@ def test_LNParamStmt_dump(): lnp = LNParamStmt.from_dict(stmt) assert_equal(lnp.to_gerber(), '%LNtest*%') + def test_LNParamStmt_string(): stmt = {'param': 'LN', 'name': 'test'} lnp = LNParamStmt.from_dict(stmt) assert_equal(str(lnp), '') + def test_comment_stmt(): """ Test comment statement """ @@ -520,31 +567,37 @@ def test_comment_stmt(): assert_equal(stmt.type, 'COMMENT') assert_equal(stmt.comment, 'A comment') + def test_comment_stmt_dump(): """ Test CommentStmt to_gerber() """ stmt = CommentStmt('A comment') assert_equal(stmt.to_gerber(), 'G04A comment*') + def test_comment_stmt_string(): stmt = CommentStmt('A comment') assert_equal(str(stmt), '') + def test_eofstmt(): """ Test EofStmt """ stmt = EofStmt() assert_equal(stmt.type, 'EOF') + def test_eofstmt_dump(): """ Test EofStmt to_gerber() """ stmt = EofStmt() assert_equal(stmt.to_gerber(), 'M02*') + def test_eofstmt_string(): assert_equal(str(EofStmt()), '') + def test_quadmodestmt_factory(): """ Test QuadrantModeStmt.from_gerber() """ @@ -557,6 +610,7 @@ def test_quadmodestmt_factory(): stmt = QuadrantModeStmt.from_gerber(line) assert_equal(stmt.mode, 'multi-quadrant') + def test_quadmodestmt_validation(): """ Test QuadrantModeStmt input validation """ @@ -564,6 +618,7 @@ def test_quadmodestmt_validation(): assert_raises(ValueError, QuadrantModeStmt.from_gerber, line) assert_raises(ValueError, QuadrantModeStmt, 'quadrant-ful') + def test_quadmodestmt_dump(): """ Test QuadrantModeStmt.to_gerber() """ @@ -571,6 +626,7 @@ def test_quadmodestmt_dump(): stmt = QuadrantModeStmt.from_gerber(line) assert_equal(stmt.to_gerber(), line) + def test_regionmodestmt_factory(): """ Test RegionModeStmt.from_gerber() """ @@ -583,6 +639,7 @@ def test_regionmodestmt_factory(): stmt = RegionModeStmt.from_gerber(line) assert_equal(stmt.mode, 'off') + def test_regionmodestmt_validation(): """ Test RegionModeStmt input validation """ @@ -590,6 +647,7 @@ def test_regionmodestmt_validation(): assert_raises(ValueError, RegionModeStmt.from_gerber, line) assert_raises(ValueError, RegionModeStmt, 'off-ish') + def test_regionmodestmt_dump(): """ Test RegionModeStmt.to_gerber() """ @@ -597,6 +655,7 @@ def test_regionmodestmt_dump(): stmt = RegionModeStmt.from_gerber(line) assert_equal(stmt.to_gerber(), line) + def test_unknownstmt(): """ Test UnknownStmt """ @@ -605,6 +664,7 @@ def test_unknownstmt(): assert_equal(stmt.type, 'UNKNOWN') assert_equal(stmt.line, line) + def test_unknownstmt_dump(): """ Test UnknownStmt.to_gerber() """ @@ -613,15 +673,17 @@ def test_unknownstmt_dump(): stmt = UnknownStmt(line) assert_equal(stmt.to_gerber(), line) + def test_statement_string(): """ Test Statement.__str__() """ stmt = Statement('PARAM') assert_in('type=PARAM', str(stmt)) - stmt.test='PASS' + stmt.test = 'PASS' assert_in('test=PASS', str(stmt)) assert_in('type=PARAM', str(stmt)) + def test_ADParamStmt_factory(): """ Test ADParamStmt factory """ @@ -653,12 +715,14 @@ def test_ADParamStmt_factory(): assert_equal(ad.shape, 'R') assert_equal(ad.modifiers, [(1.42, 1.24)]) + def test_ADParamStmt_conversion(): - stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '25.4X25.4,25.4X25.4'} + stmt = {'param': 'AD', 'd': 0, 'shape': 'C', + 'modifiers': '25.4X25.4,25.4X25.4'} ad = ADParamStmt.from_dict(stmt) ad.units = 'metric' - #No effect + # No effect ad.to_metric() assert_equal(ad.modifiers[0], (25.4, 25.4)) assert_equal(ad.modifiers[1], (25.4, 25.4)) @@ -668,7 +732,7 @@ def test_ADParamStmt_conversion(): assert_equal(ad.modifiers[0], (1., 1.)) assert_equal(ad.modifiers[1], (1., 1.)) - #No effect + # No effect ad.to_inch() assert_equal(ad.modifiers[0], (1., 1.)) assert_equal(ad.modifiers[1], (1., 1.)) @@ -677,7 +741,7 @@ def test_ADParamStmt_conversion(): ad = ADParamStmt.from_dict(stmt) ad.units = 'inch' - #No effect + # No effect ad.to_inch() assert_equal(ad.modifiers[0], (1., 1.)) assert_equal(ad.modifiers[1], (1., 1.)) @@ -686,11 +750,12 @@ def test_ADParamStmt_conversion(): assert_equal(ad.modifiers[0], (25.4, 25.4)) assert_equal(ad.modifiers[1], (25.4, 25.4)) - #No effect + # No effect ad.to_metric() assert_equal(ad.modifiers[0], (25.4, 25.4)) assert_equal(ad.modifiers[1], (25.4, 25.4)) + def test_ADParamStmt_dump(): stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} ad = ADParamStmt.from_dict(stmt) @@ -699,6 +764,7 @@ def test_ADParamStmt_dump(): ad = ADParamStmt.from_dict(stmt) assert_equal(ad.to_gerber(), '%ADD0C,1X1,1X1*%') + def test_ADPamramStmt_string(): stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} ad = ADParamStmt.from_dict(stmt) @@ -716,12 +782,14 @@ def test_ADPamramStmt_string(): ad = ADParamStmt.from_dict(stmt) assert_equal(str(ad), '') + def test_MIParamStmt_factory(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) assert_equal(mi.a, 1) assert_equal(mi.b, 1) + def test_MIParamStmt_dump(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) @@ -733,6 +801,7 @@ def test_MIParamStmt_dump(): mi = MIParamStmt.from_dict(stmt) assert_equal(mi.to_gerber(), '%MIA0B1*%') + def test_MIParamStmt_string(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) @@ -746,6 +815,7 @@ def test_MIParamStmt_string(): mi = MIParamStmt.from_dict(stmt) assert_equal(str(mi), '') + def test_coordstmt_ctor(): cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings()) assert_equal(cs.function, 'G04') @@ -755,8 +825,10 @@ def test_coordstmt_ctor(): assert_equal(cs.j, 0.3) assert_equal(cs.op, 'D01') + def test_coordstmt_factory(): - stmt = {'function': 'G04', 'x': '0', 'y': '001', 'i': '002', 'j': '003', 'op': 'D01'} + stmt = {'function': 'G04', 'x': '0', 'y': '001', + 'i': '002', 'j': '003', 'op': 'D01'} cs = CoordStmt.from_dict(stmt, FileSettings()) assert_equal(cs.function, 'G04') assert_equal(cs.x, 0.0) @@ -765,15 +837,17 @@ def test_coordstmt_factory(): assert_equal(cs.j, 0.3) assert_equal(cs.op, 'D01') + def test_coordstmt_dump(): cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings()) assert_equal(cs.to_gerber(FileSettings()), 'G04X0Y001I002J003D01*') + def test_coordstmt_conversion(): cs = CoordStmt('G71', 25.4, 25.4, 25.4, 25.4, 'D01', FileSettings()) cs.units = 'metric' - #No effect + # No effect cs.to_metric() assert_equal(cs.x, 25.4) assert_equal(cs.y, 25.4) @@ -789,7 +863,7 @@ def test_coordstmt_conversion(): assert_equal(cs.j, 1.) assert_equal(cs.function, 'G70') - #No effect + # No effect cs.to_inch() assert_equal(cs.x, 1.) assert_equal(cs.y, 1.) @@ -800,7 +874,7 @@ def test_coordstmt_conversion(): cs = CoordStmt('G70', 1., 1., 1., 1., 'D01', FileSettings()) cs.units = 'inch' - #No effect + # No effect cs.to_inch() assert_equal(cs.x, 1.) assert_equal(cs.y, 1.) @@ -815,7 +889,7 @@ def test_coordstmt_conversion(): assert_equal(cs.j, 25.4) assert_equal(cs.function, 'G71') - #No effect + # No effect cs.to_metric() assert_equal(cs.x, 25.4) assert_equal(cs.y, 25.4) @@ -823,6 +897,7 @@ def test_coordstmt_conversion(): assert_equal(cs.j, 25.4) assert_equal(cs.function, 'G71') + def test_coordstmt_offset(): c = CoordStmt('G71', 0, 0, 0, 0, 'D01', FileSettings()) c.offset(1, 0) @@ -836,9 +911,11 @@ def test_coordstmt_offset(): assert_equal(c.i, 1.) assert_equal(c.j, 1.) + def test_coordstmt_string(): cs = CoordStmt('G04', 0, 1, 2, 3, 'D01', FileSettings()) - assert_equal(str(cs), '') + assert_equal(str(cs), + '') cs = CoordStmt('G04', None, None, None, None, 'D02', FileSettings()) assert_equal(str(cs), '') cs = CoordStmt('G04', None, None, None, None, 'D03', FileSettings()) @@ -846,6 +923,7 @@ def test_coordstmt_string(): cs = CoordStmt('G04', None, None, None, None, 'TEST', FileSettings()) assert_equal(str(cs), '') + def test_aperturestmt_ctor(): ast = ApertureStmt(3, False) assert_equal(ast.d, 3) @@ -860,11 +938,10 @@ def test_aperturestmt_ctor(): assert_equal(ast.d, 3) assert_equal(ast.deprecated, False) + def test_aperturestmt_dump(): ast = ApertureStmt(3, False) assert_equal(ast.to_gerber(), 'D3*') ast = ApertureStmt(3, True) assert_equal(ast.to_gerber(), 'G54D3*') assert_equal(str(ast), '') - - -- cgit From 8cd842a41a55ab3d8f558a2e3e198beba7da58a1 Mon Sep 17 00:00:00 2001 From: Hamilton Kibbe Date: Thu, 21 Jan 2016 03:57:44 -0500 Subject: Manually mere rendering changes --- gerber/tests/test_gerber_statements.py | 145 +++++++++++++++++++++++++-------- 1 file changed, 111 insertions(+), 34 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index a89a283..2157390 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -7,6 +7,7 @@ from .tests import * from ..gerber_statements import * from ..cam import FileSettings + def test_Statement_smoketest(): stmt = Statement('Test') assert_equal(stmt.type, 'Test') @@ -16,7 +17,8 @@ def test_Statement_smoketest(): assert_in('units=inch', str(stmt)) stmt.to_metric() stmt.offset(1, 1) - assert_in('type=Test',str(stmt)) + assert_in('type=Test', str(stmt)) + def test_FSParamStmt_factory(): """ Test FSParamStruct factory @@ -35,6 +37,7 @@ def test_FSParamStmt_factory(): assert_equal(fs.notation, 'incremental') assert_equal(fs.format, (2, 7)) + def test_FSParamStmt(): """ Test FSParamStmt initialization """ @@ -48,6 +51,7 @@ def test_FSParamStmt(): assert_equal(stmt.notation, notation) assert_equal(stmt.format, fmt) + def test_FSParamStmt_dump(): """ Test FSParamStmt to_gerber() """ @@ -62,16 +66,20 @@ def test_FSParamStmt_dump(): settings = FileSettings(zero_suppression='leading', notation='absolute') assert_equal(fs.to_gerber(settings), '%FSLAX25Y25*%') + def test_FSParamStmt_string(): """ Test FSParamStmt.__str__() """ stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'} fs = FSParamStmt.from_dict(stmt) - assert_equal(str(fs), '') + assert_equal(str(fs), + '') stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'} fs = FSParamStmt.from_dict(stmt) - assert_equal(str(fs), '') + assert_equal(str(fs), + '') + def test_MOParamStmt_factory(): """ Test MOParamStruct factory @@ -94,6 +102,7 @@ def test_MOParamStmt_factory(): stmt = {'param': 'MO', 'mo': 'degrees kelvin'} assert_raises(ValueError, MOParamStmt.from_dict, stmt) + def test_MOParamStmt(): """ Test MOParamStmt initialization """ @@ -106,6 +115,7 @@ def test_MOParamStmt(): stmt = MOParamStmt(param, mode) assert_equal(stmt.mode, mode) + def test_MOParamStmt_dump(): """ Test MOParamStmt to_gerber() """ @@ -117,6 +127,7 @@ def test_MOParamStmt_dump(): mo = MOParamStmt.from_dict(stmt) assert_equal(mo.to_gerber(), '%MOMM*%') + def test_MOParamStmt_conversion(): stmt = {'param': 'MO', 'mo': 'MM'} mo = MOParamStmt.from_dict(stmt) @@ -128,6 +139,7 @@ def test_MOParamStmt_conversion(): mo.to_metric() assert_equal(mo.mode, 'metric') + def test_MOParamStmt_string(): """ Test MOParamStmt.__str__() """ @@ -139,6 +151,7 @@ def test_MOParamStmt_string(): mo = MOParamStmt.from_dict(stmt) assert_equal(str(mo), '') + def test_IPParamStmt_factory(): """ Test IPParamStruct factory """ @@ -150,6 +163,7 @@ def test_IPParamStmt_factory(): ip = IPParamStmt.from_dict(stmt) assert_equal(ip.ip, 'negative') + def test_IPParamStmt(): """ Test IPParamStmt initialization """ @@ -159,6 +173,7 @@ def test_IPParamStmt(): assert_equal(stmt.param, param) assert_equal(stmt.ip, ip) + def test_IPParamStmt_dump(): """ Test IPParamStmt to_gerber() """ @@ -170,6 +185,7 @@ def test_IPParamStmt_dump(): ip = IPParamStmt.from_dict(stmt) assert_equal(ip.to_gerber(), '%IPNEG*%') + def test_IPParamStmt_string(): stmt = {'param': 'IP', 'ip': 'POS'} ip = IPParamStmt.from_dict(stmt) @@ -179,22 +195,26 @@ def test_IPParamStmt_string(): ip = IPParamStmt.from_dict(stmt) assert_equal(str(ip), '') + def test_IRParamStmt_factory(): stmt = {'param': 'IR', 'angle': '45'} ir = IRParamStmt.from_dict(stmt) assert_equal(ir.param, 'IR') assert_equal(ir.angle, 45) + def test_IRParamStmt_dump(): stmt = {'param': 'IR', 'angle': '45'} ir = IRParamStmt.from_dict(stmt) assert_equal(ir.to_gerber(), '%IR45*%') + def test_IRParamStmt_string(): stmt = {'param': 'IR', 'angle': '45'} ir = IRParamStmt.from_dict(stmt) assert_equal(str(ir), '') + def test_OFParamStmt_factory(): """ Test OFParamStmt factory """ @@ -203,6 +223,7 @@ def test_OFParamStmt_factory(): assert_equal(of.a, 0.1234567) assert_equal(of.b, 0.1234567) + def test_OFParamStmt(): """ Test IPParamStmt initialization """ @@ -213,6 +234,7 @@ def test_OFParamStmt(): assert_equal(stmt.a, val) assert_equal(stmt.b, val) + def test_OFParamStmt_dump(): """ Test OFParamStmt to_gerber() """ @@ -220,10 +242,11 @@ def test_OFParamStmt_dump(): of = OFParamStmt.from_dict(stmt) assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%') + def test_OFParamStmt_conversion(): stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} of = OFParamStmt.from_dict(stmt) - of.units='metric' + of.units = 'metric' # No effect of.to_metric() @@ -235,7 +258,7 @@ def test_OFParamStmt_conversion(): assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) - #No effect + # No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) @@ -244,7 +267,7 @@ def test_OFParamStmt_conversion(): of = OFParamStmt.from_dict(stmt) of.units = 'inch' - #No effect + # No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) @@ -254,11 +277,12 @@ def test_OFParamStmt_conversion(): assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) - #No effect + # No effect of.to_metric() assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) + def test_OFParamStmt_offset(): s = OFParamStmt('OF', 0, 0) s.offset(1, 0) @@ -268,6 +292,7 @@ def test_OFParamStmt_offset(): assert_equal(s.a, 1.) assert_equal(s.b, 1.) + def test_OFParamStmt_string(): """ Test OFParamStmt __str__ """ @@ -275,6 +300,7 @@ def test_OFParamStmt_string(): of = OFParamStmt.from_dict(stmt) assert_equal(str(of), '') + def test_SFParamStmt_factory(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) @@ -282,18 +308,20 @@ def test_SFParamStmt_factory(): assert_equal(sf.a, 1.4) assert_equal(sf.b, 0.9) + def test_SFParamStmt_dump(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) assert_equal(sf.to_gerber(), '%SFA1.4B0.9*%') + def test_SFParamStmt_conversion(): stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} of = SFParamStmt.from_dict(stmt) of.units = 'metric' of.to_metric() - #No effect + # No effect assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) @@ -302,7 +330,7 @@ def test_SFParamStmt_conversion(): assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) - #No effect + # No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) @@ -311,7 +339,7 @@ def test_SFParamStmt_conversion(): of = SFParamStmt.from_dict(stmt) of.units = 'inch' - #No effect + # No effect of.to_inch() assert_equal(of.a, 0.1) assert_equal(of.b, 1.0) @@ -321,11 +349,12 @@ def test_SFParamStmt_conversion(): assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) - #No effect + # No effect of.to_metric() assert_equal(of.a, 2.54) assert_equal(of.b, 25.4) + def test_SFParamStmt_offset(): s = SFParamStmt('OF', 0, 0) s.offset(1, 0) @@ -335,11 +364,13 @@ def test_SFParamStmt_offset(): assert_equal(s.a, 1.) assert_equal(s.b, 1.) + def test_SFParamStmt_string(): stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} sf = SFParamStmt.from_dict(stmt) assert_equal(str(sf), '') + def test_LPParamStmt_factory(): """ Test LPParamStmt factory """ @@ -351,6 +382,7 @@ def test_LPParamStmt_factory(): lp = LPParamStmt.from_dict(stmt) assert_equal(lp.lp, 'dark') + def test_LPParamStmt_dump(): """ Test LPParamStmt to_gerber() """ @@ -362,6 +394,7 @@ def test_LPParamStmt_dump(): lp = LPParamStmt.from_dict(stmt) assert_equal(lp.to_gerber(), '%LPD*%') + def test_LPParamStmt_string(): """ Test LPParamStmt.__str__() """ @@ -373,6 +406,7 @@ def test_LPParamStmt_string(): lp = LPParamStmt.from_dict(stmt) assert_equal(str(lp), '') + def test_AMParamStmt_factory(): name = 'DONUTVAR' macro = ( @@ -387,7 +421,7 @@ def test_AMParamStmt_factory(): 7,0,0,7,6,0.2,0* 8,THIS IS AN UNSUPPORTED PRIMITIVE* ''') - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() assert_equal(len(s.primitives), 10) assert_true(isinstance(s.primitives[0], AMCommentPrimitive)) @@ -401,15 +435,16 @@ def test_AMParamStmt_factory(): assert_true(isinstance(s.primitives[8], AMThermalPrimitive)) assert_true(isinstance(s.primitives[9], AMUnsupportPrimitive)) + def testAMParamStmt_conversion(): name = 'POLYGON' macro = '5,1,8,25.4,25.4,25.4,0*' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() s.units = 'metric' - #No effect + # No effect s.to_metric() assert_equal(s.primitives[0].position, (25.4, 25.4)) assert_equal(s.primitives[0].diameter, 25.4) @@ -419,17 +454,17 @@ def testAMParamStmt_conversion(): assert_equal(s.primitives[0].position, (1., 1.)) assert_equal(s.primitives[0].diameter, 1.) - #No effect + # No effect s.to_inch() assert_equal(s.primitives[0].position, (1., 1.)) assert_equal(s.primitives[0].diameter, 1.) macro = '5,1,8,1,1,1,0*' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() s.units = 'inch' - #No effect + # No effect s.to_inch() assert_equal(s.primitives[0].position, (1., 1.)) assert_equal(s.primitives[0].diameter, 1.) @@ -439,15 +474,16 @@ def testAMParamStmt_conversion(): assert_equal(s.primitives[0].position, (25.4, 25.4)) assert_equal(s.primitives[0].diameter, 25.4) - #No effect + # No effect s.to_metric() assert_equal(s.primitives[0].position, (25.4, 25.4)) assert_equal(s.primitives[0].diameter, 25.4) + def test_AMParamStmt_dump(): name = 'POLYGON' macro = '5,1,8,25.4,25.4,25.4,0.0' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%') @@ -455,29 +491,34 @@ def test_AMParamStmt_dump(): s.build() assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,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 }) + s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) s.build() assert_equal(str(s), '') + def test_ASParamStmt_factory(): stmt = {'param': 'AS', 'mode': 'AXBY'} s = ASParamStmt.from_dict(stmt) assert_equal(s.param, 'AS') assert_equal(s.mode, 'AXBY') + def test_ASParamStmt_dump(): stmt = {'param': 'AS', 'mode': 'AXBY'} s = ASParamStmt.from_dict(stmt) assert_equal(s.to_gerber(), '%ASAXBY*%') + def test_ASParamStmt_string(): stmt = {'param': 'AS', 'mode': 'AXBY'} s = ASParamStmt.from_dict(stmt) assert_equal(str(s), '') + def test_INParamStmt_factory(): """ Test INParamStmt factory """ @@ -485,6 +526,7 @@ def test_INParamStmt_factory(): inp = INParamStmt.from_dict(stmt) assert_equal(inp.name, 'test') + def test_INParamStmt_dump(): """ Test INParamStmt to_gerber() """ @@ -492,11 +534,13 @@ def test_INParamStmt_dump(): inp = INParamStmt.from_dict(stmt) assert_equal(inp.to_gerber(), '%INtest*%') + def test_INParamStmt_string(): stmt = {'param': 'IN', 'name': 'test'} inp = INParamStmt.from_dict(stmt) assert_equal(str(inp), '') + def test_LNParamStmt_factory(): """ Test LNParamStmt factory """ @@ -504,6 +548,7 @@ def test_LNParamStmt_factory(): lnp = LNParamStmt.from_dict(stmt) assert_equal(lnp.name, 'test') + def test_LNParamStmt_dump(): """ Test LNParamStmt to_gerber() """ @@ -511,11 +556,13 @@ def test_LNParamStmt_dump(): lnp = LNParamStmt.from_dict(stmt) assert_equal(lnp.to_gerber(), '%LNtest*%') + def test_LNParamStmt_string(): stmt = {'param': 'LN', 'name': 'test'} lnp = LNParamStmt.from_dict(stmt) assert_equal(str(lnp), '') + def test_comment_stmt(): """ Test comment statement """ @@ -523,31 +570,37 @@ def test_comment_stmt(): assert_equal(stmt.type, 'COMMENT') assert_equal(stmt.comment, 'A comment') + def test_comment_stmt_dump(): """ Test CommentStmt to_gerber() """ stmt = CommentStmt('A comment') assert_equal(stmt.to_gerber(), 'G04A comment*') + def test_comment_stmt_string(): stmt = CommentStmt('A comment') assert_equal(str(stmt), '') + def test_eofstmt(): """ Test EofStmt """ stmt = EofStmt() assert_equal(stmt.type, 'EOF') + def test_eofstmt_dump(): """ Test EofStmt to_gerber() """ stmt = EofStmt() assert_equal(stmt.to_gerber(), 'M02*') + def test_eofstmt_string(): assert_equal(str(EofStmt()), '') + def test_quadmodestmt_factory(): """ Test QuadrantModeStmt.from_gerber() """ @@ -560,6 +613,7 @@ def test_quadmodestmt_factory(): stmt = QuadrantModeStmt.from_gerber(line) assert_equal(stmt.mode, 'multi-quadrant') + def test_quadmodestmt_validation(): """ Test QuadrantModeStmt input validation """ @@ -567,6 +621,7 @@ def test_quadmodestmt_validation(): assert_raises(ValueError, QuadrantModeStmt.from_gerber, line) assert_raises(ValueError, QuadrantModeStmt, 'quadrant-ful') + def test_quadmodestmt_dump(): """ Test QuadrantModeStmt.to_gerber() """ @@ -574,6 +629,7 @@ def test_quadmodestmt_dump(): stmt = QuadrantModeStmt.from_gerber(line) assert_equal(stmt.to_gerber(), line) + def test_regionmodestmt_factory(): """ Test RegionModeStmt.from_gerber() """ @@ -586,6 +642,7 @@ def test_regionmodestmt_factory(): stmt = RegionModeStmt.from_gerber(line) assert_equal(stmt.mode, 'off') + def test_regionmodestmt_validation(): """ Test RegionModeStmt input validation """ @@ -593,6 +650,7 @@ def test_regionmodestmt_validation(): assert_raises(ValueError, RegionModeStmt.from_gerber, line) assert_raises(ValueError, RegionModeStmt, 'off-ish') + def test_regionmodestmt_dump(): """ Test RegionModeStmt.to_gerber() """ @@ -600,6 +658,7 @@ def test_regionmodestmt_dump(): stmt = RegionModeStmt.from_gerber(line) assert_equal(stmt.to_gerber(), line) + def test_unknownstmt(): """ Test UnknownStmt """ @@ -608,6 +667,7 @@ def test_unknownstmt(): assert_equal(stmt.type, 'UNKNOWN') assert_equal(stmt.line, line) + def test_unknownstmt_dump(): """ Test UnknownStmt.to_gerber() """ @@ -616,15 +676,17 @@ def test_unknownstmt_dump(): stmt = UnknownStmt(line) assert_equal(stmt.to_gerber(), line) + def test_statement_string(): """ Test Statement.__str__() """ stmt = Statement('PARAM') assert_in('type=PARAM', str(stmt)) - stmt.test='PASS' + stmt.test = 'PASS' assert_in('test=PASS', str(stmt)) assert_in('type=PARAM', str(stmt)) + def test_ADParamStmt_factory(): """ Test ADParamStmt factory """ @@ -656,12 +718,14 @@ def test_ADParamStmt_factory(): assert_equal(ad.shape, 'R') assert_equal(ad.modifiers, [(1.42, 1.24)]) + def test_ADParamStmt_conversion(): - stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '25.4X25.4,25.4X25.4'} + stmt = {'param': 'AD', 'd': 0, 'shape': 'C', + 'modifiers': '25.4X25.4,25.4X25.4'} ad = ADParamStmt.from_dict(stmt) ad.units = 'metric' - #No effect + # No effect ad.to_metric() assert_equal(ad.modifiers[0], (25.4, 25.4)) assert_equal(ad.modifiers[1], (25.4, 25.4)) @@ -671,7 +735,7 @@ def test_ADParamStmt_conversion(): assert_equal(ad.modifiers[0], (1., 1.)) assert_equal(ad.modifiers[1], (1., 1.)) - #No effect + # No effect ad.to_inch() assert_equal(ad.modifiers[0], (1., 1.)) assert_equal(ad.modifiers[1], (1., 1.)) @@ -680,7 +744,7 @@ def test_ADParamStmt_conversion(): ad = ADParamStmt.from_dict(stmt) ad.units = 'inch' - #No effect + # No effect ad.to_inch() assert_equal(ad.modifiers[0], (1., 1.)) assert_equal(ad.modifiers[1], (1., 1.)) @@ -689,11 +753,12 @@ def test_ADParamStmt_conversion(): assert_equal(ad.modifiers[0], (25.4, 25.4)) assert_equal(ad.modifiers[1], (25.4, 25.4)) - #No effect + # No effect ad.to_metric() assert_equal(ad.modifiers[0], (25.4, 25.4)) assert_equal(ad.modifiers[1], (25.4, 25.4)) + def test_ADParamStmt_dump(): stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} ad = ADParamStmt.from_dict(stmt) @@ -702,6 +767,7 @@ def test_ADParamStmt_dump(): ad = ADParamStmt.from_dict(stmt) assert_equal(ad.to_gerber(), '%ADD0C,1X1,1X1*%') + def test_ADPamramStmt_string(): stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} ad = ADParamStmt.from_dict(stmt) @@ -719,12 +785,14 @@ def test_ADPamramStmt_string(): ad = ADParamStmt.from_dict(stmt) assert_equal(str(ad), '') + def test_MIParamStmt_factory(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) assert_equal(mi.a, 1) assert_equal(mi.b, 1) + def test_MIParamStmt_dump(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) @@ -736,6 +804,7 @@ def test_MIParamStmt_dump(): mi = MIParamStmt.from_dict(stmt) assert_equal(mi.to_gerber(), '%MIA0B1*%') + def test_MIParamStmt_string(): stmt = {'param': 'MI', 'a': 1, 'b': 1} mi = MIParamStmt.from_dict(stmt) @@ -749,6 +818,7 @@ def test_MIParamStmt_string(): mi = MIParamStmt.from_dict(stmt) assert_equal(str(mi), '') + def test_coordstmt_ctor(): cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings()) assert_equal(cs.function, 'G04') @@ -758,8 +828,10 @@ def test_coordstmt_ctor(): assert_equal(cs.j, 0.3) assert_equal(cs.op, 'D01') + def test_coordstmt_factory(): - stmt = {'function': 'G04', 'x': '0', 'y': '001', 'i': '002', 'j': '003', 'op': 'D01'} + stmt = {'function': 'G04', 'x': '0', 'y': '001', + 'i': '002', 'j': '003', 'op': 'D01'} cs = CoordStmt.from_dict(stmt, FileSettings()) assert_equal(cs.function, 'G04') assert_equal(cs.x, 0.0) @@ -768,15 +840,17 @@ def test_coordstmt_factory(): assert_equal(cs.j, 0.3) assert_equal(cs.op, 'D01') + def test_coordstmt_dump(): cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings()) assert_equal(cs.to_gerber(FileSettings()), 'G04X0Y001I002J003D01*') + def test_coordstmt_conversion(): cs = CoordStmt('G71', 25.4, 25.4, 25.4, 25.4, 'D01', FileSettings()) cs.units = 'metric' - #No effect + # No effect cs.to_metric() assert_equal(cs.x, 25.4) assert_equal(cs.y, 25.4) @@ -792,7 +866,7 @@ def test_coordstmt_conversion(): assert_equal(cs.j, 1.) assert_equal(cs.function, 'G70') - #No effect + # No effect cs.to_inch() assert_equal(cs.x, 1.) assert_equal(cs.y, 1.) @@ -803,7 +877,7 @@ def test_coordstmt_conversion(): cs = CoordStmt('G70', 1., 1., 1., 1., 'D01', FileSettings()) cs.units = 'inch' - #No effect + # No effect cs.to_inch() assert_equal(cs.x, 1.) assert_equal(cs.y, 1.) @@ -818,7 +892,7 @@ def test_coordstmt_conversion(): assert_equal(cs.j, 25.4) assert_equal(cs.function, 'G71') - #No effect + # No effect cs.to_metric() assert_equal(cs.x, 25.4) assert_equal(cs.y, 25.4) @@ -826,6 +900,7 @@ def test_coordstmt_conversion(): assert_equal(cs.j, 25.4) assert_equal(cs.function, 'G71') + def test_coordstmt_offset(): c = CoordStmt('G71', 0, 0, 0, 0, 'D01', FileSettings()) c.offset(1, 0) @@ -839,9 +914,11 @@ def test_coordstmt_offset(): assert_equal(c.i, 1.) assert_equal(c.j, 1.) + def test_coordstmt_string(): cs = CoordStmt('G04', 0, 1, 2, 3, 'D01', FileSettings()) - assert_equal(str(cs), '') + assert_equal(str(cs), + '') cs = CoordStmt('G04', None, None, None, None, 'D02', FileSettings()) assert_equal(str(cs), '') cs = CoordStmt('G04', None, None, None, None, 'D03', FileSettings()) @@ -849,6 +926,7 @@ def test_coordstmt_string(): cs = CoordStmt('G04', None, None, None, None, 'TEST', FileSettings()) assert_equal(str(cs), '') + def test_aperturestmt_ctor(): ast = ApertureStmt(3, False) assert_equal(ast.d, 3) @@ -863,11 +941,10 @@ def test_aperturestmt_ctor(): assert_equal(ast.d, 3) assert_equal(ast.deprecated, False) + def test_aperturestmt_dump(): ast = ApertureStmt(3, False) assert_equal(ast.to_gerber(), 'D3*') ast = ApertureStmt(3, True) assert_equal(ast.to_gerber(), 'G54D3*') assert_equal(str(ast), '') - - -- cgit From ef589a064015de3a1ce6487dbb56b99332673e9d Mon Sep 17 00:00:00 2001 From: Paulo Henrique Silva Date: Tue, 26 Nov 2019 00:37:41 -0300 Subject: Migrate to pytest (#111) * Migrate to pytest All tests were update to use pytest. Tests were alse black formatted. Eventually all code will be black formatted but need to merge some PRs first. --- gerber/tests/test_gerber_statements.py | 835 +++++++++++++++++---------------- 1 file changed, 421 insertions(+), 414 deletions(-) (limited to 'gerber/tests/test_gerber_statements.py') diff --git a/gerber/tests/test_gerber_statements.py b/gerber/tests/test_gerber_statements.py index 15f35a1..140cbd1 100644 --- a/gerber/tests/test_gerber_statements.py +++ b/gerber/tests/test_gerber_statements.py @@ -3,414 +3,413 @@ # Author: Hamilton Kibbe -from .tests import * +import pytest from ..gerber_statements import * from ..cam import FileSettings def test_Statement_smoketest(): - stmt = Statement('Test') - assert_equal(stmt.type, 'Test') + stmt = Statement("Test") + assert stmt.type == "Test" stmt.to_metric() - assert_in('units=metric', str(stmt)) + assert "units=metric" in str(stmt) stmt.to_inch() - assert_in('units=inch', str(stmt)) + assert "units=inch" in str(stmt) stmt.to_metric() stmt.offset(1, 1) - assert_in('type=Test', str(stmt)) + assert "type=Test" in str(stmt) def test_FSParamStmt_factory(): """ Test FSParamStruct factory """ - stmt = {'param': 'FS', 'zero': 'L', 'notation': 'A', 'x': '27'} + stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"} fs = FSParamStmt.from_dict(stmt) - assert_equal(fs.param, 'FS') - assert_equal(fs.zero_suppression, 'leading') - assert_equal(fs.notation, 'absolute') - assert_equal(fs.format, (2, 7)) + 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'} + stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "27"} fs = FSParamStmt.from_dict(stmt) - assert_equal(fs.param, 'FS') - assert_equal(fs.zero_suppression, 'trailing') - assert_equal(fs.notation, 'incremental') - assert_equal(fs.format, (2, 7)) + 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' + param = "FS" + zeros = "trailing" + notation = "absolute" fmt = (2, 5) stmt = FSParamStmt(param, zeros, notation, fmt) - assert_equal(stmt.param, param) - assert_equal(stmt.zero_suppression, zeros) - assert_equal(stmt.notation, notation) - assert_equal(stmt.format, fmt) + 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'} + stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"} fs = FSParamStmt.from_dict(stmt) - assert_equal(fs.to_gerber(), '%FSLAX27Y27*%') + assert fs.to_gerber() == "%FSLAX27Y27*%" - stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'} + stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "25"} fs = FSParamStmt.from_dict(stmt) - assert_equal(fs.to_gerber(), '%FSTIX25Y25*%') + assert fs.to_gerber() == "%FSTIX25Y25*%" - settings = FileSettings(zero_suppression='leading', notation='absolute') - assert_equal(fs.to_gerber(settings), '%FSLAX25Y25*%') + 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'} + stmt = {"param": "FS", "zero": "L", "notation": "A", "x": "27"} fs = FSParamStmt.from_dict(stmt) - assert_equal(str(fs), - '') + assert str(fs) == "" - stmt = {'param': 'FS', 'zero': 'T', 'notation': 'I', 'x': '25'} + stmt = {"param": "FS", "zero": "T", "notation": "I", "x": "25"} fs = FSParamStmt.from_dict(stmt) - assert_equal(str(fs), - '') + assert ( + str(fs) == "" + ) def test_MOParamStmt_factory(): """ Test MOParamStruct factory """ - stmts = [{'param': 'MO', 'mo': 'IN'}, {'param': 'MO', 'mo': 'in'}, ] + stmts = [{"param": "MO", "mo": "IN"}, {"param": "MO", "mo": "in"}] for stmt in stmts: mo = MOParamStmt.from_dict(stmt) - assert_equal(mo.param, 'MO') - assert_equal(mo.mode, 'inch') + assert mo.param == "MO" + assert mo.mode == "inch" - stmts = [{'param': 'MO', 'mo': 'MM'}, {'param': 'MO', 'mo': 'mm'}, ] + stmts = [{"param": "MO", "mo": "MM"}, {"param": "MO", "mo": "mm"}] for stmt in stmts: mo = MOParamStmt.from_dict(stmt) - assert_equal(mo.param, 'MO') - assert_equal(mo.mode, 'metric') + assert mo.param == "MO" + assert mo.mode == "metric" - stmt = {'param': 'MO'} + stmt = {"param": "MO"} mo = MOParamStmt.from_dict(stmt) - assert_equal(mo.mode, None) - stmt = {'param': 'MO', 'mo': 'degrees kelvin'} - assert_raises(ValueError, MOParamStmt.from_dict, stmt) + 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' + param = "MO" + mode = "inch" stmt = MOParamStmt(param, mode) - assert_equal(stmt.param, param) + assert stmt.param == param - for mode in ['inch', 'metric']: + for mode in ["inch", "metric"]: stmt = MOParamStmt(param, mode) - assert_equal(stmt.mode, mode) + assert stmt.mode == mode def test_MOParamStmt_dump(): """ Test MOParamStmt to_gerber() """ - stmt = {'param': 'MO', 'mo': 'IN'} + stmt = {"param": "MO", "mo": "IN"} mo = MOParamStmt.from_dict(stmt) - assert_equal(mo.to_gerber(), '%MOIN*%') + assert mo.to_gerber() == "%MOIN*%" - stmt = {'param': 'MO', 'mo': 'MM'} + stmt = {"param": "MO", "mo": "MM"} mo = MOParamStmt.from_dict(stmt) - assert_equal(mo.to_gerber(), '%MOMM*%') + assert mo.to_gerber() == "%MOMM*%" def test_MOParamStmt_conversion(): - stmt = {'param': 'MO', 'mo': 'MM'} + stmt = {"param": "MO", "mo": "MM"} mo = MOParamStmt.from_dict(stmt) mo.to_inch() - assert_equal(mo.mode, 'inch') + assert mo.mode == "inch" - stmt = {'param': 'MO', 'mo': 'IN'} + stmt = {"param": "MO", "mo": "IN"} mo = MOParamStmt.from_dict(stmt) mo.to_metric() - assert_equal(mo.mode, 'metric') + assert mo.mode == "metric" def test_MOParamStmt_string(): """ Test MOParamStmt.__str__() """ - stmt = {'param': 'MO', 'mo': 'IN'} + stmt = {"param": "MO", "mo": "IN"} mo = MOParamStmt.from_dict(stmt) - assert_equal(str(mo), '') + assert str(mo) == "" - stmt = {'param': 'MO', 'mo': 'MM'} + stmt = {"param": "MO", "mo": "MM"} mo = MOParamStmt.from_dict(stmt) - assert_equal(str(mo), '') + assert str(mo) == "" def test_IPParamStmt_factory(): """ Test IPParamStruct factory """ - stmt = {'param': 'IP', 'ip': 'POS'} + stmt = {"param": "IP", "ip": "POS"} ip = IPParamStmt.from_dict(stmt) - assert_equal(ip.ip, 'positive') + assert ip.ip == "positive" - stmt = {'param': 'IP', 'ip': 'NEG'} + stmt = {"param": "IP", "ip": "NEG"} ip = IPParamStmt.from_dict(stmt) - assert_equal(ip.ip, 'negative') + assert ip.ip == "negative" def test_IPParamStmt(): """ Test IPParamStmt initialization """ - param = 'IP' - for ip in ['positive', 'negative']: + param = "IP" + for ip in ["positive", "negative"]: stmt = IPParamStmt(param, ip) - assert_equal(stmt.param, param) - assert_equal(stmt.ip, ip) + assert stmt.param == param + assert stmt.ip == ip def test_IPParamStmt_dump(): """ Test IPParamStmt to_gerber() """ - stmt = {'param': 'IP', 'ip': 'POS'} + stmt = {"param": "IP", "ip": "POS"} ip = IPParamStmt.from_dict(stmt) - assert_equal(ip.to_gerber(), '%IPPOS*%') + assert ip.to_gerber() == "%IPPOS*%" - stmt = {'param': 'IP', 'ip': 'NEG'} + stmt = {"param": "IP", "ip": "NEG"} ip = IPParamStmt.from_dict(stmt) - assert_equal(ip.to_gerber(), '%IPNEG*%') + assert ip.to_gerber() == "%IPNEG*%" def test_IPParamStmt_string(): - stmt = {'param': 'IP', 'ip': 'POS'} + stmt = {"param": "IP", "ip": "POS"} ip = IPParamStmt.from_dict(stmt) - assert_equal(str(ip), '') + assert str(ip) == "" - stmt = {'param': 'IP', 'ip': 'NEG'} + stmt = {"param": "IP", "ip": "NEG"} ip = IPParamStmt.from_dict(stmt) - assert_equal(str(ip), '') + assert str(ip) == "" def test_IRParamStmt_factory(): - stmt = {'param': 'IR', 'angle': '45'} + stmt = {"param": "IR", "angle": "45"} ir = IRParamStmt.from_dict(stmt) - assert_equal(ir.param, 'IR') - assert_equal(ir.angle, 45) + assert ir.param == "IR" + assert ir.angle == 45 def test_IRParamStmt_dump(): - stmt = {'param': 'IR', 'angle': '45'} + stmt = {"param": "IR", "angle": "45"} ir = IRParamStmt.from_dict(stmt) - assert_equal(ir.to_gerber(), '%IR45*%') + assert ir.to_gerber() == "%IR45*%" def test_IRParamStmt_string(): - stmt = {'param': 'IR', 'angle': '45'} + stmt = {"param": "IR", "angle": "45"} ir = IRParamStmt.from_dict(stmt) - assert_equal(str(ir), '') + assert str(ir) == "" def test_OFParamStmt_factory(): """ Test OFParamStmt factory """ - stmt = {'param': 'OF', 'a': '0.1234567', 'b': '0.1234567'} + stmt = {"param": "OF", "a": "0.1234567", "b": "0.1234567"} of = OFParamStmt.from_dict(stmt) - assert_equal(of.a, 0.1234567) - assert_equal(of.b, 0.1234567) + assert of.a == 0.1234567 + assert of.b == 0.1234567 def test_OFParamStmt(): """ Test IPParamStmt initialization """ - param = 'OF' + param = "OF" for val in [0.0, -3.4567]: stmt = OFParamStmt(param, val, val) - assert_equal(stmt.param, param) - assert_equal(stmt.a, val) - assert_equal(stmt.b, val) + 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'} + stmt = {"param": "OF", "a": "0.123456", "b": "0.123456"} of = OFParamStmt.from_dict(stmt) - assert_equal(of.to_gerber(), '%OFA0.12345B0.12345*%') + assert of.to_gerber() == "%OFA0.12345B0.12345*%" def test_OFParamStmt_conversion(): - stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} + stmt = {"param": "OF", "a": "2.54", "b": "25.4"} of = OFParamStmt.from_dict(stmt) - of.units = 'metric' + of.units = "metric" # No effect of.to_metric() - assert_equal(of.a, 2.54) - assert_equal(of.b, 25.4) + assert of.a == 2.54 + assert of.b == 25.4 of.to_inch() - assert_equal(of.units, 'inch') - assert_equal(of.a, 0.1) - assert_equal(of.b, 1.0) + assert of.units == "inch" + assert of.a == 0.1 + assert of.b == 1.0 # No effect of.to_inch() - assert_equal(of.a, 0.1) - assert_equal(of.b, 1.0) + assert of.a == 0.1 + assert of.b == 1.0 - stmt = {'param': 'OF', 'a': '0.1', 'b': '1.0'} + stmt = {"param": "OF", "a": "0.1", "b": "1.0"} of = OFParamStmt.from_dict(stmt) - of.units = 'inch' + of.units = "inch" # No effect of.to_inch() - assert_equal(of.a, 0.1) - assert_equal(of.b, 1.0) + assert of.a == 0.1 + assert of.b == 1.0 of.to_metric() - assert_equal(of.units, 'metric') - assert_equal(of.a, 2.54) - assert_equal(of.b, 25.4) + assert of.units == "metric" + assert of.a == 2.54 + assert of.b == 25.4 # No effect of.to_metric() - assert_equal(of.a, 2.54) - assert_equal(of.b, 25.4) + assert of.a == 2.54 + assert of.b == 25.4 def test_OFParamStmt_offset(): - s = OFParamStmt('OF', 0, 0) + s = OFParamStmt("OF", 0, 0) s.offset(1, 0) - assert_equal(s.a, 1.) - assert_equal(s.b, 0.) + assert s.a == 1.0 + assert s.b == 0.0 s.offset(0, 1) - assert_equal(s.a, 1.) - assert_equal(s.b, 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'} + stmt = {"param": "OF", "a": "0.123456", "b": "0.123456"} of = OFParamStmt.from_dict(stmt) - assert_equal(str(of), '') + assert str(of) == "" def test_SFParamStmt_factory(): - stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} + stmt = {"param": "SF", "a": "1.4", "b": "0.9"} sf = SFParamStmt.from_dict(stmt) - assert_equal(sf.param, 'SF') - assert_equal(sf.a, 1.4) - assert_equal(sf.b, 0.9) + 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'} + stmt = {"param": "SF", "a": "1.4", "b": "0.9"} sf = SFParamStmt.from_dict(stmt) - assert_equal(sf.to_gerber(), '%SFA1.4B0.9*%') + assert sf.to_gerber() == "%SFA1.4B0.9*%" def test_SFParamStmt_conversion(): - stmt = {'param': 'OF', 'a': '2.54', 'b': '25.4'} + stmt = {"param": "OF", "a": "2.54", "b": "25.4"} of = SFParamStmt.from_dict(stmt) - of.units = 'metric' + of.units = "metric" of.to_metric() # No effect - assert_equal(of.a, 2.54) - assert_equal(of.b, 25.4) + assert of.a == 2.54 + assert of.b == 25.4 of.to_inch() - assert_equal(of.units, 'inch') - assert_equal(of.a, 0.1) - assert_equal(of.b, 1.0) + assert of.units == "inch" + assert of.a == 0.1 + assert of.b == 1.0 # No effect of.to_inch() - assert_equal(of.a, 0.1) - assert_equal(of.b, 1.0) + assert of.a == 0.1 + assert of.b == 1.0 - stmt = {'param': 'OF', 'a': '0.1', 'b': '1.0'} + stmt = {"param": "OF", "a": "0.1", "b": "1.0"} of = SFParamStmt.from_dict(stmt) - of.units = 'inch' + of.units = "inch" # No effect of.to_inch() - assert_equal(of.a, 0.1) - assert_equal(of.b, 1.0) + assert of.a == 0.1 + assert of.b == 1.0 of.to_metric() - assert_equal(of.units, 'metric') - assert_equal(of.a, 2.54) - assert_equal(of.b, 25.4) + assert of.units == "metric" + assert of.a == 2.54 + assert of.b == 25.4 # No effect of.to_metric() - assert_equal(of.a, 2.54) - assert_equal(of.b, 25.4) + assert of.a == 2.54 + assert of.b == 25.4 def test_SFParamStmt_offset(): - s = SFParamStmt('OF', 0, 0) + s = SFParamStmt("OF", 0, 0) s.offset(1, 0) - assert_equal(s.a, 1.) - assert_equal(s.b, 0.) + assert s.a == 1.0 + assert s.b == 0.0 s.offset(0, 1) - assert_equal(s.a, 1.) - assert_equal(s.b, 1.) + assert s.a == 1.0 + assert s.b == 1.0 def test_SFParamStmt_string(): - stmt = {'param': 'SF', 'a': '1.4', 'b': '0.9'} + stmt = {"param": "SF", "a": "1.4", "b": "0.9"} sf = SFParamStmt.from_dict(stmt) - assert_equal(str(sf), '') + assert str(sf) == "" def test_LPParamStmt_factory(): """ Test LPParamStmt factory """ - stmt = {'param': 'LP', 'lp': 'C'} + stmt = {"param": "LP", "lp": "C"} lp = LPParamStmt.from_dict(stmt) - assert_equal(lp.lp, 'clear') + assert lp.lp == "clear" - stmt = {'param': 'LP', 'lp': 'D'} + stmt = {"param": "LP", "lp": "D"} lp = LPParamStmt.from_dict(stmt) - assert_equal(lp.lp, 'dark') + assert lp.lp == "dark" def test_LPParamStmt_dump(): """ Test LPParamStmt to_gerber() """ - stmt = {'param': 'LP', 'lp': 'C'} + stmt = {"param": "LP", "lp": "C"} lp = LPParamStmt.from_dict(stmt) - assert_equal(lp.to_gerber(), '%LPC*%') + assert lp.to_gerber() == "%LPC*%" - stmt = {'param': 'LP', 'lp': 'D'} + stmt = {"param": "LP", "lp": "D"} lp = LPParamStmt.from_dict(stmt) - assert_equal(lp.to_gerber(), '%LPD*%') + assert lp.to_gerber() == "%LPD*%" def test_LPParamStmt_string(): """ Test LPParamStmt.__str__() """ - stmt = {'param': 'LP', 'lp': 'D'} + stmt = {"param": "LP", "lp": "D"} lp = LPParamStmt.from_dict(stmt) - assert_equal(str(lp), '') + assert str(lp) == "" - stmt = {'param': 'LP', 'lp': 'C'} + stmt = {"param": "LP", "lp": "C"} lp = LPParamStmt.from_dict(stmt) - assert_equal(str(lp), '') + assert str(lp) == "" def test_AMParamStmt_factory(): - name = 'DONUTVAR' - macro = ( -'''0 Test Macro. * + 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* @@ -420,533 +419,541 @@ def test_AMParamStmt_factory(): 6,0,0,5,0.5,0.5,2,0.1,6,0* 7,0,0,7,6,0.2,0* 8,THIS IS AN UNSUPPORTED PRIMITIVE* -''') - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) +""" + s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}) s.build() - assert_equal(len(s.primitives), 10) - assert_true(isinstance(s.primitives[0], AMCommentPrimitive)) - assert_true(isinstance(s.primitives[1], AMCirclePrimitive)) - assert_true(isinstance(s.primitives[2], AMVectorLinePrimitive)) - assert_true(isinstance(s.primitives[3], AMCenterLinePrimitive)) - assert_true(isinstance(s.primitives[4], AMLowerLeftLinePrimitive)) - assert_true(isinstance(s.primitives[5], AMOutlinePrimitive)) - assert_true(isinstance(s.primitives[6], AMPolygonPrimitive)) - assert_true(isinstance(s.primitives[7], AMMoirePrimitive)) - assert_true(isinstance(s.primitives[8], AMThermalPrimitive)) - assert_true(isinstance(s.primitives[9], AMUnsupportPrimitive)) + 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[4], AMLowerLeftLinePrimitive) + assert isinstance(s.primitives[5], AMOutlinePrimitive) + assert isinstance(s.primitives[6], AMPolygonPrimitive) + assert isinstance(s.primitives[7], AMMoirePrimitive) + assert isinstance(s.primitives[8], AMThermalPrimitive) + assert isinstance(s.primitives[9], AMUnsupportPrimitive) def testAMParamStmt_conversion(): - name = 'POLYGON' - macro = '5,1,8,25.4,25.4,25.4,0*' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) + name = "POLYGON" + macro = "5,1,8,25.4,25.4,25.4,0*" + s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}) s.build() - s.units = 'metric' + s.units = "metric" # No effect s.to_metric() - assert_equal(s.primitives[0].position, (25.4, 25.4)) - assert_equal(s.primitives[0].diameter, 25.4) + assert s.primitives[0].position == (25.4, 25.4) + assert s.primitives[0].diameter == 25.4 s.to_inch() - assert_equal(s.units, 'inch') - assert_equal(s.primitives[0].position, (1., 1.)) - assert_equal(s.primitives[0].diameter, 1.) + assert s.units == "inch" + assert s.primitives[0].position == (1.0, 1.0) + assert s.primitives[0].diameter == 1.0 # No effect s.to_inch() - assert_equal(s.primitives[0].position, (1., 1.)) - assert_equal(s.primitives[0].diameter, 1.) + assert s.primitives[0].position == (1.0, 1.0) + assert s.primitives[0].diameter == 1.0 - macro = '5,1,8,1,1,1,0*' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) + macro = "5,1,8,1,1,1,0*" + s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}) s.build() - s.units = 'inch' + s.units = "inch" # No effect s.to_inch() - assert_equal(s.primitives[0].position, (1., 1.)) - assert_equal(s.primitives[0].diameter, 1.) + assert s.primitives[0].position == (1.0, 1.0) + assert s.primitives[0].diameter == 1.0 s.to_metric() - assert_equal(s.units, 'metric') - assert_equal(s.primitives[0].position, (25.4, 25.4)) - assert_equal(s.primitives[0].diameter, 25.4) + assert s.units == "metric" + assert s.primitives[0].position == (25.4, 25.4) + assert s.primitives[0].diameter == 25.4 # No effect s.to_metric() - assert_equal(s.primitives[0].position, (25.4, 25.4)) - assert_equal(s.primitives[0].diameter, 25.4) + assert s.primitives[0].position == (25.4, 25.4) + assert s.primitives[0].diameter == 25.4 def test_AMParamStmt_dump(): - name = 'POLYGON' - macro = '5,1,8,25.4,25.4,25.4,0.0' - s = AMParamStmt.from_dict({'param': 'AM', 'name': name, 'macro': macro}) + name = "POLYGON" + macro = "5,1,8,25.4,25.4,25.4,0.0" + s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}) s.build() - assert_equal(s.to_gerber(), '%AMPOLYGON*5,1,8,25.4,25.4,25.4,0.0*%') + 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'}) + # 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"} + ) s.build() - #assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,1.08239X$1,22.5*%') - assert_equal(s.to_gerber(), '%AMOC8*5,1,8,0,0,0,22.5*%') + # 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}) + name = "POLYGON" + macro = "5,1,8,25.4,25.4,25.4,0*" + s = AMParamStmt.from_dict({"param": "AM", "name": name, "macro": macro}) s.build() - assert_equal(str(s), '') + assert str(s) == "" def test_ASParamStmt_factory(): - stmt = {'param': 'AS', 'mode': 'AXBY'} + stmt = {"param": "AS", "mode": "AXBY"} s = ASParamStmt.from_dict(stmt) - assert_equal(s.param, 'AS') - assert_equal(s.mode, 'AXBY') + assert s.param == "AS" + assert s.mode == "AXBY" def test_ASParamStmt_dump(): - stmt = {'param': 'AS', 'mode': 'AXBY'} + stmt = {"param": "AS", "mode": "AXBY"} s = ASParamStmt.from_dict(stmt) - assert_equal(s.to_gerber(), '%ASAXBY*%') + assert s.to_gerber() == "%ASAXBY*%" def test_ASParamStmt_string(): - stmt = {'param': 'AS', 'mode': 'AXBY'} + stmt = {"param": "AS", "mode": "AXBY"} s = ASParamStmt.from_dict(stmt) - assert_equal(str(s), '') + assert str(s) == "" def test_INParamStmt_factory(): """ Test INParamStmt factory """ - stmt = {'param': 'IN', 'name': 'test'} + stmt = {"param": "IN", "name": "test"} inp = INParamStmt.from_dict(stmt) - assert_equal(inp.name, 'test') + assert inp.name == "test" def test_INParamStmt_dump(): """ Test INParamStmt to_gerber() """ - stmt = {'param': 'IN', 'name': 'test'} + stmt = {"param": "IN", "name": "test"} inp = INParamStmt.from_dict(stmt) - assert_equal(inp.to_gerber(), '%INtest*%') + assert inp.to_gerber() == "%INtest*%" def test_INParamStmt_string(): - stmt = {'param': 'IN', 'name': 'test'} + stmt = {"param": "IN", "name": "test"} inp = INParamStmt.from_dict(stmt) - assert_equal(str(inp), '') + assert str(inp) == "" def test_LNParamStmt_factory(): """ Test LNParamStmt factory """ - stmt = {'param': 'LN', 'name': 'test'} + stmt = {"param": "LN", "name": "test"} lnp = LNParamStmt.from_dict(stmt) - assert_equal(lnp.name, 'test') + assert lnp.name == "test" def test_LNParamStmt_dump(): """ Test LNParamStmt to_gerber() """ - stmt = {'param': 'LN', 'name': 'test'} + stmt = {"param": "LN", "name": "test"} lnp = LNParamStmt.from_dict(stmt) - assert_equal(lnp.to_gerber(), '%LNtest*%') + assert lnp.to_gerber() == "%LNtest*%" def test_LNParamStmt_string(): - stmt = {'param': 'LN', 'name': 'test'} + stmt = {"param": "LN", "name": "test"} lnp = LNParamStmt.from_dict(stmt) - assert_equal(str(lnp), '') + assert str(lnp) == "" def test_comment_stmt(): """ Test comment statement """ - stmt = CommentStmt('A comment') - assert_equal(stmt.type, 'COMMENT') - assert_equal(stmt.comment, 'A comment') + 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_equal(stmt.to_gerber(), 'G04A comment*') + stmt = CommentStmt("A comment") + assert stmt.to_gerber() == "G04A comment*" def test_comment_stmt_string(): - stmt = CommentStmt('A comment') - assert_equal(str(stmt), '') + stmt = CommentStmt("A comment") + assert str(stmt) == "" def test_eofstmt(): """ Test EofStmt """ stmt = EofStmt() - assert_equal(stmt.type, 'EOF') + assert stmt.type == "EOF" def test_eofstmt_dump(): """ Test EofStmt to_gerber() """ stmt = EofStmt() - assert_equal(stmt.to_gerber(), 'M02*') + assert stmt.to_gerber() == "M02*" def test_eofstmt_string(): - assert_equal(str(EofStmt()), '') + assert str(EofStmt()) == "" def test_quadmodestmt_factory(): """ Test QuadrantModeStmt.from_gerber() """ - line = 'G74*' + line = "G74*" stmt = QuadrantModeStmt.from_gerber(line) - assert_equal(stmt.type, 'QuadrantMode') - assert_equal(stmt.mode, 'single-quadrant') + assert stmt.type == "QuadrantMode" + assert stmt.mode == "single-quadrant" - line = 'G75*' + line = "G75*" stmt = QuadrantModeStmt.from_gerber(line) - assert_equal(stmt.mode, 'multi-quadrant') + assert stmt.mode == "multi-quadrant" def test_quadmodestmt_validation(): """ Test QuadrantModeStmt input validation """ - line = 'G76*' - assert_raises(ValueError, QuadrantModeStmt.from_gerber, line) - assert_raises(ValueError, QuadrantModeStmt, 'quadrant-ful') + 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*',): + for line in ("G74*", "G75*"): stmt = QuadrantModeStmt.from_gerber(line) - assert_equal(stmt.to_gerber(), line) + assert stmt.to_gerber() == line def test_regionmodestmt_factory(): """ Test RegionModeStmt.from_gerber() """ - line = 'G36*' + line = "G36*" stmt = RegionModeStmt.from_gerber(line) - assert_equal(stmt.type, 'RegionMode') - assert_equal(stmt.mode, 'on') + assert stmt.type == "RegionMode" + assert stmt.mode == "on" - line = 'G37*' + line = "G37*" stmt = RegionModeStmt.from_gerber(line) - assert_equal(stmt.mode, 'off') + assert stmt.mode == "off" def test_regionmodestmt_validation(): """ Test RegionModeStmt input validation """ - line = 'G38*' - assert_raises(ValueError, RegionModeStmt.from_gerber, line) - assert_raises(ValueError, RegionModeStmt, 'off-ish') + 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*',): + for line in ("G36*", "G37*"): stmt = RegionModeStmt.from_gerber(line) - assert_equal(stmt.to_gerber(), line) + assert stmt.to_gerber() == line def test_unknownstmt(): """ Test UnknownStmt """ - line = 'G696969*' + line = "G696969*" stmt = UnknownStmt(line) - assert_equal(stmt.type, 'UNKNOWN') - assert_equal(stmt.line, line) + assert stmt.type == "UNKNOWN" + assert stmt.line == line def test_unknownstmt_dump(): """ Test UnknownStmt.to_gerber() """ - lines = ('G696969*', 'M03*',) + lines = ("G696969*", "M03*") for line in lines: stmt = UnknownStmt(line) - assert_equal(stmt.to_gerber(), line) + assert stmt.to_gerber() == line def test_statement_string(): """ Test Statement.__str__() """ - stmt = Statement('PARAM') - assert_in('type=PARAM', str(stmt)) - stmt.test = 'PASS' - assert_in('test=PASS', str(stmt)) - assert_in('type=PARAM', str(stmt)) + 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'} + stmt = {"param": "AD", "d": 0, "shape": "C"} ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.d, 0) - assert_equal(ad.shape, 'C') + assert ad.d == 0 + assert ad.shape == "C" - stmt = {'param': 'AD', 'd': 1, 'shape': 'R'} + stmt = {"param": "AD", "d": 1, "shape": "R"} ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.d, 1) - assert_equal(ad.shape, 'R') + assert ad.d == 1 + assert ad.shape == "R" - stmt = {'param': 'AD', 'd': 1, 'shape': 'C', "modifiers": "1.42"} + stmt = {"param": "AD", "d": 1, "shape": "C", "modifiers": "1.42"} ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.d, 1) - assert_equal(ad.shape, 'C') - assert_equal(ad.modifiers, [(1.42,)]) + assert ad.d == 1 + assert ad.shape == "C" + assert ad.modifiers == [(1.42,)] - stmt = {'param': 'AD', 'd': 1, 'shape': 'C', "modifiers": "1.42X"} + stmt = {"param": "AD", "d": 1, "shape": "C", "modifiers": "1.42X"} ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.d, 1) - assert_equal(ad.shape, 'C') - assert_equal(ad.modifiers, [(1.42,)]) + assert ad.d == 1 + assert ad.shape == "C" + assert ad.modifiers == [(1.42,)] - stmt = {'param': 'AD', 'd': 1, 'shape': 'R', "modifiers": "1.42X1.24"} + stmt = {"param": "AD", "d": 1, "shape": "R", "modifiers": "1.42X1.24"} ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.d, 1) - assert_equal(ad.shape, 'R') - assert_equal(ad.modifiers, [(1.42, 1.24)]) + 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'} + stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "25.4X25.4,25.4X25.4"} ad = ADParamStmt.from_dict(stmt) - ad.units = 'metric' + ad.units = "metric" # No effect ad.to_metric() - assert_equal(ad.modifiers[0], (25.4, 25.4)) - assert_equal(ad.modifiers[1], (25.4, 25.4)) + assert ad.modifiers[0] == (25.4, 25.4) + assert ad.modifiers[1] == (25.4, 25.4) ad.to_inch() - assert_equal(ad.units, 'inch') - assert_equal(ad.modifiers[0], (1., 1.)) - assert_equal(ad.modifiers[1], (1., 1.)) + 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_equal(ad.modifiers[0], (1., 1.)) - assert_equal(ad.modifiers[1], (1., 1.)) + 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'} + stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "1X1,1X1"} ad = ADParamStmt.from_dict(stmt) - ad.units = 'inch' + ad.units = "inch" # No effect ad.to_inch() - assert_equal(ad.modifiers[0], (1., 1.)) - assert_equal(ad.modifiers[1], (1., 1.)) + assert ad.modifiers[0] == (1.0, 1.0) + assert ad.modifiers[1] == (1.0, 1.0) ad.to_metric() - assert_equal(ad.modifiers[0], (25.4, 25.4)) - assert_equal(ad.modifiers[1], (25.4, 25.4)) + assert ad.modifiers[0] == (25.4, 25.4) + assert ad.modifiers[1] == (25.4, 25.4) # No effect ad.to_metric() - assert_equal(ad.modifiers[0], (25.4, 25.4)) - assert_equal(ad.modifiers[1], (25.4, 25.4)) + 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'} + stmt = {"param": "AD", "d": 0, "shape": "C"} ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.to_gerber(), '%ADD0C*%') - stmt = {'param': 'AD', 'd': 0, 'shape': 'C', 'modifiers': '1X1,1X1'} + assert ad.to_gerber() == "%ADD0C*%" + stmt = {"param": "AD", "d": 0, "shape": "C", "modifiers": "1X1,1X1"} ad = ADParamStmt.from_dict(stmt) - assert_equal(ad.to_gerber(), '%ADD0C,1X1,1X1*%') + assert ad.to_gerber() == "%ADD0C,1X1,1X1*%" def test_ADPamramStmt_string(): - stmt = {'param': 'AD', 'd': 0, 'shape': 'C'} + stmt = {"param": "AD", "d": 0, "shape": "C"} ad = ADParamStmt.from_dict(stmt) - assert_equal(str(ad), '') + assert str(ad) == "" - stmt = {'param': 'AD', 'd': 0, 'shape': 'R'} + stmt = {"param": "AD", "d": 0, "shape": "R"} ad = ADParamStmt.from_dict(stmt) - assert_equal(str(ad), '') + assert str(ad) == "" - stmt = {'param': 'AD', 'd': 0, 'shape': 'O'} + stmt = {"param": "AD", "d": 0, "shape": "O"} ad = ADParamStmt.from_dict(stmt) - assert_equal(str(ad), '') + assert str(ad) == "" - stmt = {'param': 'AD', 'd': 0, 'shape': 'test'} + stmt = {"param": "AD", "d": 0, "shape": "test"} ad = ADParamStmt.from_dict(stmt) - assert_equal(str(ad), '') + assert str(ad) == "" def test_MIParamStmt_factory(): - stmt = {'param': 'MI', 'a': 1, 'b': 1} + stmt = {"param": "MI", "a": 1, "b": 1} mi = MIParamStmt.from_dict(stmt) - assert_equal(mi.a, 1) - assert_equal(mi.b, 1) + assert mi.a == 1 + assert mi.b == 1 def test_MIParamStmt_dump(): - stmt = {'param': 'MI', 'a': 1, 'b': 1} + stmt = {"param": "MI", "a": 1, "b": 1} mi = MIParamStmt.from_dict(stmt) - assert_equal(mi.to_gerber(), '%MIA1B1*%') - stmt = {'param': 'MI', 'a': 1} + assert mi.to_gerber() == "%MIA1B1*%" + stmt = {"param": "MI", "a": 1} mi = MIParamStmt.from_dict(stmt) - assert_equal(mi.to_gerber(), '%MIA1B0*%') - stmt = {'param': 'MI', 'b': 1} + assert mi.to_gerber() == "%MIA1B0*%" + stmt = {"param": "MI", "b": 1} mi = MIParamStmt.from_dict(stmt) - assert_equal(mi.to_gerber(), '%MIA0B1*%') + assert mi.to_gerber() == "%MIA0B1*%" def test_MIParamStmt_string(): - stmt = {'param': 'MI', 'a': 1, 'b': 1} + stmt = {"param": "MI", "a": 1, "b": 1} mi = MIParamStmt.from_dict(stmt) - assert_equal(str(mi), '') + assert str(mi) == "" - stmt = {'param': 'MI', 'b': 1} + stmt = {"param": "MI", "b": 1} mi = MIParamStmt.from_dict(stmt) - assert_equal(str(mi), '') + assert str(mi) == "" - stmt = {'param': 'MI', 'a': 1} + stmt = {"param": "MI", "a": 1} mi = MIParamStmt.from_dict(stmt) - assert_equal(str(mi), '') + assert str(mi) == "" def test_coordstmt_ctor(): - cs = CoordStmt('G04', 0.0, 0.1, 0.2, 0.3, 'D01', FileSettings()) - assert_equal(cs.function, 'G04') - assert_equal(cs.x, 0.0) - assert_equal(cs.y, 0.1) - assert_equal(cs.i, 0.2) - assert_equal(cs.j, 0.3) - assert_equal(cs.op, 'D01') + 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'} + stmt = { + "function": "G04", + "x": "0", + "y": "001", + "i": "002", + "j": "003", + "op": "D01", + } cs = CoordStmt.from_dict(stmt, FileSettings()) - assert_equal(cs.function, 'G04') - assert_equal(cs.x, 0.0) - assert_equal(cs.y, 0.1) - assert_equal(cs.i, 0.2) - assert_equal(cs.j, 0.3) - assert_equal(cs.op, 'D01') + 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_equal(cs.to_gerber(FileSettings()), 'G04X0Y001I002J003D01*') + 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' + cs = CoordStmt("G71", 25.4, 25.4, 25.4, 25.4, "D01", FileSettings()) + cs.units = "metric" # No effect cs.to_metric() - assert_equal(cs.x, 25.4) - assert_equal(cs.y, 25.4) - assert_equal(cs.i, 25.4) - assert_equal(cs.j, 25.4) - assert_equal(cs.function, 'G71') + 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_equal(cs.units, 'inch') - assert_equal(cs.x, 1.) - assert_equal(cs.y, 1.) - assert_equal(cs.i, 1.) - assert_equal(cs.j, 1.) - assert_equal(cs.function, 'G70') + 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_equal(cs.x, 1.) - assert_equal(cs.y, 1.) - assert_equal(cs.i, 1.) - assert_equal(cs.j, 1.) - assert_equal(cs.function, 'G70') + 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., 1., 1., 1., 'D01', FileSettings()) - cs.units = 'inch' + cs = CoordStmt("G70", 1.0, 1.0, 1.0, 1.0, "D01", FileSettings()) + cs.units = "inch" # No effect cs.to_inch() - assert_equal(cs.x, 1.) - assert_equal(cs.y, 1.) - assert_equal(cs.i, 1.) - assert_equal(cs.j, 1.) - assert_equal(cs.function, 'G70') + 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_equal(cs.x, 25.4) - assert_equal(cs.y, 25.4) - assert_equal(cs.i, 25.4) - assert_equal(cs.j, 25.4) - assert_equal(cs.function, 'G71') + 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_equal(cs.x, 25.4) - assert_equal(cs.y, 25.4) - assert_equal(cs.i, 25.4) - assert_equal(cs.j, 25.4) - assert_equal(cs.function, 'G71') + 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 = CoordStmt("G71", 0, 0, 0, 0, "D01", FileSettings()) c.offset(1, 0) - assert_equal(c.x, 1.) - assert_equal(c.y, 0.) - assert_equal(c.i, 1.) - assert_equal(c.j, 0.) + 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_equal(c.x, 1.) - assert_equal(c.y, 1.) - assert_equal(c.i, 1.) - assert_equal(c.j, 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_equal(str(cs), - '') - cs = CoordStmt('G04', None, None, None, None, 'D02', FileSettings()) - assert_equal(str(cs), '') - cs = CoordStmt('G04', None, None, None, None, 'D03', FileSettings()) - assert_equal(str(cs), '') - cs = CoordStmt('G04', None, None, None, None, 'TEST', FileSettings()) - assert_equal(str(cs), '') + cs = CoordStmt("G04", 0, 1, 2, 3, "D01", FileSettings()) + assert ( + str(cs) == "" + ) + cs = CoordStmt("G04", None, None, None, None, "D02", FileSettings()) + assert str(cs) == "" + cs = CoordStmt("G04", None, None, None, None, "D03", FileSettings()) + assert str(cs) == "" + cs = CoordStmt("G04", None, None, None, None, "TEST", FileSettings()) + assert str(cs) == "" def test_aperturestmt_ctor(): ast = ApertureStmt(3, False) - assert_equal(ast.d, 3) - assert_equal(ast.deprecated, False) + assert ast.d == 3 + assert ast.deprecated == False ast = ApertureStmt(4, True) - assert_equal(ast.d, 4) - assert_equal(ast.deprecated, True) + assert ast.d == 4 + assert ast.deprecated == True ast = ApertureStmt(4, 1) - assert_equal(ast.d, 4) - assert_equal(ast.deprecated, True) + assert ast.d == 4 + assert ast.deprecated == True ast = ApertureStmt(3) - assert_equal(ast.d, 3) - assert_equal(ast.deprecated, False) + assert ast.d == 3 + assert ast.deprecated == False def test_aperturestmt_dump(): ast = ApertureStmt(3, False) - assert_equal(ast.to_gerber(), 'D3*') + assert ast.to_gerber() == "D3*" ast = ApertureStmt(3, True) - assert_equal(ast.to_gerber(), 'G54D3*') - assert_equal(str(ast), '') + assert ast.to_gerber() == "G54D3*" + assert str(ast) == "" -- cgit