blender
/
blender
129
397
Fork 571
Code Issues 6.2k Pull Requests 752 Projects 19 Wiki Activity

Regression Testing: Running tests based on blend files 

Runs tests based on blend files with minimum python interaction.
Developed as part of GSoC 2021 - Regression Testing of Geometry Nodes.
Earlier, tests were built from scratch by adding a modifier/operation
from the Python API.
Now, tests can also be created inside blender and are compared using
Python script.

Features: Automatically adding expected object if it doesn't exist.
This patch adds tests for the following Geometry Nodes category:
* Curves
* Geometry
* Mesh
* Points

The implemented UML diagram for refactoring of mesh test framework.
{F10225906}

Technical Changes:
SpecMeshTest: It adds the modifier/operation based on the Spec provided.
BlendFileTest: It applies already existing modifier/operation from the blend file.

Test folders hierarchy with tests. This folder should be extracted to `lib\tests\modeling`
{F10240651}
Note: The `geometry_nodes` folder might lie under another `geometry_nodes` folder while extracting, please double check. Use the inner-most one.
The hierarchy should be:
-`lib\tests\modeling\geometry_nodes\mesh`
-`lib\tests\modeling\geometry_nodes\points`
and so on.

* From `ctest` the tests should be run as `ctest -R geo_node -C [Configuration]` on Windows.
* Each single test can be run with its entire name e..g `ctest -R geo_node_geometry_join_geometry`.(just an example). Run `ctest -N -R geo_node` to see all tests.
* From blender, the tests can be run `blender -b path\to\blend\file --python path\to\geo_node_test.py`

Reviewed By: zazizizou, JacquesLucke

Differential Revision: https://developer.blender.org/D11611
This commit is contained in:
Himanshi Kalra 2021-07-27 21:00:28 +05:30 committed by Himanshi Kalra
parent d6d44faff0
commit 4a02b9ffeb
15 changed files with 691 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
tests/python/CMakeLists.txt
View File

@ -740,6 +740,29 @@ if(WITH_COMPOSITOR)
endif()
set(geo_node_tests
curves
geometry
mesh
points
)
foreach(geo_node_test ${geo_node_tests})
if(EXISTS "${TEST_SRC_DIR}/modeling/geometry_nodes/${geo_node_test}/")
file(GLOB files "${TEST_SRC_DIR}/modeling/geometry_nodes/${geo_node_test}/*.blend")
foreach(file ${files})
get_filename_component(filename ${file} NAME_WE)
add_blender_test(
geo_node_${geo_node_test}_test_${filename}
${file}
--python ${TEST_PYTHON_DIR}/geo_node_test.py
)
endforeach()
else()
MESSAGE(STATUS "No directory named ${TEST_SRC_DIR}/modeling/geometry_nodes/${geo_node_test}/ found, disabling test.")
endif()
endforeach()
if(WITH_OPENGL_DRAW_TESTS)
if(NOT OPENIMAGEIO_IDIFF)
MESSAGE(STATUS "Disabling OpenGL draw tests because OIIO idiff does not exist")

178
tests/python/bevel_operator.py
View File

