FreeCAD

1
# -*- coding: utf-8 -*-
2
# ***************************************************************************
3
# *   Copyright (c) 2022 sliptonic <shopinthewoods@gmail.com>               *
4
# *   Copyright (c) 2022 Larry Woestman <LarryWoestman2@gmail.com>          *
5
# *                                                                         *
6
# *   This program is free software; you can redistribute it and/or modify  *
7
# *   it under the terms of the GNU Lesser General Public License (LGPL)    *
8
# *   as published by the Free Software Foundation; either version 2 of     *
9
# *   the License, or (at your option) any later version.                   *
10
# *   for detail see the LICENCE text file.                                 *
11
# *                                                                         *
12
# *   This program is distributed in the hope that it will be useful,       *
13
# *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
14
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
15
# *   GNU Library General Public License for more details.                  *
16
# *                                                                         *
17
# *   You should have received a copy of the GNU Library General Public     *
18
# *   License along with this program; if not, write to the Free Software   *
19
# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
20
# *   USA                                                                   *
21
# *                                                                         *
22
# ***************************************************************************
23

24
from importlib import reload
25

26
import FreeCAD
27

28
import Path
29
import Tests.PathTestUtils as PathTestUtils
30
from Path.Post.scripts import refactored_linuxcnc_post as postprocessor
31

32

33
Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule())
34
Path.Log.trackModule(Path.Log.thisModule())
35

36

37
class TestRefactoredLinuxCNCPost(PathTestUtils.PathTestBase):
38
    @classmethod
39
    def setUpClass(cls):
40
        """setUpClass()...
41
        This method is called upon instantiation of this test class.  Add code
42
        and objects here that are needed for the duration of the test() methods
43
        in this class.  In other words, set up the 'global' test environment
44
        here; use the `setUp()` method to set up a 'local' test environment.
45
        This method does not have access to the class `self` reference, but it
46
        is able to call static methods within this same class.
47
        """
48

49
        # Open existing FreeCAD document with test geometry
50
        FreeCAD.newDocument("Unnamed")
51

52
    @classmethod
53
    def tearDownClass(cls):
54
        """tearDownClass()...
55
        This method is called prior to destruction of this test class.  Add
56
        code and objects here that cleanup the test environment after the
57
        test() methods in this class have been executed.  This method does not
58
        have access to the class `self` reference.  This method
59
        is able to call static methods within this same class.
60
        """
61
        # Close geometry document without saving
62
        FreeCAD.closeDocument(FreeCAD.ActiveDocument.Name)
63

64
    # Setup and tear down methods called before and after each unit test
65
    def setUp(self):
66
        """setUp()...
67
        This method is called prior to each `test()` method.  Add code and
68
        objects here that are needed for multiple `test()` methods.
69
        """
70
        self.doc = FreeCAD.ActiveDocument
71
        self.con = FreeCAD.Console
72
        self.docobj = FreeCAD.ActiveDocument.addObject("Path::Feature", "testpath")
73
        reload(
74
            postprocessor
75
        )  # technical debt.  This shouldn't be necessary but here to bypass a bug
76

77
    def tearDown(self):
78
        """tearDown()...
79
        This method is called after each test() method. Add cleanup instructions here.
80
        Such cleanup instructions will likely undo those in the setUp() method.
81
        """
82
        FreeCAD.ActiveDocument.removeObject("testpath")
83

84
    def test000(self):
85
        """Test Output Generation.
86
        Empty path.  Produces only the preamble and postable.
87
        """
88

89
        self.docobj.Path = Path.Path([])
90
        postables = [self.docobj]
91

92
        # Test generating with header
93
        # Header contains a time stamp that messes up unit testing.
94
        # Only test length of result.
95
        args = "--no-show-editor"
96
        gcode = postprocessor.export(postables, "-", args)
97
        self.assertTrue(len(gcode.splitlines()) == 14)
98

99
        # Test without header
100
        expected = """(Begin preamble)
101
G17 G54 G40 G49 G80 G90
102
G21
103
(Begin operation: testpath)
104
(Machine units: mm/min)
105
(Finish operation: testpath)
106
(Begin postamble)
107
M05
108
G17 G54 G90 G80 G40
109
M2
110
"""
111

112
        self.docobj.Path = Path.Path([])
113
        postables = [self.docobj]
114

115
        args = "--no-header --no-show-editor"
116
        # args = ("--no-header --no-comments --no-show-editor --precision=2")
117
        gcode = postprocessor.export(postables, "-", args)
118
        self.assertEqual(gcode, expected)
119

120
        # test without comments
121
        expected = """G17 G54 G40 G49 G80 G90
122
G21
123
M05
124
G17 G54 G90 G80 G40
125
M2
126
"""
127

128
        args = "--no-header --no-comments --no-show-editor"
129
        # args = ("--no-header --no-comments --no-show-editor --precision=2")
130
        gcode = postprocessor.export(postables, "-", args)
131
        self.assertEqual(gcode, expected)
132

133
    def test010(self):
134
        """Test command Generation.
135
        Test Precision
136
        """
137
        c = Path.Command("G0 X10 Y20 Z30")
138

139
        self.docobj.Path = Path.Path([c])
140
        postables = [self.docobj]
141

142
        args = "--no-header --no-show-editor"
143
        gcode = postprocessor.export(postables, "-", args)
144
        result = gcode.splitlines()[5]
