blender
/
blender
135
403
Fork 586
Code Issues 6.2k Pull Requests 757 Projects 19 Wiki Activity

Cleanup: run autopep8 on tests/

This commit is contained in:
Campbell Barton 2022-04-19 15:25:55 +10:00
parent 58d86527ae
commit 3035235def
24 changed files with 817 additions and 623 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
tests/performance/api/config.py
View File

@ -68,11 +68,14 @@ class TestQueue:
def rows(self, use_revision_columns: bool) -> List:
# Generate rows of entries for printing and running.
entries = sorted(self.entries, key=lambda entry:
(entry.revision,
entry.device_id,
entry.category,
entry.test))
entries = sorted(
self.entries,
key=lambda entry: (
entry.revision,
entry.device_id,
entry.category,
entry.test,
))
if not use_revision_columns:
# One entry per row.

11
tests/performance/api/environment.py
View File

@ -32,7 +32,7 @@ class TestEnvironment:
self._init_default_blender_executable()
self.set_default_blender_executable()
def get_machine(self, need_gpus: bool=True) -> None:
def get_machine(self, need_gpus: bool = True) -> None:
if not self.machine or (need_gpus and not self.machine.has_gpus):
self.machine = TestMachine(self, need_gpus)
@ -61,7 +61,8 @@ class TestEnvironment:
if not self.blender_dir.exists():
print(f'Init git worktree in {self.blender_dir}')
self.call([self.git_executable, 'worktree', 'add', '--detach', self.blender_dir, 'HEAD'], self.blender_git_dir)
self.call([self.git_executable, 'worktree', 'add', '--detach',
self.blender_dir, 'HEAD'], self.blender_git_dir)
else:
print(f'Exists {self.blender_dir}')
@ -165,7 +166,7 @@ class TestEnvironment:
def unset_log_file(self) -> None:
self.log_file = None
def call(self, args: List[str], cwd: pathlib.Path, silent: bool=False, environment: Dict={}) -> List[str]:
def call(self, args: List[str], cwd: pathlib.Path, silent: bool = False, environment: Dict = {}) -> List[str]:
# Execute command with arguments in specified directory,
# and return combined stdout and stderr output.
@ -220,7 +221,7 @@ class TestEnvironment:
def run_in_blender(self,
function: Callable[[Dict], Dict],
args: Dict,
blender_args: List=[],
blender_args: List = [],
foreground=False) -> Dict:
# Run function in a Blender instance. Arguments and return values are
# passed as a Python object that must be serializable with pickle.
@ -274,7 +275,7 @@ class TestEnvironment:
return names
def get_configs(self, name: str=None, names_only: bool=False) -> List:
def get_configs(self, name: str = None, names_only: bool = False) -> List:
# Get list of configurations in the benchmarks directory.
configs = []

2
tests/performance/api/test.py
View File

@ -32,7 +32,7 @@ class Test:
class TestCollection:
def __init__(self, env, names_filter: List=['*'], categories_filter: List=['*']):
def __init__(self, env, names_filter: List = ['*'], categories_filter: List = ['*']):
import importlib
import pkgutil
import tests

308
tests/python/bevel_operator.py
View File

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

4
tests/python/bl_animation_fcurves.py
View File

@ -72,7 +72,7 @@ class EulerFilterTest(AbstractAnimationTest, unittest.TestCase):
self.activate_object('Three-Channel-Jump')
fcu_rot = self.active_object_rotation_channels()
## Check some pre-filter values to make sure the file is as we expect.
# # Check some pre-filter values to make sure the file is as we expect.
# Keyframes before the "jump". These shouldn't be touched by the filter.
self.assertEqualAngle(-87.5742, fcu_rot[0], 22)
self.assertEqualAngle(69.1701, fcu_rot[1], 22)
@ -99,7 +99,7 @@ class EulerFilterTest(AbstractAnimationTest, unittest.TestCase):
self.activate_object('One-Channel-Jumps')
fcu_rot = self.active_object_rotation_channels()
## Check some pre-filter values to make sure the file is as we expect.
# # Check some pre-filter values to make sure the file is as we expect.
# Keyframes before the "jump". These shouldn't be touched by the filter.
self.assertEqualAngle(360, fcu_rot[0], 15)
self.assertEqualAngle(396, fcu_rot[1], 21) # X and Y are keyed on different frames.

8
tests/python/bl_blendfile_liblink.py
View File

@ -204,7 +204,12 @@ class TestBlendLibAppendBasic(TestBlendLibLinkHelper):
bpy.ops.wm.append(directory=link_dir, filename="LibMesh",
instance_object_data=False, set_fake=False, use_recursive=False, do_reuse_local_id=False)
print(bpy.data.materials[:], bpy.data.materials[0].library, bpy.data.materials[0].users, bpy.data.materials[0].use_fake_user)
print(
bpy.data.materials[:],
bpy.data.materials[0].library,
bpy.data.materials[0].users,
bpy.data.materials[0].use_fake_user,
)
assert(len(bpy.data.materials) == 1)
assert(bpy.data.materials[0].library is not None)
@ -400,7 +405,6 @@ class TestBlendLibLibraryReload(TestBlendLibLinkHelper):
assert(orig_data == reload_data)
class TestBlendLibLibraryRelocate(TestBlendLibLinkHelper):
def __init__(self, args):

10
tests/python/bl_blendfile_library_overrides.py
View File

