da79e1ff86
An assertEqualLocale function has been added to replace , by . in the values impacted by the locale with before comparison with the expected string containing a . as decimal separator. Works fine
220 lines
11 KiB
Python
220 lines
11 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# ***************************************************************************
|
|
# * *
|
|
# * Copyright (c) 2017 sliptonic <shopinthewoods@gmail.com> *
|
|
# * *
|
|
# * This program is free software; you can redistribute it and/or modify *
|
|
# * it under the terms of the GNU Lesser General Public License (LGPL) *
|
|
# * as published by the Free Software Foundation; either version 2 of *
|
|
# * the License, or (at your option) any later version. *
|
|
# * for detail see the LICENCE text file. *
|
|
# * *
|
|
# * This program is distributed in the hope that it will be useful, *
|
|
# * but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
# * GNU Library General Public License for more details. *
|
|
# * *
|
|
# * You should have received a copy of the GNU Library General Public *
|
|
# * License along with this program; if not, write to the Free Software *
|
|
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
# * USA *
|
|
# * *
|
|
# ***************************************************************************
|
|
|
|
import FreeCAD
|
|
import Path
|
|
import PathScripts.PathSetupSheet as PathSetupSheet
|
|
import PathScripts.PathLog as PathLog
|
|
import sys
|
|
|
|
PathLog.setLevel(PathLog.Level.DEBUG, PathLog.thisModule())
|
|
|
|
from PathTests.PathTestUtils import PathTestBase
|
|
|
|
def refstring(string):
|
|
if sys.version_info.major < 3:
|
|
return string
|
|
return string.replace(" u'", " '")
|
|
|
|
|
|
class TestPathSetupSheet(PathTestBase):
|
|
|
|
def setUp(self):
|
|
self.doc = FreeCAD.newDocument("TestPathSetupSheet")
|
|
|
|
def tearDown(self):
|
|
FreeCAD.closeDocument(self.doc.Name)
|
|
|
|
def test00(self):
|
|
'''Verify SetupSheet templateAttributes'''
|
|
ss = PathSetupSheet.Create().Proxy
|
|
self.doc.recompute()
|
|
|
|
attrs = ss.templateAttributes(True, True)
|
|
|
|
self.assertEqualLocale(attrs[PathSetupSheet.Template.HorizRapid], '0.00 mm/s')
|
|
self.assertEqualLocale(attrs[PathSetupSheet.Template.VertRapid], '0.00 mm/s')
|
|
self.assertEqualLocale(attrs[PathSetupSheet.Template.SafeHeightOffset], '3.00 mm')
|
|
self.assertEqual(attrs[PathSetupSheet.Template.SafeHeightExpression], 'StartDepth+SetupSheet.SafeHeightOffset')
|
|
self.assertEqualLocale(attrs[PathSetupSheet.Template.ClearanceHeightOffset], '5.00 mm')
|
|
self.assertEqual(attrs[PathSetupSheet.Template.ClearanceHeightExpression], 'StartDepth+SetupSheet.ClearanceHeightOffset')
|
|
|
|
def test01(self):
|
|
'''Verify SetupSheet template attributes roundtrip.'''
|
|
o1 = PathSetupSheet.Create()
|
|
self.doc.recompute()
|
|
o1.VertRapid = '10 mm/s'
|
|
o1.HorizRapid = '22 mm/s'
|
|
o1.SafeHeightOffset = '18 mm'
|
|
o1.SafeHeightExpression = 'Hugo+Olga'
|
|
o1.ClearanceHeightOffset = '23 mm'
|
|
o1.ClearanceHeightExpression = 'Peter+Paul'
|
|
o1.StartDepthExpression = 'Alpha'
|
|
o1.FinalDepthExpression = 'Omega'
|
|
o1.StepDownExpression = '1'
|
|
|
|
o2 = PathSetupSheet.Create()
|
|
self.doc.recompute()
|
|
o2.Proxy.setFromTemplate(o1.Proxy.templateAttributes())
|
|
self.doc.recompute()
|
|
|
|
|
|
self.assertRoughly(o1.VertRapid, o2.VertRapid)
|
|
self.assertRoughly(o1.HorizRapid, o2.HorizRapid)
|
|
self.assertRoughly(o1.SafeHeightOffset, o2.SafeHeightOffset)
|
|
self.assertEqual(o1.SafeHeightExpression, o2.SafeHeightExpression)
|
|
self.assertRoughly(o1.ClearanceHeightOffset, o2.ClearanceHeightOffset)
|
|
self.assertEqual(o1.ClearanceHeightExpression, o2.ClearanceHeightExpression)
|
|
self.assertEqual(o1.StartDepthExpression, o2.StartDepthExpression)
|
|
self.assertEqual(o1.FinalDepthExpression, o2.FinalDepthExpression)
|
|
self.assertEqual(o1.StepDownExpression, o2.StepDownExpression)
|
|
|
|
def test02(self):
|
|
'''Verify default value detection logic.'''
|
|
obj = PathSetupSheet.Create()
|
|
ss = obj.Proxy
|
|
|
|
self.assertTrue(ss.hasDefaultToolRapids())
|
|
self.assertTrue(ss.hasDefaultOperationHeights())
|
|
self.assertTrue(ss.hasDefaultOperationDepths())
|
|
|
|
obj.VertRapid = '1 mm/s'
|
|
self.assertFalse(ss.hasDefaultToolRapids())
|
|
obj.VertRapid = '0 mm/s'
|
|
self.assertTrue(ss.hasDefaultToolRapids())
|
|
obj.HorizRapid = '1 mm/s'
|
|
self.assertFalse(ss.hasDefaultToolRapids())
|
|
obj.HorizRapid = '0 mm/s'
|
|
self.assertTrue(ss.hasDefaultToolRapids())
|
|
|
|
obj.SafeHeightOffset = '0 mm'
|
|
self.assertFalse(ss.hasDefaultOperationHeights())
|
|
obj.SafeHeightOffset = ss.decodeAttributeString(PathSetupSheet.SetupSheet.DefaultSafeHeightOffset)
|
|
self.assertTrue(ss.hasDefaultOperationHeights())
|
|
obj.ClearanceHeightOffset = '0 mm'
|
|
self.assertFalse(ss.hasDefaultOperationHeights())
|
|
obj.ClearanceHeightOffset = ss.decodeAttributeString(PathSetupSheet.SetupSheet.DefaultClearanceHeightOffset)
|
|
self.assertTrue(ss.hasDefaultOperationHeights())
|
|
|
|
obj.SafeHeightExpression = '0 mm'
|
|
self.assertFalse(ss.hasDefaultOperationHeights())
|
|
obj.SafeHeightExpression = ss.decodeAttributeString(PathSetupSheet.SetupSheet.DefaultSafeHeightExpression)
|
|
self.assertTrue(ss.hasDefaultOperationHeights())
|
|
obj.ClearanceHeightExpression = '0 mm'
|
|
self.assertFalse(ss.hasDefaultOperationHeights())
|
|
obj.ClearanceHeightExpression = ss.decodeAttributeString(PathSetupSheet.SetupSheet.DefaultClearanceHeightExpression)
|
|
self.assertTrue(ss.hasDefaultOperationHeights())
|
|
|
|
obj.StartDepthExpression = ''
|
|
self.assertFalse(ss.hasDefaultOperationDepths())
|
|
obj.StartDepthExpression = ss.decodeAttributeString(PathSetupSheet.SetupSheet.DefaultStartDepthExpression)
|
|
self.assertTrue(ss.hasDefaultOperationDepths())
|
|
obj.FinalDepthExpression = ''
|
|
self.assertFalse(ss.hasDefaultOperationDepths())
|
|
obj.FinalDepthExpression = ss.decodeAttributeString(PathSetupSheet.SetupSheet.DefaultFinalDepthExpression)
|
|
self.assertTrue(ss.hasDefaultOperationDepths())
|
|
obj.StepDownExpression = ''
|
|
self.assertFalse(ss.hasDefaultOperationDepths())
|
|
obj.StepDownExpression = ss.decodeAttributeString(PathSetupSheet.SetupSheet.DefaultStepDownExpression)
|
|
self.assertTrue(ss.hasDefaultOperationDepths())
|
|
|
|
def test10(self):
|
|
'''Verify template attributes encoding/decoding of floats.'''
|
|
ss = PathSetupSheet.Create().Proxy
|
|
|
|
self.assertEqual(ss.expressionReference(), 'SetupSheet')
|
|
|
|
self.assertEqual(str(ss.encodeTemplateAttributes({'00': 13.00})), "{'00': 13.0}")
|
|
self.assertEqual(str(ss.decodeTemplateAttributes({'00': 13.00})), "{'00': 13.0}")
|
|
|
|
def test11(self):
|
|
'''Verify template attributes encoding/decoding of strings.'''
|
|
ss = PathSetupSheet.Create().Proxy
|
|
|
|
self.assertEqual(str(ss.encodeTemplateAttributes({'00': 'hugo'})), refstring("{'00': u'hugo'}"))
|
|
self.assertEqual(str(ss.encodeTemplateAttributes({'00': 'SetupSheet'})), refstring("{'00': u'${SetupSheet}'}"))
|
|
self.assertEqual(str(ss.encodeTemplateAttributes({'00': 'SetupSheet.y'})), refstring("{'00': u'${SetupSheet}.y'}"))
|
|
self.assertEqual(str(ss.encodeTemplateAttributes({'00': '${hugo}'})), refstring("{'00': u'${hugo}'}"))
|
|
|
|
self.assertEqual(str(ss.decodeTemplateAttributes({'00': 'hugo'})), refstring("{'00': u'hugo'}"))
|
|
self.assertEqual(str(ss.decodeTemplateAttributes({'00': '${SetupSheet}'})), refstring("{'00': u'SetupSheet'}"))
|
|
self.assertEqual(str(ss.decodeTemplateAttributes({'00': '${SetupSheet}.y'})), refstring("{'00': u'SetupSheet.y'}"))
|
|
self.assertEqual(str(ss.decodeTemplateAttributes({'00': '${SetupSheet}.y - ${SetupSheet}.z'})), refstring("{'00': u'SetupSheet.y - SetupSheet.z'}"))
|
|
|
|
def test12(self):
|
|
'''Verify template attributes encoding/decoding of dictionaries.'''
|
|
ss = PathSetupSheet.Create().Proxy
|
|
|
|
self.assertEqual(str(ss.encodeTemplateAttributes({'00': {'01': 'hugo'}})), refstring("{'00': {'01': u'hugo'}}"))
|
|
self.assertEqual(str(ss.encodeTemplateAttributes({'00': {'01': 'SetupSheet.y - SetupSheet.z'}})), refstring("{'00': {'01': u'${SetupSheet}.y - ${SetupSheet}.z'}}"))
|
|
|
|
self.assertEqual(str(ss.decodeTemplateAttributes({'00': {'01': 'hugo'}})), refstring("{'00': {'01': u'hugo'}}"))
|
|
self.assertEqual(str(ss.decodeTemplateAttributes({'00': {'01': '${SetupSheet}.y - ${SetupSheet}.z'}})), refstring("{'00': {'01': u'SetupSheet.y - SetupSheet.z'}}"))
|
|
|
|
def test13(self):
|
|
'''Verify template attributes encoding/decoding of lists.'''
|
|
ss = PathSetupSheet.Create().Proxy
|
|
|
|
attrs = {}
|
|
attrs['00'] = 'x.SetupSheet'
|
|
attrs['01'] = [{'10': 'SetupSheet', '11': 'SetupSheet.y'}, {'20': 'SetupSheet'}]
|
|
attrs['02'] = [{'a': [{'b': 'SetupSheet'}, {'c': 'SetupSheet'}], 'b': [{'b': 'SetupSheet'}]}]
|
|
|
|
encoded = ss.encodeTemplateAttributes(attrs)
|
|
self.assertEqual(encoded['00'], 'x.${SetupSheet}')
|
|
self.assertEqual(len(encoded['01']), 2)
|
|
self.assertEqual(encoded['01'][0]['10'], '${SetupSheet}')
|
|
self.assertEqual(encoded['01'][0]['11'], '${SetupSheet}.y')
|
|
self.assertEqual(str(encoded['01'][1]), refstring("{'20': u'${SetupSheet}'}"))
|
|
self.assertEqual(len(encoded['02']), 1)
|
|
self.assertEqual(len(encoded['02'][0]['a']), 2)
|
|
self.assertEqual(str(encoded['02'][0]['a'][0]), refstring("{'b': u'${SetupSheet}'}"))
|
|
self.assertEqual(str(encoded['02'][0]['a'][1]), refstring("{'c': u'${SetupSheet}'}"))
|
|
self.assertEqual(len(encoded['02'][0]['b']), 1)
|
|
self.assertEqual(str(encoded['02'][0]['b'][0]), refstring("{'b': u'${SetupSheet}'}"))
|
|
|
|
decoded = ss.decodeTemplateAttributes(encoded)
|
|
self.assertEqual(len(decoded), len(attrs))
|
|
self.assertEqual(decoded['00'], attrs['00'])
|
|
self.assertEqual(len(decoded['01']), len(attrs['01']))
|
|
self.assertEqual(decoded['01'][0]['10'], attrs['01'][0]['10'])
|
|
self.assertEqual(decoded['01'][0]['11'], attrs['01'][0]['11'])
|
|
self.assertEqual(decoded['01'][1]['20'], attrs['01'][1]['20'])
|
|
self.assertEqual(len(decoded['02']), len(attrs['02']))
|
|
self.assertEqual(len(decoded['02'][0]['a']), len(attrs['02'][0]['a']))
|
|
self.assertEqual(decoded['02'][0]['a'][0]['b'], attrs['02'][0]['a'][0]['b'])
|
|
self.assertEqual(decoded['02'][0]['a'][1]['c'], attrs['02'][0]['a'][1]['c'])
|
|
self.assertEqual(len(decoded['02'][0]['b']), len(attrs['02'][0]['b']))
|
|
self.assertEqual(decoded['02'][0]['b'][0]['b'], attrs['02'][0]['b'][0]['b'])
|
|
|
|
# just to be safe ...
|
|
s2 = PathSetupSheet.Create().Proxy
|
|
self.doc.recompute()
|
|
s2.setFromTemplate(ss.templateAttributes())
|
|
self.assertEqual(s2.expressionReference(), 'SetupSheet001')
|
|
dec = s2.decodeTemplateAttributes(encoded)
|
|
# pick one
|
|
self.assertEqual(dec['01'][0]['11'], 'SetupSheet001.y')
|
|
|