CAM: Used inheritance to simplify the refactored postprocessors more

Updated the Masso tests now that it is using the new API.
2025-02-27 15:08:58 -08:00
parent 7bf1b5d787
commit f680ee7af9
9 changed files with 478 additions and 1151 deletions
--- a/src/Mod/CAM/CAMTests/TestRefactoredMassoG3Post.py
+++ b/src/Mod/CAM/CAMTests/TestRefactoredMassoG3Post.py
@@ -35,7 +35,7 @@ import FreeCAD

 import Path
 import CAMTests.PathTestUtils as PathTestUtils
-from Path.Post.scripts import refactored_masso_g3_post as postprocessor
+from Path.Post.Processor import PostProcessorFactory


 Path.Log.setLevel(Path.Log.Level.DEBUG, Path.Log.thisModule())
@@ -54,8 +54,16 @@ class TestRefactoredMassoG3Post(PathTestUtils.PathTestBase):
        is able to call static methods within this same class.
        """

-        # Open existing FreeCAD document with test geometry
-        FreeCAD.newDocument("Unnamed")
+        FreeCAD.ConfigSet("SuppressRecomputeRequiredDialog", "True")
+        cls.doc = FreeCAD.open(FreeCAD.getHomePath() + "/Mod/CAM/CAMTests/boxtest.fcstd")
+        cls.job = cls.doc.getObject("Job")
+        cls.post = PostProcessorFactory.get_post_processor(cls.job, "refactored_masso_g3")
+        # locate the operation named "Profile"
+        for op in cls.job.Operations.Group:
+            if op.Label == "Profile":
+                # remember the "Profile" operation
+                cls.profile_op = op
+                return

    @classmethod
    def tearDownClass(cls):
@@ -66,8 +74,8 @@ class TestRefactoredMassoG3Post(PathTestUtils.PathTestBase):
        have access to the class `self` reference.  This method
        is able to call static methods within this same class.
        """
-        # Close geometry document without saving
-        FreeCAD.closeDocument(FreeCAD.ActiveDocument.Name)
+        FreeCAD.closeDocument(cls.doc.Name)
+        FreeCAD.ConfigSet("SuppressRecomputeRequiredDialog", "")

    # Setup and tear down methods called before and after each unit test
    def setUp(self):
@@ -75,87 +83,106 @@ class TestRefactoredMassoG3Post(PathTestUtils.PathTestBase):
        This method is called prior to each `test()` method.  Add code and
        objects here that are needed for multiple `test()` methods.
        """
-        self.doc = FreeCAD.ActiveDocument
-        self.con = FreeCAD.Console
-        self.docobj = FreeCAD.ActiveDocument.addObject("Path::Feature", "testpath")
-        reload(
-            postprocessor
-        )  # technical debt.  This shouldn't be necessary but here to bypass a bug
+        # allow a full length "diff" if an error occurs
+        self.maxDiff = None
+        # reinitialize the postprocessor data structures between tests
+        self.post.reinitialize()

    def tearDown(self):
        """tearDown()...
        This method is called after each test() method. Add cleanup instructions here.
        Such cleanup instructions will likely undo those in the setUp() method.
        """
-        FreeCAD.ActiveDocument.removeObject("testpath")
+        pass

    def test000(self):
        """Test Output Generation.
        Empty path.  Produces only the preamble and postable.
        """
+        nl = "\n"

-        self.docobj.Path = Path.Path([])
-        postables = [self.docobj]
+        self.profile_op.Path = Path.Path([])

        # Test generating with header
        # Header contains a time stamp that messes up unit testing.
        # Only test length of result.
-        args = "--no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        self.assertTrue(len(gcode.splitlines()) == 14)
+        self.job.PostProcessorArgs = "--no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        self.assertTrue(len(gcode.splitlines()) == 26)

        # Test without header
        expected = """(Begin preamble)
 G17 G54 G40 G49 G80 G90
 G21
-(Begin operation: testpath)
+(Begin operation: Fixture)
 (Machine units: mm/min)
