tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity
tornavis/tests/python/modifiers.py

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

347 lines
20 KiB
Python
Raw Normal View History

File headers: SPDX License migration Use a shorter/simpler license convention, stops the header taking so much space. Follow the SPDX license specification: https://spdx.org/licenses - C/C++/objc/objc++ - Python - Shell Scripts - CMake, GNUmakefile While most of the source tree has been included - `./extern/` was left out. - `./intern/cycles` & `./intern/atomic` are also excluded because they use different header conventions. doc/license/SPDX-license-identifiers.txt has been added to list SPDX all used identifiers. See P2788 for the script that automated these edits. Reviewed By: brecht, mont29, sergey Ref D14069
2022-02-10 23:07:11 +01:00
# SPDX-License-Identifier: GPL-2.0-or-later
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
import math
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
import os
import sys
from random import shuffle, seed
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
import bpy
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
sys.path.append(os.path.dirname(os.path.realpath(__file__)))
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
2021-07-27 17:30:28 +02:00
from modules.mesh_test import RunTest, ModifierSpec, SpecMeshTest
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
seed(0)
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
def get_generate_modifiers_list(test_object_name, randomize=False):
"""
Construct a list of 'Generate' modifiers with default parameters.
:param test_object_name: str - name of test object. Some modifiers like boolean need an extra parameter beside
the default one. E.g. boolean needs object, mask needs vertex group etc...
The extra parameter name will be <test_object_name>_<modifier_type>
:param randomize: bool - if True shuffle the list of modifiers.
:return: list of 'Generate' modifiers with default parameters.
"""
boolean_test_object = bpy.data.objects[test_object_name + "_boolean"]
generate_modifiers = [
ModifierSpec('array', 'ARRAY', {}),
Mix modifiers test after commit to bevel modifier defaults {rB6b5e4ad5899d} neglected to update the modifier tests to reflect the fact that the default limit method is no longer "NONE".
2021-01-13 06:54:46 +01:00
ModifierSpec('bevel', 'BEVEL', {'width': 0.1, 'limit_method': 'NONE'}),
Re-enable modifer and bmesh_boolean tests. These were disabled in the newboolean merge commit. This commit renables them, using the original 'FAST' solver so that the result objects need not change. A TODO to add more tests using the 'EXACT' solver, though most functionality there is now covered by unit gtests.
2020-08-30 14:31:40 +02:00
ModifierSpec('boolean', 'BOOLEAN', {'object': boolean_test_object, 'solver': 'FAST'}),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
ModifierSpec('build', 'BUILD', {'frame_start': 1, 'frame_duration': 1}, 2),
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
ModifierSpec('decimate', 'DECIMATE', {}),
ModifierSpec('edge split', 'EDGE_SPLIT', {}),
# mask can effectively delete the mesh since the vertex group need to be updated after each
# applied modifier. Needs to be tested separately.
# ModifierSpec('mask', 'MASK', {'vertex_group': mask_vertex_group}, False),
ModifierSpec('mirror', 'MIRROR', {}),
ModifierSpec('multires', 'MULTIRES', {}),
# remesh can also generate an empty mesh. Skip.
# ModifierSpec('remesh', 'REMESH', {}),
# ModifierSpec('screw', 'SCREW', {}), # screw can make the test very slow. Skipping for now.
ModifierSpec('solidify', 'SOLIDIFY', {}),
Make mesh modifier tests not fail with optimized OSD lib When building opensubdiv with more aggressive optimization flags (-march=native -02) the output meshes would differ a bit from what we expected in the current automated modifier test file. The differences in vertex position is within the 1e-6 range, which I would call is acceptable for floats. In addition to this, all the modifier test that tests the subdiv modifier in particular pass without any modifications. I've updated two tests in the modifier test file and script to make it pass (listed below). Updated following test categories: 1. Decimate test Here there was a subdiv modifier applied before the actual decimate modifier. Because the decimate modifier creates a queue of potential vertices it can remove, it is highly sensitive to even small changes as it drastically changes in which order the vertices are decimated in. As this test should only be testing the decimate modifier, I pre-applied the subdiv modifier in the test file. 2. RandomCubeModifier For these tests I removed the subdiv modifier as well. As with decimate, a small change in vertex position here can lead to quite different results. Reviewed By: Sergey, Bastien Differential Revision: http://developer.blender.org/D9004
2021-01-04 19:21:07 +01:00
# Opensubdiv results might differ slightly when compiled with different optimization flags.
#ModifierSpec('subsurf', 'SUBSURF', {}),
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
ModifierSpec('triangulate', 'TRIANGULATE', {}),
ModifierSpec('wireframe', 'WIREFRAME', {})
]
if randomize:
shuffle(generate_modifiers)
return generate_modifiers
def main():
mask_first_list = get_generate_modifiers_list("testCubeMaskFirst", randomize=True)
mask_vertex_group = "testCubeMaskFirst" + "_mask"
mask_first_list.insert(0, ModifierSpec('mask', 'MASK', {'vertex_group': mask_vertex_group}))
tests = [
###############################
# List of 'Generate' modifiers on a cube
###############################
# 0
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
2021-07-27 17:30:28 +02:00
# SpecMeshTest("testCube", "expectedCube", get_generate_modifiers_list("testCube")),
SpecMeshTest("CubeRandom", "testCubeRandom", "expectedCubeRandom",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
get_generate_modifiers_list("testCubeRandom", randomize=True)),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CubeMaskFirst", "testCubeMaskFirst", "expectedCubeMaskFirst", mask_first_list),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CollapseDecimate", "testCollapseDecimate", "expectedCollapseDecimate",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('decimate', 'DECIMATE',
{'decimate_type': 'COLLAPSE', 'ratio': 0.25, 'use_collapse_triangulate': True})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("PlanarDecimate", "testPlanarDecimate", "expectedPlanarDecimate",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('decimate', 'DECIMATE',
{'decimate_type': 'DISSOLVE', 'angle_limit': math.radians(30)})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("UnsubdivideDecimate", "testUnsubdivideDecimate", "expectedUnsubdivideDecimate",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('decimate', 'DECIMATE', {'decimate_type': 'UNSUBDIV', 'iterations': 2})]),
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
# 5
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("RadialBisectMirror", "testRadialBisectMirror", "expectedRadialBisectMirror",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('mirror1', 'MIRROR', {'use_bisect_axis': (True, False, False)}),
ModifierSpec('mirror2', 'MIRROR', {'use_bisect_axis': (True, False, False),
'mirror_object': bpy.data.objects[
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
"testRadialBisectMirrorHelper"]}),
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
ModifierSpec('mirror3', 'MIRROR',
{'use_axis': (False, True, False), 'use_bisect_axis': (False, True, False),
'use_bisect_flip_axis': (False, True, False),
'mirror_object': bpy.data.objects["testRadialBisectMirrorHelper"]})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("T58411Mirror", "regressT58411Mirror", "expectedT58411Mirror",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('mirror', 'MIRROR', {}),
ModifierSpec('bevel', 'BEVEL', {'segments': 2, 'limit_method': 'WEIGHT'}),
ModifierSpec('subd', 'SUBSURF', {'levels': 1})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("BasicScrew", "testBasicScrew", "expectedBasicScrew",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[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})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("ObjectScrew", "testObjectScrew", "expectedObjectScrew",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('mirror', 'MIRROR', {'mirror_object': bpy.data.objects["testObjectScrewHelper2"]}),
ModifierSpec("screw", 'SCREW',
{"angle": math.radians(600), 'steps': 32, 'iterations': 1,
'use_object_screw_offset': True,
'use_normal_calculate': True, 'object': bpy.data.objects["testObjectScrewHelper1"]})]),
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
# 9
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("MergedScrewWeld", "testMergedScrewWeld", "expectedMergedScrewWeld",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[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})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("T72380Weld", "regressT72380Weld", "expectedT72380Weld",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('vedit', 'VERTEX_WEIGHT_EDIT',
{'vertex_group': 'Group', 'use_remove': True, 'remove_threshold': 1}),
ModifierSpec("weld", 'WELD', {"merge_threshold": 0.2, "vertex_group": "Group"})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("T72792Weld", "regressT72792Weld", "expectedT72792Weld",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('array', 'ARRAY', {'fit_type': 'FIXED_COUNT', 'count': 2}),
ModifierSpec("weld", 'WELD', {"merge_threshold": 0.1, "vertex_group": "Group"})]),
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
############################################
# One 'Generate' modifier on primitive meshes
#############################################
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
# 12
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CubeArray", "testCubeArray", "expectedCubeArray",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('array', 'ARRAY', {})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CapArray", "testCapArray", "expectedCapArray",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('array', 'ARRAY',
{'fit_type': 'FIT_LENGTH', 'fit_length': 2.0,
'start_cap': bpy.data.objects["testCapStart"],
'end_cap': bpy.data.objects["testCapEnd"]})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveArray", "testCurveArray", "expectedCurveArray",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[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)})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("RadialArray", "testRadialArray", "expectedRadialArray",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[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"]})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CylinderBuild", "testCylinderBuild", "expectedCylinderBuild",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('build', 'BUILD', {'frame_start': 1, 'frame_duration': 1}, 2)]),
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
# 17
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("ConeDecimate", "testConeDecimate", "expectedConeDecimate",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('decimate', 'DECIMATE', {'ratio': 0.5})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('edge split', 'EDGE_SPLIT', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("SphereMirror", "testSphereMirror", "expectedSphereMirror",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('mirror', 'MIRROR', {})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("LocalMirror", "testLocalMirror", "expectedLocalMirror",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('mirror', 'MIRROR', {'use_clip': True})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("ObjectOffsetMirror", "testObjectOffsetMirror", "expectedObjectOffsetMirror",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('mirror', 'MIRROR',
{'mirror_object': bpy.data.objects["testObjectOffsetMirrorHelper"]})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CylinderMask", "testCylinderMask", "expectedCylinderMask",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('mask', 'MASK', {'vertex_group': "mask_vertex_group"})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("ConeMultiRes", "testConeMultiRes", "expectedConeMultiRes",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('multires', 'MULTIRES', {})]),
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
# 24
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CubeScrew", "testCubeScrew", "expectedCubeScrew",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('screw', 'SCREW', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CubeSolidify", "testCubeSolidify", "expectedCubeSolidify",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('solidify', 'SOLIDIFY', {})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("ComplexSolidify", "testComplexSolidify", "expectedComplexSolidify",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('solidify', 'SOLIDIFY', {'solidify_mode': 'NON_MANIFOLD', 'thickness': 0.05, 'offset': 0,
'nonmanifold_thickness_mode': 'CONSTRAINTS'})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("T63063Solidify", "regressT63063Solidify", "expectedT63063Solidify",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('solid', 'SOLIDIFY', {'thickness': 0.1, 'offset': 0.7})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("T61979Solidify", "regressT61979Solidify", "expectedT61979Solidify",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('solid', 'SOLIDIFY',
{'thickness': -0.25, 'use_even_offset': True, 'use_quality_normals': True})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("MonkeySubsurf", "testMonkeySubsurf", "expectedMonkeySubsurf",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('subsurf', 'SUBSURF', {})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CatmullClarkSubdivisionSurface", "testCatmullClarkSubdivisionSurface",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
"expectedCatmullClarkSubdivisionSurface",
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("SimpleSubdivisionSurface", "testSimpleSubdivisionSurface", "expectedSimpleSubdivisionSurface",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2, 'subdivision_type': 'SIMPLE'})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("Crease2dSubdivisionSurface", "testCrease2dSubdivisionSurface", "expectedCrease2dSubdivisionSurface",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("Crease3dSubdivisionSurface", "testCrease3dSubdivisionSurface", "expectedCrease3dSubdivisionSurface",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec("subdivision", 'SUBSURF', {"levels": 2})]),
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
# 34
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("SphereTriangulate", "testSphereTriangulate", "expectedSphereTriangulate",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('triangulate', 'TRIANGULATE', {})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("MonkeyWireframe", "testMonkeyWireframe", "expectedMonkeyWireframe",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('wireframe', 'WIREFRAME', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
# Duplicate the object, test object and expected object have same world coordinates.
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("Skin", "testObjPlaneSkin", "expObjPlaneSkin",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('skin', 'SKIN', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("MergedWeld", "testMergedWeld", "expectedMergedWeld",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec("weld", 'WELD', {"merge_threshold": 0.021})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("MergedAllWeld", "testMergedAllWeld", "expectedMergedAllWeld",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec("weld", 'WELD', {"merge_threshold": 1.8})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("MergedNoneWeld", "testMergedNoneWeld", "expectedMergedNoneWeld",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec("weld", 'WELD', {"merge_threshold": 0.019})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
#############################################
# One 'Deform' modifier on primitive meshes
#############################################
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
# 39
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("MonkeyArmature", "testMonkeyArmature", "expectedMonkeyArmature",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('armature', 'ARMATURE',
{'object': bpy.data.objects['testArmature'], 'use_vertex_groups': True})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("TorusCast", "testTorusCast", "expectedTorusCast",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('cast', 'CAST', {'factor': 2.64})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CubeCurve", "testCubeCurve", "expectedCubeCurve",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('curve', 'CURVE', {'object': bpy.data.objects['testBezierCurve']})]),
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("MonkeyDisplace", "testMonkeyDisplace", "expectedMonkeyDisplace",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('displace', "DISPLACE", {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
# Hook modifier requires moving the hook object to get a mesh change
# so can't test it with the current framework
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
2021-07-27 17:30:28 +02:00
# SpecMeshTest("MonkeyHook", "testMonkeyHook", "expectedMonkeyHook",
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
# [ModifierSpec('hook', 'HOOK', {'object': bpy.data.objects["EmptyHook"], 'vertex_group':
# "HookVertexGroup"})]),
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
Applying patch D6576, more tests for modifiers. Patch from Jesse Y, reviewed by Habib Gahbiche. Addes tests for modifiers: array, decimiate, mirror, screw, solidify, subd, and weld.
2020-01-29 13:11:42 +01:00
# 43
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
# ModifierSpec('laplacian_deform', 'LAPLACIANDEFORM', {}) Laplacian requires a more complex mesh
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CubeLattice", "testCubeLattice", "expectedCubeLattice",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('lattice', 'LATTICE', {'object': bpy.data.objects["testLattice"]})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("PlaneShrinkWrap", "testPlaneShrinkWrap", "expectedPlaneShrinkWrap",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('shrinkwrap', 'SHRINKWRAP',
{'target': bpy.data.objects["testCubeWrap"], 'offset': 0.5})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CylinderSimpleDeform", "testCylinderSimpleDeform", "expectedCylinderSimpleDeform",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('simple_deform', 'SIMPLE_DEFORM', {'angle': math.radians(180), 'deform_axis': 'Z'})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("PlaneSmooth", "testPlaneSmooth", "expectedPlaneSmooth",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('smooth', 'SMOOTH', {'iterations': 11})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
# Smooth corrective requires a complex mesh.
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("BalloonLaplacianSmooth", "testBalloonLaplacianSmooth", "expectedBalloonLaplacianSmooth",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('laplaciansmooth', 'LAPLACIANSMOOTH', {'lambda_factor': 12, 'lambda_border': 12})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
# Gets updated often
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("WavePlane", "testObjPlaneWave", "expObjPlaneWave",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('wave', 'WAVE', {})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
#############################################
# CURVES Generate Modifiers
#############################################
# Caution: Make sure test object has no modifier in "added" state, the test may fail.
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("BezCurveArray", "testObjBezierCurveArray", "expObjBezierCurveArray",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('array', 'ARRAY', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveBevel", "testObjBezierCurveBevel", "expObjBezierCurveBevel",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('bevel', 'BEVEL', {'limit_method': 'NONE'})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveBuild", "testObjBezierCurveBuild", "expObjBezierCurveBuild",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('build', 'BUILD', {'frame_start': 1, 'frame_duration': 1}, 2)]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveDecimate", "testObjBezierCurveDecimate", "expObjBezierCurveDecimate",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('decimate', 'DECIMATE', {'ratio': 0.5})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveEdgeSplit", "testObjBezierCurveEdgeSplit", "expObjBezierCurveEdgeSplit",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('edgeSplit', 'EDGE_SPLIT', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveMirror", "testObjBezierCurveMirror", "expObjBezierCurveMirror",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('mirror', 'MIRROR', {'use_axis': (True, True, False)})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveScrew", "testObjBezierCurveScrew", "expObjBezierCurveScrew",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('screw', 'SCREW', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveSolidify", "testObjBezierCurveSolidify", "expObjBezierCurveSolidify",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('solidify', 'SOLIDIFY', {'thickness': 1})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveSubSurf", "testObjBezierCurveSubSurf", "expObjBezierCurveSubSurf",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('subSurf', 'SUBSURF', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveTriangulate", "testObjBezierCurveTriangulate", "expObjBezierCurveTriangulate",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('triangulate', 'TRIANGULATE', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
# Test 60
# Caution Weld: if the distance is increased beyond a limit, the object disappears
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveWeld", "testObjBezierCurveWeld", "expObjBezierCurveWeld",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('weld', 'WELD', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveWeld2", "testObjBezierCurveWeld2", "expObjBezierCurveWeld2",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('weld', 'WELD', {})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
#############################################
# Curves Deform Modifiers
#############################################
# Test 62
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveCast", "testObjBezierCurveCast", "expObjBezierCurveCast",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('Cast', 'CAST', {'cast_type': 'CYLINDER', 'factor': 10})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveShrinkWrap", "testObjBezierCurveShrinkWrap", "expObjBezierCurveShrinkWrap",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('ShrinkWrap', 'SHRINKWRAP',
{'target': bpy.data.objects['testShrinkWrapHelperSuzanne']})]),
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveSimpleDeform", "testObjBezierCurveSimpleDeform", "expObjBezierCurveSimpleDeform",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('simple_deform', 'SIMPLE_DEFORM', {'angle': math.radians(90)})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveSmooth", "testObjBezierCurveSmooth", "expObjBezierCurveSmooth",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('smooth', 'SMOOTH', {'factor': 10})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveWave", "testObjBezierCurveWave", "expObjBezierCurveWave",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('curve_wave', 'WAVE', {'time_offset': -1.5})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
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
2021-07-27 17:30:28 +02:00
SpecMeshTest("CurveCurve", "testObjBezierCurveCurve", "expObjBezierCurveCurve",
Cleanup: run autopep8 on tests/
2022-04-19 07:25:55 +02:00
[ModifierSpec('curve_Curve', 'CURVE', {'object': bpy.data.objects['NurbsCurve']})]),
Apply patch D6620, Adde tests for Deform modifiers. This test is authored by Himanshi Kalra (calra). It requires a new modifers.blend in the svn tests.
2020-02-29 20:07:14 +01:00
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
]
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
modifiers_test = RunTest(tests)
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
command = list(sys.argv)
for i, cmd in enumerate(command):
if cmd == "--run-all-tests":
modifiers_test.apply_modifiers = True
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
modifiers_test.do_compare = True
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
modifiers_test.run_all_tests()
break
elif cmd == "--run-test":
modifiers_test.apply_modifiers = False
Updated and extended Regression Testing frameworks (Gsoc 2020) This revision contains the following changes- - Updated the existing testing framework for Modifiers for Regression Testing. - Tests for Physics modifiers and remaining Generate and Deform modifiers are added. - The existing `ModifierSpec` is updated with backward compatibility to support Physics Modifiers. - Now there is support for frame number and giving nested parameters for attributes. - Some Deform modifiers required Object Operators, e.g. "Bind" in Mesh Deform, so a new class was added to support that functionality. - A separate class for holding Particles System, they are tested by converting all the particles to mesh and joining it to the mesh they were added. - Updated the format to add tests for Bevel, Boolean and Operators as well. Reviewed By: zazizizou, mont29, campbellbarton Differential Revision: https://developer.blender.org/D8507
2020-12-17 16:14:55 +01:00
modifiers_test.do_compare = False
name = command[i + 1]
modifiers_test.run_test(name)
Accepting patch D5357: Modifiers and operators automated testing. Patch from Habib Gahbiche (zazizizou) moves the "run operator and compare mesh to a golden" paradigm used in bevel and boolean tests into a general framework that separates the test specs from the blend files. Then adds some other operator and modifier tests using the new framework. Diff D5357.id20724.diff was applied. New .blend files, modifiers.blend and operators.blend are needed in the tests/modeling svn directory; those were separately committed.
2020-01-13 13:11:45 +01:00
break
if __name__ == "__main__":
Tests: fix some tests passing even if there are Python errors Blender was not configured to exit with non-zero return code on Python errors. A bunch of tests worked around this but not all. This removes the need for such workarounds.
2020-04-27 17:43:47 +02:00
main()