@ -59,7 +59,7 @@ class TestLibraryOverrides(TestHelper, unittest.TestCase):
self.assertIsNone(local_id.data.override_library)
assert(len(local_id.override_library.properties) == 0)
##### Generate an override property & operation automatically by editing the local override data.
# #### Generate an override property & operation automatically by editing the local override data.
local_id.location.y = 1.0
local_id.override_library.operations_update()
assert(len(local_id.override_library.properties) == 1)
@ -71,12 +71,12 @@ class TestLibraryOverrides(TestHelper, unittest.TestCase):
# Setting location.y overrode all elements in the location array. -1 is a wildcard.
assert(override_operation.subitem_local_index == -1)
##### Reset the override to its linked reference data.
# #### Reset the override to its linked reference data.
local_id.override_library.reset()
assert(len(local_id.override_library.properties) == 0)
assert(local_id.location == local_id.override_library.reference.location)
##### Generate an override property & operation manually using the API.
# #### Generate an override property & operation manually using the API.
override_property = local_id.override_library.properties.add(rna_path="location")
override_property.operations.add(operation='REPLACE')
@ -95,11 +95,11 @@ class TestLibraryOverrides(TestHelper, unittest.TestCase):
assert(len(local_id.override_library.properties) == 0)
##### Delete the override.
# #### Delete the override.
local_id_name = local_id.name
assert(bpy.data.objects.get((local_id_name, None), None) == local_id)
local_id.override_library.destroy()
assert(bpy.data.objects.get((local_id_name, None), None) == None)
assert(bpy.data.objects.get((local_id_name, None), None) is None)
def test_link_permissive(self):
"""

3
tests/python/bl_keymap_validate.py
View File

@ -72,6 +72,7 @@ ALLOW_DUPLICATES = {
# -----------------------------------------------------------------------------
# Generic Utilities
@contextlib.contextmanager
def temp_fn_argument_extractor(
mod: types.ModuleType,
@ -200,7 +201,7 @@ def keyconfig_config_as_filename_component(values: Sequence[Tuple[str, Any]]) ->
return "(" + quote(
".".join([
"-".join((str(key), str(val)))
for key, val in values
for key, val in values
]),
# Needed so forward slashes aren't included in the resulting name.
safe="",

2
tests/python/bl_pyapi_idprop.py
View File

@ -12,6 +12,7 @@ try:
except ImportError:
np = None
class TestHelper:
@property
@ -179,7 +180,6 @@ class TestIdPropertyGroupView(TestHelper, unittest.TestCase):
self.assertEqual(len(group), len(text))
self.assertEqual(list(iter(group)), text)
def test_contains(self):
# Check `idprop.types.IDPropertyGroupView{Keys/Values/Items}.__contains__`
text = ["A", "B", "C"]

12
tests/python/bl_rigging_symmetrize.py
View File

@ -98,7 +98,7 @@ def check_constraints(self, input_arm, expected_arm, bone, exp_bone):
# Make sure that the constraint exists
self.assertTrue(const_name in bone.constraints,
"Bone %s is expected to contain constraint %s, but it does not." % (
bone.name, const_name))
bone.name, const_name))
constraint = bone.constraints[const_name]
const_variables = constraint.bl_rna.properties.keys()
@ -119,7 +119,7 @@ def check_constraints(self, input_arm, expected_arm, bone, exp_bone):
if isinstance(value, str):
self.assertEqual(value, exp_value,
"Missmatching constraint value in pose.bones[%s].constraints[%s].%s" % (
bone.name, const_name, var))
bone.name, const_name, var))
elif hasattr(value, "name"):
# Some constraints targets the armature itself, so the armature name should missmatch.
if value.name == input_arm.name and exp_value.name == expected_arm.name:
@ -127,16 +127,16 @@ def check_constraints(self, input_arm, expected_arm, bone, exp_bone):
self.assertEqual(value.name, exp_value.name,
"Missmatching constraint value in pose.bones[%s].constraints[%s].%s" % (
bone.name, const_name, var))
bone.name, const_name, var))
elif isinstance(value, bool):
self.assertEqual(value, exp_value,
"Missmatching constraint boolean in pose.bones[%s].constraints[%s].%s" % (
bone.name, const_name, var))
"Missmatching constraint boolean in pose.bones[%s].constraints[%s].%s" % (
bone.name, const_name, var))
else:
self.assertAlmostEqual(value, exp_value,
"Missmatching constraint value in pose.bones[%s].constraints[%s].%s" % (
bone.name, const_name, var))
bone.name, const_name, var))
class AbstractAnimationTest:

3
tests/python/bl_usd_import_test.py
View File

@ -10,6 +10,7 @@ import bpy
args = None
class AbstractUSDTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
@ -22,6 +23,7 @@ class AbstractUSDTest(unittest.TestCase):
# Make sure we always start with a known-empty file.
bpy.ops.wm.open_mainfile(filepath=str(self.testdir / "empty.blend"))
class USDImportTest(AbstractUSDTest):
def test_import_prim_hierarchy(self):
@ -42,6 +44,7 @@ class USDImportTest(AbstractUSDTest):
self.assertEqual(objects['World'], objects['Empty'].parent)
self.assertEqual(objects['Empty'], objects['Plane_002'].parent)
def main():
global args
import argparse

34
tests/python/boolean_operator.py
View File

@ -20,31 +20,31 @@ def main():
tests = [
SpecMeshTest('Cubecube_intersect_union', 'Cubecube', 'Cubecube_result_1',
[OperatorSpecEditMode('intersect_boolean',
{'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
[OperatorSpecEditMode('intersect_boolean',
{'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
SpecMeshTest('Cubecube_intersect_intersect', 'Cubecube', 'Cubecube_result_2',
[OperatorSpecEditMode('intersect_boolean', {'operation': 'INTERSECT', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
[OperatorSpecEditMode('intersect_boolean', {'operation': 'INTERSECT', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
SpecMeshTest('Cubecube_intersect_difference', 'Cubecube', 'Cubecube_result_3',
[OperatorSpecEditMode('intersect_boolean', {'operation': 'DIFFERENCE', 'solver': 'FAST'}, 'FACE',
{0, 1, 2, 3, 4, 5}, )]),
[OperatorSpecEditMode('intersect_boolean', {'operation': 'DIFFERENCE', 'solver': 'FAST'}, 'FACE',
{0, 1, 2, 3, 4, 5}, )]),
SpecMeshTest('Cubecube_intersect_cut', 'Cubecube', 'Cubecube_result_4', [OperatorSpecEditMode('intersect',
{'separate_mode': 'CUT', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
{'separate_mode': 'CUT', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
SpecMeshTest('Cubecube_intersect_all', 'Cubecube', 'Cubecube_result_5',
[OperatorSpecEditMode('intersect',
{'separate_mode': 'ALL', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
[OperatorSpecEditMode('intersect',
{'separate_mode': 'ALL', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
SpecMeshTest('Cubecube_intersect_none', 'Cubecube', 'Cubecube_result_6',
[OperatorSpecEditMode('intersect',
{'separate_mode': 'NONE', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
[OperatorSpecEditMode('intersect',
{'separate_mode': 'NONE', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
SpecMeshTest('Cubecube_intersect_select_none', 'Cubecube',
'Cubecube_result_7',
[OperatorSpecEditMode('intersect',
{'mode': 'SELECT', 'separate_mode': 'NONE', 'solver': 'FAST'}, 'FACE',
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, )]),
'Cubecube_result_7',
[OperatorSpecEditMode('intersect',
{'mode': 'SELECT', 'separate_mode': 'NONE', 'solver': 'FAST'}, 'FACE',
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, )]),
SpecMeshTest('Cubecone_intersect_union', 'Cubecone', 'Cubecone_result_1',
[OperatorSpecEditMode('intersect_boolean',
{'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {6, 7, 8, 9, 10}, )]),
[OperatorSpecEditMode('intersect_boolean',
{'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {6, 7, 8, 9, 10}, )]),
SpecMeshTest('Cubecones_intersect_union', 'Cubecones', 'Cubecones_result_1',
[OperatorSpecEditMode('intersect_boolean', {'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
[OperatorSpecEditMode('intersect_boolean', {'operation': 'UNION', 'solver': 'FAST'}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
]

64
tests/python/curve_to_mesh.py
View File

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

64
tests/python/deform_modifiers.py
View File

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

212
tests/python/modifiers.py
View File

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

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

@ -87,6 +87,7 @@ class OperatorSpecEditMode:
"""
Holds one operator and its parameters.
"""
def __init__(
self,
operator_name: str,
@ -206,7 +207,7 @@ class MeshTest(ABC):
self.expected_object = self.evaluated_object
self.expected_object.name = self.exp_object_name
x, y, z = self.test_object.location
self.expected_object.location = (x, y+10, z)
self.expected_object.location = (x, y + 10, z)
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
def create_evaluated_object(self):
@ -261,7 +262,6 @@ class MeshTest(ABC):
if not inside_loop_flag:
success = False
if success:
self.print_passed_test_result(result)
# Clean up.
@ -320,7 +320,7 @@ class MeshTest(ABC):
bm = bmesh.from_edit_mesh(mesh)
#bpy.ops.object.mode_set(mode='OBJECT')
# bpy.ops.object.mode_set(mode='OBJECT')
bpy.context.tool_settings.mesh_select_mode = (select_mode == 'VERT',
select_mode == 'EDGE',

2
tests/python/modules/test_utils.py
View File

@ -43,7 +43,7 @@ class AbstractBlenderRunnerTest(unittest.TestCase):
blender: pathlib.Path = None
testdir: pathlib.Path = None
def run_blender(self, filepath: str, python_script: str, timeout: int=300) -> str:
def run_blender(self, filepath: str, python_script: str, timeout: int = 300) -> str:
"""Runs Blender by opening a blendfile and executing a script.
Returns Blender's stdout + stderr combined into one string.

654
tests/python/operators.py
View File