-(Finish operation: testpath)
+G54
+(Finish operation: Fixture)
+(Begin operation: TC: Default Tool)
+(Machine units: mm/min)
+(TC: Default Tool)
+(Begin toolchange)
+M5
+T1 M6
+G43 H1
+(Finish operation: TC: Default Tool)
+(Begin operation: Profile)
+(Machine units: mm/min)
+(Finish operation: Profile)
 (Begin postamble)
 M05
 G17 G54 G90 G80 G40
 M2
 """

-        self.docobj.Path = Path.Path([])
-        postables = [self.docobj]
+        self.profile_op.Path = Path.Path([])

-        args = "--no-header --no-show-editor"
+        self.job.PostProcessorArgs = "--no-header --no-show-editor"
        # args = ("--no-header --no-comments --no-show-editor --precision=2")
-        gcode = postprocessor.export(postables, "-", args)
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
        self.assertEqual(gcode, expected)

        # test without comments
        expected = """G17 G54 G40 G49 G80 G90
 G21
+G54
+M5
+T1 M6
+G43 H1
 M05
 G17 G54 G90 G80 G40
 M2
 """

-        args = "--no-header --no-comments --no-show-editor"
+        self.job.PostProcessorArgs = "--no-header --no-comments --no-show-editor"
        # args = ("--no-header --no-comments --no-show-editor --precision=2")
-        gcode = postprocessor.export(postables, "-", args)
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
        self.assertEqual(gcode, expected)

    def test010(self):
        """Test command Generation.
        Test Precision
        """
+        nl = "\n"
+
        c = Path.Command("G0 X10 Y20 Z30")

-        self.docobj.Path = Path.Path([c])
-        postables = [self.docobj]
+        self.profile_op.Path = Path.Path([c])

-        args = "--no-header --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        result = gcode.splitlines()[5]
+        self.job.PostProcessorArgs = "--no-header --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        result = gcode.splitlines()[17]
        expected = "G0 X10.000 Y20.000 Z30.000"
        self.assertEqual(result, expected)

-        args = "--no-header --precision=2 --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        result = gcode.splitlines()[5]
+        self.job.PostProcessorArgs = "--no-header --precision=2 --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        result = gcode.splitlines()[17]
        expected = "G0 X10.00 Y20.00 Z30.00"
        self.assertEqual(result, expected)

@@ -163,27 +190,32 @@ M2
        """
        Test Line Numbers
        """
+        nl = "\n"
+
        c = Path.Command("G0 X10 Y20 Z30")

-        self.docobj.Path = Path.Path([c])
-        postables = [self.docobj]
+        self.profile_op.Path = Path.Path([c])

-        args = "--no-header --line-numbers --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        result = gcode.splitlines()[5]
-        expected = "N150 G0 X10.000 Y20.000 Z30.000"
+        self.job.PostProcessorArgs = "--no-header --line-numbers --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        result = gcode.splitlines()[17]
+        expected = "N270 G0 X10.000 Y20.000 Z30.000"
        self.assertEqual(result, expected)

    def test030(self):
        """
        Test Pre-amble
        """
+        nl = "\n"

-        self.docobj.Path = Path.Path([])
-        postables = [self.docobj]
+        self.profile_op.Path = Path.Path([])

-        args = "--no-header --no-comments --preamble='G18 G55' --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
+        self.job.PostProcessorArgs = (
+            "--no-header --no-comments --preamble='G18 G55' --no-show-editor"
+        )
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
        result = gcode.splitlines()[0]
        self.assertEqual(result, "G18 G55")

@@ -191,10 +223,15 @@ M2
        """
        Test Post-amble
        """
-        self.docobj.Path = Path.Path([])
-        postables = [self.docobj]
-        args = "--no-header --no-comments --postamble='G0 Z50\nM2' --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
+        nl = "\n"
+
+        self.profile_op.Path = Path.Path([])
+
+        self.job.PostProcessorArgs = (
+            "--no-header --no-comments --postamble='G0 Z50\nM2' --no-show-editor"
+        )
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
        result = gcode.splitlines()[-2]
        self.assertEqual(result, "G0 Z50")
        self.assertEqual(gcode.splitlines()[-1], "M2")
@@ -203,22 +240,25 @@ M2
        """
        Test inches
        """
+        nl = "\n"

        c = Path.Command("G0 X10 Y20 Z30")
-        self.docobj.Path = Path.Path([c])
-        postables = [self.docobj]

-        args = "--no-header --inches --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
+        self.profile_op.Path = Path.Path([c])
+
+        self.job.PostProcessorArgs = "--no-header --inches --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
        self.assertEqual(gcode.splitlines()[2], "G20")

-        result = gcode.splitlines()[5]
+        result = gcode.splitlines()[17]
        expected = "G0 X0.3937 Y0.7874 Z1.1811"
        self.assertEqual(result, expected)

-        args = "--no-header --inches --precision=2 --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        result = gcode.splitlines()[5]
+        self.job.PostProcessorArgs = "--no-header --inches --precision=2 --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        result = gcode.splitlines()[17]
        expected = "G0 X0.39 Y0.79 Z1.18"
        self.assertEqual(result, expected)

@@ -227,15 +267,17 @@ M2
        Test test modal
        Suppress the command name if the same as previous
        """
