kindred/create
1
1
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity

Merge pull request #869 from kkremitzki/pdtests4

Browse Source 
PDN: Restructure tests and add cases for dressup features, linear/polar patterns
This commit is contained in:
Yorik van Havre
2017-07-11 10:10:23 -03:00
committed by GitHub
parent 1b56637c6f 4331a8073c
commit 165dcc9e1e
17 changed files with 1318 additions and 521 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/Mod/PartDesign/App/CMakeLists.txt
View File

@@ -153,6 +153,20 @@ SET(PartDesign_Scripts
Scripts/RadialCopy.py
Scripts/Parallelepiped.py
Scripts/Spring.py
PartDesignTests/__init__.py
PartDesignTests/TestDatum.py
PartDesignTests/TestPad.py
PartDesignTests/TestPocket.py
PartDesignTests/TestRevolve.py
PartDesignTests/TestLoft.py
PartDesignTests/TestPipe.py
PartDesignTests/TestMirrored.py
PartDesignTests/TestLinearPattern.py
PartDesignTests/TestPolarPattern.py
PartDesignTests/TestFillet.py
PartDesignTests/TestChamfer.py
PartDesignTests/TestDraft.py
PartDesignTests/TestThickness.py
fcgear/__init__.py
fcgear/fcgear.py
fcgear/fcgeardialog.py

20
src/Mod/PartDesign/CMakeLists.txt
View File

@@ -30,6 +30,26 @@ INSTALL(
DESTINATION
Mod/PartDesign/Scripts
)
INSTALL(
FILES
PartDesignTests/__init__.py
PartDesignTests/TestDatum.py
PartDesignTests/TestPad.py
PartDesignTests/TestPocket.py
PartDesignTests/TestRevolve.py
PartDesignTests/TestLoft.py
PartDesignTests/TestPipe.py
PartDesignTests/TestMirrored.py
PartDesignTests/TestLinearPattern.py
PartDesignTests/TestPolarPattern.py
PartDesignTests/TestFillet.py
PartDesignTests/TestChamfer.py
PartDesignTests/TestDraft.py
PartDesignTests/TestThickness.py
DESTINATION
Mod/PartDesign/PartDesignTests
)
INSTALL(
FILES

49
src/Mod/PartDesign/PartDesignTests/TestChamfer.py Normal file
View File

@@ -0,0 +1,49 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
class TestChamfer(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestChamfer")
def testChamferCubeToOctahedron(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.Chamfer = self.Doc.addObject("PartDesign::Chamfer","Chamfer")
self.Chamfer.Base = (self.Box, ['Face'+str(i+1) for i in range(6)])
self.Chamfer.Size = 4.999999
self.Body.addObject(self.Chamfer)
self.Doc.recompute()
self.MajorFaces = [face for face in self.Chamfer.Shape.Faces if face.Area > 1e-3]
self.assertEqual(len(self.MajorFaces), 8)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestChamfer")
# print ("omit closing document for debugging")

81
src/Mod/PartDesign/PartDesignTests/TestDatum.py Normal file
View File

@@ -0,0 +1,81 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
App = FreeCAD
class TestDatumPoint(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestDatumPoint")
def testOriginDatumPoint(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.DatumPoint = self.Doc.addObject('PartDesign::Point','DatumPoint')
self.DatumPoint.Support = [(self.Doc.XY_Plane,'')]
self.DatumPoint.MapMode = 'ObjectOrigin'
self.Body.addObject(self.DatumPoint)
self.Doc.recompute()
self.assertEqual(self.DatumPoint.superPlacement.Base, App.Vector(0))
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestDatumPoint")
#print ("omit closing document for debugging")
class TestDatumLine(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestDatumLine")
def testXAxisDatumLine(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.DatumLine = self.Doc.addObject('PartDesign::Line','DatumLine')
self.DatumLine.Support = [(self.Doc.XY_Plane,'')]
self.DatumLine.MapMode = 'ObjectX'
self.Body.addObject(self.DatumLine)
self.Doc.recompute()
self.assertNotIn('Invalid', self.DatumLine.State)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestDatumLine")
#print ("omit closing document for debugging")
class TestDatumPlane(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestDatumPlane")
def testXYDatumPlane(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.DatumPlane = self.Doc.addObject('PartDesign::Plane','DatumPlane')
self.DatumPlane.Support = [(self.Doc.XY_Plane,'')]
self.DatumPlane.MapMode = 'FlatFace'
self.Body.addObject(self.DatumPlane)
self.Doc.recompute()
self.DatumPlaneNormal = self.DatumPlane.Shape.Surface.Axis
self.assertEqual(abs(self.DatumPlaneNormal.dot(App.Vector(0,0,1))), 1)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestDatumPlane")
#print ("omit closing document for debugging")

77
src/Mod/PartDesign/PartDesignTests/TestDraft.py Normal file
View File

@@ -0,0 +1,77 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
App = FreeCAD
class TestDraft(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestDraft")
def testSimpleDraft(self):
# fix: create datum plane on YZ. create datum line on Z + 10i
# find top face by first making list comprehension of Z-normal faces
# and then find which has the higher center of mass Z-value
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.DatumPlane = self.Doc.addObject('PartDesign::Plane','DatumPlane')
self.DatumPlane.Support = [(self.Doc.YZ_Plane,'')]
self.DatumPlane.MapMode = 'FlatFace'
self.Body.addObject(self.DatumPlane)
self.Doc.recompute()
self.DatumLine = self.Doc.addObject('PartDesign::Line','DatumLine')
self.DatumLine.Support = [(self.Doc.X_Axis,'')]
self.DatumLine.MapMode = 'TwoPointLine'
self.Body.addObject(self.DatumLine)
self.Doc.recompute()
self.Draft = self.Doc.addObject("PartDesign::Draft","Draft")
# Draft.Base needs to be top face
self.Faces = self.Box.Shape.Faces
# Grab the two faces with Z-normals and find the higher one
self.ZFaceIndexes = [i for i in range(len(self.Faces)) if self.Faces[i].Surface.Axis == App.Vector(0,0,1)]
if self.Faces[self.ZFaceIndexes[0]].CenterOfMass.z > self.Faces[self.ZFaceIndexes[1]].CenterOfMass.z:
self.TopFaceIndex = self.ZFaceIndexes[0]
else:
self.TopFaceIndex = self.ZFaceIndexes[1]
self.Draft.Base = (self.Box, ["Face"+str(self.TopFaceIndex+1)])
self.Draft.NeutralPlane = (self.DatumPlane, [''])
self.Draft.PullDirection = (self.DatumLine, [''])
self.Draft.Angle = 45.0
self.Draft.Reversed = 1
self.Body.addObject(self.Draft)
self.Doc.recompute()
if 'Invalid' in self.Draft.State:
self.Draft.Reversed = 0
self.Doc.recompute()
self.assertAlmostEqual(self.Draft.Shape.Volume, 1500)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestDraft")
# print ("omit closing document for debugging")

50
src/Mod/PartDesign/PartDesignTests/TestFillet.py Normal file
View File

@@ -0,0 +1,50 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
from __future__ import division
from math import pi
import unittest
import FreeCAD
class TestFillet(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestFillet")
def testFilletCubeToSphere(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.Fillet = self.Doc.addObject("PartDesign::Fillet","Fillet")
self.Fillet.Base = (self.Box, ['Face'+str(i+1) for i in range(6)])
self.Fillet.Radius = 4.999999
self.Body.addObject(self.Fillet)
self.Doc.recompute()
self.assertAlmostEqual(self.Fillet.Shape.Volume, 4/3 * pi * 5**3, places=3)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestFillet")
# print ("omit closing document for debugging")

145
src/Mod/PartDesign/PartDesignTests/TestLinearPattern.py Normal file
View File

@@ -0,0 +1,145 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
import TestSketcherApp
class TestLinearPattern(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestLinearPattern")
def testXAxisLinearPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.LinearPattern = self.Doc.addObject("PartDesign::LinearPattern","LinearPattern")
self.LinearPattern.Originals = [self.Box]
self.LinearPattern.Direction = (self.Doc.X_Axis,[""])
self.LinearPattern.Length = 90.0
self.LinearPattern.Occurrences = 10
self.Body.addObject(self.LinearPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.LinearPattern.Shape.Volume, 1e4)
def testYAxisLinearPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.LinearPattern = self.Doc.addObject("PartDesign::LinearPattern","LinearPattern")
self.LinearPattern.Originals = [self.Box]
self.LinearPattern.Direction = (self.Doc.Y_Axis,[""])
self.LinearPattern.Length = 90.0
self.LinearPattern.Occurrences = 10
self.Body.addObject(self.LinearPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.LinearPattern.Shape.Volume, 1e4)
def testZAxisLinearPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.LinearPattern = self.Doc.addObject("PartDesign::LinearPattern","LinearPattern")
self.LinearPattern.Originals = [self.Box]
self.LinearPattern.Direction = (self.Doc.Z_Axis,[""])
self.LinearPattern.Length = 90.0
self.LinearPattern.Occurrences = 10
self.Body.addObject(self.LinearPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.LinearPattern.Shape.Volume, 1e4)
def testNormalSketchAxisLinearPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 10
self.Doc.recompute()
self.LinearPattern = self.Doc.addObject("PartDesign::LinearPattern","LinearPattern")
self.LinearPattern.Originals = [self.Pad]
self.LinearPattern.Direction = (self.PadSketch,["N_Axis"])
self.LinearPattern.Length = 90.0
self.LinearPattern.Occurrences = 10
self.Body.addObject(self.LinearPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.LinearPattern.Shape.Volume, 1e4)
def testVerticalSketchAxisLinearPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 10
self.Doc.recompute()
self.LinearPattern = self.Doc.addObject("PartDesign::LinearPattern","LinearPattern")
self.LinearPattern.Originals = [self.Pad]
self.LinearPattern.Direction = (self.PadSketch,["V_Axis"])
self.LinearPattern.Length = 90.0
self.LinearPattern.Occurrences = 10
self.Body.addObject(self.LinearPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.LinearPattern.Shape.Volume, 1e4)
def testHorizontalSketchAxisLinearPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 10
self.Doc.recompute()
self.LinearPattern = self.Doc.addObject("PartDesign::LinearPattern","LinearPattern")
self.LinearPattern.Originals = [self.Pad]
self.LinearPattern.Direction = (self.PadSketch,["H_Axis"])
self.LinearPattern.Length = 90.0
self.LinearPattern.Occurrences = 10
self.Body.addObject(self.LinearPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.LinearPattern.Shape.Volume, 1e4)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestLinearPattern")
# print ("omit closing document for debugging")

83
src/Mod/PartDesign/PartDesignTests/TestLoft.py Normal file
View File

@@ -0,0 +1,83 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
import TestSketcherApp
class TestLoft(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestLoft")
def testSimpleAdditiveLoftCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.ProfileSketch = self.Doc.addObject('Sketcher::SketchObject', 'ProfileSketch')
self.Body.addObject(self.ProfileSketch)
TestSketcherApp.CreateRectangleSketch(self.ProfileSketch, (0, 0), (1, 1))
self.Doc.recompute()
self.LoftSketch = self.Doc.addObject('Sketcher::SketchObject', 'LoftSketch')
self.Body.addObject(self.LoftSketch)
self.LoftSketch.MapMode = 'FlatFace'
self.LoftSketch.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.LoftSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.AdditiveLoft = self.Doc.addObject("PartDesign::AdditiveLoft","AdditiveLoft")
self.Body.addObject(self.AdditiveLoft)
self.AdditiveLoft.Profile = self.ProfileSketch
self.AdditiveLoft.Sections = [self.LoftSketch]
self.Doc.recompute()
self.assertAlmostEqual(self.AdditiveLoft.Shape.Volume, 1)
def testSimpleSubtractiveLoftCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 2
self.Doc.recompute()
self.ProfileSketch = self.Doc.addObject('Sketcher::SketchObject', 'ProfileSketch')
self.Body.addObject(self.ProfileSketch)
TestSketcherApp.CreateRectangleSketch(self.ProfileSketch, (0, 0), (1, 1))
self.Doc.recompute()
self.LoftSketch = self.Doc.addObject('Sketcher::SketchObject', 'LoftSketch')
self.Body.addObject(self.LoftSketch)
self.LoftSketch.MapMode = 'FlatFace'
self.LoftSketch.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.LoftSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.SubtractiveLoft = self.Doc.addObject("PartDesign::SubtractiveLoft","SubtractiveLoft")
self.Body.addObject(self.SubtractiveLoft)
self.SubtractiveLoft.Profile = self.ProfileSketch
self.SubtractiveLoft.Sections = [self.LoftSketch]
self.Doc.recompute()
self.assertAlmostEqual(self.SubtractiveLoft.Shape.Volume, 1)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestLoft")
#print ("omit closing document for debugging")

93
src/Mod/PartDesign/PartDesignTests/TestMirrored.py Normal file
View File

@@ -0,0 +1,93 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
import TestSketcherApp
class TestMirrored(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestMirrored")
def testMirroredSketchCase(self):
"""
Creates a unit cube cornered at the origin and mirrors it about the Y axis.
This operation should create a rectangular prism with volume 2.0.
"""
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Rect = self.Doc.addObject('Sketcher::SketchObject','Rect')
self.Body.addObject(self.Rect)
TestSketcherApp.CreateRectangleSketch(self.Rect, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad","Pad")
self.Pad.Profile = self.Rect
self.Pad.Length = 1
self.Body.addObject(self.Pad)
self.Doc.recompute()
self.Mirrored = self.Doc.addObject("PartDesign::Mirrored","Mirrored")
self.Mirrored.Originals = [self.Pad]
self.Mirrored.MirrorPlane = (self.Rect, ["V_Axis"])
self.Body.addObject(self.Mirrored)
self.Doc.recompute()
self.assertAlmostEqual(self.Mirrored.Shape.Volume, 2.0)
def testMirroredPrimitiveCase(self):
"""
Tests the same mirroring scenario as in the sketch case,
but is designed to ensure the same end result occurs with
a different base object.
"""
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Box.Length=1
self.Box.Width=1
self.Box.Height=1
self.Body.addObject(self.Box)
self.Doc.recompute()
self.Mirrored = self.Doc.addObject("PartDesign::Mirrored", "Mirrored")
self.Mirrored.Originals = [self.Box]
self.Mirrored.MirrorPlane = (self.Doc.XY_Plane, [""])
self.Body.addObject(self.Mirrored)
self.Doc.recompute()
self.assertAlmostEqual(self.Mirrored.Shape.Volume, 2.0)
def testMirroredOffsetFailureCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Rect = self.Doc.addObject('Sketcher::SketchObject','Rect')
self.Body.addObject(self.Rect)
TestSketcherApp.CreateRectangleSketch(self.Rect, (0, 1), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad","Pad")
self.Pad.Profile = self.Rect
self.Pad.Length = 1
self.Body.addObject(self.Pad)
self.Doc.recompute()
self.Mirrored = self.Doc.addObject("PartDesign::Mirrored","Mirrored")
self.Mirrored.Originals = [self.Pad]
self.Mirrored.MirrorPlane = (self.Rect, ["H_Axis"])
self.Body.addObject(self.Mirrored)
self.Doc.recompute()
self.assertEqual(self.Mirrored.State, ["Invalid"])
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestMirrored")
#print ("omit closing document for debugging")

158
src/Mod/PartDesign/PartDesignTests/TestPad.py Normal file
View File

@@ -0,0 +1,158 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
import TestSketcherApp
class TestPad(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestPad")
def testBoxCase(self):
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject','SketchPad')
TestSketcherApp.CreateSlotPlateSet(self.PadSketch)
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad","Pad")
self.Pad.Profile = self.PadSketch
self.Doc.recompute()
self.assertEqual(len(self.Pad.Shape.Faces), 6)
def testPadToFirstCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
# Make first offset cube Pad
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Doc.recompute()
# Make second pad on different plane and pad to first
self.PadSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad1')
self.Body.addObject(self.PadSketch1)
self.PadSketch1.MapMode = 'FlatFace'
self.PadSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PadSketch1, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad1 = self.Doc.addObject("PartDesign::Pad", "Pad1")
self.Body.addObject(self.Pad1)
self.Pad1.Profile = self.PadSketch1
self.Pad1.Type = 2
self.Pad1.Reversed = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pad1.Shape.Volume, 2.0)
def testPadtoLastCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
# Make first offset cube Pad
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0.5, 1), (0.5, 2))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Doc.recompute()
# Make second pad on different plane and pad to first
self.PadSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad1')
self.Body.addObject(self.PadSketch1)
self.PadSketch1.MapMode = 'FlatFace'
self.PadSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PadSketch1, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad1 = self.Doc.addObject("PartDesign::Pad", "Pad1")
self.Body.addObject(self.Pad1)
self.Pad1.Profile = self.PadSketch1
self.Pad1.Type = 1
self.Pad1.Reversed = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pad1.Shape.Volume, 3.0)
def testPadToFaceCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
# Make first offset cube Pad
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Doc.recompute()
# Make second pad on different plane and pad to face on first
self.PadSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad1')
self.Body.addObject(self.PadSketch1)
self.PadSketch1.MapMode = 'FlatFace'
self.PadSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PadSketch1, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad1 = self.Doc.addObject("PartDesign::Pad", "Pad1")
self.Body.addObject(self.Pad1)
self.Pad1.Profile = self.PadSketch1
self.Pad1.Type = 3
self.Pad1.UpToFace = (self.Pad, ["Face3"])
self.Pad1.Reversed = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pad1.Shape.Volume, 2.0)
def testPadTwoDimensionsCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
# Make first offset cube Pad
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Doc.recompute()
# Make second pad on different plane and pad to face on first
self.PadSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad1')
self.Body.addObject(self.PadSketch1)
self.PadSketch1.MapMode = 'FlatFace'
self.PadSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PadSketch1, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad1 = self.Doc.addObject("PartDesign::Pad", "Pad1")
self.Body.addObject(self.Pad1)
self.Pad1.Profile = self.PadSketch1
self.Pad1.Type = 4
self.Pad1.Length = 2.0
self.Pad1.Length2 = 1.0
self.Pad1.Reversed = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pad1.Shape.Volume, 4.0)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestPad")
#print ("omit closing document for debugging")

93
src/Mod/PartDesign/PartDesignTests/TestPipe.py Normal file
View File

@@ -0,0 +1,93 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
import Part
import Sketcher
import TestSketcherApp
App = FreeCAD
class TestPipe(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestPipe")
def testSimpleAdditivePipeCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.ProfileSketch = self.Doc.addObject('Sketcher::SketchObject', 'ProfileSketch')
self.Body.addObject(self.ProfileSketch)
TestSketcherApp.CreateCircleSketch(self.ProfileSketch, (0, 0), 1)
self.Doc.recompute()
self.SpineSketch = self.Doc.addObject('Sketcher::SketchObject', 'SpineSketch')
self.Body.addObject(self.SpineSketch)
self.SpineSketch.MapMode = 'FlatFace'
self.SpineSketch.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
self.SpineSketch.addGeometry(Part.LineSegment(App.Vector(0.0,0.0,0),App.Vector(0,1,0)),False)
self.SpineSketch.addConstraint(Sketcher.Constraint('Coincident',0,1,-1,1))
self.SpineSketch.addConstraint(Sketcher.Constraint('PointOnObject',0,2,-2))
self.SpineSketch.addConstraint(Sketcher.Constraint('DistanceY',0,1,0,2,1))
self.Doc.recompute()
self.AdditivePipe = self.Doc.addObject("PartDesign::AdditivePipe","AdditivePipe")
self.Body.addObject(self.AdditivePipe)
self.AdditivePipe.Profile = self.ProfileSketch
self.AdditivePipe.Spine = self.SpineSketch
self.Doc.recompute()
self.assertAlmostEqual(self.AdditivePipe.Shape.Volume, 3.14159265)
def testSimpleSubtractivePipeCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.ProfileSketch = self.Doc.addObject('Sketcher::SketchObject', 'ProfileSketch')
self.Body.addObject(self.ProfileSketch)
TestSketcherApp.CreateCircleSketch(self.ProfileSketch, (0, 0), 1)
self.Doc.recompute()
self.SpineSketch = self.Doc.addObject('Sketcher::SketchObject', 'SpineSketch')
self.Body.addObject(self.SpineSketch)
self.SpineSketch.MapMode = 'FlatFace'
self.SpineSketch.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
self.SpineSketch.addGeometry(Part.LineSegment(App.Vector(0.0,0.0,0),App.Vector(0,1,0)),False)
self.SpineSketch.addConstraint(Sketcher.Constraint('Coincident',0,1,-1,1))
self.SpineSketch.addConstraint(Sketcher.Constraint('PointOnObject',0,2,-2))
self.SpineSketch.addConstraint(Sketcher.Constraint('DistanceY',0,1,0,2,1))
self.Doc.recompute()
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (-5, -5), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1.0
self.Doc.recompute()
self.SubtractivePipe = self.Doc.addObject("PartDesign::SubtractivePipe","SubtractivePipe")
self.Body.addObject(self.SubtractivePipe)
self.SubtractivePipe.Profile = self.ProfileSketch
self.SubtractivePipe.Spine = self.SpineSketch
self.Doc.recompute()
self.assertAlmostEqual(self.SubtractivePipe.Shape.Volume, 100 - 3.14159265)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestPipe")
#print ("omit closing document for debugging")

168
src/Mod/PartDesign/PartDesignTests/TestPocket.py Normal file
View File

@@ -0,0 +1,168 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
import TestSketcherApp
class TestPocket(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestPocket")
def testPocketDimensionCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Pad.Reversed = 1
self.Doc.recompute()
self.PocketSketch = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch)
TestSketcherApp.CreateRectangleSketch(self.PocketSketch, (2.5, 2.5), (5, 5))
self.Doc.recompute()
self.Pocket = self.Doc.addObject("PartDesign::Pocket", "Pocket")
self.Body.addObject(self.Pocket)
self.Pocket.Profile = self.PocketSketch
self.Pocket.Length = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pocket.Shape.Volume, 75.0)
def testPocketThroughAllCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Pad.Reversed = 1
self.Doc.recompute()
self.PocketSketch = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch)
TestSketcherApp.CreateRectangleSketch(self.PocketSketch, (2.5, 2.5), (5, 5))
self.Doc.recompute()
self.Pocket = self.Doc.addObject("PartDesign::Pocket", "Pocket")
self.Body.addObject(self.Pocket)
self.Pocket.Profile = self.PocketSketch
self.Pocket.Length = 1
self.Doc.recompute()
self.PocketSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch1)
self.PocketSketch1.MapMode = 'FlatFace'
self.PocketSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PocketSketch1, (2.5, -1), (5, 1))
self.Doc.recompute()
self.Pocket001 = self.Doc.addObject("PartDesign::Pocket", "Pocket001")
self.Body.addObject(self.Pocket001)
self.Pocket001.Profile = self.PocketSketch1
self.Pocket001.Type = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pocket001.Shape.Volume, 25.0)
def testPocketToFirstCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Pad.Reversed = 1
self.Doc.recompute()
self.PocketSketch = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch)
TestSketcherApp.CreateRectangleSketch(self.PocketSketch, (2.5, 2.5), (5, 5))
self.Doc.recompute()
self.Pocket = self.Doc.addObject("PartDesign::Pocket", "Pocket")
self.Body.addObject(self.Pocket)
self.Pocket.Profile = self.PocketSketch
self.Pocket.Length = 1
self.Doc.recompute()
self.PocketSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch1)
self.PocketSketch1.MapMode = 'FlatFace'
self.PocketSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PocketSketch1, (2.5, -1), (5, 1))
self.Doc.recompute()
self.Pocket001 = self.Doc.addObject("PartDesign::Pocket", "Pocket001")
self.Body.addObject(self.Pocket001)
self.Pocket001.Profile = self.PocketSketch1
self.Pocket001.Type = 2
self.Doc.recompute()
self.assertAlmostEqual(self.Pocket001.Shape.Volume, 62.5)
def testPocketToFaceCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Pad.Reversed = 1
self.Doc.recompute()
self.PocketSketch = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch)
TestSketcherApp.CreateRectangleSketch(self.PocketSketch, (2.5, 2.5), (5, 5))
self.Doc.recompute()
self.Pocket = self.Doc.addObject("PartDesign::Pocket", "Pocket")
self.Body.addObject(self.Pocket)
self.Pocket.Profile = self.PocketSketch
self.Pocket.Length = 1
self.Doc.recompute()
self.PocketSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch1)
self.PocketSketch1.MapMode = 'FlatFace'
self.PocketSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PocketSketch1, (0, -1), (10, 1))
self.Doc.recompute()
self.Pocket001 = self.Doc.addObject("PartDesign::Pocket", "Pocket001")
self.Body.addObject(self.Pocket001)
self.Pocket001.Profile = self.PocketSketch1
self.Pocket001.Type = 3
# Handle face-naming inconsistency in OCC < 7
self.FaceNumber = 7
self.Pocket001.UpToFace = (self.Pocket, ["Face"+str(self.FaceNumber)])
self.Doc.recompute()
while (('Invalid' in self.Pocket001.State or round(self.Pocket001.Shape.Volume, 7) != 50.0) and self.FaceNumber < 11):
self.FaceNumber += 1
self.Pocket001.UpToFace = (self.Pocket, ["Face"+str(self.FaceNumber)])
self.Doc.recompute()
self.assertAlmostEqual(self.Pocket001.Shape.Volume, 50.0)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestPocket")
#print ("omit closing document for debugging")

145
src/Mod/PartDesign/PartDesignTests/TestPolarPattern.py Normal file
View File

@@ -0,0 +1,145 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
import TestSketcherApp
class TestPolarPattern(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestPolarPattern")
def testXAxisPolarPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.PolarPattern = self.Doc.addObject("PartDesign::PolarPattern","PolarPattern")
self.PolarPattern.Originals = [self.Box]
self.PolarPattern.Axis = (self.Doc.X_Axis,[""])
self.PolarPattern.Angle = 360
self.PolarPattern.Occurrences = 4
self.Body.addObject(self.PolarPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.PolarPattern.Shape.Volume, 4000)
def testYAxisPolarPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.PolarPattern = self.Doc.addObject("PartDesign::PolarPattern","PolarPattern")
self.PolarPattern.Originals = [self.Box]
self.PolarPattern.Axis = (self.Doc.Y_Axis,[""])
self.PolarPattern.Angle = 360
self.PolarPattern.Occurrences = 4
self.Body.addObject(self.PolarPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.PolarPattern.Shape.Volume, 4000)
def testZAxisPolarPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.PolarPattern = self.Doc.addObject("PartDesign::PolarPattern","PolarPattern")
self.PolarPattern.Originals = [self.Box]
self.PolarPattern.Axis = (self.Doc.Z_Axis,[""])
self.PolarPattern.Angle = 360
self.PolarPattern.Occurrences = 4
self.Body.addObject(self.PolarPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.PolarPattern.Shape.Volume, 4000)
def testNormalSketchAxisPolarPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 10
self.Doc.recompute()
self.PolarPattern = self.Doc.addObject("PartDesign::PolarPattern","PolarPattern")
self.PolarPattern.Originals = [self.Pad]
self.PolarPattern.Axis = (self.PadSketch,["N_Axis"])
self.PolarPattern.Angle = 360
self.PolarPattern.Occurrences = 4
self.Body.addObject(self.PolarPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.PolarPattern.Shape.Volume, 4000)
def testVerticalSketchAxisPolarPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 10
self.Doc.recompute()
self.PolarPattern = self.Doc.addObject("PartDesign::PolarPattern","PolarPattern")
self.PolarPattern.Originals = [self.Pad]
self.PolarPattern.Axis = (self.PadSketch,["V_Axis"])
self.PolarPattern.Angle = 360
self.PolarPattern.Occurrences = 4
self.Body.addObject(self.PolarPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.PolarPattern.Shape.Volume, 4000)
def testHorizontalSketchAxisPolarPattern(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 10
self.Doc.recompute()
self.PolarPattern = self.Doc.addObject("PartDesign::PolarPattern","PolarPattern")
self.PolarPattern.Originals = [self.Pad]
self.PolarPattern.Axis = (self.PadSketch,["H_Axis"])
self.PolarPattern.Angle = 360
self.PolarPattern.Occurrences = 4
self.Body.addObject(self.PolarPattern)
self.Doc.recompute()
self.assertAlmostEqual(self.PolarPattern.Shape.Volume, 4000)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestPolarPattern")
# print ("omit closing document for debugging")

68
src/Mod/PartDesign/PartDesignTests/TestRevolve.py Normal file
View File

@@ -0,0 +1,68 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
class TestRevolve(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestRevolve")
def testRevolveFace(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.Revolution = self.Doc.addObject("PartDesign::Revolution","Revolution")
self.Revolution.Profile = (self.Box, ["Face6"])
self.Revolution.ReferenceAxis = (self.Doc.Y_Axis,[""])
self.Revolution.Angle = 180.0
self.Revolution.Reversed = 1
self.Body.addObject(self.Revolution)
self.Doc.recompute()
# depending on if refinement is done we expect 8 or 10 faces
self.assertIn(len(self.Revolution.Shape.Faces), (8, 10))
def testGrooveFace(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.Groove = self.Doc.addObject("PartDesign::Groove","Groove")
self.Groove.Profile = (self.Box, ["Face6"])
self.Groove.ReferenceAxis = (self.Doc.X_Axis,[""])
self.Groove.Angle = 180.0
self.Groove.Reversed = 1
self.Body.addObject(self.Groove)
self.Doc.recompute()
self.assertEqual(len(self.Groove.Shape.Faces), 5)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestRevolve")
# print ("omit closing document for debugging")

53
src/Mod/PartDesign/PartDesignTests/TestThickness.py Normal file
View File

@@ -0,0 +1,53 @@
# (c) Juergen Riegel (FreeCAD@juergen-riegel.net) 2011 LGPL *
# *
# This file is part of the FreeCAD CAx development system. *
# *
# 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. *
# *
# FreeCAD 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 FreeCAD; if not, write to the Free Software *
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import unittest
import FreeCAD
class TestThickness(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestThickness")
def testReversedThickness(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.Thickness = self.Doc.addObject("PartDesign::Thickness", "Thickness")
self.Thickness.Base = (self.Box, ["Face1"])
self.Body.addObject(self.Thickness)
self.Doc.recompute()
self.Thickness.Value = 1.0
self.Thickness.Reversed = 1
self.Thickness.Mode = 0
self.Thickness.Join = 0
self.Thickness.Base = (self.Box, ["Face1"])
self.Doc.recompute()
self.assertEqual(len(self.Thickness.Shape.Faces), 11)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestThickness")
# print ("omit closing document for debugging")

0
src/Mod/PartDesign/PartDesignTests/__init__.py Normal file
View File

542
src/Mod/PartDesign/TestPartDesignApp.py
View File

@@ -18,532 +18,32 @@
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
# USA *
#**************************************************************************
import os
import sys
import unittest
import FreeCAD
import Part
import Sketcher
import PartDesign
import TestSketcherApp
App = FreeCAD
#---------------------------------------------------------------------------
# define the test cases to test the FreeCAD PartDesign module
#---------------------------------------------------------------------------
# datum tools
from PartDesignTests.TestDatum import TestDatumPoint, TestDatumLine, TestDatumPlane
#from PartDesignTests.TestShapeBinder import TestShapeBinder
class PartDesignPadTestCases(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestPad")
# additive/subtractive features & primitives
from PartDesignTests.TestPad import TestPad
from PartDesignTests.TestPocket import TestPocket
from PartDesignTests.TestRevolve import TestRevolve
from PartDesignTests.TestPipe import TestPipe
from PartDesignTests.TestLoft import TestLoft
#from PartDesignTests.TestPrimitive import TestPrimitive
def testBoxCase(self):
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject','SketchPad')
TestSketcherApp.CreateSlotPlateSet(self.PadSketch)
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad","Pad")
self.Pad.Profile = self.PadSketch
self.Doc.recompute()
self.assertEqual(len(self.Pad.Shape.Faces), 6)
def testPadToFirstCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
# Make first offset cube Pad
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Doc.recompute()
# Make second pad on different plane and pad to first
self.PadSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad1')
self.Body.addObject(self.PadSketch1)
self.PadSketch1.MapMode = 'FlatFace'
self.PadSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PadSketch1, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad1 = self.Doc.addObject("PartDesign::Pad", "Pad1")
self.Body.addObject(self.Pad1)
self.Pad1.Profile = self.PadSketch1
self.Pad1.Type = 2
self.Pad1.Reversed = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pad1.Shape.Volume, 2.0)
def testPadtoLastCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
# Make first offset cube Pad
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0.5, 1), (0.5, 2))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Doc.recompute()
# Make second pad on different plane and pad to first
self.PadSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad1')
self.Body.addObject(self.PadSketch1)
self.PadSketch1.MapMode = 'FlatFace'
self.PadSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PadSketch1, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad1 = self.Doc.addObject("PartDesign::Pad", "Pad1")
self.Body.addObject(self.Pad1)
self.Pad1.Profile = self.PadSketch1
self.Pad1.Type = 1
self.Pad1.Reversed = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pad1.Shape.Volume, 3.0)
def testPadToFaceCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
# Make first offset cube Pad
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Doc.recompute()
# Make second pad on different plane and pad to face on first
self.PadSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad1')
self.Body.addObject(self.PadSketch1)
self.PadSketch1.MapMode = 'FlatFace'
self.PadSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PadSketch1, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad1 = self.Doc.addObject("PartDesign::Pad", "Pad1")
self.Body.addObject(self.Pad1)
self.Pad1.Profile = self.PadSketch1
self.Pad1.Type = 3
self.Pad1.UpToFace = (self.Pad, ["Face3"])
self.Pad1.Reversed = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pad1.Shape.Volume, 2.0)
def testPadTwoDimensionsCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
# Make first offset cube Pad
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Doc.recompute()
# Make second pad on different plane and pad to face on first
self.PadSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad1')
self.Body.addObject(self.PadSketch1)
self.PadSketch1.MapMode = 'FlatFace'
self.PadSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PadSketch1, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad1 = self.Doc.addObject("PartDesign::Pad", "Pad1")
self.Body.addObject(self.Pad1)
self.Pad1.Profile = self.PadSketch1
self.Pad1.Type = 4
self.Pad1.Length = 2.0
self.Pad1.Length2 = 1.0
self.Pad1.Reversed = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pad1.Shape.Volume, 4.0)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestPad")
#print ("omit closing document for debugging")
class PartDesignRevolveTestCases(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestRevolve")
def testRevolveFace(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.Revolution = self.Doc.addObject("PartDesign::Revolution","Revolution")
self.Revolution.Profile = (self.Box, ["Face6"])
self.Revolution.ReferenceAxis = (self.Doc.Y_Axis,[""])
self.Revolution.Angle = 180.0
self.Revolution.Reversed = 1
self.Body.addObject(self.Revolution)
self.Doc.recompute()
# depending on if refinement is done we expect 8 or 10 faces
self.assertIn(len(self.Revolution.Shape.Faces), (8, 10))
def testGrooveFace(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Body.addObject(self.Box)
self.Box.Length=10.00
self.Box.Width=10.00
self.Box.Height=10.00
self.Doc.recompute()
self.Groove = self.Doc.addObject("PartDesign::Groove","Groove")
self.Groove.Profile = (self.Box, ["Face6"])
self.Groove.ReferenceAxis = (self.Doc.X_Axis,[""])
self.Groove.Angle = 180.0
self.Groove.Reversed = 1
self.Body.addObject(self.Groove)
self.Doc.recompute()
self.assertEqual(len(self.Groove.Shape.Faces), 5)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestRevolve")
# print ("omit closing document for debugging")
class PartDesignMirroredTestCases(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestMirrored")
def testMirroredSketchCase(self):
"""
Creates a unit cube cornered at the origin and mirrors it about the Y axis.
This operation should create a rectangular prism with volume 2.0.
"""
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Rect = self.Doc.addObject('Sketcher::SketchObject','Rect')
self.Body.addObject(self.Rect)
TestSketcherApp.CreateRectangleSketch(self.Rect, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad","Pad")
self.Pad.Profile = self.Rect
self.Pad.Length = 1
self.Body.addObject(self.Pad)
self.Doc.recompute()
self.Mirrored = self.Doc.addObject("PartDesign::Mirrored","Mirrored")
self.Mirrored.Originals = [self.Pad]
self.Mirrored.MirrorPlane = (self.Rect, ["V_Axis"])
self.Body.addObject(self.Mirrored)
self.Doc.recompute()
self.assertAlmostEqual(self.Mirrored.Shape.Volume, 2.0)
def testMirroredPrimitiveCase(self):
"""
Tests the same mirroring scenario as in the sketch case,
but is designed to ensure the same end result occurs with
a different base object.
"""
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Box = self.Doc.addObject('PartDesign::AdditiveBox','Box')
self.Box.Length=1
self.Box.Width=1
self.Box.Height=1
self.Body.addObject(self.Box)
self.Doc.recompute()
self.Mirrored = self.Doc.addObject("PartDesign::Mirrored", "Mirrored")
self.Mirrored.Originals = [self.Box]
self.Mirrored.MirrorPlane = (self.Doc.XY_Plane, [""])
self.Body.addObject(self.Mirrored)
self.Doc.recompute()
self.assertAlmostEqual(self.Mirrored.Shape.Volume, 2.0)
def testMirroredOffsetFailureCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.Rect = self.Doc.addObject('Sketcher::SketchObject','Rect')
self.Body.addObject(self.Rect)
TestSketcherApp.CreateRectangleSketch(self.Rect, (0, 1), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad","Pad")
self.Pad.Profile = self.Rect
self.Pad.Length = 1
self.Body.addObject(self.Pad)
self.Doc.recompute()
self.Mirrored = self.Doc.addObject("PartDesign::Mirrored","Mirrored")
self.Mirrored.Originals = [self.Pad]
self.Mirrored.MirrorPlane = (self.Rect, ["H_Axis"])
self.Body.addObject(self.Mirrored)
self.Doc.recompute()
self.assertEqual(self.Mirrored.State, ["Invalid"])
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestMirrored")
#print ("omit closing document for debugging")
class PartDesignPocketTestCases(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestPocket")
def testPocketDimensionCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Pad.Reversed = 1
self.Doc.recompute()
self.PocketSketch = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch)
TestSketcherApp.CreateRectangleSketch(self.PocketSketch, (2.5, 2.5), (5, 5))
self.Doc.recompute()
self.Pocket = self.Doc.addObject("PartDesign::Pocket", "Pocket")
self.Body.addObject(self.Pocket)
self.Pocket.Profile = self.PocketSketch
self.Pocket.Length = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pocket.Shape.Volume, 75.0)
def testPocketThroughAllCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Pad.Reversed = 1
self.Doc.recompute()
self.PocketSketch = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch)
TestSketcherApp.CreateRectangleSketch(self.PocketSketch, (2.5, 2.5), (5, 5))
self.Doc.recompute()
self.Pocket = self.Doc.addObject("PartDesign::Pocket", "Pocket")
self.Body.addObject(self.Pocket)
self.Pocket.Profile = self.PocketSketch
self.Pocket.Length = 1
self.Doc.recompute()
self.PocketSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch1)
self.PocketSketch1.MapMode = 'FlatFace'
self.PocketSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PocketSketch1, (2.5, -1), (5, 1))
self.Doc.recompute()
self.Pocket001 = self.Doc.addObject("PartDesign::Pocket", "Pocket001")
self.Body.addObject(self.Pocket001)
self.Pocket001.Profile = self.PocketSketch1
self.Pocket001.Type = 1
self.Doc.recompute()
self.assertAlmostEqual(self.Pocket001.Shape.Volume, 25.0)
def testPocketToFirstCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Pad.Reversed = 1
self.Doc.recompute()
self.PocketSketch = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch)
TestSketcherApp.CreateRectangleSketch(self.PocketSketch, (2.5, 2.5), (5, 5))
self.Doc.recompute()
self.Pocket = self.Doc.addObject("PartDesign::Pocket", "Pocket")
self.Body.addObject(self.Pocket)
self.Pocket.Profile = self.PocketSketch
self.Pocket.Length = 1
self.Doc.recompute()
self.PocketSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch1)
self.PocketSketch1.MapMode = 'FlatFace'
self.PocketSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PocketSketch1, (2.5, -1), (5, 1))
self.Doc.recompute()
self.Pocket001 = self.Doc.addObject("PartDesign::Pocket", "Pocket001")
self.Body.addObject(self.Pocket001)
self.Pocket001.Profile = self.PocketSketch1
self.Pocket001.Type = 2
self.Doc.recompute()
self.assertAlmostEqual(self.Pocket001.Shape.Volume, 62.5)
def testPocketToFaceCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1
self.Pad.Reversed = 1
self.Doc.recompute()
self.PocketSketch = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch)
TestSketcherApp.CreateRectangleSketch(self.PocketSketch, (2.5, 2.5), (5, 5))
self.Doc.recompute()
self.Pocket = self.Doc.addObject("PartDesign::Pocket", "Pocket")
self.Body.addObject(self.Pocket)
self.Pocket.Profile = self.PocketSketch
self.Pocket.Length = 1
self.Doc.recompute()
self.PocketSketch1 = self.Doc.addObject('Sketcher::SketchObject', 'PocketSketch')
self.Body.addObject(self.PocketSketch1)
self.PocketSketch1.MapMode = 'FlatFace'
self.PocketSketch1.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.PocketSketch1, (0, -1), (10, 1))
self.Doc.recompute()
self.Pocket001 = self.Doc.addObject("PartDesign::Pocket", "Pocket001")
self.Body.addObject(self.Pocket001)
self.Pocket001.Profile = self.PocketSketch1
self.Pocket001.Type = 3
# Handle face-naming inconsistency in OCC < 7
self.FaceNumber = 7
self.Pocket001.UpToFace = (self.Pocket, ["Face"+str(self.FaceNumber)])
self.Doc.recompute()
while (('Invalid' in self.Pocket001.State or round(self.Pocket001.Shape.Volume, 7) != 50.0) and self.FaceNumber < 11):
self.FaceNumber += 1
self.Pocket001.UpToFace = (self.Pocket, ["Face"+str(self.FaceNumber)])
self.Doc.recompute()
self.assertAlmostEqual(self.Pocket001.Shape.Volume, 50.0)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestPocket")
#print ("omit closing document for debugging")
class PartDesignPipeTestCases(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestPipe")
def testSimpleAdditivePipeCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.ProfileSketch = self.Doc.addObject('Sketcher::SketchObject', 'ProfileSketch')
self.Body.addObject(self.ProfileSketch)
TestSketcherApp.CreateCircleSketch(self.ProfileSketch, (0, 0), 1)
self.Doc.recompute()
self.SpineSketch = self.Doc.addObject('Sketcher::SketchObject', 'SpineSketch')
self.Body.addObject(self.SpineSketch)
self.SpineSketch.MapMode = 'FlatFace'
self.SpineSketch.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
self.SpineSketch.addGeometry(Part.LineSegment(App.Vector(0.0,0.0,0),App.Vector(0,1,0)),False)
self.SpineSketch.addConstraint(Sketcher.Constraint('Coincident',0,1,-1,1))
self.SpineSketch.addConstraint(Sketcher.Constraint('PointOnObject',0,2,-2))
self.SpineSketch.addConstraint(Sketcher.Constraint('DistanceY',0,1,0,2,1))
self.Doc.recompute()
self.AdditivePipe = self.Doc.addObject("PartDesign::AdditivePipe","AdditivePipe")
self.Body.addObject(self.AdditivePipe)
self.AdditivePipe.Profile = self.ProfileSketch
self.AdditivePipe.Spine = self.SpineSketch
self.Doc.recompute()
self.assertAlmostEqual(self.AdditivePipe.Shape.Volume, 3.14159265)
def testSimpleSubtractivePipeCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.ProfileSketch = self.Doc.addObject('Sketcher::SketchObject', 'ProfileSketch')
self.Body.addObject(self.ProfileSketch)
TestSketcherApp.CreateCircleSketch(self.ProfileSketch, (0, 0), 1)
self.Doc.recompute()
self.SpineSketch = self.Doc.addObject('Sketcher::SketchObject', 'SpineSketch')
self.Body.addObject(self.SpineSketch)
self.SpineSketch.MapMode = 'FlatFace'
self.SpineSketch.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
self.SpineSketch.addGeometry(Part.LineSegment(App.Vector(0.0,0.0,0),App.Vector(0,1,0)),False)
self.SpineSketch.addConstraint(Sketcher.Constraint('Coincident',0,1,-1,1))
self.SpineSketch.addConstraint(Sketcher.Constraint('PointOnObject',0,2,-2))
self.SpineSketch.addConstraint(Sketcher.Constraint('DistanceY',0,1,0,2,1))
self.Doc.recompute()
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'PadSketch')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (-5, -5), (10, 10))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 1.0
self.Doc.recompute()
self.SubtractivePipe = self.Doc.addObject("PartDesign::SubtractivePipe","SubtractivePipe")
self.Body.addObject(self.SubtractivePipe)
self.SubtractivePipe.Profile = self.ProfileSketch
self.SubtractivePipe.Spine = self.SpineSketch
self.Doc.recompute()
self.assertAlmostEqual(self.SubtractivePipe.Shape.Volume, 100 - 3.14159265)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestPipe")
#print ("omit closing document for debugging")
class PartDesignLoftTestCases(unittest.TestCase):
def setUp(self):
self.Doc = FreeCAD.newDocument("PartDesignTestLoft")
def testSimpleAdditiveLoftCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.ProfileSketch = self.Doc.addObject('Sketcher::SketchObject', 'ProfileSketch')
self.Body.addObject(self.ProfileSketch)
TestSketcherApp.CreateRectangleSketch(self.ProfileSketch, (0, 0), (1, 1))
self.Doc.recompute()
self.LoftSketch = self.Doc.addObject('Sketcher::SketchObject', 'LoftSketch')
self.Body.addObject(self.LoftSketch)
self.LoftSketch.MapMode = 'FlatFace'
self.LoftSketch.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.LoftSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.AdditiveLoft = self.Doc.addObject("PartDesign::AdditiveLoft","AdditiveLoft")
self.Body.addObject(self.AdditiveLoft)
self.AdditiveLoft.Profile = self.ProfileSketch
self.AdditiveLoft.Sections = [self.LoftSketch]
self.Doc.recompute()
self.assertAlmostEqual(self.AdditiveLoft.Shape.Volume, 1)
def testSimpleSubtractiveLoftCase(self):
self.Body = self.Doc.addObject('PartDesign::Body','Body')
self.PadSketch = self.Doc.addObject('Sketcher::SketchObject', 'SketchPad')
self.Body.addObject(self.PadSketch)
TestSketcherApp.CreateRectangleSketch(self.PadSketch, (0, 0), (1, 1))
self.Doc.recompute()
self.Pad = self.Doc.addObject("PartDesign::Pad", "Pad")
self.Body.addObject(self.Pad)
self.Pad.Profile = self.PadSketch
self.Pad.Length = 2
self.Doc.recompute()
self.ProfileSketch = self.Doc.addObject('Sketcher::SketchObject', 'ProfileSketch')
self.Body.addObject(self.ProfileSketch)
TestSketcherApp.CreateRectangleSketch(self.ProfileSketch, (0, 0), (1, 1))
self.Doc.recompute()
self.LoftSketch = self.Doc.addObject('Sketcher::SketchObject', 'LoftSketch')
self.Body.addObject(self.LoftSketch)
self.LoftSketch.MapMode = 'FlatFace'
self.LoftSketch.Support = (self.Doc.XZ_Plane, [''])
self.Doc.recompute()
TestSketcherApp.CreateRectangleSketch(self.LoftSketch, (0, 1), (1, 1))
self.Doc.recompute()
self.SubtractiveLoft = self.Doc.addObject("PartDesign::SubtractiveLoft","SubtractiveLoft")
self.Body.addObject(self.SubtractiveLoft)
self.SubtractiveLoft.Profile = self.ProfileSketch
self.SubtractiveLoft.Sections = [self.LoftSketch]
self.Doc.recompute()
self.assertAlmostEqual(self.SubtractiveLoft.Shape.Volume, 1)
def tearDown(self):
#closing doc
FreeCAD.closeDocument("PartDesignTestLoft")
#print ("omit closing document for debugging")
# transformations and boolean
from PartDesignTests.TestMirrored import TestMirrored
from PartDesignTests.TestLinearPattern import TestLinearPattern
from PartDesignTests.TestPolarPattern import TestPolarPattern
#from PartDesignTests.TestMultiTransform import TestMultiTransform
#from PartDesignTests.TestBoolean import TestBoolean
# dressup features
from PartDesignTests.TestFillet import TestFillet
from PartDesignTests.TestChamfer import TestChamfer
from PartDesignTests.TestDraft import TestDraft
from PartDesignTests.TestThickness import TestThickness