@ -22,104 +22,154 @@ MONKEY_LOOP_EDGE = {131, 278, 299, 305, 307, 334, 337, 359, 384, 396, 399, 412,
def main():
tests = [
# bisect
SpecMeshTest("CubeBisect", "testCubeBisect", "expectedCubeBisect",
[OperatorSpecEditMode("bisect",
{"plane_co": (0, 0, 0), "plane_no": (0, 1, 1), "clear_inner": True,
"use_fill": True}, 'FACE', {0, 1, 2, 3, 4, 5}, )]),
SpecMeshTest(
"CubeBisect", "testCubeBisect", "expectedCubeBisect",
[OperatorSpecEditMode("bisect",
{"plane_co": (0, 0, 0), "plane_no": (0, 1, 1), "clear_inner": True,
"use_fill": True}, 'FACE', {0, 1, 2, 3, 4, 5}, )],
),
# blend from shape
SpecMeshTest("CubeBlendFromShape", "testCubeBlendFromShape", "expectedCubeBlendFromShape",
[OperatorSpecEditMode("blend_from_shape", {"shape": "Key 1"}, 'FACE', {0, 1, 2, 3, 4, 5})]),
SpecMeshTest(
"CubeBlendFromShape", "testCubeBlendFromShape", "expectedCubeBlendFromShape",
[OperatorSpecEditMode("blend_from_shape", {"shape": "Key 1"}, 'FACE', {0, 1, 2, 3, 4, 5})],
),
# bridge edge loops
SpecMeshTest("CubeBridgeEdgeLoop", "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop",
[OperatorSpecEditMode("bridge_edge_loops", {}, "FACE", {0, 1})]),
SpecMeshTest(
"CubeBridgeEdgeLoop", "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop",
[OperatorSpecEditMode("bridge_edge_loops", {}, "FACE", {0, 1})],
),
# decimate
SpecMeshTest("MonkeyDecimate", "testMonkeyDecimate", "expectedMonkeyDecimate",
[OperatorSpecEditMode("decimate",
{"ratio": 0.1}, "FACE", {i for i in range(500)})]),
SpecMeshTest(
"MonkeyDecimate", "testMonkeyDecimate", "expectedMonkeyDecimate",
[OperatorSpecEditMode("decimate",
{"ratio": 0.1}, "FACE", {i for i in range(500)})],
),
# delete
SpecMeshTest("CubeDeleteVertices", "testCubeDeleteVertices", "expectedCubeDeleteVertices",
[OperatorSpecEditMode("delete", {}, "VERT", {3})]),
SpecMeshTest("CubeDeleteFaces", "testCubeDeleteFaces", "expectedCubeDeleteFaces",
[OperatorSpecEditMode("delete", {}, "FACE", {0})]),
SpecMeshTest("CubeDeleteEdges", "testCubeDeleteEdges", "expectedCubeDeleteEdges",
[OperatorSpecEditMode("delete", {}, "EDGE", {0, 1, 2, 3})]),
SpecMeshTest(
"CubeDeleteVertices", "testCubeDeleteVertices", "expectedCubeDeleteVertices",
[OperatorSpecEditMode("delete", {}, "VERT", {3})],
),
SpecMeshTest(
"CubeDeleteFaces", "testCubeDeleteFaces", "expectedCubeDeleteFaces",
[OperatorSpecEditMode("delete", {}, "FACE", {0})],
),
SpecMeshTest(
"CubeDeleteEdges", "testCubeDeleteEdges", "expectedCubeDeleteEdges",
[OperatorSpecEditMode("delete", {}, "EDGE", {0, 1, 2, 3})],
),
# delete edge loop
SpecMeshTest("MonkeyDeleteEdgeLoopVertices", "testMokneyDeleteEdgeLoopVertices",
"expectedMonkeyDeleteEdgeLoopVertices",
[OperatorSpecEditMode("delete_edgeloop", {}, "VERT", MONKEY_LOOP_VERT)]),
SpecMeshTest(
"MonkeyDeleteEdgeLoopVertices", "testMokneyDeleteEdgeLoopVertices",
"expectedMonkeyDeleteEdgeLoopVertices",
[OperatorSpecEditMode("delete_edgeloop", {}, "VERT", MONKEY_LOOP_VERT)],
),
SpecMeshTest("MonkeyDeleteEdgeLoopEdges", "testMokneyDeleteEdgeLoopEdges",
"expectedMonkeyDeleteEdgeLoopEdges",
[OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE)]),
SpecMeshTest(
"MonkeyDeleteEdgeLoopEdges", "testMokneyDeleteEdgeLoopEdges",
"expectedMonkeyDeleteEdgeLoopEdges",
[OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE)],
),
# delete loose
SpecMeshTest("CubeDeleteLooseVertices", "testCubeDeleteLooseVertices",
"expectedCubeDeleteLooseVertices",
[OperatorSpecEditMode("delete_loose", {"use_verts": True, "use_edges": False, "use_faces": False},
"VERT",
{i for i in range(12)})]),
SpecMeshTest("CubeDeleteLooseEdges", "testCubeDeleteLooseEdges",
"expectedCubeDeleteLooseEdges",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": True, "use_faces": False},
"EDGE",
{i for i in range(14)})]),
SpecMeshTest("CubeDeleteLooseFaces", "testCubeDeleteLooseFaces",
"expectedCubeDeleteLooseFaces",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": False, "use_faces": True},
"FACE",
{i for i in range(7)})]),
SpecMeshTest(
"CubeDeleteLooseVertices", "testCubeDeleteLooseVertices",
"expectedCubeDeleteLooseVertices",
[OperatorSpecEditMode("delete_loose", {"use_verts": True, "use_edges": False, "use_faces": False},
"VERT",
{i for i in range(12)})],
),
SpecMeshTest(
"CubeDeleteLooseEdges", "testCubeDeleteLooseEdges",
"expectedCubeDeleteLooseEdges",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": True, "use_faces": False},
"EDGE",
{i for i in range(14)})],
),
SpecMeshTest(
"CubeDeleteLooseFaces", "testCubeDeleteLooseFaces",
"expectedCubeDeleteLooseFaces",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": False, "use_faces": True},
"FACE",
{i for i in range(7)})],
),
# dissolve degenerate
SpecMeshTest("CubeDissolveDegenerate", "testCubeDissolveDegenerate",
"expectedCubeDissolveDegenerate",
[OperatorSpecEditMode("dissolve_degenerate", {}, "VERT", {i for i in range(8)})]),
SpecMeshTest(
"CubeDissolveDegenerate", "testCubeDissolveDegenerate",
"expectedCubeDissolveDegenerate",
[OperatorSpecEditMode("dissolve_degenerate", {}, "VERT", {i for i in range(8)})],
),
# dissolve edges
SpecMeshTest("CylinderDissolveEdges", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges",
[OperatorSpecEditMode("dissolve_edges", {}, "EDGE", {0, 5, 6, 9})]),
SpecMeshTest(
"CylinderDissolveEdges", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges",
[OperatorSpecEditMode("dissolve_edges", {}, "EDGE", {0, 5, 6, 9})],
),
# dissolve faces
SpecMeshTest("CubeDissolveFaces", "testCubeDissolveFaces", "expectedCubeDissolveFaces",
[OperatorSpecEditMode("dissolve_faces", {}, "VERT", {5, 34, 47, 49, 83, 91, 95})]),
SpecMeshTest(
"CubeDissolveFaces", "testCubeDissolveFaces", "expectedCubeDissolveFaces",
[OperatorSpecEditMode("dissolve_faces", {}, "VERT", {5, 34, 47, 49, 83, 91, 95})],
),
# dissolve verts
SpecMeshTest("CubeDissolveVerts", "testCubeDissolveVerts", "expectedCubeDissolveVerts",
[OperatorSpecEditMode("dissolve_verts", {}, "VERT", {16, 20, 22, 23, 25})]),
SpecMeshTest(
"CubeDissolveVerts", "testCubeDissolveVerts", "expectedCubeDissolveVerts",
[OperatorSpecEditMode("dissolve_verts", {}, "VERT", {16, 20, 22, 23, 25})],
),
# duplicate
SpecMeshTest("ConeDuplicateVertices", "testConeDuplicateVertices",
"expectedConeDuplicateVertices",
[OperatorSpecEditMode("duplicate", {}, "VERT", {i for i in range(33)} - {23})]),
SpecMeshTest(
"ConeDuplicateVertices", "testConeDuplicateVertices",
"expectedConeDuplicateVertices",
[OperatorSpecEditMode("duplicate", {}, "VERT", {i for i in range(33)} - {23})],
),
SpecMeshTest("ConeDuplicateOneVertex", "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex",
[OperatorSpecEditMode("duplicate", {}, "VERT", {23})]),
SpecMeshTest("ConeDuplicateFaces", "testConeDuplicateFaces", "expectedConeDuplicateFaces",
[OperatorSpecEditMode("duplicate", {}, "FACE", {6, 9})]),
SpecMeshTest("ConeDuplicateEdges", "testConeDuplicateEdges", "expectedConeDuplicateEdges",
[OperatorSpecEditMode("duplicate", {}, "EDGE", {i for i in range(64)})]),
SpecMeshTest(
"ConeDuplicateOneVertex", "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex",
[OperatorSpecEditMode("duplicate", {}, "VERT", {23})],
),
SpecMeshTest(
"ConeDuplicateFaces", "testConeDuplicateFaces", "expectedConeDuplicateFaces",
[OperatorSpecEditMode("duplicate", {}, "FACE", {6, 9})],
),
SpecMeshTest(
"ConeDuplicateEdges", "testConeDuplicateEdges", "expectedConeDuplicateEdges",
[OperatorSpecEditMode("duplicate", {}, "EDGE", {i for i in range(64)})],
),
# edge collapse
SpecMeshTest("CylinderEdgeCollapse", "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse",
[OperatorSpecEditMode("edge_collapse", {}, "EDGE", {1, 9, 4})]),
SpecMeshTest(
"CylinderEdgeCollapse", "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse",
[OperatorSpecEditMode("edge_collapse", {}, "EDGE", {1, 9, 4})],
),
# edge face add
SpecMeshTest("CubeEdgeFaceAddFace", "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {1, 3, 4, 5, 7})]),
SpecMeshTest("CubeEdgeFaceAddEdge", "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {4, 5})]),
SpecMeshTest(
"CubeEdgeFaceAddFace", "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {1, 3, 4, 5, 7})],
),
SpecMeshTest(
"CubeEdgeFaceAddEdge", "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {4, 5})],
),
# edge rotate
SpecMeshTest("CubeEdgeRotate", "testCubeEdgeRotate", "expectedCubeEdgeRotate",
[OperatorSpecEditMode("edge_rotate", {}, "EDGE", {1})]),
SpecMeshTest(
"CubeEdgeRotate", "testCubeEdgeRotate", "expectedCubeEdgeRotate",
[OperatorSpecEditMode("edge_rotate", {}, "EDGE", {1})],
),
# edge split
SpecMeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
[OperatorSpecEditMode("edge_split", {}, "EDGE", {2, 5, 8, 11, 14, 17, 20, 23})]),
SpecMeshTest(
"CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
[OperatorSpecEditMode("edge_split", {}, "EDGE", {2, 5, 8, 11, 14, 17, 20, 23})],
),
# edge ring select - Cannot be tested. Need user input.
# SpecMeshTest("CubeEdgeRingSelect", "testCubeEdgeRingSelect", "expectedCubeEdgeRingSelect",
@ -130,113 +180,173 @@ def main():
# [OperatorSpecEditMode("edgering_select", {}, "VERT", {})]),
# edges select sharp
SpecMeshTest("CubeEdgesSelectSharp", "testCubeEdgeSelectSharp", "expectedCubeEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {}, "EDGE", {20})]),
SpecMeshTest("SphereEdgesSelectSharp", "testSphereEdgesSelectSharp", "expectedSphereEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.25}, "EDGE", {288})]),
SpecMeshTest("HoledSphereEdgesSelectSharp", "testHoledSphereEdgesSelectSharp", "expectedHoledSphereEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.18}, "VERT", {})]),
SpecMeshTest("EmptyMeshEdgesSelectSharp", "testEmptyMeshEdgeSelectSharp", "expectedEmptyMeshEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {}, "VERT", {})]),
SpecMeshTest(
"CubeEdgesSelectSharp", "testCubeEdgeSelectSharp", "expectedCubeEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {}, "EDGE", {20})],
),
SpecMeshTest(
"SphereEdgesSelectSharp", "testSphereEdgesSelectSharp", "expectedSphereEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.25}, "EDGE", {288})],
),
SpecMeshTest(
"HoledSphereEdgesSelectSharp", "testHoledSphereEdgesSelectSharp", "expectedHoledSphereEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {"sharpness": 0.18}, "VERT", {})],
),
SpecMeshTest(
"EmptyMeshEdgesSelectSharp", "testEmptyMeshEdgeSelectSharp", "expectedEmptyMeshEdgeSelectSharp",
[OperatorSpecEditMode("edges_select_sharp", {}, "VERT", {})],
),
# face make planar
SpecMeshTest("MonkeyFaceMakePlanar", "testMonkeyFaceMakePlanar",
"expectedMonkeyFaceMakePlanar",
[OperatorSpecEditMode("face_make_planar", {}, "FACE", {i for i in range(500)})]),
SpecMeshTest(
"MonkeyFaceMakePlanar", "testMonkeyFaceMakePlanar",
"expectedMonkeyFaceMakePlanar",
[OperatorSpecEditMode("face_make_planar", {}, "FACE", {i for i in range(500)})],
),
# face split by edges
SpecMeshTest("PlaneFaceSplitByEdges", "testPlaneFaceSplitByEdges",
"expectedPlaneFaceSplitByEdges",
[OperatorSpecEditMode("face_split_by_edges", {}, "VERT", {i for i in range(6)})]),
SpecMeshTest(
"PlaneFaceSplitByEdges", "testPlaneFaceSplitByEdges",
"expectedPlaneFaceSplitByEdges",
[OperatorSpecEditMode("face_split_by_edges", {}, "VERT", {i for i in range(6)})],
),
# faces select linked flat
SpecMeshTest("CubeFacesSelectLinkedFlat", "testCubeFaceSelectLinkedFlat", "expectedCubeFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "FACE", {7})]),
SpecMeshTest("PlaneFacesSelectLinkedFlat", "testPlaneFaceSelectLinkedFlat", "expectedPlaneFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {1})]),
SpecMeshTest("EmptyMeshFacesSelectLinkedFlat", "testEmptyMeshFaceSelectLinkedFlat",
"expectedEmptyMeshFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {})]),
SpecMeshTest(
"CubeFacesSelectLinkedFlat", "testCubeFaceSelectLinkedFlat", "expectedCubeFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "FACE", {7})],
),
SpecMeshTest(
"PlaneFacesSelectLinkedFlat", "testPlaneFaceSelectLinkedFlat", "expectedPlaneFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {1})],
),
SpecMeshTest(
"EmptyMeshFacesSelectLinkedFlat", "testEmptyMeshFaceSelectLinkedFlat",
"expectedEmptyMeshFaceSelectLinkedFlat",
[OperatorSpecEditMode("faces_select_linked_flat", {}, "VERT", {})],
),
# fill
SpecMeshTest("IcosphereFill", "testIcosphereFill", "expectedIcosphereFill",
[OperatorSpecEditMode("fill", {}, "EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49})]),
SpecMeshTest("IcosphereFillUseBeautyFalse",
"testIcosphereFillUseBeautyFalse", "expectedIcosphereFillUseBeautyFalse",
[OperatorSpecEditMode("fill", {"use_beauty": False}, "EDGE",
{20, 21, 22, 23, 24, 45, 46, 47, 48, 49})]),
SpecMeshTest(
"IcosphereFill", "testIcosphereFill", "expectedIcosphereFill",
[OperatorSpecEditMode("fill", {}, "EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49})],
),
SpecMeshTest(
"IcosphereFillUseBeautyFalse",
"testIcosphereFillUseBeautyFalse", "expectedIcosphereFillUseBeautyFalse",
[OperatorSpecEditMode("fill", {"use_beauty": False}, "EDGE",
{20, 21, 22, 23, 24, 45, 46, 47, 48, 49})],
),
# fill grid
SpecMeshTest("PlaneFillGrid", "testPlaneFillGrid",
"expectedPlaneFillGrid",
[OperatorSpecEditMode("fill_grid", {}, "EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})]),
SpecMeshTest("PlaneFillGridSimpleBlending",
"testPlaneFillGridSimpleBlending",
"expectedPlaneFillGridSimpleBlending",
[OperatorSpecEditMode("fill_grid", {"use_interp_simple": True}, "EDGE",
{1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})]),
SpecMeshTest(
"PlaneFillGrid", "testPlaneFillGrid",
"expectedPlaneFillGrid",
[OperatorSpecEditMode("fill_grid", {}, "EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})],
),
SpecMeshTest(
"PlaneFillGridSimpleBlending",
"testPlaneFillGridSimpleBlending",
"expectedPlaneFillGridSimpleBlending",
[OperatorSpecEditMode("fill_grid", {"use_interp_simple": True}, "EDGE",
{1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})],
),
# fill holes
SpecMeshTest("SphereFillHoles", "testSphereFillHoles", "expectedSphereFillHoles",
[OperatorSpecEditMode("fill_holes", {"sides": 9}, "VERT", {i for i in range(481)})]),
SpecMeshTest(
"SphereFillHoles", "testSphereFillHoles", "expectedSphereFillHoles",
[OperatorSpecEditMode("fill_holes", {"sides": 9}, "VERT", {i for i in range(481)})],
),
# face shade smooth (not a real test)
SpecMeshTest("CubeShadeSmooth", "testCubeShadeSmooth", "expectedCubeShadeSmooth",
[OperatorSpecEditMode("faces_shade_smooth", {}, "VERT", {i for i in range(8)})]),
SpecMeshTest(
"CubeShadeSmooth", "testCubeShadeSmooth", "expectedCubeShadeSmooth",
[OperatorSpecEditMode("faces_shade_smooth", {}, "VERT", {i for i in range(8)})],
),
# faces shade flat (not a real test)
SpecMeshTest("CubeShadeFlat", "testCubeShadeFlat", "expectedCubeShadeFlat",
[OperatorSpecEditMode("faces_shade_flat", {}, "FACE", {i for i in range(6)})]),
SpecMeshTest(
"CubeShadeFlat", "testCubeShadeFlat", "expectedCubeShadeFlat",
[OperatorSpecEditMode("faces_shade_flat", {}, "FACE", {i for i in range(6)})],
),
# hide
SpecMeshTest("HideFace", "testCubeHideFace", "expectedCubeHideFace",
[OperatorSpecEditMode("hide", {}, "FACE", {3})]),
SpecMeshTest("HideEdge", "testCubeHideEdge", "expectedCubeHideEdge",
[OperatorSpecEditMode("hide", {}, "EDGE", {1})]),
SpecMeshTest("HideVertex", "testCubeHideVertex", "expectedCubeHideVertex",
[OperatorSpecEditMode("hide", {}, "VERT", {0})]),
SpecMeshTest(
"HideFace", "testCubeHideFace", "expectedCubeHideFace",
[OperatorSpecEditMode("hide", {}, "FACE", {3})],
),
SpecMeshTest(
"HideEdge", "testCubeHideEdge", "expectedCubeHideEdge",
[OperatorSpecEditMode("hide", {}, "EDGE", {1})],
),
SpecMeshTest(
"HideVertex", "testCubeHideVertex", "expectedCubeHideVertex",
[OperatorSpecEditMode("hide", {}, "VERT", {0})],
),
# inset faces
SpecMeshTest("CubeInset",
"testCubeInset", "expectedCubeInset", [OperatorSpecEditMode("inset", {"thickness": 0.2}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50,
52,
59, 61, 62, 65, 83, 91, 95})]),
SpecMeshTest("CubeInsetEvenOffsetFalse",
"testCubeInsetEvenOffsetFalse", "expectedCubeInsetEvenOffsetFalse",
[OperatorSpecEditMode("inset", {"thickness": 0.2, "use_even_offset": False}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95})]),
SpecMeshTest("CubeInsetDepth",
"testCubeInsetDepth",
"expectedCubeInsetDepth", [OperatorSpecEditMode("inset", {"thickness": 0.2, "depth": 0.2}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61,
62,
65, 83, 91, 95})]),
SpecMeshTest("GridInsetRelativeOffset", "testGridInsetRelativeOffset",
"expectedGridInsetRelativeOffset",
[OperatorSpecEditMode("inset", {"thickness": 0.4,
"use_relative_offset": True}, "FACE",
{35, 36, 37, 45, 46, 47, 55, 56, 57})]),
SpecMeshTest(
"CubeInset",
"testCubeInset", "expectedCubeInset", [OperatorSpecEditMode("inset", {"thickness": 0.2}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50,
52,
59, 61, 62, 65, 83, 91, 95})],
),
SpecMeshTest(
"CubeInsetEvenOffsetFalse",
"testCubeInsetEvenOffsetFalse", "expectedCubeInsetEvenOffsetFalse",
[OperatorSpecEditMode("inset", {"thickness": 0.2, "use_even_offset": False}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95})],
),
SpecMeshTest(
"CubeInsetDepth",
"testCubeInsetDepth",
"expectedCubeInsetDepth", [OperatorSpecEditMode("inset", {"thickness": 0.2, "depth": 0.2}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61,
62,
65, 83, 91, 95})],
),
SpecMeshTest(
"GridInsetRelativeOffset", "testGridInsetRelativeOffset",
"expectedGridInsetRelativeOffset",
[OperatorSpecEditMode("inset", {"thickness": 0.4,
"use_relative_offset": True}, "FACE",
{35, 36, 37, 45, 46, 47, 55, 56, 57})],
),
# loop multi select
SpecMeshTest("MokeyLoopMultiSelect", "testMonkeyLoopMultiSelect", "expectedMonkeyLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {355, 359, 73, 301, 302})]),
SpecMeshTest("HoledGridLoopMultiSelect", "testGridLoopMultiSelect", "expectedGridLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {257, 169, 202, 207, 274, 278, 63})]),
SpecMeshTest("EmptyMeshLoopMultiSelect", "testEmptyMeshLoopMultiSelect", "expectedEmptyMeshLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {})]),
SpecMeshTest(
"MokeyLoopMultiSelect", "testMonkeyLoopMultiSelect", "expectedMonkeyLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {355, 359, 73, 301, 302})],
),
SpecMeshTest(
"HoledGridLoopMultiSelect", "testGridLoopMultiSelect", "expectedGridLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {257, 169, 202, 207, 274, 278, 63})],
),
SpecMeshTest(
"EmptyMeshLoopMultiSelect", "testEmptyMeshLoopMultiSelect", "expectedEmptyMeshLoopMultiSelect",
[OperatorSpecEditMode("loop_multi_select", {}, "VERT", {})],
),
# mark seam
SpecMeshTest("CubeMarkSeam", "testCubeMarkSeam", "expectedCubeMarkSeam",
[OperatorSpecEditMode("mark_seam", {}, "EDGE", {1})]),
SpecMeshTest(
"CubeMarkSeam", "testCubeMarkSeam", "expectedCubeMarkSeam",
[OperatorSpecEditMode("mark_seam", {}, "EDGE", {1})],
),
# select all
SpecMeshTest("CircleSelectAll", "testCircleSelectAll", "expectedCircleSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {1})]),
SpecMeshTest("IsolatedVertsSelectAll", "testIsolatedVertsSelectAll", "expectedIsolatedVertsSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {})]),
SpecMeshTest("EmptyMeshSelectAll", "testEmptyMeshSelectAll", "expectedEmptyMeshSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {})]),
SpecMeshTest(
"CircleSelectAll", "testCircleSelectAll", "expectedCircleSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {1})],
),
SpecMeshTest(
"IsolatedVertsSelectAll", "testIsolatedVertsSelectAll", "expectedIsolatedVertsSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {})],
),
SpecMeshTest(
"EmptyMeshSelectAll", "testEmptyMeshSelectAll", "expectedEmptyMeshSelectAll",
[OperatorSpecEditMode("select_all", {}, "VERT", {})],
),
# select axis - Cannot be tested. Needs active vert selection
# SpecMeshTest("MonkeySelectAxisX", "testMonkeySelectAxisX", "expectedMonkeySelectAxisX",
@ -249,120 +359,183 @@ def main():
# OperatorSpecEditMode("select_axis", {"axis": "Z", "sign": "NEG"}, "FACE", {})]),
# select faces by sides
SpecMeshTest("CubeSelectFacesBySide", "testCubeSelectFacesBySide", "expectedCubeSelectFacesBySide",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
SpecMeshTest("CubeSelectFacesBySideGreater", "testCubeSelectFacesBySideGreater", "expectedCubeSelectFacesBySideGreater",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4, "type": "GREATER", "extend": True}, "FACE", {})]),
SpecMeshTest("CubeSelectFacesBySideLess", "testCubeSelectFacesBySideLess", "expectedCubeSelectFacesBySideLess",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4, "type": "GREATER", "extend": True}, "FACE", {})]),
SpecMeshTest(
"CubeSelectFacesBySide", "testCubeSelectFacesBySide", "expectedCubeSelectFacesBySide",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})],
),
SpecMeshTest(
"CubeSelectFacesBySideGreater", "testCubeSelectFacesBySideGreater", "expectedCubeSelectFacesBySideGreater",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4,
"type": "GREATER", "extend": True}, "FACE", {})],
),
SpecMeshTest(
"CubeSelectFacesBySideLess", "testCubeSelectFacesBySideLess", "expectedCubeSelectFacesBySideLess",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4,
"type": "GREATER", "extend": True}, "FACE", {})],
),
# select interior faces
SpecMeshTest("CubeSelectInteriorFaces", "testCubeSelectInteriorFaces", "expectedCubeSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
SpecMeshTest("HoledCubeSelectInteriorFaces", "testHoledCubeSelectInteriorFaces", "expectedHoledCubeSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
SpecMeshTest("EmptyMeshSelectInteriorFaces", "testEmptyMeshSelectInteriorFaces", "expectedEmptyMeshSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})]),
SpecMeshTest(
"CubeSelectInteriorFaces", "testCubeSelectInteriorFaces", "expectedCubeSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})],
),
SpecMeshTest(
"HoledCubeSelectInteriorFaces", "testHoledCubeSelectInteriorFaces", "expectedHoledCubeSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})],
),
SpecMeshTest(
"EmptyMeshSelectInteriorFaces", "testEmptyMeshSelectInteriorFaces", "expectedEmptyMeshSelectInteriorFaces",
[OperatorSpecEditMode("select_face_by_sides", {"number": 4}, "FACE", {})],
),
# select less
SpecMeshTest("MonkeySelectLess", "testMonkeySelectLess", "expectedMonkeySelectLess",
[OperatorSpecEditMode("select_less", {}, "VERT", {2, 8, 24, 34, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 68,
69, 70, 71, 74, 75, 78, 80, 81, 82, 83, 90, 91, 93, 95, 97, 99,
101, 109, 111, 115, 117, 119, 121, 123, 125, 127, 129, 130, 131,
132, 133, 134, 135, 136, 138, 141, 143, 145, 147, 149, 151, 153,
155, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
175, 176, 177, 178, 181, 182, 184, 185, 186, 187, 188, 189, 190,
192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
206, 207, 208, 210, 216, 217, 218, 219, 220, 221, 222, 229, 230,
231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255,
257, 259, 263, 267, 269, 271, 275, 277, 289, 291, 293, 295, 309,
310, 311, 312, 316, 317, 318, 319, 320, 323, 325, 327, 329, 331,
341, 347, 349, 350, 351, 354, 356, 359, 361, 363, 365, 367, 369,
375, 379, 381, 382, 385, 386, 387, 388, 389, 390, 391, 392, 393,
394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406,
407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419,
420, 421, 423, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434,
435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447,
448, 449, 450, 451, 452, 454, 455, 456, 457, 458, 459, 460, 461,
462, 463, 464, 471, 473, 474, 475, 476, 477, 478, 479, 480, 481,
482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 495,
496, 497, 498, 499, 502, 505})]),
SpecMeshTest("HoledCubeSelectLess", "testHoledCubeSelectLess", "expectedHoledCubeSelectLess",
[OperatorSpecEditMode("select_face_by_sides", {}, "FACE", {})]),
SpecMeshTest("EmptyMeshSelectLess", "testEmptyMeshSelectLess", "expectedEmptyMeshSelectLess",
[OperatorSpecEditMode("select_face_by_sides", {}, "VERT", {})]),
SpecMeshTest(
"MonkeySelectLess", "testMonkeySelectLess", "expectedMonkeySelectLess",
[OperatorSpecEditMode("select_less", {}, "VERT", {
2, 8, 24, 34, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 68,
69, 70, 71, 74, 75, 78, 80, 81, 82, 83, 90, 91, 93, 95, 97, 99,
101, 109, 111, 115, 117, 119, 121, 123, 125, 127, 129, 130, 131,
132, 133, 134, 135, 136, 138, 141, 143, 145, 147, 149, 151, 153,
155, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
175, 176, 177, 178, 181, 182, 184, 185, 186, 187, 188, 189, 190,
192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
206, 207, 208, 210, 216, 217, 218, 219, 220, 221, 222, 229, 230,
231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255,
257, 259, 263, 267, 269, 271, 275, 277, 289, 291, 293, 295, 309,
310, 311, 312, 316, 317, 318, 319, 320, 323, 325, 327, 329, 331,
341, 347, 349, 350, 351, 354, 356, 359, 361, 363, 365, 367, 369,
375, 379, 381, 382, 385, 386, 387, 388, 389, 390, 391, 392, 393,
394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406,
407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419,
420, 421, 423, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434,
435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447,
448, 449, 450, 451, 452, 454, 455, 456, 457, 458, 459, 460, 461,
462, 463, 464, 471, 473, 474, 475, 476, 477, 478, 479, 480, 481,
482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 495,
496, 497, 498, 499, 502, 505,
})],
),
SpecMeshTest(
"HoledCubeSelectLess", "testHoledCubeSelectLess", "expectedHoledCubeSelectLess",
[OperatorSpecEditMode("select_face_by_sides", {}, "FACE", {})],
),
SpecMeshTest(
"EmptyMeshSelectLess", "testEmptyMeshSelectLess", "expectedEmptyMeshSelectLess",
[OperatorSpecEditMode("select_face_by_sides", {}, "VERT", {})],
),
# select linked
SpecMeshTest("PlanesSelectLinked", "testPlanesSelectLinked", "expectedPlanesSelectedLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {7})]),
SpecMeshTest("CubesSelectLinked", "testCubesSelectLinked", "expectedCubesSelectLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {11})]),
SpecMeshTest("EmptyMeshSelectLinked", "testEmptyMeshSelectLinked", "expectedEmptyMeshSelectLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {})]),
SpecMeshTest(
"PlanesSelectLinked", "testPlanesSelectLinked", "expectedPlanesSelectedLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {7})],
),
SpecMeshTest(
"CubesSelectLinked", "testCubesSelectLinked", "expectedCubesSelectLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {11})],
),
SpecMeshTest(
"EmptyMeshSelectLinked", "testEmptyMeshSelectLinked", "expectedEmptyMeshSelectLinked",
[OperatorSpecEditMode("select_linked", {}, "VERT", {})],
),
# select nth (checkered deselect)
SpecMeshTest("CircleSelect2nd", "testCircleSelect2nd", "expectedCircleSelect2nd",
[OperatorSpecEditMode("select_nth", {}, "VERT", {i for i in range(32)})]),
SpecMeshTest(
"CircleSelect2nd", "testCircleSelect2nd", "expectedCircleSelect2nd",
[OperatorSpecEditMode("select_nth", {}, "VERT", {i for i in range(32)})],
),
# Subdivide edgering - Not currently functional, operator returns inconsistently
#SpecMeshTest("SubdivideEdgeringSurface", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringSurface",
# SpecMeshTest("SubdivideEdgeringSurface", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringSurface",
# [OperatorSpecEditMode("subdivide_edgering", {"number_cuts": 5, "interpolation": 'SURFACE', "profile_shape_factor": 0.1}, "EDGE", {0, (i for i in range(96) if (i % 3))})]),
#SpecMeshTest("SubdivideEdgeringPath", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringPath",
# SpecMeshTest("SubdivideEdgeringPath", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringPath",
# [OperatorSpecEditMode("subdivide_edgering", {"number_cuts": 5, "interpolation": 'PATH', "profile_shape_factor": 0.1}, "EDGE", {0, (i for i in range(96) if (i % 3))})]),
#SpecMeshTest("SubdivideEdgeringLinear", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringLinear",
# SpecMeshTest("SubdivideEdgeringLinear", "testCylinderSubdivideEdgering", "expectedCylinderSubdivideEdgeringLinear",
# [OperatorSpecEditMode("subdivide_edgering", {"number_cuts": 5, "interpolation": 'LINEAR', "profile_shape_factor": 0.1}, "EDGE", {0, (i for i in range(96) if (i % 3))})]),
# Symmetry Snap
SpecMeshTest("SymmetrySnap", "testPlaneSymmetrySnap", "expectedPlaneSymmetrySnap",
[OperatorSpecEditMode("symmetry_snap", {"direction": 'POSITIVE_X', "threshold": 1, "factor": 0.75,
"use_center": False}, "VERT", {i for i in range(5)})]),
SpecMeshTest("SymmetrySnapCenter", "testPlaneSymmetrySnap", "expectedPlaneSymmetrySnapCenter",
[OperatorSpecEditMode("symmetry_snap", {"direction": 'NEGATIVE_X', "threshold": 1, "factor": 0.75,
"use_center": True}, "VERT", {i for i in range(5)})]),
SpecMeshTest(
"SymmetrySnap", "testPlaneSymmetrySnap", "expectedPlaneSymmetrySnap",
[OperatorSpecEditMode("symmetry_snap", {"direction": 'POSITIVE_X', "threshold": 1, "factor": 0.75,
"use_center": False}, "VERT", {i for i in range(5)})],
),
SpecMeshTest(
"SymmetrySnapCenter", "testPlaneSymmetrySnap", "expectedPlaneSymmetrySnapCenter",
[OperatorSpecEditMode("symmetry_snap", {"direction": 'NEGATIVE_X', "threshold": 1, "factor": 0.75,
"use_center": True}, "VERT", {i for i in range(5)})],
),
# Tris to Quads
SpecMeshTest("TrisToQuads", "testPlanesTrisToQuad", "expectedPlanesTrisToQuad",
[OperatorSpecEditMode("tris_convert_to_quads", {"face_threshold":0.174533, "shape_threshold":0.174533,
"uvs":True, "vcols":True, "seam":True, "sharp":True, "materials":True}, "VERT", {i for i in range(32)})]),
SpecMeshTest(
"TrisToQuads", "testPlanesTrisToQuad", "expectedPlanesTrisToQuad",
[OperatorSpecEditMode("tris_convert_to_quads", {"face_threshold": 0.174533, "shape_threshold": 0.174533,
"uvs": True, "vcols": True, "seam": True, "sharp": True, "materials": True}, "VERT", {i for i in range(32)})],
),
# unsubdivide
# normal case
SpecMeshTest("CubeFaceUnsubdivide", "testCubeUnsubdivide", "expectedCubeUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {}, "FACE", {i for i in range(6)})]),
SpecMeshTest(
"CubeFaceUnsubdivide", "testCubeUnsubdivide", "expectedCubeUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {}, "FACE", {i for i in range(6)})],
),
# UV Manipulation
SpecMeshTest("UVRotate", "testCubeUV", "expectedCubeUVRotate",
[OperatorSpecEditMode("uvs_rotate", {}, "FACE", {2})]),
SpecMeshTest("UVRotateCCW", "testCubeUV", "expectedCubeUVRotateCCW",
[OperatorSpecEditMode("uvs_rotate", {"use_ccw": True}, "FACE", {2})]),
SpecMeshTest("UVReverse", "testCubeUV", "expectedCubeUVReverse",
[OperatorSpecEditMode("uvs_reverse", {}, "FACE", {2})]),
SpecMeshTest("UVAdd", "testCubeUV", "expectedCubeUVAdd",
[OperatorSpecEditMode("uv_texture_add", {}, "FACE", {})]),
SpecMeshTest("UVRemove", "testCubeUV", "expectedCubeUVRemove",
[OperatorSpecEditMode("uv_texture_remove", {}, "FACE", {})]),
SpecMeshTest(
"UVRotate", "testCubeUV", "expectedCubeUVRotate",
[OperatorSpecEditMode("uvs_rotate", {}, "FACE", {2})],
),
SpecMeshTest(
"UVRotateCCW", "testCubeUV", "expectedCubeUVRotateCCW",
[OperatorSpecEditMode("uvs_rotate", {"use_ccw": True}, "FACE", {2})],
),
SpecMeshTest(
"UVReverse", "testCubeUV", "expectedCubeUVReverse",
[OperatorSpecEditMode("uvs_reverse", {}, "FACE", {2})],
),
SpecMeshTest(
"UVAdd", "testCubeUV", "expectedCubeUVAdd",
[OperatorSpecEditMode("uv_texture_add", {}, "FACE", {})],
),
SpecMeshTest(
"UVRemove", "testCubeUV", "expectedCubeUVRemove",
[OperatorSpecEditMode("uv_texture_remove", {}, "FACE", {})],
),
# Vert Connect Concave
SpecMeshTest("VertexConnectConcave", "testPlaneVertConnectConcave", "expectedPlaneVertConnectConcave",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})]),
SpecMeshTest("VertexConnectConcaveConvexPentagon", "testPentagonVertConnectConcave", "expectedPentagonVertConnectConcave",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})]),
SpecMeshTest("VertexConnectConcaveQuad", "testPlaneVertConnectConcaveQuad", "expectedPlaneVertConnectConcaveQuad",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})]),
SpecMeshTest(
"VertexConnectConcave", "testPlaneVertConnectConcave", "expectedPlaneVertConnectConcave",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})],
),
SpecMeshTest(
"VertexConnectConcaveConvexPentagon", "testPentagonVertConnectConcave", "expectedPentagonVertConnectConcave",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})],
),
SpecMeshTest(
"VertexConnectConcaveQuad", "testPlaneVertConnectConcaveQuad", "expectedPlaneVertConnectConcaveQuad",
[OperatorSpecEditMode("vert_connect_concave", {}, "FACE", {0})],
),
# Vert Connect Nonplanar
SpecMeshTest("VertexConnectNonplanar", "testPlaneVertConnectNonplanar", "expectedPlaneVertConnectNonplanar",
[OperatorSpecEditMode("vert_connect_nonplanar", {"angle_limit": 0.17453292}, "VERT", {i for i in range(9)})]),
SpecMeshTest("VertexConnectNonplanarNgon", "testPlaneVertConnectNonplanarNgon", "expectedPlaneVertConnectNonplanarNgon",
[OperatorSpecEditMode("vert_connect_nonplanar", {"angle_limit": 0.218166}, "VERT", {i for i in range(6)})]),
SpecMeshTest(
"VertexConnectNonplanar", "testPlaneVertConnectNonplanar", "expectedPlaneVertConnectNonplanar",
[OperatorSpecEditMode("vert_connect_nonplanar", {
"angle_limit": 0.17453292}, "VERT", {i for i in range(9)})],
),
SpecMeshTest(
"VertexConnectNonplanarNgon", "testPlaneVertConnectNonplanarNgon", "expectedPlaneVertConnectNonplanarNgon",
[OperatorSpecEditMode("vert_connect_nonplanar", {"angle_limit": 0.218166}, "VERT", {i for i in range(6)})],
),
# T87259 - test cases
SpecMeshTest("CubeEdgeUnsubdivide", "testCubeEdgeUnsubdivide", "expectedCubeEdgeUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {}, "EDGE", {i for i in range(6)})]),
SpecMeshTest("UVSphereUnsubdivide", "testUVSphereUnsubdivide", "expectedUVSphereUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {'iterations': 9}, "FACE", {i for i in range(512)})]),
SpecMeshTest(
"CubeEdgeUnsubdivide", "testCubeEdgeUnsubdivide", "expectedCubeEdgeUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {}, "EDGE", {i for i in range(6)})],
),
SpecMeshTest(
"UVSphereUnsubdivide", "testUVSphereUnsubdivide", "expectedUVSphereUnsubdivide",
[OperatorSpecEditMode("unsubdivide", {'iterations': 9}, "FACE", {i for i in range(512)})],
),
# vert connect path
# Tip: It works only if there is an already existing face or more than 2 vertices.
@ -395,23 +568,32 @@ def main():
# Laplacian Smooth
SpecMeshTest(
"LaplacianSmoothDefault", "testSphereLaplacianSmoothDefault", "expectedSphereLaplacianSmoothDefault",
[OperatorSpecEditMode("vertices_smooth_laplacian", {"preserve_volume": False}, "VERT", {i for i in range(482)})],
[OperatorSpecEditMode("vertices_smooth_laplacian", {
"preserve_volume": False}, "VERT", {i for i in range(482)})],
),
SpecMeshTest(
"LaplacianSmoothHighValues", "testSphereLaplacianSmoothHigh", "expectedSphereLaplacianSmoothHigh",
[OperatorSpecEditMode("vertices_smooth_laplacian", {"preserve_volume": False, "repeat": 100, "lambda_factor": 10.0}, "VERT", {i for i in range(482)})],
[OperatorSpecEditMode("vertices_smooth_laplacian",
{"preserve_volume": False,
"repeat": 100,
"lambda_factor": 10.0},
"VERT",
{i for i in range(482)})],
),
SpecMeshTest(
"LaplacianSmoothBorder", "testCubeLaplacianSmoothBorder", "expectedCubeLaplacianSmoothBorder",
[OperatorSpecEditMode("vertices_smooth_laplacian", {"preserve_volume": False, "lambda_border": 1.0}, "VERT", {i for i in range(25)})],
[OperatorSpecEditMode("vertices_smooth_laplacian", {
"preserve_volume": False, "lambda_border": 1.0}, "VERT", {i for i in range(25)})],
),
SpecMeshTest(
"LaplacianSmoothHighBorder", "testCubeLaplacianSmoothHighBorder", "expectedCubeLaplacianSmoothHighBorder",
[OperatorSpecEditMode("vertices_smooth_laplacian", {"preserve_volume": False, "lambda_border": 100.0}, "VERT", {i for i in range(25)})],
[OperatorSpecEditMode("vertices_smooth_laplacian", {
"preserve_volume": False, "lambda_border": 100.0}, "VERT", {i for i in range(25)})],
),
SpecMeshTest(
"LaplacianSmoothPreserveVolume", "testSphereLaplacianSmoothPreserveVol", "expectedSphereLaplacianSmoothPreserveVol",
[OperatorSpecEditMode("vertices_smooth_laplacian", {"preserve_volume": True}, "VERT", {i for i in range(482)})],
[OperatorSpecEditMode("vertices_smooth_laplacian", {
"preserve_volume": True}, "VERT", {i for i in range(482)})],
),

4
tests/python/physics_cloth.py
View File

@ -15,7 +15,7 @@ def main():
test = [
SpecMeshTest("ClothSimple", "testClothPlane", "expectedClothPlane",
[ModifierSpec('Cloth', 'CLOTH', {'settings': {'quality': 5}}, 15)], threshold=1e-3),
[ModifierSpec('Cloth', 'CLOTH', {'settings': {'quality': 5}}, 15)], threshold=1e-3),
# Not reproducible
# SpecMeshTest("ClothPressure", "testObjClothPressure", "expObjClothPressure",
@ -27,7 +27,7 @@ def main():
# [ModifierSpec('Cloth', 'CLOTH', {'collision_settings': {'use_self_collision': True}}, 67)]),
SpecMeshTest("ClothSpring", "testTorusClothSpring", "expTorusClothSpring",
[ModifierSpec('Cloth2', 'CLOTH', {'settings': {'use_internal_springs': True}}, 10)], threshold=1e-3),
[ModifierSpec('Cloth2', 'CLOTH', {'settings': {'use_internal_springs': True}}, 10)], threshold=1e-3),
]
cloth_test = RunTest(test)