+        nl = "\n"
+
        c = Path.Command("G0 X10 Y20 Z30")
        c1 = Path.Command("G0 X10 Y30 Z30")

-        self.docobj.Path = Path.Path([c, c1])
-        postables = [self.docobj]
+        self.profile_op.Path = Path.Path([c, c1])

-        args = "--no-header --modal --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        result = gcode.splitlines()[6]
+        self.job.PostProcessorArgs = "--no-header --modal --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        result = gcode.splitlines()[18]
        expected = "X10.000 Y30.000 Z30.000"
        self.assertEqual(result, expected)

@@ -244,15 +286,17 @@ M2
        Test axis modal
        Suppress the axis coordinate if the same as previous
        """
+        nl = "\n"
+
        c = Path.Command("G0 X10 Y20 Z30")
        c1 = Path.Command("G0 X10 Y30 Z30")

-        self.docobj.Path = Path.Path([c, c1])
-        postables = [self.docobj]
+        self.profile_op.Path = Path.Path([c, c1])

-        args = "--no-header --axis-modal --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        result = gcode.splitlines()[6]
+        self.job.PostProcessorArgs = "--no-header --axis-modal --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        result = gcode.splitlines()[18]
        expected = "G0 Y30.000"
        self.assertEqual(result, expected)

@@ -260,35 +304,40 @@ M2
        """
        Test tool change
        """
+        nl = "\n"
+
        c = Path.Command("M6 T2")
        c2 = Path.Command("M3 S3000")
-        self.docobj.Path = Path.Path([c, c2])
-        postables = [self.docobj]

-        args = "--no-header --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        self.assertEqual(gcode.splitlines()[6], "M5")
-        self.assertEqual(gcode.splitlines()[7], "T2 M6")
-        self.assertEqual(gcode.splitlines()[8], "G43 H2")
-        self.assertEqual(gcode.splitlines()[9], "M3 S3000")
+        self.profile_op.Path = Path.Path([c, c2])
+
+        self.job.PostProcessorArgs = "--no-header --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        self.assertEqual(gcode.splitlines()[18], "M5")
+        self.assertEqual(gcode.splitlines()[19], "T2 M6")
+        self.assertEqual(gcode.splitlines()[20], "G43 H2")
+        self.assertEqual(gcode.splitlines()[21], "M3 S3000")

        # suppress TLO
-        args = "--no-header --no-tlo --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        self.assertEqual(gcode.splitlines()[8], "M3 S3000")
+        self.job.PostProcessorArgs = "--no-header --no-tlo --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        self.assertEqual(gcode.splitlines()[19], "M3 S3000")

    def test090(self):
        """
        Test comment
        """
+        nl = "\n"

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

-        self.docobj.Path = Path.Path([c])
-        postables = [self.docobj]
+        self.profile_op.Path = Path.Path([c])

-        args = "--no-header --no-show-editor"
-        gcode = postprocessor.export(postables, "-", args)
-        result = gcode.splitlines()[5]
+        self.job.PostProcessorArgs = "--no-header --no-show-editor"
+        gcode = self.post.export()[0][1]
+        # print(f"--------{nl}{gcode}--------{nl}")
+        result = gcode.splitlines()[17]
        expected = "(comment)"
        self.assertEqual(result, expected)