Page MenuHome
Differential D8507 Diff 32109 tests/python/operators.py

Changeset View

Standalone View

View Options

tests/python/operators.py

Show All 20 Lines
import bpy import bpy
import os import os
import sys import sys
from random import shuffle, seed from random import shuffle, seed
seed(0) seed(0)
sys.path.append(os.path.dirname(os.path.realpath(__file__))) sys.path.append(os.path.dirname(os.path.realpath(__file__)))
from modules.mesh_test import OperatorTest, OperatorSpec from modules.mesh_test import MeshTest, OperatorSpecEditMode, RunTest
# Central vertical loop of Suzanne # Central vertical loop of Suzanne
MONKEY_LOOP_VERT = {68, 69, 71, 73, 74, 75, 76, 77, 90, 129, 136, 175, 188, 189, 198, 207, MONKEY_LOOP_VERT = {68, 69, 71, 73, 74, 75, 76, 77, 90, 129, 136, 175, 188, 189, 198, 207,
216, 223, 230, 301, 302, 303, 304, 305, 306, 307, 308} 216, 223, 230, 301, 302, 303, 304, 305, 306, 307, 308}
MONKEY_LOOP_EDGE = {131, 278, 299, 305, 307, 334, 337, 359, 384, 396, 399, 412, 415, 560, MONKEY_LOOP_EDGE = {131, 278, 299, 305, 307, 334, 337, 359, 384, 396, 399, 412, 415, 560,
567, 572, 577, 615, 622, 627, 632, 643, 648, 655, 660, 707} 567, 572, 577, 615, 622, 627, 632, 643, 648, 655, 660, 707}
def main(): def main():
tests = [ tests = [
#### 0 #### 0
# bisect # bisect
['FACE', {0, 1, 2, 3, 4, 5}, "testCubeBisect", "expectedCubeBisect", "bisect", MeshTest("CubeBisect", "testCubeBisect", "expectedCubeBisect",
{"plane_co": (0, 0, 0), "plane_no": (0, 1, 1), "clear_inner": True, "use_fill": True}], [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 # blend from shape
['FACE', {0, 1, 2, 3, 4, 5}, "testCubeBlendFromShape", "expectedCubeBlendFromShape", "blend_from_shape", MeshTest("CubeBlendFromShape", "testCubeBlendFromShape", "expectedCubeBlendFromShape",
{"shape": "Key 1"}], [OperatorSpecEditMode("blend_from_shape", {"shape": "Key 1"}, 'FACE', {0, 1, 2, 3, 4, 5})]),
# bridge edge loops # bridge edge loops
["FACE", {0, 1}, "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop", "bridge_edge_loops", {}], MeshTest("CubeBridgeEdgeLoop", "testCubeBrigeEdgeLoop", "expectedCubeBridgeEdgeLoop",
[OperatorSpecEditMode("bridge_edge_loops", {}, "FACE", {0, 1})]),
# decimate # decimate
["FACE", {i for i in range(500)}, "testMonkeyDecimate", "expectedMonkeyDecimate", "decimate", {"ratio": 0.1}], MeshTest("MonkeyDecimate", "testMonkeyDecimate", "expectedMonkeyDecimate",
[OperatorSpecEditMode("decimate",
{"ratio": 0.1}, "FACE", {i for i in range(500)})]),
### 4 ### 4
# delete # delete
["VERT", {3}, "testCubeDeleteVertices", "expectedCubeDeleteVertices", "delete", {}], MeshTest("CubeDeleteVertices", "testCubeDeleteVertices", "expectedCubeDeleteVertices",
["FACE", {0}, "testCubeDeleteFaces", "expectedCubeDeleteFaces", "delete", {}], [OperatorSpecEditMode("delete", {}, "VERT", {3})]),
["EDGE", {0, 1, 2, 3}, "testCubeDeleteEdges", "expectedCubeDeleteEdges", "delete", {}], MeshTest("CubeDeleteFaces", "testCubeDeleteFaces", "expectedCubeDeleteFaces",
[OperatorSpecEditMode("delete", {}, "FACE", {0})]),
MeshTest("CubeDeleteEdges", "testCubeDeleteEdges", "expectedCubeDeleteEdges",
[OperatorSpecEditMode("delete", {}, "EDGE", {0, 1, 2, 3})]),
# delete edge loop # delete edge loop
["VERT", MONKEY_LOOP_VERT, "testMokneyDeleteEdgeLoopVertices", "expectedMonkeyDeleteEdgeLoopVertices", MeshTest("MonkeyDeleteEdgeLoopVertices", "testMokneyDeleteEdgeLoopVertices",
"delete_edgeloop", {}], "expectedMonkeyDeleteEdgeLoopVertices",
["EDGE", MONKEY_LOOP_EDGE, "testMokneyDeleteEdgeLoopEdges", "expectedMonkeyDeleteEdgeLoopEdges", [OperatorSpecEditMode("delete_edgeloop", {}, "VERT", MONKEY_LOOP_VERT)]),
"delete_edgeloop", {}],
MeshTest("MonkeyDeleteEdgeLoopEdges", "testMokneyDeleteEdgeLoopEdges",
"expectedMonkeyDeleteEdgeLoopEdges",
[OperatorSpecEditMode("delete_edgeloop", {}, "EDGE", MONKEY_LOOP_EDGE)]),
### 9 ### 9
# delete loose # delete loose
["VERT", {i for i in range(12)}, "testCubeDeleteLooseVertices", "expectedCubeDeleteLooseVertices", MeshTest("CubeDeleteLooseVertices", "testCubeDeleteLooseVertices",
"delete_loose", {"use_verts": True, "use_edges": False, "use_faces": False}], "expectedCubeDeleteLooseVertices",
["EDGE", {i for i in range(14)}, "testCubeDeleteLooseEdges", "expectedCubeDeleteLooseEdges", [OperatorSpecEditMode("delete_loose", {"use_verts": True, "use_edges": False, "use_faces": False},
"delete_loose", {"use_verts": False, "use_edges": True, "use_faces": False}], "VERT",
["FACE", {i for i in range(7)}, "testCubeDeleteLooseFaces", "expectedCubeDeleteLooseFaces", {i for i in range(12)})]),
"delete_loose", {"use_verts": False, "use_edges": False, "use_faces": True}], MeshTest("CubeDeleteLooseEdges", "testCubeDeleteLooseEdges",
"expectedCubeDeleteLooseEdges",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": True, "use_faces": False},
"EDGE",
{i for i in range(14)})]),
MeshTest("CubeDeleteLooseFaces", "testCubeDeleteLooseFaces",
"expectedCubeDeleteLooseFaces",
[OperatorSpecEditMode("delete_loose", {"use_verts": False, "use_edges": False, "use_faces": True},
"FACE",
{i for i in range(7)})]),
# dissolve degenerate # dissolve degenerate
["VERT", {i for i in range(8)}, "testCubeDissolveDegenerate", "expectedCubeDissolveDegenerate", MeshTest("CubeDissolveDegenerate", "testCubeDissolveDegenerate",
"dissolve_degenerate", {}], "expectedCubeDissolveDegenerate",
[OperatorSpecEditMode("dissolve_degenerate", {}, "VERT", {i for i in range(8)})]),
### 13 ### 13
# dissolve edges # dissolve edges
["EDGE", {0, 5, 6, 9}, "testCylinderDissolveEdges", "expectedCylinderDissolveEdges", MeshTest("CylinderDissolveEdges", "testCylinderDissolveEdges", "expectedCylinderDissolveEdges",
"dissolve_edges", {}], [OperatorSpecEditMode("dissolve_edges", {}, "EDGE", {0, 5, 6, 9})]),
# dissolve faces # dissolve faces
["VERT", {5, 34, 47, 49, 83, 91, 95}, "testCubeDissolveFaces", "expectedCubeDissolveFaces", "dissolve_faces", MeshTest("CubeDissolveFaces", "testCubeDissolveFaces", "expectedCubeDissolveFaces",
{}], [OperatorSpecEditMode("dissolve_faces", {}, "VERT", {5, 34, 47, 49, 83, 91, 95})]),
### 15 ### 15
# dissolve verts # dissolve verts
["VERT", {16, 20, 22, 23, 25}, "testCubeDissolveVerts", "expectedCubeDissolveVerts", "dissolve_verts", {}], MeshTest("CubeDissolveVerts", "testCubeDissolveVerts", "expectedCubeDissolveVerts",
[OperatorSpecEditMode("dissolve_verts", {}, "VERT", {16, 20, 22, 23, 25})]),
# duplicate # duplicate
["VERT", {i for i in range(33)} - {23}, "testConeDuplicateVertices", "expectedConeDuplicateVertices", MeshTest("ConeDuplicateVertices", "testConeDuplicateVertices",
"duplicate", {}], "expectedConeDuplicateVertices",
["VERT", {23}, "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex", "duplicate", {}], [OperatorSpecEditMode("duplicate", {}, "VERT", {i for i in range(33)} - {23})]),
["FACE", {6, 9}, "testConeDuplicateFaces", "expectedConeDuplicateFaces", "duplicate", {}],
["EDGE", {i for i in range(64)}, "testConeDuplicateEdges", "expectedConeDuplicateEdges", "duplicate", {}], MeshTest("ConeDuplicateOneVertex", "testConeDuplicateOneVertex", "expectedConeDuplicateOneVertex",
[OperatorSpecEditMode("duplicate", {}, "VERT", {23})]),
MeshTest("ConeDuplicateFaces", "testConeDuplicateFaces", "expectedConeDuplicateFaces",
[OperatorSpecEditMode("duplicate", {}, "FACE", {6, 9})]),
MeshTest("ConeDuplicateEdges", "testConeDuplicateEdges", "expectedConeDuplicateEdges",
[OperatorSpecEditMode("duplicate", {}, "EDGE", {i for i in range(64)})]),
### 20 ### 20
# edge collapse # edge collapse
["EDGE", {1, 9, 4}, "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse", "edge_collapse", {}], MeshTest("CylinderEdgeCollapse", "testCylinderEdgeCollapse", "expectedCylinderEdgeCollapse",
[OperatorSpecEditMode("edge_collapse", {}, "EDGE", {1, 9, 4})]),
# edge face add # edge face add
["VERT", {1, 3, 4, 5, 7}, "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace", "edge_face_add", {}], MeshTest("CubeEdgeFaceAddFace", "testCubeEdgeFaceAddFace", "expectedCubeEdgeFaceAddFace",
["VERT", {4, 5}, "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge", "edge_face_add", {}], [OperatorSpecEditMode("edge_face_add", {}, "VERT", {1, 3, 4, 5, 7})]),
MeshTest("CubeEdgeFaceAddEdge", "testCubeEdgeFaceAddEdge", "expectedCubeEdgeFaceAddEdge",
[OperatorSpecEditMode("edge_face_add", {}, "VERT", {4, 5})]),
# edge rotate # edge rotate
["EDGE", {1}, "testCubeEdgeRotate", "expectedCubeEdgeRotate", "edge_rotate", {}], MeshTest("CubeEdgeRotate", "testCubeEdgeRotate", "expectedCubeEdgeRotate",
[OperatorSpecEditMode("edge_rotate", {}, "EDGE", {1})]),
# edge split # edge split
["EDGE", {2, 5, 8, 11, 14, 17, 20, 23}, "testCubeEdgeSplit", "expectedCubeEdgeSplit", "edge_split", {}], MeshTest("CubeEdgeSplit", "testCubeEdgeSplit", "expectedCubeEdgeSplit",
[OperatorSpecEditMode("edge_split", {}, "EDGE", {2, 5, 8, 11, 14, 17, 20, 23})]),
### 25 ### 25
# face make planar # face make planar
["FACE", {i for i in range(500)}, "testMonkeyFaceMakePlanar", "expectedMonkeyFaceMakePlanar", MeshTest("MonkeyFaceMakePlanar", "testMonkeyFaceMakePlanar",
"face_make_planar", {}], "expectedMonkeyFaceMakePlanar",
[OperatorSpecEditMode("face_make_planar", {}, "FACE", {i for i in range(500)})]),
# face split by edges # face split by edges
["VERT", {i for i in range(6)}, "testPlaneFaceSplitByEdges", "expectedPlaneFaceSplitByEdges", MeshTest("PlaneFaceSplitByEdges", "testPlaneFaceSplitByEdges",
"face_split_by_edges", {}], "expectedPlaneFaceSplitByEdges",
[OperatorSpecEditMode("face_split_by_edges", {}, "VERT", {i for i in range(6)})]),
# fill # fill
["EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49}, "testIcosphereFill", "expectedIcosphereFill", MeshTest("IcosphereFill", "testIcosphereFill", "expectedIcosphereFill",
"fill", {}], [OperatorSpecEditMode("fill", {}, "EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49})]),
["EDGE", {20, 21, 22, 23, 24, 45, 46, 47, 48, 49}, "testIcosphereFillUseBeautyFalse", MeshTest("IcosphereFillUseBeautyFalse",
"expectedIcosphereFillUseBeautyFalse", "fill", {"use_beauty": False}], "testIcosphereFillUseBeautyFalse", "expectedIcosphereFillUseBeautyFalse",
[OperatorSpecEditMode("fill", {"use_beauty": False}, "EDGE",
{20, 21, 22, 23, 24, 45, 46, 47, 48, 49})]),
# fill grid # fill grid
["EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15}, "testPlaneFillGrid", "expectedPlaneFillGrid", MeshTest("PlaneFillGrid", "testPlaneFillGrid",
"fill_grid", {}], "expectedPlaneFillGrid",
["EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15}, "testPlaneFillGridSimpleBlending", [OperatorSpecEditMode("fill_grid", {}, "EDGE", {1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})]),
"expectedPlaneFillGridSimpleBlending", "fill_grid", {"use_interp_simple": True}],
MeshTest("PlaneFillGridSimpleBlending",
"testPlaneFillGridSimpleBlending",
"expectedPlaneFillGridSimpleBlending",
[OperatorSpecEditMode("fill_grid", {"use_interp_simple": True}, "EDGE",
{1, 2, 3, 4, 5, 7, 9, 10, 11, 12, 13, 15})]),
### 31 ### 31
# fill holes # fill holes
["VERT", {i for i in range(481)}, "testSphereFillHoles", "expectedSphereFillHoles", "fill_holes", {"sides": 9}], MeshTest("SphereFillHoles", "testSphereFillHoles", "expectedSphereFillHoles",
[OperatorSpecEditMode("fill_holes", {"sides": 9}, "VERT", {i for i in range(481)})]),
# inset faces # inset faces
["VERT", {5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95}, "testCubeInset", MeshTest("CubeInset",
"expectedCubeInset", "inset", {"thickness": 0.2}], "testCubeInset", "expectedCubeInset", [OperatorSpecEditMode("inset", {"thickness": 0.2}, "VERT",
["VERT", {5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95}, {5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50,
52,
59, 61, 62, 65, 83, 91, 95})]),
MeshTest("CubeInsetEvenOffsetFalse",
"testCubeInsetEvenOffsetFalse", "expectedCubeInsetEvenOffsetFalse", "testCubeInsetEvenOffsetFalse", "expectedCubeInsetEvenOffsetFalse",
"inset", {"thickness": 0.2, "use_even_offset": False}], [OperatorSpecEditMode("inset", {"thickness": 0.2, "use_even_offset": False}, "VERT",
["VERT", {5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95}, "testCubeInsetDepth", {5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61, 62, 65, 83, 91, 95})]),
"expectedCubeInsetDepth", "inset", {"thickness": 0.2, "depth": 0.2}], MeshTest("CubeInsetDepth",
["FACE", {35, 36, 37, 45, 46, 47, 55, 56, 57}, "testGridInsetRelativeOffset", "expectedGridInsetRelativeOffset", "testCubeInsetDepth",
"inset", {"thickness": 0.4, "use_relative_offset": True}], "expectedCubeInsetDepth", [OperatorSpecEditMode("inset", {"thickness": 0.2, "depth": 0.2}, "VERT",
{5, 16, 17, 19, 20, 22, 23, 34, 47, 49, 50, 52, 59, 61,
62,
65, 83, 91, 95})]),
MeshTest("GridInsetRelativeOffset", "testGridInsetRelativeOffset",
"expectedGridInsetRelativeOffset",
[OperatorSpecEditMode("inset", {"thickness": 0.4,
"use_relative_offset": True}, "FACE",
{35, 36, 37, 45, 46, 47, 55, 56, 57})]),
] ]
operators_test = OperatorTest(tests) operators_test = RunTest(tests)
command = list(sys.argv) command = list(sys.argv)
for i, cmd in enumerate(command): for i, cmd in enumerate(command):
if cmd == "--run-all-tests": if cmd == "--run-all-tests":
operators_test.do_compare = True
operators_test.run_all_tests() operators_test.run_all_tests()
break break
elif cmd == "--run-test": elif cmd == "--run-test":
operators_test.apply_modifiers = False operators_test.do_compare = False
index = int(command[i + 1]) name = command[i + 1]
operators_test.run_test(index) operators_test.run_test(name)
break break
if __name__ == "__main__": if __name__ == "__main__":
main() main()