8
tests/python/physics_dynamic_paint.py
View File

@ -15,10 +15,10 @@ def main():
test = [
SpecMeshTest("DynamicPaintSimple", "testObjDynamicPaintPlane", "expObjDynamicPaintPlane",
[ModifierSpec('dynamic_paint', 'DYNAMIC_PAINT',
{'ui_type': 'CANVAS',
'canvas_settings': {'canvas_surfaces': {'surface_type': 'WAVE', 'frame_end': 15}}},
15)]),
[ModifierSpec('dynamic_paint', 'DYNAMIC_PAINT',
{'ui_type': 'CANVAS',
'canvas_settings': {'canvas_surfaces': {'surface_type': 'WAVE', 'frame_end': 15}}},
15)]),
]
dynamic_paint_test = RunTest(test)

2
tests/python/physics_ocean.py
View File

@ -15,7 +15,7 @@ def main():
test = [
# World coordinates of test and expected object should be same.
SpecMeshTest("PlaneOcean", "testObjPlaneOcean", "expObjPlaneOcean",
[ModifierSpec('Ocean', 'OCEAN', {})]),
[ModifierSpec('Ocean', 'OCEAN', {})]),
]
ocean_test = RunTest(test)

4
tests/python/physics_particle_instance.py
View File

@ -15,8 +15,8 @@ def main():
test = [
SpecMeshTest("ParticleInstanceSimple", "testParticleInstance", "expectedParticleInstance",
[ModifierSpec('ParticleInstance', 'PARTICLE_INSTANCE', {'object': bpy.data.objects['Cube']})],
threshold=1e-3),
[ModifierSpec('ParticleInstance', 'PARTICLE_INSTANCE', {'object': bpy.data.objects['Cube']})],
threshold=1e-3),
]
particle_instance_test = RunTest(test)