@ -27,272 +27,272 @@ import os
import sys
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import MeshTest, OperatorSpecEditMode, RunTest
from modules.mesh_test import SpecMeshTest, OperatorSpecEditMode, RunTest
def main():
tests = [
# 0
MeshTest('Cube_test_1', 'Cube_test', 'Cube_result_1',
SpecMeshTest('Cube_test_1', 'Cube_test', 'Cube_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.2}, 'EDGE', {10})]),
MeshTest('Cube_test_2', 'Cube_test', 'Cube_result_2',
SpecMeshTest('Cube_test_2', 'Cube_test', 'Cube_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'offset_type': 'WIDTH'}, 'EDGE', {10, 7}, )]),
MeshTest('Cube_test_3', 'Cube_test', 'Cube_result_3',
SpecMeshTest('Cube_test_3', 'Cube_test', 'Cube_result_3',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'offset_type': 'DEPTH'}, 'EDGE', {8, 10, 7}, )]),
MeshTest('Cube_test_4', 'Cube_test', 'Cube_result_4',
SpecMeshTest('Cube_test_4', 'Cube_test', 'Cube_result_4',
[OperatorSpecEditMode('bevel', {'offset': 0.4, 'segments': 2}, 'EDGE', {10}, )]),
MeshTest('Cube_test_5', 'Cube_test', 'Cube_result_5',
SpecMeshTest('Cube_test_5', 'Cube_test', 'Cube_result_5',
[OperatorSpecEditMode('bevel', {'offset': 0.4, 'segments': 3}, 'EDGE', {10, 7}, )]),
# 5
MeshTest('Cube_test_6', 'Cube_test', 'Cube_result_6',
SpecMeshTest('Cube_test_6', 'Cube_test', 'Cube_result_6',
[OperatorSpecEditMode('bevel', {'offset': 0.4, 'segments': 4}, 'EDGE', {8, 10, 7}, )]),
MeshTest('Cube_test_7', 'Cube_test', 'Cube_result_7',
SpecMeshTest('Cube_test_7', 'Cube_test', 'Cube_result_7',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 5, 'profile': 0.2}, 'EDGE', {0, 10, 4, 7}, )]),
MeshTest('Cube_test_8', 'Cube_test', 'Cube_result_8',
SpecMeshTest('Cube_test_8', 'Cube_test', 'Cube_result_8',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 5, 'profile': 0.25}, 'EDGE', {8, 10, 7}, )]),
MeshTest('Cube_test_9', 'Cube_test', 'Cube_result_9',
SpecMeshTest('Cube_test_9', 'Cube_test', 'Cube_result_9',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 6, 'profile': 0.9}, 'EDGE', {8, 10, 7}, )]),
MeshTest('Cube_test_10', 'Cube_test', 'Cube_result_10',
SpecMeshTest('Cube_test_10', 'Cube_test', 'Cube_result_10',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 4, 'profile': 1.0}, 'EDGE', {10, 7}, )]),
# 10
MeshTest('Cube_test_11', 'Cube_test', 'Cube_result_11',
SpecMeshTest('Cube_test_11', 'Cube_test', 'Cube_result_11',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 5, 'profile': 1.0}, 'EDGE', {8, 10, 7}, )]),
MeshTest("test 12", 'Cube_test', 'Cube_result_12',
SpecMeshTest("test 12", 'Cube_test', 'Cube_result_12',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 8}, 'EDGE',
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, )]),
MeshTest('Pyramid4_test_1', 'Pyr4_test', 'Pyr4_result_1',
SpecMeshTest('Pyramid4_test_1', 'Pyr4_test', 'Pyr4_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {5}, )]),
MeshTest('Pyramid4_test_2', 'Pyr4_test', 'Pyr4_result_2',
SpecMeshTest('Pyramid4_test_2', 'Pyr4_test', 'Pyr4_result_2',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {2, 5}, )]),
MeshTest('Pyramid4_test_3', 'Pyr4_test', 'Pyr4_result_3',
SpecMeshTest('Pyramid4_test_3', 'Pyr4_test', 'Pyr4_result_3',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {2, 3, 5}, )]),
# 15
MeshTest('Pyramid4_test_4', 'Pyr4_test', 'Pyr4_result_4',
SpecMeshTest('Pyramid4_test_4', 'Pyr4_test', 'Pyr4_result_4',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {1, 2, 3, 5}, )]),
MeshTest('Pyramid4_test_5', 'Pyr4_test', 'Pyr4_result_5',
SpecMeshTest('Pyramid4_test_5', 'Pyr4_test', 'Pyr4_result_5',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 3}, 'EDGE', {1, 2, 3, 5}, )]),
MeshTest('Pyramid4_test_6', 'Pyr4_test', 'Pyr4_result_6',
SpecMeshTest('Pyramid4_test_6', 'Pyr4_test', 'Pyr4_result_6',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {2, 3}, )]),
MeshTest('Pyramid4_test_7', 'Pyr4_test', 'Pyr4_result_7',
SpecMeshTest('Pyramid4_test_7', 'Pyr4_test', 'Pyr4_result_7',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 4, 'profile': 0.15}, 'EDGE', {1, 2, 3, 5}, )]),
MeshTest('Pyramid4_test_8', 'Pyr4_test', 'Pyr4_result_8',
SpecMeshTest('Pyramid4_test_8', 'Pyr4_test', 'Pyr4_result_8',
[OperatorSpecEditMode('bevel',
{'offset': 0.75, 'segments': 4, 'affect': 'VERTICES'}, 'VERT', {1}, )]),
# 20
MeshTest('Pyramid4_test_9', 'Pyr4_test', 'Pyr4_result_9',
SpecMeshTest('Pyramid4_test_9', 'Pyr4_test', 'Pyr4_result_9',
[OperatorSpecEditMode('bevel',
{'offset': 0.75, 'segments': 3, 'affect': 'VERTICES', 'profile': 0.25}, 'VERT',
{1}, )]),
MeshTest('Pyramid6_test_1', 'Pyr6_test', 'Pyr6_result_1',
SpecMeshTest('Pyramid6_test_1', 'Pyr6_test', 'Pyr6_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {2, 3}, )]),
MeshTest('Pyramid6_test_2', 'Pyr6_test', 'Pyr6_result_2',
SpecMeshTest('Pyramid6_test_2', 'Pyr6_test', 'Pyr6_result_2',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {8, 2, 3}, )]),
MeshTest('Pyramid6_test_3', 'Pyr6_test', 'Pyr6_result_3',
SpecMeshTest('Pyramid6_test_3', 'Pyr6_test', 'Pyr6_result_3',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 4, 'profile': 0.8}, 'EDGE',
{0, 2, 3, 4, 6, 7, 9, 10, 11}, )]),
MeshTest('Sept_test_1', 'Sept_test', 'Sept_result_1',
SpecMeshTest('Sept_test_1', 'Sept_test', 'Sept_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.1}, 'EDGE', {8, 9, 3, 11}, )]),
# 25
MeshTest('Sept_test_2', 'Sept_test', 'Sept_result_2',
SpecMeshTest('Sept_test_2', 'Sept_test', 'Sept_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.1, 'offset_type': 'WIDTH'}, 'EDGE', {8, 9, 11}, )]),
MeshTest('Saddle_test_1', 'Saddle_test', 'Saddle_result_1',
SpecMeshTest('Saddle_test_1', 'Saddle_test', 'Saddle_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.3, 'segments': 5}, 'EDGE', {2, 8, 9, 12, 13, 14}, )]),
MeshTest('Saddle_test_2', 'Saddle_test', 'Saddle_result_2',
SpecMeshTest('Saddle_test_2', 'Saddle_test', 'Saddle_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.6, 'segments': 6, 'affect': 'VERTICES'}, 'VERT', {4}, )]),
MeshTest('Bent_test', 'Bent_test', 'Bent_result_1',
SpecMeshTest('Bent_test', 'Bent_test', 'Bent_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3},
'EDGE',
{2, 5, 8, 11, 14, 18, 21, 24, 27, 30, 34, 37, 40, 43, 46, 50, 53, 56, 59, 62,
112, 113, 114, 115}, )]),
MeshTest('Bentlines_test_1', 'Bentlines_test', 'Bentlines_result_1',
SpecMeshTest('Bentlines_test_1', 'Bentlines_test', 'Bentlines_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 3}, 'EDGE', {1, 8, 9, 10, 11}, )]),
# 30
MeshTest('Flaretop_test_1', 'Flaretop_test', 'Flaretop_result_1',
SpecMeshTest('Flaretop_test_1', 'Flaretop_test', 'Flaretop_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 2}, 'EDGE', {26, 12, 20}, )]),
MeshTest('Flaretop_test_2', 'Flaretop_test', 'Flaretop_result_2',
SpecMeshTest('Flaretop_test_2', 'Flaretop_test', 'Flaretop_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 2, 'profile': 1.0}, 'EDGE', {26, 12, 20}, )]),
MeshTest('Flaretop_test_3', 'Flaretop_test', 'Flaretop_result_3',
SpecMeshTest('Flaretop_test_3', 'Flaretop_test', 'Flaretop_result_3',
[OperatorSpecEditMode('bevel',
{'offset': 0.4, 'segments': 4}, 'FACE', {1, 6, 7, 8, 9, 10, 11, 12}, )]),
MeshTest('BentL_test', 'BentL_test', 'BentL_result_1',
SpecMeshTest('BentL_test', 'BentL_test', 'BentL_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {4, 8, 10, 18, 24}, )]),
MeshTest('Wires_test_1', 'Wires_test', 'Wires_test_result_1',
SpecMeshTest('Wires_test_1', 'Wires_test', 'Wires_test_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.3}, 'EDGE', {0, 1, 2, 10}, )]),
# 35
MeshTest('Wires_test_2', 'Wires_test', 'Wires_test_result_2',
SpecMeshTest('Wires_test_2', 'Wires_test', 'Wires_test_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.3, 'affect': 'VERTICES'}, 'VERT',
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, )]),
MeshTest('tri_test_1', 'tri', 'tri_result_1',
SpecMeshTest('tri_test_1', 'tri', 'tri_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri_test_2', 'tri', 'tri_result_2',
SpecMeshTest('tri_test_2', 'tri', 'tri_result_2',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri_test_3', 'tri', 'tri_result_3',
SpecMeshTest('tri_test_3', 'tri', 'tri_result_3',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri_test_4', 'tri', 'tri_result_4',
SpecMeshTest('tri_test_4', 'tri', 'tri_result_4',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4}, )]),
# 40
MeshTest('tri_test_5', 'tri', 'tri_result_5',
SpecMeshTest('tri_test_5', 'tri', 'tri_result_5',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4}, )]),
MeshTest('tri_test_6', 'tri', 'tri_result_6',
SpecMeshTest('tri_test_6', 'tri', 'tri_result_6',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'affect': 'VERTICES'}, 'VERT', {3}, )]),
MeshTest('tri_test_7', 'tri', 'tri_result_7',
SpecMeshTest('tri_test_7', 'tri', 'tri_result_7',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2, 'affect': 'VERTICES'}, 'VERT', {3}, )]),
MeshTest('tri_test_8', 'tri', 'tri_result_8',
SpecMeshTest('tri_test_8', 'tri', 'tri_result_8',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 3, 'affect': 'VERTICES'}, 'VERT', {3}, )]),
MeshTest('tri_test_9', 'tri', 'tri_result_9',
SpecMeshTest('tri_test_9', 'tri', 'tri_result_9',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'affect': 'VERTICES'}, 'VERT', {1}, )]),
# 45
MeshTest('tri1gap_test_2', 'tri1gap', 'tri1gap_result_2',
SpecMeshTest('tri1gap_test_2', 'tri1gap', 'tri1gap_result_2',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri1gap_test_3', 'tri1gap', 'tri1gap_result_3',
SpecMeshTest('tri1gap_test_3', 'tri1gap', 'tri1gap_result_3',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri1gap_test_1', 'tri1gap', 'tri1gap_result_1',
SpecMeshTest('tri1gap_test_1', 'tri1gap', 'tri1gap_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri1gap_test_4', 'tri1gap', 'tri1gap_result_4',
SpecMeshTest('tri1gap_test_4', 'tri1gap', 'tri1gap_result_4',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4}, )]),
MeshTest('tri1gap_test_5', 'tri1gap', 'tri1gap_result_5',
SpecMeshTest('tri1gap_test_5', 'tri1gap', 'tri1gap_result_5',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4}, )]),
# 50
MeshTest('tri1gap_test_6', 'tri1gap', 'tri1gap_result_6',
SpecMeshTest('tri1gap_test_6', 'tri1gap', 'tri1gap_result_6',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4}, )]),
MeshTest('tri1gap_test_7', 'tri1gap', 'tri1gap_result_7',
SpecMeshTest('tri1gap_test_7', 'tri1gap', 'tri1gap_result_7',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 5}, )]),
MeshTest('tri1gap_test_8', 'tri1gap', 'tri1gap_result_8',
SpecMeshTest('tri1gap_test_8', 'tri1gap', 'tri1gap_result_8',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 5}, )]),
MeshTest('tri1gap_test_9', 'tri1gap', 'tri1gap_result_9',
SpecMeshTest('tri1gap_test_9', 'tri1gap', 'tri1gap_result_9',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 5}, )]),
MeshTest('tri1gap_test_10', 'tri1gap', 'tri1gap_result_10',
SpecMeshTest('tri1gap_test_10', 'tri1gap', 'tri1gap_result_10',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'affect': 'VERTICES'}, 'VERT', {3}, )]),
# 55
MeshTest('tri2gaps_test_1', 'tri2gaps', 'tri2gaps_result_1',
SpecMeshTest('tri2gaps_test_1', 'tri2gaps', 'tri2gaps_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri2gaps_test_2', 'tri2gaps', 'tri2gaps_result_2',
SpecMeshTest('tri2gaps_test_2', 'tri2gaps', 'tri2gaps_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri2gaps_test_3', 'tri2gaps', 'tri2gaps_result_3',
SpecMeshTest('tri2gaps_test_3', 'tri2gaps', 'tri2gaps_result_3',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri2gaps_test_4', 'tri2gaps', 'tri2gaps_result_4',
SpecMeshTest('tri2gaps_test_4', 'tri2gaps', 'tri2gaps_result_4',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4}, )]),
MeshTest('tri2gaps_test_5', 'tri2gaps', 'tri2gaps_result_5',
SpecMeshTest('tri2gaps_test_5', 'tri2gaps', 'tri2gaps_result_5',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4}, )]),
# 60
MeshTest('tri2gaps_test_6', 'tri2gaps', 'tri2gaps_result_6',
SpecMeshTest('tri2gaps_test_6', 'tri2gaps', 'tri2gaps_result_6',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4}, )]),
MeshTest('tri3gaps_test_1', 'tri3gaps', 'tri3gaps_result_1',
SpecMeshTest('tri3gaps_test_1', 'tri3gaps', 'tri3gaps_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri3gaps_test_2', 'tri3gaps', 'tri3gaps_result_2',
SpecMeshTest('tri3gaps_test_2', 'tri3gaps', 'tri3gaps_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2}, 'EDGE', {3, 4, 5}, )]),
MeshTest('tri3gaps_test_3', 'tri3gaps', 'tri3gaps_result_3',
SpecMeshTest('tri3gaps_test_3', 'tri3gaps', 'tri3gaps_result_3',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 3}, 'EDGE', {3, 4, 5}, )]),
MeshTest('cube3_test_1', 'cube3', 'cube3_result_1',
SpecMeshTest('cube3_test_1', 'cube3', 'cube3_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.2}, 'EDGE', {32, 33, 34, 35, 24, 25, 26, 27, 28, 29, 30, 31}, )]),
# 65
MeshTest('cube3_test_2', 'cube3', 'cube3_result_2',
SpecMeshTest('cube3_test_2', 'cube3', 'cube3_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2}, 'EDGE',
{32, 33, 34, 35, 24, 25, 26, 27, 28, 29, 30, 31}, )]),
MeshTest('cube3_test_3', 'cube3', 'cube3_result_3',
SpecMeshTest('cube3_test_3', 'cube3', 'cube3_result_3',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {32, 35}, )]),
MeshTest('cube3_test_4', 'cube3', 'cube3_result_4',
SpecMeshTest('cube3_test_4', 'cube3', 'cube3_result_4',
[OperatorSpecEditMode('bevel', {'offset': 0.2}, 'EDGE', {24, 35}, )]),
MeshTest('cube3_test_5', 'cube3', 'cube3_result_5',
SpecMeshTest('cube3_test_5', 'cube3', 'cube3_result_5',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 2}, 'EDGE', {24, 32, 35}, )]),
MeshTest('cube3_test_6', 'cube3', 'cube3_result_6',
SpecMeshTest('cube3_test_6', 'cube3', 'cube3_result_6',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {24, 32, 35}, )]),
# 70
MeshTest('Tray', 'Tray', 'Tray_result_1',
SpecMeshTest('Tray', 'Tray', 'Tray_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.01, 'segments': 2}, 'EDGE', {0, 1, 6, 7, 12, 14, 16, 17}, )]),
MeshTest("test 73", 'Bumptop', 'Bumptop_result_1',
SpecMeshTest("test 73", 'Bumptop', 'Bumptop_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.1, 'segments': 4}, 'EDGE',
{33, 4, 38, 8, 41, 10, 42, 12, 14, 17, 24, 31}, )]),
MeshTest('Multisegment_test_1', 'Multisegment_test', 'Multisegment_result_1',
SpecMeshTest('Multisegment_test_1', 'Multisegment_test', 'Multisegment_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.2}, 'EDGE', {16, 14, 15}, )]),
MeshTest('Window_test', 'Window_test', 'Window_result_1',
SpecMeshTest('Window_test', 'Window_test', 'Window_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.05, 'segments': 2}, 'EDGE', {19, 20, 23, 15}, )]),
# 75
MeshTest("test 77", 'Cube_hn_test', 'Cube_hn_result_1',
SpecMeshTest("test 77", 'Cube_hn_test', 'Cube_hn_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'harden_normals': True}, 'EDGE', {8}, )]),
MeshTest('Blocksteps_test_1', 'Blocksteps_test', 'Blocksteps_result_1',
SpecMeshTest('Blocksteps_test_1', 'Blocksteps_test', 'Blocksteps_result_1',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'miter_outer': 'PATCH'}, 'EDGE', {4, 7, 39, 27, 30, 31}, )]),
MeshTest('Blocksteps_test_2', 'Blocksteps_test', 'Blocksteps_result_2',
SpecMeshTest('Blocksteps_test_2', 'Blocksteps_test', 'Blocksteps_result_2',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2, 'miter_outer': 'PATCH'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
MeshTest('Blocksteps_test_3', 'Blocksteps_test', 'Blocksteps_result_3',
SpecMeshTest('Blocksteps_test_3', 'Blocksteps_test', 'Blocksteps_result_3',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 3, 'miter_outer': 'PATCH'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
MeshTest('Blocksteps_test_4', 'Blocksteps_test', 'Blocksteps_result_4',
SpecMeshTest('Blocksteps_test_4', 'Blocksteps_test', 'Blocksteps_result_4',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'miter_outer': 'ARC'}, 'EDGE', {4, 7, 39, 27, 30, 31}, )]),
# 80
MeshTest('Blocksteps_test_5', 'Blocksteps_test', 'Blocksteps_result_5',
SpecMeshTest('Blocksteps_test_5', 'Blocksteps_test', 'Blocksteps_result_5',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2, 'miter_outer': 'ARC'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
MeshTest('Blocksteps_test_6', 'Blocksteps_test', 'Blocksteps_result_6',
SpecMeshTest('Blocksteps_test_6', 'Blocksteps_test', 'Blocksteps_result_6',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 3, 'miter_outer': 'ARC'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
MeshTest('Blocksteps_test_7', 'Blocksteps_test', 'Blocksteps_result_7',
SpecMeshTest('Blocksteps_test_7', 'Blocksteps_test', 'Blocksteps_result_7',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'miter_outer': 'PATCH', 'miter_inner': 'ARC'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
MeshTest("Blocksteps_test_8", 'Blocksteps_test', 'Blocksteps_result_8',
SpecMeshTest("Blocksteps_test_8", 'Blocksteps_test', 'Blocksteps_result_8',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2, 'miter_outer': 'PATCH', 'miter_inner': 'ARC'},
'EDGE', {4, 7, 39, 27, 30, 31}, )]),
MeshTest('Blocksteps2_test', 'Blocksteps2_test', 'Blocksteps2_result_9',
SpecMeshTest('Blocksteps2_test', 'Blocksteps2_test', 'Blocksteps2_result_9',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2, 'miter_outer': 'ARC'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
# 85
MeshTest('Blocksteps3_test', 'Blocksteps3_test', 'Blocksteps3_result_10',
SpecMeshTest('Blocksteps3_test', 'Blocksteps3_test', 'Blocksteps3_result_10',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2, 'miter_outer': 'ARC'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
MeshTest('Blocksteps4_test_1', 'Blocksteps4_test', 'Blocksteps4_result_11',
SpecMeshTest('Blocksteps4_test_1', 'Blocksteps4_test', 'Blocksteps4_result_11',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 2, 'miter_outer': 'ARC'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
MeshTest('Blocksteps4_test_2', 'Blocksteps4_test', 'Blocksteps4_result_12',
SpecMeshTest('Blocksteps4_test_2', 'Blocksteps4_test', 'Blocksteps4_result_12',
[OperatorSpecEditMode('bevel',
{'offset': 0.2, 'segments': 3, 'miter_outer': 'ARC'}, 'EDGE',
{4, 7, 39, 27, 30, 31}, )]),
MeshTest('Spike_test', 'Spike_test', 'Spike_result_1',
SpecMeshTest('Spike_test', 'Spike_test', 'Spike_result_1',
[OperatorSpecEditMode('bevel', {'offset': 0.2, 'segments': 3}, 'EDGE', {1, 7})])
]

20
tests/python/boolean_operator.py
View File

@ -29,37 +29,37 @@ import os
import sys
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import MeshTest, OperatorSpecEditMode, RunTest
from modules.mesh_test import SpecMeshTest, OperatorSpecEditMode, RunTest
def main():
tests = [
MeshTest('Cubecube_intersect_union', 'Cubecube', 'Cubecube_result_1',
SpecMeshTest('Cubecube_intersect_union', 'Cubecube', 'Cubecube_result_1',
[OperatorSpecEditMode('intersect_boolean',
{'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
MeshTest('Cubecube_intersect_intersect', 'Cubecube', 'Cubecube_result_2',
SpecMeshTest('Cubecube_intersect_intersect', 'Cubecube', 'Cubecube_result_2',
[OperatorSpecEditMode('intersect_boolean', {'operation': 'INTERSECT', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
MeshTest('Cubecube_intersect_difference', 'Cubecube', 'Cubecube_result_3',
SpecMeshTest('Cubecube_intersect_difference', 'Cubecube', 'Cubecube_result_3',
[OperatorSpecEditMode('intersect_boolean', {'operation': 'DIFFERENCE', 'solver': 'FAST'}, 'FACE',
{0, 1, 2, 3, 4, 5}, )]),
MeshTest('Cubecube_intersect_cut', 'Cubecube', 'Cubecube_result_4', [OperatorSpecEditMode('intersect',
SpecMeshTest('Cubecube_intersect_cut', 'Cubecube', 'Cubecube_result_4', [OperatorSpecEditMode('intersect',
{'separate_mode': 'CUT', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
MeshTest('Cubecube_intersect_all', 'Cubecube', 'Cubecube_result_5',
SpecMeshTest('Cubecube_intersect_all', 'Cubecube', 'Cubecube_result_5',
[OperatorSpecEditMode('intersect',
{'separate_mode': 'ALL', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
MeshTest('Cubecube_intersect_none', 'Cubecube', 'Cubecube_result_6',
SpecMeshTest('Cubecube_intersect_none', 'Cubecube', 'Cubecube_result_6',
[OperatorSpecEditMode('intersect',
{'separate_mode': 'NONE', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
MeshTest('Cubecube_intersect_select_none', 'Cubecube',
SpecMeshTest('Cubecube_intersect_select_none', 'Cubecube',
'Cubecube_result_7',
[OperatorSpecEditMode('intersect',
{'mode': 'SELECT', 'separate_mode': 'NONE', 'solver': 'FAST'}, 'FACE',
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, )]),
MeshTest('Cubecone_intersect_union', 'Cubecone', 'Cubecone_result_1',
SpecMeshTest('Cubecone_intersect_union', 'Cubecone', 'Cubecone_result_1',
[OperatorSpecEditMode('intersect_boolean',
{'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {6, 7, 8, 9, 10}, )]),
MeshTest('Cubecones_intersect_union', 'Cubecones', 'Cubecones_result_1',
SpecMeshTest('Cubecones_intersect_union', 'Cubecones', 'Cubecones_result_1',
[OperatorSpecEditMode('intersect_boolean', {'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
]

66
tests/python/curve_to_mesh.py
View File

@ -24,74 +24,74 @@ import os
import sys
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import MeshTest, OperatorSpecObjectMode, RunTest
from modules.mesh_test import SpecMeshTest, OperatorSpecObjectMode, RunTest
def main():
tests = [
MeshTest('2D Non Cyclic', 'test2DNonCyclic', 'expected2DNonCyclic',
SpecMeshTest('2D Non Cyclic', 'test2DNonCyclic', 'expected2DNonCyclic',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('2D NURBS With Tail', 'test2DNURBSWithTail', 'expected2DNURBSWithTail',
SpecMeshTest('2D NURBS With Tail', 'test2DNURBSWithTail', 'expected2DNURBSWithTail',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('2D Shape With Hole', 'test2DShapeWithHole', 'expected2DShapeWithHole',
SpecMeshTest('2D Shape With Hole', 'test2DShapeWithHole', 'expected2DShapeWithHole',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('2D Simple Lower Res', 'test2DSimpleLowerRes', 'expected2DSimpleLowerRes',
SpecMeshTest('2D Simple Lower Res', 'test2DSimpleLowerRes', 'expected2DSimpleLowerRes',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('2D Simple Low Res', 'test2DSimpleLowRes', 'expected2DSimpleLowRes',
SpecMeshTest('2D Simple Low Res', 'test2DSimpleLowRes', 'expected2DSimpleLowRes',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('2D Square', 'test2DSquare', 'expected2DSquare',
SpecMeshTest('2D Square', 'test2DSquare', 'expected2DSquare',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('2D Extrude', 'test2DExtrude', 'expected2DExtrude',
SpecMeshTest('2D Extrude', 'test2DExtrude', 'expected2DExtrude',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Back', 'testBevelBack', 'expectedBevelBack',
SpecMeshTest('Bevel Back', 'testBevelBack', 'expectedBevelBack',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Back Low Res', 'testBevelBackLowRes', 'expectedBevelBackLowRes',
SpecMeshTest('Bevel Back Low Res', 'testBevelBackLowRes', 'expectedBevelBackLowRes',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Extrude Back', 'testBevelExtrudeBack', 'expectedBevelExtrudeBack',
SpecMeshTest('Bevel Extrude Back', 'testBevelExtrudeBack', 'expectedBevelExtrudeBack',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Extrude Front', 'testBevelExtrudeFront', 'expectedBevelExtrudeFront',
SpecMeshTest('Bevel Extrude Front', 'testBevelExtrudeFront', 'expectedBevelExtrudeFront',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Extrude Full', 'testBevelExtrudeFull', 'expectedBevelExtrudeFull',
SpecMeshTest('Bevel Extrude Full', 'testBevelExtrudeFull', 'expectedBevelExtrudeFull',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Extrude Half', 'testBevelExtrudeHalf', 'expectedBevelExtrudeHalf',
SpecMeshTest('Bevel Extrude Half', 'testBevelExtrudeHalf', 'expectedBevelExtrudeHalf',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Front', 'testBevelFront', 'expectedBevelFront',
SpecMeshTest('Bevel Front', 'testBevelFront', 'expectedBevelFront',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Front Low Res', 'testBevelFrontLowRes', 'expectedBevelFrontLowRes',
SpecMeshTest('Bevel Front Low Res', 'testBevelFrontLowRes', 'expectedBevelFrontLowRes',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Full', 'testBevelFull', 'expectedBevelFull',
SpecMeshTest('Bevel Full', 'testBevelFull', 'expectedBevelFull',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Full Low Res', 'testBevelFullLowRes', 'expectedBevelFullLowRes',
SpecMeshTest('Bevel Full Low Res', 'testBevelFullLowRes', 'expectedBevelFullLowRes',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Half', 'testBevelHalf', 'expectedBevelHalf',
SpecMeshTest('Bevel Half', 'testBevelHalf', 'expectedBevelHalf',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Bevel Half Low Res', 'testBevelHalfLowRes', 'expectedBevelHalfLowRes',
SpecMeshTest('Bevel Half Low Res', 'testBevelHalfLowRes', 'expectedBevelHalfLowRes',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps None', 'testCapsNone', 'expectedCapsNone',
SpecMeshTest('Caps None', 'testCapsNone', 'expectedCapsNone',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps Object Bevel', 'testCapsObjectBevel', 'expectedCapsObjectBevel',
SpecMeshTest('Caps Object Bevel', 'testCapsObjectBevel', 'expectedCapsObjectBevel',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps Profile Bevel', 'testCapsProfileBevel', 'expectedCapsProfileBevel',
SpecMeshTest('Caps Profile Bevel', 'testCapsProfileBevel', 'expectedCapsProfileBevel',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps Profile Bevel Half', 'testCapsProfileBevelHalf', 'expectedCapsProfileBevelHalf',
SpecMeshTest('Caps Profile Bevel Half', 'testCapsProfileBevelHalf', 'expectedCapsProfileBevelHalf',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps Profile Bevel Quarter', 'testCapsProfileBevelQuarter', 'expectedCapsProfileBevelQuarter',
SpecMeshTest('Caps Profile Bevel Quarter', 'testCapsProfileBevelQuarter', 'expectedCapsProfileBevelQuarter',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps Round Bevel', 'testCapsRoundBevel', 'expectedCapsRoundBevel',
SpecMeshTest('Caps Round Bevel', 'testCapsRoundBevel', 'expectedCapsRoundBevel',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps Round Bevel Extrude', 'testCapsRoundBevelExtrude', 'expectedCapsRoundBevelExtrude',
SpecMeshTest('Caps Round Bevel Extrude', 'testCapsRoundBevelExtrude', 'expectedCapsRoundBevelExtrude',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps Round Bevel Half', 'testCapsRoundBevelHalf', 'expectedCapsRoundBevelHalf',
SpecMeshTest('Caps Round Bevel Half', 'testCapsRoundBevelHalf', 'expectedCapsRoundBevelHalf',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Caps Round Bevel Quarter', 'testCapsRoundBevelQuarter', 'expectedCapsRoundBevelQuarter',
SpecMeshTest('Caps Round Bevel Quarter', 'testCapsRoundBevelQuarter', 'expectedCapsRoundBevelQuarter',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Extrude Back', 'testExtrudeBack', 'expectedExtrudeBack',
SpecMeshTest('Extrude Back', 'testExtrudeBack', 'expectedExtrudeBack',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Extrude Front', 'testExtrudeFront', 'expectedExtrudeFront',
SpecMeshTest('Extrude Front', 'testExtrudeFront', 'expectedExtrudeFront',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Extrude Full', 'testExtrudeFull', 'expectedExtrudeFull',
SpecMeshTest('Extrude Full', 'testExtrudeFull', 'expectedExtrudeFull',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
MeshTest('Extrude Half', 'testExtrudeHalf', 'expectedExtrudeHalf',
SpecMeshTest('Extrude Half', 'testExtrudeHalf', 'expectedExtrudeHalf',
[OperatorSpecObjectMode('convert', {'target': 'MESH'})]),
]
operator_test = RunTest(tests)

22
tests/python/deform_modifiers.py
View File

@ -28,14 +28,14 @@ import sys
import bpy
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import MeshTest, ModifierSpec, OperatorSpecObjectMode, DeformModifierSpec, RunTest
from modules.mesh_test import SpecMeshTest, ModifierSpec, OperatorSpecObjectMode, DeformModifierSpec, RunTest
tests = [
# Surface Deform Test, finally can bind to the Target object.
# Actual deformation occurs by animating imitating user input.
MeshTest("SurfaceDeform", "testObjMonkeySurfaceDeform", "expObjMonkeySurfaceDeform",
SpecMeshTest("SurfaceDeform", "testObjMonkeySurfaceDeform", "expObjMonkeySurfaceDeform",
[DeformModifierSpec(10, [
ModifierSpec('surface_deform', 'SURFACE_DEFORM', {'target': bpy.data.objects["Cube"]})],
OperatorSpecObjectMode('surfacedeform_bind', {'modifier': 'surface_deform'}))]),
@ -43,7 +43,7 @@ tests = [
# Mesh Deform Test, finally can bind to the Target object.
# Actual deformation occurs by animating imitating user input.
MeshTest("MeshDeform", "testObjMonkeyMeshDeform", "expObjMonkeyMeshDeform",
SpecMeshTest("MeshDeform", "testObjMonkeyMeshDeform", "expObjMonkeyMeshDeform",
[DeformModifierSpec(10, [ModifierSpec('mesh_deform', 'MESH_DEFORM',
{'object': bpy.data.objects["MeshCube"], 'precision': 2})],
OperatorSpecObjectMode('meshdeform_bind', {'modifier': 'mesh_deform'}))]),
@ -51,21 +51,21 @@ tests = [
# Surface Deform Test, finally can bind to the Target object.
# Actual deformation occurs by animating imitating user input.
MeshTest("Hook", "testObjHookPlane", "expObjHookPlane",
SpecMeshTest("Hook", "testObjHookPlane", "expObjHookPlane",
[DeformModifierSpec(10, [ModifierSpec('hook', 'HOOK',
{'object': bpy.data.objects["Empty"], 'falloff_radius': 1,
'vertex_group': 'Group'})])]),
# Laplacian Deform Test, first a hook is attached.
MeshTest("Laplace", "testObjCubeLaplacian", "expObjCubeLaplacian",
SpecMeshTest("Laplace", "testObjCubeLaplacian", "expObjCubeLaplacian",
[DeformModifierSpec(10,
[ModifierSpec('hook2', 'HOOK', {'object': bpy.data.objects["Empty.001"],
'vertex_group': 'hook_vg'}),
ModifierSpec('laplace', 'LAPLACIANDEFORM', {'vertex_group': 'laplace_vg'})],
OperatorSpecObjectMode('laplaciandeform_bind', {'modifier': 'laplace'}))]),
MeshTest("WarpPlane", "testObjPlaneWarp", "expObjPlaneWarp",
SpecMeshTest("WarpPlane", "testObjPlaneWarp", "expObjPlaneWarp",
[DeformModifierSpec(10, [ModifierSpec('warp', 'WARP',
{'object_from': bpy.data.objects["From"],
'object_to': bpy.data.objects["To"],
@ -74,29 +74,29 @@ tests = [
#############################################
# Curves Deform Modifiers
#############################################
MeshTest("CurveArmature", "testObjBezierCurveArmature", "expObjBezierCurveArmature",
SpecMeshTest("CurveArmature", "testObjBezierCurveArmature", "expObjBezierCurveArmature",
[DeformModifierSpec(10, [ModifierSpec('curve_armature', 'ARMATURE',
{'object': bpy.data.objects['testArmatureHelper'],
'use_vertex_groups': False, 'use_bone_envelopes': True})])]),
MeshTest("CurveLattice", "testObjBezierCurveLattice", "expObjBezierCurveLattice",
SpecMeshTest("CurveLattice", "testObjBezierCurveLattice", "expObjBezierCurveLattice",
[DeformModifierSpec(10, [ModifierSpec('curve_lattice', 'LATTICE',
{'object': bpy.data.objects['testLatticeCurve']})])]),
# HOOK for Curves can't be tested with current framework, as it requires going to Edit Mode to select vertices,
# here is no equivalent of a vertex group in Curves.
# Dummy test for Hook, can also be called corner case
MeshTest("CurveHook", "testObjBezierCurveHook", "expObjBezierCurveHook",
SpecMeshTest("CurveHook", "testObjBezierCurveHook", "expObjBezierCurveHook",
[DeformModifierSpec(10,
[ModifierSpec('curve_Hook', 'HOOK', {'object': bpy.data.objects['EmptyCurve']})])]),
MeshTest("MeshDeformCurve", "testObjCurveMeshDeform", "expObjCurveMeshDeform",
SpecMeshTest("MeshDeformCurve", "testObjCurveMeshDeform", "expObjCurveMeshDeform",
[DeformModifierSpec(10, [
ModifierSpec('mesh_deform_curve', 'MESH_DEFORM', {'object': bpy.data.objects["Cylinder"],
'precision': 2})],
OperatorSpecObjectMode('meshdeform_bind', {'modifier': 'mesh_deform_curve'}))]),
MeshTest("WarpCurve", "testObjBezierCurveWarp", "expObjBezierCurveWarp",
SpecMeshTest("WarpCurve", "testObjBezierCurveWarp", "expObjBezierCurveWarp",
[DeformModifierSpec(10, [ModifierSpec('warp_curve', 'WARP',
{'object_from': bpy.data.objects["From_curve"],
'object_to': bpy.data.objects["To_curve"]})])]),

33
tests/python/geo_node_test.py Normal file
View File

@ -0,0 +1,33 @@
# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####
# <pep8 compliant>
import os
import sys
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import BlendFileTest
geo_node_test = BlendFileTest("test_object", "expected_object")
result = geo_node_test.run_test()
# Telling `ctest` about the failed test by raising Exception.
if result == False:
raise Exception("Failed {}".format(geo_node_test.test_name))

142
tests/python/modifiers.py
View File

@ -26,7 +26,7 @@ from random import shuffle, seed
import bpy
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
seed(0)
@ -87,22 +87,22 @@ def main():
# List of 'Generate' modifiers on a cube
###############################
# 0
# MeshTest("testCube", "expectedCube", get_generate_modifiers_list("testCube")),
MeshTest("CubeRandom", "testCubeRandom", "expectedCubeRandom",
# SpecMeshTest("testCube", "expectedCube", get_generate_modifiers_list("testCube")),
SpecMeshTest("CubeRandom", "testCubeRandom", "expectedCubeRandom",
get_generate_modifiers_list("testCubeRandom", randomize=True)),
MeshTest("CubeMaskFirst", "testCubeMaskFirst", "expectedCubeMaskFirst", mask_first_list),
SpecMeshTest("CubeMaskFirst", "testCubeMaskFirst", "expectedCubeMaskFirst", mask_first_list),
MeshTest("CollapseDecimate", "testCollapseDecimate", "expectedCollapseDecimate",
SpecMeshTest("CollapseDecimate", "testCollapseDecimate", "expectedCollapseDecimate",
[ModifierSpec('decimate', 'DECIMATE',
{'decimate_type': 'COLLAPSE', 'ratio': 0.25, 'use_collapse_triangulate': True})]),
MeshTest("PlanarDecimate", "testPlanarDecimate", "expectedPlanarDecimate",
SpecMeshTest("PlanarDecimate", "testPlanarDecimate", "expectedPlanarDecimate",
[ModifierSpec('decimate', 'DECIMATE',
{'decimate_type': 'DISSOLVE', 'angle_limit': math.radians(30)})]),
MeshTest("UnsubdivideDecimate", "testUnsubdivideDecimate", "expectedUnsubdivideDecimate",
SpecMeshTest("UnsubdivideDecimate", "testUnsubdivideDecimate", "expectedUnsubdivideDecimate",
[ModifierSpec('decimate', 'DECIMATE', {'decimate_type': 'UNSUBDIV', 'iterations': 2})]),
# 5
MeshTest("RadialBisectMirror", "testRadialBisectMirror", "expectedRadialBisectMirror",
SpecMeshTest("RadialBisectMirror", "testRadialBisectMirror", "expectedRadialBisectMirror",
[ModifierSpec('mirror1', 'MIRROR', {'use_bisect_axis': (True, False, False)}),
ModifierSpec('mirror2', 'MIRROR', {'use_bisect_axis': (True, False, False),
'mirror_object': bpy.data.objects[
@ -111,17 +111,17 @@ def main():
{'use_axis': (False, True, False), 'use_bisect_axis': (False, True, False),
'use_bisect_flip_axis': (False, True, False),
'mirror_object': bpy.data.objects["testRadialBisectMirrorHelper"]})]),
MeshTest("T58411Mirror", "regressT58411Mirror", "expectedT58411Mirror",
SpecMeshTest("T58411Mirror", "regressT58411Mirror", "expectedT58411Mirror",
[ModifierSpec('mirror', 'MIRROR', {}),
ModifierSpec('bevel', 'BEVEL', {'segments': 2, 'limit_method': 'WEIGHT'}),
ModifierSpec('subd', 'SUBSURF', {'levels': 1})]),
MeshTest("BasicScrew", "testBasicScrew", "expectedBasicScrew",
SpecMeshTest("BasicScrew", "testBasicScrew", "expectedBasicScrew",
[ModifierSpec('mirror', 'MIRROR', {'mirror_object': bpy.data.objects["testBasicScrewHelper"]}),
ModifierSpec("screw", 'SCREW',
{'angle': math.radians(400), 'steps': 20, 'iterations': 2, 'screw_offset': 2,
'use_normal_calculate': True})]),
MeshTest("ObjectScrew", "testObjectScrew", "expectedObjectScrew",
SpecMeshTest("ObjectScrew", "testObjectScrew", "expectedObjectScrew",
[ModifierSpec('mirror', 'MIRROR', {'mirror_object': bpy.data.objects["testObjectScrewHelper2"]}),
ModifierSpec("screw", 'SCREW',
{"angle": math.radians(600), 'steps': 32, 'iterations': 1,
@ -129,16 +129,16 @@ def main():
'use_normal_calculate': True, 'object': bpy.data.objects["testObjectScrewHelper1"]})]),
# 9
MeshTest("MergedScrewWeld", "testMergedScrewWeld", "expectedMergedScrewWeld",
SpecMeshTest("MergedScrewWeld", "testMergedScrewWeld", "expectedMergedScrewWeld",
[ModifierSpec("screw", 'SCREW',
{'angle': math.radians(360), 'steps': 12, 'iterations': 1, 'screw_offset': 1,
'use_normal_calculate': True, 'use_merge_vertices': True}),
ModifierSpec("weld", 'WELD', {"merge_threshold": 0.001})]),
MeshTest("T72380Weld", "regressT72380Weld", "expectedT72380Weld",
SpecMeshTest("T72380Weld", "regressT72380Weld", "expectedT72380Weld",
[ModifierSpec('vedit', 'VERTEX_WEIGHT_EDIT',
{'vertex_group': 'Group', 'use_remove': True, 'remove_threshold': 1}),
ModifierSpec("weld", 'WELD', {"merge_threshold": 0.2, "vertex_group": "Group"})]),
MeshTest("T72792Weld", "regressT72792Weld", "expectedT72792Weld",
SpecMeshTest("T72792Weld", "regressT72792Weld", "expectedT72792Weld",
[ModifierSpec('array', 'ARRAY', {'fit_type': 'FIXED_COUNT', 'count': 2}),
ModifierSpec("weld", 'WELD', {"merge_threshold": 0.1, "vertex_group": "Group"})]),
@ -146,89 +146,89 @@ def main():
# One 'Generate' modifier on primitive meshes
#############################################
# 12
MeshTest("CubeArray", "testCubeArray", "expectedCubeArray",
SpecMeshTest("CubeArray", "testCubeArray", "expectedCubeArray",
[ModifierSpec('array', 'ARRAY', {})]),
MeshTest("CapArray", "testCapArray", "expectedCapArray",
SpecMeshTest("CapArray", "testCapArray", "expectedCapArray",
[ModifierSpec('array', 'ARRAY',
{'fit_type': 'FIT_LENGTH', 'fit_length': 2.0,
'start_cap': bpy.data.objects["testCapStart"],
'end_cap': bpy.data.objects["testCapEnd"]})]),
MeshTest("CurveArray", "testCurveArray", "expectedCurveArray",
SpecMeshTest("CurveArray", "testCurveArray", "expectedCurveArray",
[ModifierSpec('array', 'ARRAY',
{'fit_type': 'FIT_CURVE', 'curve': bpy.data.objects["testCurveArrayHelper"],
'use_relative_offset': False, 'use_constant_offset': True,
'constant_offset_displace': (0.5, 0, 0)})]),
MeshTest("RadialArray", "testRadialArray", "expectedRadialArray",
SpecMeshTest("RadialArray", "testRadialArray", "expectedRadialArray",
[ModifierSpec('array', 'ARRAY', {'fit_type': 'FIXED_COUNT', 'count': 3, 'use_merge_vertices': True,
'use_merge_vertices_cap': True, 'use_relative_offset': False,
'use_object_offset': True,
'offset_object': bpy.data.objects["testRadialArrayHelper"]})]),
MeshTest("CylinderBuild", "testCylinderBuild", "expectedCylinderBuild",
SpecMeshTest("CylinderBuild", "testCylinderBuild", "expectedCylinderBuild",
[ModifierSpec('build', 'BUILD', {'frame_start': 1, 'frame_duration': 1}, 2)]),
# 17
MeshTest("ConeDecimate", "testConeDecimate", "expectedConeDecimate",
SpecMeshTest("ConeDecimate", "testConeDecimate", "expectedConeDecimate",
[ModifierSpec('decimate', 'DECIMATE', {'ratio': 0.5})]),
MeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
SpecMeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
[ModifierSpec('edge split', 'EDGE_SPLIT', {})]),
MeshTest("SphereMirror", "testSphereMirror", "expectedSphereMirror",
SpecMeshTest("SphereMirror", "testSphereMirror", "expectedSphereMirror",
[ModifierSpec('mirror', 'MIRROR', {})]),
MeshTest("LocalMirror", "testLocalMirror", "expectedLocalMirror",
SpecMeshTest("LocalMirror", "testLocalMirror", "expectedLocalMirror",
[ModifierSpec('mirror', 'MIRROR', {'use_clip': True})]),
MeshTest("ObjectOffsetMirror", "testObjectOffsetMirror", "expectedObjectOffsetMirror",
SpecMeshTest("ObjectOffsetMirror", "testObjectOffsetMirror", "expectedObjectOffsetMirror",
[ModifierSpec('mirror', 'MIRROR',
{'mirror_object': bpy.data.objects["testObjectOffsetMirrorHelper"]})]),
MeshTest("CylinderMask", "testCylinderMask", "expectedCylinderMask",
SpecMeshTest("CylinderMask", "testCylinderMask", "expectedCylinderMask",
[ModifierSpec('mask', 'MASK', {'vertex_group': "mask_vertex_group"})]),
MeshTest("ConeMultiRes", "testConeMultiRes", "expectedConeMultiRes",
SpecMeshTest("ConeMultiRes", "testConeMultiRes", "expectedConeMultiRes",
[ModifierSpec('multires', 'MULTIRES', {})]),
# 24
MeshTest("CubeScrew", "testCubeScrew", "expectedCubeScrew",
SpecMeshTest("CubeScrew", "testCubeScrew", "expectedCubeScrew",
[ModifierSpec('screw', 'SCREW', {})]),
MeshTest("CubeSolidify", "testCubeSolidify", "expectedCubeSolidify",
SpecMeshTest("CubeSolidify", "testCubeSolidify", "expectedCubeSolidify",
[ModifierSpec('solidify', 'SOLIDIFY', {})]),
MeshTest("ComplexSolidify", "testComplexSolidify", "expectedComplexSolidify",
SpecMeshTest("ComplexSolidify", "testComplexSolidify", "expectedComplexSolidify",
[ModifierSpec('solidify', 'SOLIDIFY', {'solidify_mode': 'NON_MANIFOLD', 'thickness': 0.05, 'offset': 0,
'nonmanifold_thickness_mode': 'CONSTRAINTS'})]),
MeshTest("T63063Solidify", "regressT63063Solidify", "expectedT63063Solidify",
SpecMeshTest("T63063Solidify", "regressT63063Solidify", "expectedT63063Solidify",
[ModifierSpec('solid', 'SOLIDIFY', {'thickness': 0.1, 'offset': 0.7})]),
MeshTest("T61979Solidify", "regressT61979Solidify", "expectedT61979Solidify",
SpecMeshTest("T61979Solidify", "regressT61979Solidify", "expectedT61979Solidify",
[ModifierSpec('solid', 'SOLIDIFY',
{'thickness': -0.25, 'use_even_offset': True, 'use_quality_normals': True})]),
MeshTest("MonkeySubsurf", "testMonkeySubsurf", "expectedMonkeySubsurf",
SpecMeshTest("MonkeySubsurf", "testMonkeySubsurf", "expectedMonkeySubsurf",
[ModifierSpec('subsurf', 'SUBSURF', {})]),
MeshTest("CatmullClarkSubdivisionSurface", "testCatmullClarkSubdivisionSurface",
SpecMeshTest("CatmullClarkSubdivisionSurface", "testCatmullClarkSubdivisionSurface",
"expectedCatmullClarkSubdivisionSurface",
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
MeshTest("SimpleSubdivisionSurface", "testSimpleSubdivisionSurface", "expectedSimpleSubdivisionSurface",
SpecMeshTest("SimpleSubdivisionSurface", "testSimpleSubdivisionSurface", "expectedSimpleSubdivisionSurface",
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2, 'subdivision_type': 'SIMPLE'})]),
MeshTest("Crease2dSubdivisionSurface", "testCrease2dSubdivisionSurface", "expectedCrease2dSubdivisionSurface",
SpecMeshTest("Crease2dSubdivisionSurface", "testCrease2dSubdivisionSurface", "expectedCrease2dSubdivisionSurface",
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
MeshTest("Crease3dSubdivisionSurface", "testCrease3dSubdivisionSurface", "expectedCrease3dSubdivisionSurface",
SpecMeshTest("Crease3dSubdivisionSurface", "testCrease3dSubdivisionSurface", "expectedCrease3dSubdivisionSurface",
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
# 34
MeshTest("SphereTriangulate", "testSphereTriangulate", "expectedSphereTriangulate",
SpecMeshTest("SphereTriangulate", "testSphereTriangulate", "expectedSphereTriangulate",
[ModifierSpec('triangulate', 'TRIANGULATE', {})]),
MeshTest("MonkeyWireframe", "testMonkeyWireframe", "expectedMonkeyWireframe",
SpecMeshTest("MonkeyWireframe", "testMonkeyWireframe", "expectedMonkeyWireframe",
[ModifierSpec('wireframe', 'WIREFRAME', {})]),
# Duplicate the object, test object and expected object have same world coordinates.
MeshTest("Skin", "testObjPlaneSkin", "expObjPlaneSkin",
SpecMeshTest("Skin", "testObjPlaneSkin", "expObjPlaneSkin",
[ModifierSpec('skin', 'SKIN', {})]),
MeshTest("MergedWeld", "testMergedWeld", "expectedMergedWeld",
SpecMeshTest("MergedWeld", "testMergedWeld", "expectedMergedWeld",
[ModifierSpec("weld", 'WELD', {"merge_threshold": 0.021})]),
MeshTest("MergedAllWeld", "testMergedAllWeld", "expectedMergedAllWeld",
SpecMeshTest("MergedAllWeld", "testMergedAllWeld", "expectedMergedAllWeld",
[ModifierSpec("weld", 'WELD', {"merge_threshold": 1.8})]),
MeshTest("MergedNoneWeld", "testMergedNoneWeld", "expectedMergedNoneWeld",
SpecMeshTest("MergedNoneWeld", "testMergedNoneWeld", "expectedMergedNoneWeld",
[ModifierSpec("weld", 'WELD', {"merge_threshold": 0.019})]),
@ -236,109 +236,109 @@ def main():
# One 'Deform' modifier on primitive meshes
#############################################
# 39
MeshTest("MonkeyArmature", "testMonkeyArmature", "expectedMonkeyArmature",
SpecMeshTest("MonkeyArmature", "testMonkeyArmature", "expectedMonkeyArmature",
[ModifierSpec('armature', 'ARMATURE',
{'object': bpy.data.objects['testArmature'], 'use_vertex_groups': True})]),
MeshTest("TorusCast", "testTorusCast", "expectedTorusCast",
SpecMeshTest("TorusCast", "testTorusCast", "expectedTorusCast",
[ModifierSpec('cast', 'CAST', {'factor': 2.64})]),
MeshTest("CubeCurve", "testCubeCurve", "expectedCubeCurve",
SpecMeshTest("CubeCurve", "testCubeCurve", "expectedCubeCurve",
[ModifierSpec('curve', 'CURVE', {'object': bpy.data.objects['testBezierCurve']})]),
MeshTest("MonkeyDisplace", "testMonkeyDisplace", "expectedMonkeyDisplace",
SpecMeshTest("MonkeyDisplace", "testMonkeyDisplace", "expectedMonkeyDisplace",
[ModifierSpec('displace', "DISPLACE", {})]),
# Hook modifier requires moving the hook object to get a mesh change
# so can't test it with the current framework
# MeshTest("MonkeyHook", "testMonkeyHook", "expectedMonkeyHook",
# SpecMeshTest("MonkeyHook", "testMonkeyHook", "expectedMonkeyHook",
# [ModifierSpec('hook', 'HOOK', {'object': bpy.data.objects["EmptyHook"], 'vertex_group':
# "HookVertexGroup"})]),
# 43
# ModifierSpec('laplacian_deform', 'LAPLACIANDEFORM', {}) Laplacian requires a more complex mesh
MeshTest("CubeLattice", "testCubeLattice", "expectedCubeLattice",
SpecMeshTest("CubeLattice", "testCubeLattice", "expectedCubeLattice",
[ModifierSpec('lattice', 'LATTICE', {'object': bpy.data.objects["testLattice"]})]),
MeshTest("PlaneShrinkWrap", "testPlaneShrinkWrap", "expectedPlaneShrinkWrap",
SpecMeshTest("PlaneShrinkWrap", "testPlaneShrinkWrap", "expectedPlaneShrinkWrap",
[ModifierSpec('shrinkwrap', 'SHRINKWRAP',
{'target': bpy.data.objects["testCubeWrap"], 'offset': 0.5})]),
MeshTest("CylinderSimpleDeform", "testCylinderSimpleDeform", "expectedCylinderSimpleDeform",
SpecMeshTest("CylinderSimpleDeform", "testCylinderSimpleDeform", "expectedCylinderSimpleDeform",
[ModifierSpec('simple_deform', 'SIMPLE_DEFORM', {'angle': math.radians(180), 'deform_axis': 'Z'})]),
MeshTest("PlaneSmooth", "testPlaneSmooth", "expectedPlaneSmooth",
SpecMeshTest("PlaneSmooth", "testPlaneSmooth", "expectedPlaneSmooth",
[ModifierSpec('smooth', 'SMOOTH', {'iterations': 11})]),
# Smooth corrective requires a complex mesh.
MeshTest("BalloonLaplacianSmooth", "testBalloonLaplacianSmooth", "expectedBalloonLaplacianSmooth",
SpecMeshTest("BalloonLaplacianSmooth", "testBalloonLaplacianSmooth", "expectedBalloonLaplacianSmooth",
[ModifierSpec('laplaciansmooth', 'LAPLACIANSMOOTH', {'lambda_factor': 12, 'lambda_border': 12})]),
# Gets updated often
MeshTest("WavePlane", "testObjPlaneWave", "expObjPlaneWave",
SpecMeshTest("WavePlane", "testObjPlaneWave", "expObjPlaneWave",
[ModifierSpec('wave', 'WAVE', {})]),
#############################################
# CURVES Generate Modifiers
#############################################
# Caution: Make sure test object has no modifier in "added" state, the test may fail.
MeshTest("BezCurveArray", "testObjBezierCurveArray", "expObjBezierCurveArray",
SpecMeshTest("BezCurveArray", "testObjBezierCurveArray", "expObjBezierCurveArray",
[ModifierSpec('array', 'ARRAY', {})]),
MeshTest("CurveBevel", "testObjBezierCurveBevel", "expObjBezierCurveBevel",
SpecMeshTest("CurveBevel", "testObjBezierCurveBevel", "expObjBezierCurveBevel",
[ModifierSpec('bevel', 'BEVEL', {'limit_method': 'NONE'})]),
MeshTest("CurveBuild", "testObjBezierCurveBuild", "expObjBezierCurveBuild",
SpecMeshTest("CurveBuild", "testObjBezierCurveBuild", "expObjBezierCurveBuild",
[ModifierSpec('build', 'BUILD', {'frame_start': 1, 'frame_duration': 1}, 2)]),
MeshTest("CurveDecimate", "testObjBezierCurveDecimate", "expObjBezierCurveDecimate",
SpecMeshTest("CurveDecimate", "testObjBezierCurveDecimate", "expObjBezierCurveDecimate",
[ModifierSpec('decimate', 'DECIMATE', {'ratio': 0.5})]),
MeshTest("CurveEdgeSplit", "testObjBezierCurveEdgeSplit", "expObjBezierCurveEdgeSplit",
SpecMeshTest("CurveEdgeSplit", "testObjBezierCurveEdgeSplit", "expObjBezierCurveEdgeSplit",
[ModifierSpec('edgeSplit', 'EDGE_SPLIT', {})]),
MeshTest("CurveMirror", "testObjBezierCurveMirror", "expObjBezierCurveMirror",
SpecMeshTest("CurveMirror", "testObjBezierCurveMirror", "expObjBezierCurveMirror",
[ModifierSpec('mirror', 'MIRROR', {'use_axis': (True, True, False)})]),
MeshTest("CurveScrew", "testObjBezierCurveScrew", "expObjBezierCurveScrew",
SpecMeshTest("CurveScrew", "testObjBezierCurveScrew", "expObjBezierCurveScrew",
[ModifierSpec('screw', 'SCREW', {})]),
MeshTest("CurveSolidify", "testObjBezierCurveSolidify", "expObjBezierCurveSolidify",
SpecMeshTest("CurveSolidify", "testObjBezierCurveSolidify", "expObjBezierCurveSolidify",
[ModifierSpec('solidify', 'SOLIDIFY', {'thickness': 1})]),
MeshTest("CurveSubSurf", "testObjBezierCurveSubSurf", "expObjBezierCurveSubSurf",
SpecMeshTest("CurveSubSurf", "testObjBezierCurveSubSurf", "expObjBezierCurveSubSurf",
[ModifierSpec('subSurf', 'SUBSURF', {})]),
MeshTest("CurveTriangulate", "testObjBezierCurveTriangulate", "expObjBezierCurveTriangulate",
SpecMeshTest("CurveTriangulate", "testObjBezierCurveTriangulate", "expObjBezierCurveTriangulate",
[ModifierSpec('triangulate', 'TRIANGULATE', {})]),
# Test 60
# Caution Weld: if the distance is increased beyond a limit, the object disappears
MeshTest("CurveWeld", "testObjBezierCurveWeld", "expObjBezierCurveWeld",
SpecMeshTest("CurveWeld", "testObjBezierCurveWeld", "expObjBezierCurveWeld",
[ModifierSpec('weld', 'WELD', {})]),
MeshTest("CurveWeld2", "testObjBezierCurveWeld2", "expObjBezierCurveWeld2",
SpecMeshTest("CurveWeld2", "testObjBezierCurveWeld2", "expObjBezierCurveWeld2",
[ModifierSpec('weld', 'WELD', {})]),
#############################################
# Curves Deform Modifiers
#############################################
# Test 62
MeshTest("CurveCast", "testObjBezierCurveCast", "expObjBezierCurveCast",
SpecMeshTest("CurveCast", "testObjBezierCurveCast", "expObjBezierCurveCast",
[ModifierSpec('Cast', 'CAST', {'cast_type': 'CYLINDER', 'factor': 10})]),
MeshTest("CurveShrinkWrap", "testObjBezierCurveShrinkWrap", "expObjBezierCurveShrinkWrap",
SpecMeshTest("CurveShrinkWrap", "testObjBezierCurveShrinkWrap", "expObjBezierCurveShrinkWrap",
[ModifierSpec('ShrinkWrap', 'SHRINKWRAP',
{'target': bpy.data.objects['testShrinkWrapHelperSuzanne']})]),
MeshTest("CurveSimpleDeform", "testObjBezierCurveSimpleDeform", "expObjBezierCurveSimpleDeform",
SpecMeshTest("CurveSimpleDeform", "testObjBezierCurveSimpleDeform", "expObjBezierCurveSimpleDeform",
[ModifierSpec('simple_deform', 'SIMPLE_DEFORM', {'angle': math.radians(90)})]),
MeshTest("CurveSmooth", "testObjBezierCurveSmooth", "expObjBezierCurveSmooth",
SpecMeshTest("CurveSmooth", "testObjBezierCurveSmooth", "expObjBezierCurveSmooth",
[ModifierSpec('smooth', 'SMOOTH', {'factor': 10})]),
MeshTest("CurveWave", "testObjBezierCurveWave", "expObjBezierCurveWave",
SpecMeshTest("CurveWave", "testObjBezierCurveWave", "expObjBezierCurveWave",
[ModifierSpec('curve_wave', 'WAVE', {'time_offset': -1.5})]),
MeshTest("CurveCurve", "testObjBezierCurveCurve", "expObjBezierCurveCurve",
SpecMeshTest("CurveCurve", "testObjBezierCurveCurve", "expObjBezierCurveCurve",
[ModifierSpec('curve_Curve', 'CURVE', {'object': bpy.data.objects['NurbsCurve']})]),
]

558
tests/python/modules/mesh_test.py
View File

@ -33,13 +33,14 @@
# delete the duplicate object
#
# The words in angle brackets are parameters of the test, and are specified in
# the main class MeshTest.
# the abstract class MeshTest.
#
# If the environment variable BLENDER_TEST_UPDATE is set to 1, the <expected_object>
# is updated with the new test result.
# Tests are verbose when the environment variable BLENDER_VERBOSE is set.
from abc import ABC, abstractmethod
import bpy
import functools
import inspect
@ -161,121 +162,321 @@ class DeformModifierSpec:
return "Modifier: " + str(self.modifier_list) + " with object operator " + str(self.object_operator_spec)
class MeshTest:
class MeshTest(ABC):
"""
A mesh testing class targeted at testing modifiers and operators on a single object.
It holds a stack of mesh operations, i.e. modifiers or operators. The test is executed using
the public method run_test().
A mesh testing Abstract class that hold common functionalities for testting operations.
"""
def __init__(
self,
test_name: str,
test_object_name: str,
expected_object_name: str,
operations_stack=None,
apply_modifiers=False,
do_compare=False,
threshold=None
):
def __init__(self, test_object_name, exp_object_name, test_name=None, threshold=None, do_compare=True):
"""
Constructs a MeshTest object. Raises a KeyError if objects with names expected_object_name
or test_object_name don't exist.
:param test_name: str - unique test name identifier.
:param test_object_name: str - Name of object of mesh type to run the operations on.
:param expected_object_name: str - Name of object of mesh type that has the expected
:param exp_object_name: str - Name of object of mesh type that has the expected
geometry after running the operations.
:param operations_stack: list - stack holding operations to perform on the test_object.
:param apply_modifiers: bool - True if we want to apply the modifiers right after adding them to the object.
- True if we want to apply the modifier to a list of modifiers, after some operation.
This affects operations of type ModifierSpec and DeformModifierSpec.
:param test_name: str - Name of the test.
:param threshold: exponent: To allow variations and accept difference to a certain degree.
:param do_compare: bool - True if we want to compare the test and expected objects, False otherwise.
:param threshold : exponent: To allow variations and accept difference to a certain degree.
"""
if operations_stack is None:
operations_stack = []
for operation in operations_stack:
if not (isinstance(operation, ModifierSpec) or isinstance(operation, OperatorSpecEditMode)
or isinstance(operation, OperatorSpecObjectMode) or isinstance(operation, DeformModifierSpec)
or isinstance(operation, ParticleSystemSpec)):
raise ValueError("Expected operation of type {} or {} or {} or {}. Got {}".
format(type(ModifierSpec), type(OperatorSpecEditMode),
type(DeformModifierSpec), type(ParticleSystemSpec),
type(operation)))
self.operations_stack = operations_stack
self.apply_modifier = apply_modifiers
self.do_compare = do_compare
self.threshold = threshold
self.test_name = test_name
self.verbose = os.environ.get("BLENDER_VERBOSE") is not None
self.update = os.getenv('BLENDER_TEST_UPDATE') is not None
# Initialize test objects.
objects = bpy.data.objects
self.test_object = objects[test_object_name]
self.expected_object = objects[expected_object_name]
if self.verbose:
print("Found test object {}".format(test_object_name))
print("Found test object {}".format(expected_object_name))
# Private flag to indicate whether the blend file was updated after the test.
self._test_updated = False
def set_test_object(self, test_object_name):
"""
Set test object for the test. Raises a KeyError if object with given name does not exist.
:param test_object_name: name of test object to run operations on.
"""
objects = bpy.data.objects
self.test_object = objects[test_object_name]
def set_expected_object(self, expected_object_name):
"""
Set expected object for the test. Raises a KeyError if object with given name does not exist
:param expected_object_name: Name of expected object.
"""
objects = bpy.data.objects
self.expected_object = objects[expected_object_name]
def _on_failed_test(self, compare_result, validation_success, evaluated_test_object):
if self.update and validation_success:
if self.verbose:
print("Test failed expectantly. Updating expected mesh...")
# Replace expected object with object we ran operations on, i.e. evaluated_test_object.
evaluated_test_object.location = self.expected_object.location
expected_object_name = self.expected_object.name
evaluated_selection = {v.index for v in evaluated_test_object.data.vertices if v.select}
bpy.data.objects.remove(self.expected_object, do_unlink=True)
evaluated_test_object.name = expected_object_name
self._do_selection(evaluated_test_object.data, "VERT", evaluated_selection)
# Save file.
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
self._test_updated = True
# Set new expected object.
self.expected_object = evaluated_test_object
return True
self.test_object_name = test_object_name
self.exp_object_name = exp_object_name
if test_name:
self.test_name = test_name
else:
print("Test comparison result: {}".format(compare_result))
print("Test validation result: {}".format(validation_success))
print("Resulting object mesh '{}' did not match expected object '{}' from file {}".
format(evaluated_test_object.name, self.expected_object.name, bpy.data.filepath))
filepath = bpy.data.filepath
self.test_name = bpy.path.display_name_from_filepath(filepath)
self.threshold = threshold
self.do_compare = do_compare
self.update = os.getenv("BLENDER_TEST_UPDATE") is not None
self.verbose = os.getenv("BLENDER_VERBOSE") is not None
self.test_updated_counter = 0
objects = bpy.data.objects
self.evaluated_object = None
self.test_object = objects[self.test_object_name]
if self.update:
if exp_object_name in objects:
self.expected_object = objects[self.exp_object_name]
else:
self.create_expected_object()
else:
self.expected_object = objects[self.exp_object_name]
def create_expected_object(self):
"""
Creates an expected object 10 units away
in Y direction from test object.
"""
if self.verbose:
print("Creating expected object...")
self.create_evaluated_object()
self.expected_object = self.evaluated_object
self.expected_object.name = self.exp_object_name
x, y, z = self.test_object.location
self.expected_object.location = (x, y+10, z)
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
def create_evaluated_object(self):
"""
Creates an evaluated object.
"""
bpy.context.view_layer.objects.active = self.test_object
# Duplicate test object.
bpy.ops.object.mode_set(mode="OBJECT")
bpy.ops.object.select_all(action="DESELECT")
bpy.context.view_layer.objects.active = self.test_object
self.test_object.select_set(True)
bpy.ops.object.duplicate()
self.evaluated_object = bpy.context.active_object
self.evaluated_object.name = "evaluated_object"
@staticmethod
def _print_result(result):
"""
Prints the comparison, selection and validation result.
"""
print("Results:")
for key in result:
print("{} : {}".format(key, result[key][1]))
print()
def run_test(self):
"""
Runs a single test, runs it again if test file is updated.
"""
self.create_evaluated_object()
self.apply_operations(self.evaluated_object.name)
if not self.do_compare:
print("\nVisualization purpose only: Open Blender in GUI mode")
print("Compare evaluated and expected object in Blender.\n")
return False
def is_test_updated(self):
result = self.compare_meshes(self.evaluated_object, self.expected_object, self.threshold)
# Initializing with True to get correct resultant of result_code booleans.
success = True
inside_loop_flag = False
for key in result:
inside_loop_flag = True
success = success and result[key][0]
# Check "success" is actually evaluated and is not the default True value.
if not inside_loop_flag:
success = False
if success:
self.print_passed_test_result(result)
# Clean up.
if self.verbose:
print("Cleaning up...")
# Delete evaluated_test_object.
bpy.ops.object.delete()
return True
elif self.update:
self.print_failed_test_result(result)
self.update_failed_test()
# Check for testing the blend file is updated and re-running.
# Also safety check to avoid infinite recursion loop.
if self.test_updated_counter == 1:
print("Re-running test...")
self.run_test()
else:
print("The test fails consistently. Exiting...")
return False
else:
self.print_failed_test_result(result)
return False
def print_failed_test_result(self, result):
"""
Check whether running the test with BLENDER_TEST_UPDATE actually modified the .blend test file.
:return: Bool - True if blend file has been updated. False otherwise.
Print results for failed test.
"""
return self._test_updated
print("\nFAILED {} test with the following: ".format(self.test_name))
self._print_result(result)
def print_passed_test_result(self, result):
"""
Print results for passing test.
"""
print("\nPASSED {} test successfully.".format(self.test_name))
self._print_result(result)
def do_selection(self, mesh: bpy.types.Mesh, select_mode: str, selection: set):
"""
Do selection on a mesh.
:param mesh: bpy.types.Mesh - input mesh
:param: select_mode: str - selection mode. Must be 'VERT', 'EDGE' or 'FACE'
:param: selection: set - indices of selection.
Example: select_mode='VERT' and selection={1,2,3} selects veritces 1, 2 and 3 of input mesh
"""
# Deselect all objects.
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.object.mode_set(mode='OBJECT')
bpy.context.tool_settings.mesh_select_mode = (select_mode == 'VERT',
select_mode == 'EDGE',
select_mode == 'FACE')
items = (mesh.vertices if select_mode == 'VERT'
else mesh.edges if select_mode == 'EDGE'
else mesh.polygons if select_mode == 'FACE'
else None)
if items is None:
raise ValueError("Invalid selection mode")
for index in selection:
items[index].select = True
def update_failed_test(self):
"""
Updates expected object.
"""
self.evaluated_object.location = self.expected_object.location
expected_object_name = self.expected_object.name
evaluated_selection = {
v.index for v in self.evaluated_object.data.vertices if v.select}
bpy.data.objects.remove(self.expected_object, do_unlink=True)
self.evaluated_object.name = expected_object_name
self.do_selection(self.evaluated_object.data,
"VERT", evaluated_selection)
# Save file.
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
self.test_updated_counter += 1
self.expected_object = self.evaluated_object
@staticmethod
def compare_meshes(evaluated_object, expected_object, threshold):
"""
Compares evaluated object mesh with expected object mesh.
:param evaluated_object: first object for comparison.
:param expected_object: second object for comparison.
:param threshold: exponent: To allow variations and accept difference to a certain degree.
:return: dict: Contains results of different comparisons.
"""
objects = bpy.data.objects
evaluated_test_mesh = objects[evaluated_object.name].data
expected_mesh = expected_object.data
result_codes = {}
# Mesh Comparison.
if threshold:
result_mesh = expected_mesh.unit_test_compare(
mesh=evaluated_test_mesh, threshold=threshold)
else:
result_mesh = expected_mesh.unit_test_compare(
mesh=evaluated_test_mesh)
if result_mesh == "Same":
result_codes['Mesh Comparison'] = (True, result_mesh)
else:
result_codes['Mesh Comparison'] = (False, result_mesh)
# Selection comparison.
selected_evaluated_verts = [
v.index for v in evaluated_test_mesh.vertices if v.select]
selected_expected_verts = [
v.index for v in expected_mesh.vertices if v.select]
if selected_evaluated_verts == selected_expected_verts:
result_selection = "Same"
result_codes['Selection Comparison'] = (True, result_selection)
else:
result_selection = "Selection doesn't match."
result_codes['Selection Comparison'] = (False, result_selection)
# Validation check.
result_validation = evaluated_test_mesh.validate(verbose=True)
if result_validation:
result_validation = "Invalid Mesh"
result_codes['Mesh Validation'] = (False, result_validation)
else:
result_validation = "Valid"
result_codes['Mesh Validation'] = (True, result_validation)
return result_codes
@abstractmethod
def apply_operations(self, object_name):
"""
Apply operations on this object.
object_name (str): Name of the test object on which operations will be applied.
"""
pass
class SpecMeshTest(MeshTest):
"""
A mesh testing class inherited from MeshTest class targeted at testing modifiers and operators on a single object.
It holds a stack of mesh operations, i.e. modifiers or operators. The test is executed using MeshTest's run_test.
"""
def __init__(self, test_name,
test_object_name,
exp_object_name,
operations_stack=None,
apply_modifier=True,
threshold=None):
"""
Constructor for SpecMeshTest.
:param test_name: str - Name of the test.
:param test_object_name: str - Name of object of mesh type to run the operations on.
:param exp_object_name: str - Name of object of mesh type that has the expected
geometry after running the operations.
:param operations_stack: list - stack holding operations to perform on the test_object.
:param apply_modifier: bool - True if we want to apply the modifiers right after adding them to the object.
- True if we want to apply the modifier to list of modifiers, after some operation.
This affects operations of type ModifierSpec and DeformModifierSpec.
"""
super().__init__(test_object_name, exp_object_name, test_name, threshold)
self.test_name = test_name
if operations_stack is None:
self.operations_stack = []
else:
self.operations_stack = operations_stack
self.apply_modifier = apply_modifier
def apply_operations(self, evaluated_test_object_name):
# Add modifiers and operators.
SpecMeshTest.apply_operations.__doc__ = MeshTest.apply_operations.__doc__
evaluated_test_object = bpy.data.objects[evaluated_test_object_name]
if self.verbose:
print("Applying operations...")
for operation in self.operations_stack:
if isinstance(operation, ModifierSpec):
self._add_modifier(evaluated_test_object, operation)
if self.apply_modifier:
self._apply_modifier(
evaluated_test_object, operation.modifier_name)
elif isinstance(operation, OperatorSpecEditMode):
self._apply_operator_edit_mode(
evaluated_test_object, operation)
elif isinstance(operation, OperatorSpecObjectMode):
self._apply_operator_object_mode(operation)
elif isinstance(operation, DeformModifierSpec):
self._apply_deform_modifier(evaluated_test_object, operation)
elif isinstance(operation, ParticleSystemSpec):
self._apply_particle_system(evaluated_test_object, operation)
else:
raise ValueError("Expected operation of type {} or {} or {} or {}. Got {}".
format(type(ModifierSpec), type(OperatorSpecEditMode),
type(OperatorSpecObjectMode), type(ParticleSystemSpec), type(operation)))
def _set_parameters_impl(self, modifier, modifier_parameters, nested_settings_path, modifier_name):
"""
@ -312,14 +513,15 @@ class MeshTest:
for key in modifier_parameters:
nested_settings_path.append(key)
self._set_parameters_impl(modifier, modifier_parameters[key], nested_settings_path, modifier_name)
self._set_parameters_impl(
modifier, modifier_parameters[key], nested_settings_path, modifier_name)
if nested_settings_path:
nested_settings_path.pop()
def set_parameters(self, modifier, modifier_parameters):
"""
Wrapper for _set_parameters_util
Wrapper for _set_parameters_impl.
"""
settings = []
modifier_name = modifier.name
@ -430,40 +632,14 @@ class MeshTest:
if self.apply_modifier:
self._apply_modifier(test_object, particle_sys_spec.modifier_name)
def _do_selection(self, mesh: bpy.types.Mesh, select_mode: str, selection: set):
"""
Do selection on a mesh
:param mesh: bpy.types.Mesh - input mesh
:param: select_mode: str - selection mode. Must be 'VERT', 'EDGE' or 'FACE'
:param: selection: set - indices of selection.
Example: select_mode='VERT' and selection={1,2,3} selects veritces 1, 2 and 3 of input mesh
"""
# deselect all
bpy.ops.object.mode_set(mode='EDIT')
bpy.ops.mesh.select_all(action='DESELECT')
bpy.ops.object.mode_set(mode='OBJECT')
bpy.context.tool_settings.mesh_select_mode = (select_mode == 'VERT',
select_mode == 'EDGE',
select_mode == 'FACE')
items = (mesh.vertices if select_mode == 'VERT'
else mesh.edges if select_mode == 'EDGE'
else mesh.polygons if select_mode == 'FACE'
else None)
if items is None:
raise ValueError("Invalid selection mode")
for index in selection:
items[index].select = True
def _apply_operator_edit_mode(self, test_object, operator: OperatorSpecEditMode):
"""
Apply operator on test object.
:param test_object: bpy.types.Object - Blender object to apply operator on.
:param operator: OperatorSpecEditMode - OperatorSpecEditMode object with parameters.
"""
self._do_selection(test_object.data, operator.select_mode, operator.selection)
self.do_selection(
test_object.data, operator.select_mode, operator.selection)
# Apply operator in edit mode.
bpy.ops.object.mode_set(mode='EDIT')
@ -528,96 +704,27 @@ class MeshTest:
for mod_name in modifier_names:
self._apply_modifier(test_object, mod_name)
def run_test(self):
"""
Apply operations in self.operations_stack on self.test_object and compare the
resulting mesh with self.expected_object.data
:return: bool - True if the test passed, False otherwise.
"""
self._test_updated = False
bpy.context.view_layer.objects.active = self.test_object
# Duplicate test object.
bpy.ops.object.mode_set(mode="OBJECT")
bpy.ops.object.select_all(action="DESELECT")
bpy.context.view_layer.objects.active = self.test_object
class BlendFileTest(MeshTest):
"""
A mesh testing class inherited from MeshTest aimed at testing operations like modifiers loaded directly from
blend file i.e. without adding them from scratch or without adding specifications.
"""
self.test_object.select_set(True)
bpy.ops.object.duplicate()
evaluated_test_object = bpy.context.active_object
evaluated_test_object.name = "evaluated_object"
if self.verbose:
print()
print(evaluated_test_object.name, "is set to active")
def apply_operations(self, evaluated_test_object_name):
# Add modifiers and operators.
for operation in self.operations_stack:
if isinstance(operation, ModifierSpec):
self._add_modifier(evaluated_test_object, operation)
if self.apply_modifier:
self._apply_modifier(evaluated_test_object, operation.modifier_name)
elif isinstance(operation, OperatorSpecEditMode):
self._apply_operator_edit_mode(evaluated_test_object, operation)
elif isinstance(operation, OperatorSpecObjectMode):
self._apply_operator_object_mode(operation)
elif isinstance(operation, DeformModifierSpec):
self._apply_deform_modifier(evaluated_test_object, operation)
elif isinstance(operation, ParticleSystemSpec):
self._apply_particle_system(evaluated_test_object, operation)
else:
raise ValueError("Expected operation of type {} or {} or {} or {}. Got {}".
format(type(ModifierSpec), type(OperatorSpecEditMode),
type(OperatorSpecObjectMode), type(ParticleSystemSpec), type(operation)))
# Compare resulting mesh with expected one.
# Compare only when self.do_compare is set to True, it is set to False for run-test and returns.
if not self.do_compare:
print("Meshes/objects are not compared, compare evaluated and expected object in Blender for "
"visualization only.")
return False
if self.verbose:
print("Comparing expected mesh with resulting mesh...")
evaluated_test_mesh = evaluated_test_object.data
expected_mesh = self.expected_object.data
if self.threshold:
compare_result = evaluated_test_mesh.unit_test_compare(mesh=expected_mesh, threshold=self.threshold)
else:
compare_result = evaluated_test_mesh.unit_test_compare(mesh=expected_mesh)
compare_success = (compare_result == 'Same')
selected_evaluatated_verts = [v.index for v in evaluated_test_mesh.vertices if v.select]
selected_expected_verts = [v.index for v in expected_mesh.vertices if v.select]
if selected_evaluatated_verts != selected_expected_verts:
compare_result = "Selection doesn't match"
compare_success = False
# Also check if invalid geometry (which is never expected) had to be corrected...
validation_success = not evaluated_test_mesh.validate(verbose=True)
if compare_success and validation_success:
if self.verbose:
print("Success!")
# Clean up.
if self.verbose:
print("Cleaning up...")
# Delete evaluated_test_object.
bpy.ops.object.delete()
return True
else:
return self._on_failed_test(compare_result, validation_success, evaluated_test_object)
BlendFileTest.apply_operations.__doc__ = MeshTest.apply_operations.__doc__
evaluated_test_object = bpy.data.objects[evaluated_test_object_name]
modifiers_list = evaluated_test_object.modifiers
if not modifiers_list:
raise Exception("No modifiers are added to test object.")
for modifier in modifiers_list:
bpy.ops.object.modifier_apply(modifier=modifier.name)
class RunTest:
"""
Helper class that stores and executes modifier tests.
Helper class that stores and executes SpecMeshTest tests.
Example usage:
@ -629,9 +736,9 @@ class RunTest:
>>> OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE),
>>> ]
>>> tests = [
>>> MeshTest("Test1", "testCube", "expectedCube", modifier_list),
>>> MeshTest("Test2", "testCube_2", "expectedCube_2", modifier_list),
>>> MeshTest("MonkeyDeleteEdge", "testMonkey","expectedMonkey", operator_list)
>>> SpecMeshTest("Test1", "testCube", "expectedCube", modifier_list),
>>> SpecMeshTest("Test2", "testCube_2", "expectedCube_2", modifier_list),
>>> SpecMeshTest("MonkeyDeleteEdge", "testMonkey","expectedMonkey", operator_list)
>>> ]
>>> modifiers_test = RunTest(tests)
>>> modifiers_test.run_all_tests()
@ -639,7 +746,7 @@ class RunTest:
def __init__(self, tests, apply_modifiers=False, do_compare=False):
"""
Construct a modifier test.
Construct a test suite.
:param tests: list - list of modifier or operator test cases. Each element in the list must contain the
following
in the correct order:
@ -674,7 +781,7 @@ class RunTest:
def run_all_tests(self):
"""
Run all tests in self.tests list. Raises an exception if one the tests fails.
Run all tests in self.tests list. Displays all failed tests at bottom.
"""
for test_number, each_test in enumerate(self.tests):
test_name = each_test.test_name
@ -717,15 +824,8 @@ class RunTest:
raise Exception('No test called {} found!'.format(test_name))
test = case
if self.apply_modifiers:
test.apply_modifier = True
if self.do_compare:
test.do_compare = True
test.apply_modifier = self.apply_modifiers
test.do_compare = self.do_compare
success = test.run_test()
if test.is_test_updated():
# Run the test again if the blend file has been updated.
success = test.run_test()
return success

154
tests/python/operators.py
View File

@ -26,7 +26,7 @@ from random import shuffle, seed
seed(0)
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import MeshTest, OperatorSpecEditMode, RunTest
from modules.mesh_test import SpecMeshTest, OperatorSpecEditMode, RunTest
# Central vertical loop of Suzanne
MONKEY_LOOP_VERT = {68, 69, 71, 73, 74, 75, 76, 77, 90, 129, 136, 175, 188, 189, 198, 207,
@ -38,242 +38,242 @@ MONKEY_LOOP_EDGE = {131, 278, 299, 305, 307, 334, 337, 359, 384, 396, 399, 412,
def main():
tests = [
# bisect
MeshTest("CubeBisect", "testCubeBisect", "expectedCubeBisect",
SpecMeshTest("CubeBisect", "testCubeBisect", "expectedCubeBisect",
[OperatorSpecEditMode("bisect",
{"plane_co": (0, 0, 0), "plane_no": (0, 1, 1), "clear_inner": True,
"use_fill": True}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
# blend from shape
MeshTest("CubeBlendFromShape", "testCubeBlendFromShape", "expectedCubeBlendFromShape",
SpecMeshTest("CubeBlendFromShape", "testCubeBlendFromShape", "expectedCubeBlendFromShape",
[OperatorSpecEditMode("blend_from_shape", {"shape": "Key 1"}, 'FACE', {0, 1, 2, 3, 4, 5})]),
# bridge edge loops
MeshTest("CubeBridgeEdgeLoop", "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop",
SpecMeshTest("CubeBridgeEdgeLoop", "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop",
[OperatorSpecEditMode("bridge_edge_loops", {}, "FACE", {0, 1})]),
# decimate
MeshTest("MonkeyDecimate", "testMonkeyDecimate", "expectedMonkeyDecimate",
SpecMeshTest("MonkeyDecimate", "testMonkeyDecimate", "expectedMonkeyDecimate",
[OperatorSpecEditMode("decimate",
{"ratio": 0.1}, "FACE", {i for i in range(500)})]),
# delete
MeshTest("CubeDeleteVertices", "testCubeDeleteVertices", "expectedCubeDeleteVertices",
SpecMeshTest("CubeDeleteVertices", "testCubeDeleteVertices", "expectedCubeDeleteVertices",
[OperatorSpecEditMode("delete", {}, "VERT", {3})]),
MeshTest("CubeDeleteFaces", "testCubeDeleteFaces", "expectedCubeDeleteFaces",
SpecMeshTest("CubeDeleteFaces", "testCubeDeleteFaces", "expectedCubeDeleteFaces",
[OperatorSpecEditMode("delete", {}, "FACE", {0})]),
MeshTest("CubeDeleteEdges", "testCubeDeleteEdges", "expectedCubeDeleteEdges",
SpecMeshTest("CubeDeleteEdges", "testCubeDeleteEdges", "expectedCubeDeleteEdges",
[OperatorSpecEditMode("delete", {}, "EDGE", {0, 1, 2, 3})]),
# delete edge loop
MeshTest("MonkeyDeleteEdgeLoopVertices", "testMokneyDeleteEdgeLoopVertices",
SpecMeshTest("MonkeyDeleteEdgeLoopVertices", "testMokneyDeleteEdgeLoopVertices",
"expectedMonkeyDeleteEdgeLoopVertices",
[OperatorSpecEditMode("delete_edgeloop", {}, "VERT", MONKEY_LOOP_VERT)]),
MeshTest("MonkeyDeleteEdgeLoopEdges", "testMokneyDeleteEdgeLoopEdges",
SpecMeshTest("MonkeyDeleteEdgeLoopEdges", "testMokneyDeleteEdgeLoopEdges",
"expectedMonkeyDeleteEdgeLoopEdges",
[OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE)]),
# delete loose
MeshTest("CubeDeleteLooseVertices", "testCubeDeleteLooseVertices",
SpecMeshTest("CubeDeleteLooseVertices", "testCubeDeleteLooseVertices",
"expectedCubeDeleteLooseVertices",
[OperatorSpecEditMode("delete_loose", {"use_verts": True, "use_edges": False, "use_faces": False},
"VERT",
{i for i in range(12)})]),
MeshTest("CubeDeleteLooseEdges", "testCubeDeleteLooseEdges",
SpecMeshTest("CubeDeleteLooseEdges", "testCubeDeleteLooseEdges",
"expectedCubeDeleteLooseEdges",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": True, "use_faces": False},
"EDGE",
{i for i in range(14)})]),
MeshTest("CubeDeleteLooseFaces", "testCubeDeleteLooseFaces",
SpecMeshTest("CubeDeleteLooseFaces", "testCubeDeleteLooseFaces",
"expectedCubeDeleteLooseFaces",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": False, "use_faces": True},
"FACE",
{i for i in range(7)})]),
# dissolve degenerate
MeshTest("CubeDissolveDegenerate", "testCubeDissolveDegenerate",
SpecMeshTest("CubeDissolveDegenerate", "testCubeDissolveDegenerate",
"expectedCubeDissolveDegenerate",
[OperatorSpecEditMode("dissolve_degenerate", {}, "VERT", {i for i in range(8)})]),
# dissolve edges
MeshTest("CylinderDissolveEdges", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges",
SpecMeshTest("CylinderDissolveEdges", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges",
[OperatorSpecEditMode("dissolve_edges", {}, "EDGE", {0, 5, 6, 9})]),
# dissolve faces
MeshTest("CubeDissolveFaces", "testCubeDissolveFaces", "expectedCubeDissolveFaces",
SpecMeshTest("CubeDissolveFaces", "testCubeDissolveFaces", "expectedCubeDissolveFaces",
[OperatorSpecEditMode("dissolve_faces", {}, "VERT", {5, 34, 47, 49, 83, 91, 95})]),
# dissolve verts
MeshTest("CubeDissolveVerts", "testCubeDissolveVerts", "expectedCubeDissolveVerts",
SpecMeshTest("CubeDissolveVerts", "testCubeDissolveVerts", "expectedCubeDissolveVerts",
[OperatorSpecEditMode("dissolve_verts", {}, "VERT", {16, 20, 22, 23, 25})]),
# duplicate
MeshTest("ConeDuplicateVertices", "testConeDuplicateVertices",
SpecMeshTest("ConeDuplicateVertices", "testConeDuplicateVertices",
"expectedConeDuplicateVertices",
[OperatorSpecEditMode("duplicate", {}, "VERT", {i for i in range(33)} - {23})]),
MeshTest("ConeDuplicateOneVertex", "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex",
SpecMeshTest("ConeDuplicateOneVertex", "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex",
[OperatorSpecEditMode("duplicate", {}, "VERT", {23})]),
MeshTest("ConeDuplicateFaces", "testConeDuplicateFaces", "expectedConeDuplicateFaces",
SpecMeshTest("ConeDuplicateFaces", "testConeDuplicateFaces", "expectedConeDuplicateFaces",
[OperatorSpecEditMode("duplicate", {}, "FACE", {6, 9})]),
MeshTest("ConeDuplicateEdges", "testConeDuplicateEdges", "expectedConeDuplicateEdges",
SpecMeshTest("ConeDuplicateEdges", "testConeDuplicateEdges", "expectedConeDuplicateEdges",
[OperatorSpecEditMode("duplicate", {}, "EDGE", {i for i in range(64)})]),
# edge collapse
MeshTest("CylinderEdgeCollapse", "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse",
SpecMeshTest("CylinderEdgeCollapse", "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse",
[OperatorSpecEditMode("edge_collapse", {}, "EDGE", {1, 9, 4})]),
# edge face add
MeshTest("CubeEdgeFaceAddFace", "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace",
SpecMeshTest("CubeEdgeFaceAddFace", "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {1, 3, 4, 5, 7})]),
MeshTest("CubeEdgeFaceAddEdge", "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge",
SpecMeshTest("CubeEdgeFaceAddEdge", "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {4, 5})]),
# edge rotate
MeshTest("CubeEdgeRotate", "testCubeEdgeRotate", "expectedCubeEdgeRotate",
SpecMeshTest("CubeEdgeRotate", "testCubeEdgeRotate", "expectedCubeEdgeRotate",
[OperatorSpecEditMode("edge_rotate", {}, "EDGE", {1})]),
# edge split
MeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
SpecMeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
[OperatorSpecEditMode("edge_split", {}, "EDGE", {2, 5, 8, 11, 14, 17, 20, 23})]),
# edge ring select - Cannot be tested. Need user input.
# MeshTest("CubeEdgeRingSelect", "testCubeEdgeRingSelect", "expectedCubeEdgeRingSelect",
# SpecMeshTest("CubeEdgeRingSelect", "testCubeEdgeRingSelect", "expectedCubeEdgeRingSelect",
# [OperatorSpecEditMode("edgering_select", {}, "EDGE", {5, 20, 25, 26})]),
# MeshTest("EmptyMeshEdgeRingSelect", "testGridEdgeRingSelect", "expectedGridEdgeRingSelect",
# SpecMeshTest("EmptyMeshEdgeRingSelect", "testGridEdgeRingSelect", "expectedGridEdgeRingSelect",
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {65, 66, 67})]),
# MeshTest("EmptyMeshEdgeRingSelect", "testEmptyMeshdgeRingSelect", "expectedEmptyMeshEdgeRingSelect",
# SpecMeshTest("EmptyMeshEdgeRingSelect", "testEmptyMeshdgeRingSelect", "expectedEmptyMeshEdgeRingSelect",
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {})]),
# edges select sharp
MeshTest("CubeEdgesSelectSharp", "testCubeEdgeSelectSharp", "expectedCubeEdgeSelectSharp",
SpecMeshTest("CubeEdgesSelectSharp", "testCubeEdgeSelectSharp", "expectedCubeEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {}, "EDGE", {20})]),
MeshTest("SphereEdgesSelectSharp", "testSphereEdgesSelectSharp", "expectedSphereEdgeSelectSharp",
SpecMeshTest("SphereEdgesSelectSharp", "testSphereEdgesSelectSharp", "expectedSphereEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.25}, "EDGE", {288})]),
MeshTest("HoledSphereEdgesSelectSharp", "testHoledSphereEdgesSelectSharp", "expectedHoledSphereEdgeSelectSharp",
SpecMeshTest("HoledSphereEdgesSelectSharp", "testHoledSphereEdgesSelectSharp", "expectedHoledSphereEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.18}, "VERT", {})]),
MeshTest("EmptyMeshEdgesSelectSharp", "testEmptyMeshEdgeSelectSharp", "expectedEmptyMeshEdgeSelectSharp",
SpecMeshTest("EmptyMeshEdgesSelectSharp", "testEmptyMeshEdgeSelectSharp", "expectedEmptyMeshEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {}, "VERT", {})]),
# face make planar
MeshTest("MonkeyFaceMakePlanar", "testMonkeyFaceMakePlanar",
SpecMeshTest("MonkeyFaceMakePlanar", "testMonkeyFaceMakePlanar",
"expectedMonkeyFaceMakePlanar",
[OperatorSpecEditMode("face_make_planar", {}, "FACE", {i for i in range(500)})]),
# face split by edges
MeshTest("PlaneFaceSplitByEdges", "testPlaneFaceSplitByEdges",
SpecMeshTest("PlaneFaceSplitByEdges", "testPlaneFaceSplitByEdges",
"expectedPlaneFaceSplitByEdges",
[OperatorSpecEditMode("face_split_by_edges", {}, "VERT", {i for i in range(6)})]),
# faces select linked flat
MeshTest("CubeFacesSelectLinkedFlat", "testCubeFaceSelectLinkedFlat", "expectedCubeFaceSelectLinkedFlat",
SpecMeshTest("CubeFacesSelectLinkedFlat", "testCubeFaceSelectLinkedFlat", "expectedCubeFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "FACE", {7})]),
MeshTest("PlaneFacesSelectLinkedFlat", "testPlaneFaceSelectLinkedFlat", "expectedPlaneFaceSelectLinkedFlat",
SpecMeshTest("PlaneFacesSelectLinkedFlat", "testPlaneFaceSelectLinkedFlat", "expectedPlaneFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {1})]),
MeshTest("EmptyMeshFacesSelectLinkedFlat", "testEmptyMeshFaceSelectLinkedFlat",
SpecMeshTest("EmptyMeshFacesSelectLinkedFlat", "testEmptyMeshFaceSelectLinkedFlat",
"expectedEmptyMeshFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {})]),
# fill
MeshTest("IcosphereFill", "testIcosphereFill", "expectedIcosphereFill",
SpecMeshTest("IcosphereFill", "testIcosphereFill", "expectedIcosphereFill",
[OperatorSpecEditMode("fill", {}, "EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49})]),
MeshTest("IcosphereFillUseBeautyFalse",
SpecMeshTest("IcosphereFillUseBeautyFalse",
"testIcosphereFillUseBeautyFalse", "expectedIcosphereFillUseBeautyFalse",
[OperatorSpecEditMode("fill", {"use_beauty": False}, "EDGE",
{20, 21, 22, 23, 24, 45, 46, 47, 48, 49})]),
# fill grid
MeshTest("PlaneFillGrid", "testPlaneFillGrid",
SpecMeshTest("PlaneFillGrid", "testPlaneFillGrid",
"expectedPlaneFillGrid",
[OperatorSpecEditMode("fill_grid", {}, "EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})]),
MeshTest("PlaneFillGridSimpleBlending",
SpecMeshTest("PlaneFillGridSimpleBlending",
"testPlaneFillGridSimpleBlending",
"expectedPlaneFillGridSimpleBlending",
[OperatorSpecEditMode("fill_grid", {"use_interp_simple": True}, "EDGE",
{1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})]),
# fill holes
MeshTest("SphereFillHoles", "testSphereFillHoles", "expectedSphereFillHoles",
SpecMeshTest("SphereFillHoles", "testSphereFillHoles", "expectedSphereFillHoles",
[OperatorSpecEditMode("fill_holes", {"sides": 9}, "VERT", {i for i in range(481)})]),
# face shade smooth (not a real test)
MeshTest("CubeShadeSmooth", "testCubeShadeSmooth", "expectedCubeShadeSmooth",
SpecMeshTest("CubeShadeSmooth", "testCubeShadeSmooth", "expectedCubeShadeSmooth",
[OperatorSpecEditMode("faces_shade_smooth", {}, "VERT", {i for i in range(8)})]),
# faces shade flat (not a real test)
MeshTest("CubeShadeFlat", "testCubeShadeFlat", "expectedCubeShadeFlat",
SpecMeshTest("CubeShadeFlat", "testCubeShadeFlat", "expectedCubeShadeFlat",
[OperatorSpecEditMode("faces_shade_flat", {}, "FACE", {i for i in range(6)})]),
# inset faces
MeshTest("CubeInset",
SpecMeshTest("CubeInset",
"testCubeInset", "expectedCubeInset", [OperatorSpecEditMode("inset", {"thickness": 0.2}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50,
52,
59, 61, 62, 65, 83, 91, 95})]),
MeshTest("CubeInsetEvenOffsetFalse",
SpecMeshTest("CubeInsetEvenOffsetFalse",
"testCubeInsetEvenOffsetFalse", "expectedCubeInsetEvenOffsetFalse",
[OperatorSpecEditMode("inset", {"thickness": 0.2, "use_even_offset": False}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95})]),
MeshTest("CubeInsetDepth",
SpecMeshTest("CubeInsetDepth",
"testCubeInsetDepth",
"expectedCubeInsetDepth", [OperatorSpecEditMode("inset", {"thickness": 0.2, "depth": 0.2}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61,
62,
65, 83, 91, 95})]),
MeshTest("GridInsetRelativeOffset", "testGridInsetRelativeOffset",
SpecMeshTest("GridInsetRelativeOffset", "testGridInsetRelativeOffset",
"expectedGridInsetRelativeOffset",
[OperatorSpecEditMode("inset", {"thickness": 0.4,
"use_relative_offset": True}, "FACE",
{35, 36, 37, 45, 46, 47, 55, 56, 57})]),
# loop multi select
MeshTest("MokeyLoopMultiSelect", "testMonkeyLoopMultiSelect", "expectedMonkeyLoopMultiSelect",
SpecMeshTest("MokeyLoopMultiSelect", "testMonkeyLoopMultiSelect", "expectedMonkeyLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {355, 359, 73, 301, 302})]),
MeshTest("HoledGridLoopMultiSelect", "testGridLoopMultiSelect", "expectedGridLoopMultiSelect",
SpecMeshTest("HoledGridLoopMultiSelect", "testGridLoopMultiSelect", "expectedGridLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {257, 169, 202, 207, 274, 278, 63})]),
MeshTest("EmptyMeshLoopMultiSelect", "testEmptyMeshLoopMultiSelect", "expectedEmptyMeshLoopMultiSelect",
SpecMeshTest("EmptyMeshLoopMultiSelect", "testEmptyMeshLoopMultiSelect", "expectedEmptyMeshLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {})]),
# mark seam
MeshTest("CubeMarkSeam", "testCubeMarkSeam", "expectedCubeMarkSeam",
SpecMeshTest("CubeMarkSeam", "testCubeMarkSeam", "expectedCubeMarkSeam",
[OperatorSpecEditMode("mark_seam", {}, "EDGE", {1})]),
# select all
MeshTest("CircleSelectAll", "testCircleSelectAll", "expectedCircleSelectAll",
SpecMeshTest("CircleSelectAll", "testCircleSelectAll", "expectedCircleSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {1})]),
MeshTest("IsolatedVertsSelectAll", "testIsolatedVertsSelectAll", "expectedIsolatedVertsSelectAll",
SpecMeshTest("IsolatedVertsSelectAll", "testIsolatedVertsSelectAll", "expectedIsolatedVertsSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {})]),
MeshTest("EmptyMeshSelectAll", "testEmptyMeshSelectAll", "expectedEmptyMeshSelectAll",
SpecMeshTest("EmptyMeshSelectAll", "testEmptyMeshSelectAll", "expectedEmptyMeshSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {})]),
# select axis - Cannot be tested. Needs active vert selection
# MeshTest("MonkeySelectAxisX", "testMonkeySelectAxisX", "expectedMonkeySelectAxisX",
# SpecMeshTest("MonkeySelectAxisX", "testMonkeySelectAxisX", "expectedMonkeySelectAxisX",
# [OperatorSpecEditMode("select_axis", {"axis": "X"}, "VERT", {13})]),
# MeshTest("MonkeySelectAxisY", "testMonkeySelectAxisY", "expectedMonkeySelectAxisY",
# SpecMeshTest("MonkeySelectAxisY", "testMonkeySelectAxisY", "expectedMonkeySelectAxisY",
# [OperatorSpecEditMode("select_axis", {"axis": "Y", "sign": "NEG"}, "FACE", {317})]),
# MeshTest("MonkeySelectAxisXYZ", "testMonkeySelectAxisXYZ", "expectedMonkeySelectAxisXYZ",
# SpecMeshTest("MonkeySelectAxisXYZ", "testMonkeySelectAxisXYZ", "expectedMonkeySelectAxisXYZ",
# [OperatorSpecEditMode("select_axis", {"axis": "X", "sign": "NEG"}, "FACE", {317}),
# OperatorSpecEditMode("select_axis", {"axis": "Y", "sign": "POS"}, "FACE", {}),
# OperatorSpecEditMode("select_axis", {"axis": "Z", "sign": "NEG"}, "FACE", {})]),
# select faces by sides
MeshTest("CubeSelectFacesBySide", "testCubeSelectFacesBySide", "expectedCubeSelectFacesBySide",
SpecMeshTest("CubeSelectFacesBySide", "testCubeSelectFacesBySide", "expectedCubeSelectFacesBySide",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
MeshTest("CubeSelectFacesBySideGreater", "testCubeSelectFacesBySideGreater", "expectedCubeSelectFacesBySideGreater",
SpecMeshTest("CubeSelectFacesBySideGreater", "testCubeSelectFacesBySideGreater", "expectedCubeSelectFacesBySideGreater",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4, "type": "GREATER", "extend": True}, "FACE", {})]),
MeshTest("CubeSelectFacesBySideLess", "testCubeSelectFacesBySideLess", "expectedCubeSelectFacesBySideLess",
SpecMeshTest("CubeSelectFacesBySideLess", "testCubeSelectFacesBySideLess", "expectedCubeSelectFacesBySideLess",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4, "type": "GREATER", "extend": True}, "FACE", {})]),
# select interior faces
MeshTest("CubeSelectInteriorFaces", "testCubeSelectInteriorFaces", "expectedCubeSelectInteriorFaces",
SpecMeshTest("CubeSelectInteriorFaces", "testCubeSelectInteriorFaces", "expectedCubeSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
MeshTest("HoledCubeSelectInteriorFaces", "testHoledCubeSelectInteriorFaces", "expectedHoledCubeSelectInteriorFaces",
SpecMeshTest("HoledCubeSelectInteriorFaces", "testHoledCubeSelectInteriorFaces", "expectedHoledCubeSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
MeshTest("EmptyMeshSelectInteriorFaces", "testEmptyMeshSelectInteriorFaces", "expectedEmptyMeshSelectInteriorFaces",
SpecMeshTest("EmptyMeshSelectInteriorFaces", "testEmptyMeshSelectInteriorFaces", "expectedEmptyMeshSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
# select less
MeshTest("MonkeySelectLess", "testMonkeySelectLess", "expectedMonkeySelectLess",
SpecMeshTest("MonkeySelectLess", "testMonkeySelectLess", "expectedMonkeySelectLess",
[OperatorSpecEditMode("select_less", {}, "VERT", {2, 8, 24, 34, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 68,
69, 70, 71, 74, 75, 78, 80, 81, 82, 83, 90, 91, 93, 95, 97, 99,
101, 109, 111, 115, 117, 119, 121, 123, 125, 127, 129, 130, 131,
@ -295,37 +295,37 @@ def main():
462, 463, 464, 471, 473, 474, 475, 476, 477, 478, 479, 480, 481,
482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 495,
496, 497, 498, 499, 502, 505})]),
MeshTest("HoledCubeSelectLess", "testHoledCubeSelectLess", "expectedHoledCubeSelectLess",
SpecMeshTest("HoledCubeSelectLess", "testHoledCubeSelectLess", "expectedHoledCubeSelectLess",
[OperatorSpecEditMode("select_face_by_sides", {}, "FACE", {})]),
MeshTest("EmptyMeshSelectLess", "testEmptyMeshSelectLess", "expectedEmptyMeshSelectLess",
SpecMeshTest("EmptyMeshSelectLess", "testEmptyMeshSelectLess", "expectedEmptyMeshSelectLess",
[OperatorSpecEditMode("select_face_by_sides", {}, "VERT", {})]),
# select linked
MeshTest("PlanesSelectLinked", "testPlanesSelectLinked", "expectedPlanesSelectedLinked",
SpecMeshTest("PlanesSelectLinked", "testPlanesSelectLinked", "expectedPlanesSelectedLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {7})]),
MeshTest("CubesSelectLinked", "testCubesSelectLinked", "expectedCubesSelectLinked",
SpecMeshTest("CubesSelectLinked", "testCubesSelectLinked", "expectedCubesSelectLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {11})]),
MeshTest("EmptyMeshSelectLinked", "testEmptyMeshSelectLinked", "expectedEmptyMeshSelectLinked",
SpecMeshTest("EmptyMeshSelectLinked", "testEmptyMeshSelectLinked", "expectedEmptyMeshSelectLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {})]),
# select nth (checkered deselect)
MeshTest("CircleSelect2nd", "testCircleSelect2nd", "expectedCircleSelect2nd",
SpecMeshTest("CircleSelect2nd", "testCircleSelect2nd", "expectedCircleSelect2nd",
[OperatorSpecEditMode("select_nth", {}, "VERT", {i for i in range(32)})]),
# unsubdivide
# normal case
MeshTest("CubeFaceUnsubdivide", "testCubeUnsubdivide", "expectedCubeUnsubdivide",
SpecMeshTest("CubeFaceUnsubdivide", "testCubeUnsubdivide", "expectedCubeUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {}, "FACE", {i for i in range(6)})]),
# T87259 - test cases
MeshTest("CubeEdgeUnsubdivide", "testCubeEdgeUnsubdivide", "expectedCubeEdgeUnsubdivide",
SpecMeshTest("CubeEdgeUnsubdivide", "testCubeEdgeUnsubdivide", "expectedCubeEdgeUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {}, "EDGE", {i for i in range(6)})]),
MeshTest("UVSphereUnsubdivide", "testUVSphereUnsubdivide", "expectedUVSphereUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {'iterations': 9}, "FACE", {i for i in range(512)})]),
SpecMeshTest("UVSphereUnsubdivide", "testUVSphereUnsubdivide", "expectedUVSphereUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {'iterations': 9}, "FACE", {i for i in range(512)})]),
# vert connect path
# Tip: It works only if there is an already existing face or more than 2 vertices.
MeshTest("CubeVertConnectPath", "testCubeVertConnectPath", "expectedCubeVertConnectPath",
SpecMeshTest("CubeVertConnectPath", "testCubeVertConnectPath", "expectedCubeVertConnectPath",
[OperatorSpecEditMode("vert_connect_path", {}, "VERT", {0, 5})]),
]

10
tests/python/physics_cloth.py
View File

@ -24,25 +24,25 @@ import sys
import bpy
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
def main():
test = [
MeshTest("ClothSimple", "testClothPlane", "expectedClothPlane",
SpecMeshTest("ClothSimple", "testClothPlane", "expectedClothPlane",
[ModifierSpec('Cloth', 'CLOTH', {'settings': {'quality': 5}}, 15)], threshold=1e-3),
# Not reproducible
# MeshTest("ClothPressure", "testObjClothPressure", "expObjClothPressure",
# SpecMeshTest("ClothPressure", "testObjClothPressure", "expObjClothPressure",
# [ModifierSpec('Cloth2', 'CLOTH', {'settings': {'use_pressure': True,
# 'uniform_pressure_force': 1}}, 16)]),
# Not reproducible
# MeshTest("ClothSelfCollision", "testClothCollision", "expClothCollision",
# SpecMeshTest("ClothSelfCollision", "testClothCollision", "expClothCollision",
# [ModifierSpec('Cloth', 'CLOTH', {'collision_settings': {'use_self_collision': True}}, 67)]),
MeshTest("ClothSpring", "testTorusClothSpring", "expTorusClothSpring",
SpecMeshTest("ClothSpring", "testTorusClothSpring", "expTorusClothSpring",
[ModifierSpec('Cloth2', 'CLOTH', {'settings': {'use_internal_springs': True}}, 10)], threshold=1e-3),
]

4
tests/python/physics_dynamic_paint.py
View File

@ -24,13 +24,13 @@ import sys
import bpy
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
def main():
test = [
MeshTest("DynamicPaintSimple", "testObjDynamicPaintPlane", "expObjDynamicPaintPlane",
SpecMeshTest("DynamicPaintSimple", "testObjDynamicPaintPlane", "expObjDynamicPaintPlane",
[ModifierSpec('dynamic_paint', 'DYNAMIC_PAINT',
{'ui_type': 'CANVAS',
'canvas_settings': {'canvas_surfaces': {'surface_type': 'WAVE', 'frame_end': 15}}},

4
tests/python/physics_ocean.py
View File

@ -24,13 +24,13 @@ import sys
import bpy
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
def main():
test = [
# World coordinates of test and expected object should be same.
MeshTest("PlaneOcean", "testObjPlaneOcean", "expObjPlaneOcean",
SpecMeshTest("PlaneOcean", "testObjPlaneOcean", "expObjPlaneOcean",
[ModifierSpec('Ocean', 'OCEAN', {})]),
]
ocean_test = RunTest(test)

4
tests/python/physics_particle_instance.py
View File

@ -24,13 +24,13 @@ import sys
import bpy
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
def main():
test = [
MeshTest("ParticleInstanceSimple", "testParticleInstance", "expectedParticleInstance",
SpecMeshTest("ParticleInstanceSimple", "testParticleInstance", "expectedParticleInstance",
[ModifierSpec('ParticleInstance', 'PARTICLE_INSTANCE', {'object': bpy.data.objects['Cube']})],
threshold=1e-3),

5
tests/python/physics_particle_system.py
View File

@ -20,16 +20,15 @@
import os
import sys
import bpy
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import RunTest, ParticleSystemSpec, MeshTest
from modules.mesh_test import RunTest, ParticleSystemSpec, SpecMeshTest
def main():
test = [
MeshTest("ParticleSystemTest", "testParticleSystem", "expParticleSystem",
SpecMeshTest("ParticleSystemTest", "testParticleSystem", "expParticleSystem",
[ParticleSystemSpec('Particles', 'PARTICLE_SYSTEM', {'render_type': "OBJECT",
'instance_object': bpy.data.objects['Cube']}, 20)], threshold=1e-3),

4
tests/python/physics_softbody.py
View File

@ -24,13 +24,13 @@ import sys
import bpy
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import RunTest, ModifierSpec, MeshTest
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
def main():
test = [
MeshTest("SoftBodySimple", "testSoftBody", "expectedSoftBody",
SpecMeshTest("SoftBodySimple", "testSoftBody", "expectedSoftBody",
[ModifierSpec('Softbody', 'SOFT_BODY',
{'settings': {'use_goal': False, 'bend': 8, 'pull': 0.8, 'push': 0.8}},
45)]),