145
        expected = "G0 X10.000 Y20.000 Z30.000"
146
        self.assertEqual(result, expected)
147

148
        args = "--no-header --precision=2 --no-show-editor"
149
        gcode = postprocessor.export(postables, "-", args)
150
        result = gcode.splitlines()[5]
151
        expected = "G0 X10.00 Y20.00 Z30.00"
152
        self.assertEqual(result, expected)
153

154
    def test020(self):
155
        """
156
        Test Line Numbers
157
        """
158
        c = Path.Command("G0 X10 Y20 Z30")
159

160
        self.docobj.Path = Path.Path([c])
161
        postables = [self.docobj]
162

163
        args = "--no-header --line-numbers --no-show-editor"
164
        gcode = postprocessor.export(postables, "-", args)
165
        result = gcode.splitlines()[5]
166
        expected = "N150 G0 X10.000 Y20.000 Z30.000"
167
        self.assertEqual(result, expected)
168

169
    def test030(self):
170
        """
171
        Test Pre-amble
172
        """
173

174
        self.docobj.Path = Path.Path([])
175
        postables = [self.docobj]
176

177
        args = "--no-header --no-comments --preamble='G18 G55' --no-show-editor"
178
        gcode = postprocessor.export(postables, "-", args)
179
        result = gcode.splitlines()[0]
180
        self.assertEqual(result, "G18 G55")
181

182
    def test040(self):
183
        """
184
        Test Post-amble
185
        """
186
        self.docobj.Path = Path.Path([])
187
        postables = [self.docobj]
188
        args = "--no-header --no-comments --postamble='G0 Z50\nM2' --no-show-editor"
189
        gcode = postprocessor.export(postables, "-", args)
190
        result = gcode.splitlines()[-2]
191
        self.assertEqual(result, "G0 Z50")
192
        self.assertEqual(gcode.splitlines()[-1], "M2")
193

194
    def test050(self):
195
        """
196
        Test inches
197
        """
198

199
        c = Path.Command("G0 X10 Y20 Z30")
200
        self.docobj.Path = Path.Path([c])
201
        postables = [self.docobj]
202

203
        args = "--no-header --inches --no-show-editor"
204
        gcode = postprocessor.export(postables, "-", args)
205
        self.assertEqual(gcode.splitlines()[2], "G20")
206

207
        result = gcode.splitlines()[5]
208
        expected = "G0 X0.3937 Y0.7874 Z1.1811"
209
        self.assertEqual(result, expected)
210

211
        args = "--no-header --inches --precision=2 --no-show-editor"
212
        gcode = postprocessor.export(postables, "-", args)
213
        result = gcode.splitlines()[5]
214
        expected = "G0 X0.39 Y0.79 Z1.18"
215
        self.assertEqual(result, expected)
216

217
    def test060(self):
218
        """
219
        Test test modal
220
        Suppress the command name if the same as previous
221
        """
222
        c = Path.Command("G0 X10 Y20 Z30")
223
        c1 = Path.Command("G0 X10 Y30 Z30")
224

225
        self.docobj.Path = Path.Path([c, c1])
226
        postables = [self.docobj]
227

228
        args = "--no-header --modal --no-show-editor"
229
        gcode = postprocessor.export(postables, "-", args)
230
        result = gcode.splitlines()[6]
231
        expected = "X10.000 Y30.000 Z30.000"
232
        self.assertEqual(result, expected)
233

234
    def test070(self):
235
        """
236
        Test axis modal
237
        Suppress the axis coordinate if the same as previous
238
        """
239
        c = Path.Command("G0 X10 Y20 Z30")
240
        c1 = Path.Command("G0 X10 Y30 Z30")
241

242
        self.docobj.Path = Path.Path([c, c1])
243
        postables = [self.docobj]
244

245
        args = "--no-header --axis-modal --no-show-editor"
246
        gcode = postprocessor.export(postables, "-", args)
247
        result = gcode.splitlines()[6]
248
        expected = "G0 Y30.000"
249
        self.assertEqual(result, expected)
250

251
    def test080(self):
252
        """
253
        Test tool change
254
        """
255
        c = Path.Command("M6 T2")
256
        c2 = Path.Command("M3 S3000")
257
        self.docobj.Path = Path.Path([c, c2])
258
        postables = [self.docobj]
259

260
        args = "--no-header --no-show-editor"
261
        gcode = postprocessor.export(postables, "-", args)
262
        self.assertEqual(gcode.splitlines()[6], "M5")
263
        self.assertEqual(gcode.splitlines()[7], "M6 T2")
264
        self.assertEqual(gcode.splitlines()[8], "G43 H2")
265
        self.assertEqual(gcode.splitlines()[9], "M3 S3000")
266

267
        # suppress TLO
268
        args = "--no-header --no-tlo --no-show-editor"
269
        gcode = postprocessor.export(postables, "-", args)
270
        self.assertEqual(gcode.splitlines()[8], "M3 S3000")
271

272
    def test090(self):
273
        """
274
        Test comment
275
        """
276

277
        c = Path.Command("(comment)")
278

279
        self.docobj.Path = Path.Path([c])
280
        postables = [self.docobj]
281

282
        args = "--no-header --no-show-editor"
283
        gcode = postprocessor.export(postables, "-", args)
284
        result = gcode.splitlines()[5]
285
        expected = "(comment)"
286
        self.assertEqual(result, expected)
287