4
tests/python/physics_particle_system.py
View File

@ -13,8 +13,8 @@ from modules.mesh_test import RunTest, ParticleSystemSpec, SpecMeshTest
def main():
test = [
SpecMeshTest("ParticleSystemTest", "testParticleSystem", "expParticleSystem",
[ParticleSystemSpec('Particles', 'PARTICLE_SYSTEM', {'render_type': "OBJECT",
'instance_object': bpy.data.objects['Cube']}, 20)], threshold=1e-3),
[ParticleSystemSpec('Particles', 'PARTICLE_SYSTEM', {'render_type': "OBJECT",
'instance_object': bpy.data.objects['Cube']}, 20)], threshold=1e-3),
]
particle_test = RunTest(test)

6
tests/python/physics_softbody.py
View File

@ -15,9 +15,9 @@ def main():
test = [
SpecMeshTest("SoftBodySimple", "testSoftBody", "expectedSoftBody",
[ModifierSpec('Softbody', 'SOFT_BODY',
{'settings': {'use_goal': False, 'bend': 8, 'pull': 0.8, 'push': 0.8}},
45)]),
[ModifierSpec('Softbody', 'SOFT_BODY',
{'settings': {'use_goal': False, 'bend': 8, 'pull': 0.8, 'push': 0.8}},
45)]),
]
soft_body_test = RunTest(test)