tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: pep8

This commit is contained in:
Campbell Barton 2018-07-03 07:12:24 +02:00
parent 00fc1d70a7
commit 646f8bdb48
50 changed files with 658 additions and 655 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/python/eevee_render_tests.py
View File

@ -8,6 +8,7 @@ import shutil
import subprocess
import sys
def setup():
import bpy
@ -29,6 +30,7 @@ def setup():
mat.use_screen_refraction = True
mat.use_screen_subsurface = True
# When run from inside Blender, render and exit.
try:
import bpy

26
tests/python/view_layer/test_active_collection.py
View File

@ -42,23 +42,23 @@ class UnitTesting(ViewLayerTesting):
layer.collections.link(subzero)
lookup = [
'Master Collection',
'1',
'sub-zero',
'scorpion',
'2',
'3',
'4',
'5',
'sub-zero',
'scorpion']
'Master Collection',
'1',
'sub-zero',
'scorpion',
'2',
'3',
'4',
'5',
'sub-zero',
'scorpion']
for i, name in enumerate(lookup):
layer.collections.active_index = i
self.assertEqual(
name, layer.collections.active.name,
"Collection index mismatch: [{0}] : {1} != {2}".format(
i, name, layer.collections.active.name))
name, layer.collections.active.name,
"Collection index mismatch: [{0}] : {1} != {2}".format(
i, name, layer.collections.active.name))
# ############################################################

12
tests/python/view_layer/test_collection_new_sync.py
View File

@ -26,16 +26,16 @@ class UnitTesting(ViewLayerTesting):
self.assertEqual(view_layer.collections[0].collection, scene.master_collection)
self.assertEqual(
{collection.name for collection in view_layer.collections[0].collections},
{'Collection 1'})
{collection.name for collection in view_layer.collections[0].collections},
{'Collection 1'})
self.assertEqual(
bpy.ops.outliner.collection_new(),
{'FINISHED'})
bpy.ops.outliner.collection_new(),
{'FINISHED'})
self.assertEqual(
{collection.name for collection in view_layer.collections[0].collections},
{'Collection 1', 'Collection 2'})
{collection.name for collection in view_layer.collections[0].collections},
{'Collection 1', 'Collection 2'})
# ############################################################

1
tests/python/view_layer/test_group_d.py
View File

@ -46,7 +46,6 @@ class UnitTesting(ViewLayerTesting):
self.assertEqual(1, bpy.data.groups[0].users)
self.assertEqual(3, len(bpy.data.groups[0].objects))
# empty the group of objects
group = bpy.data.groups[0]
while group.objects:

2
tests/python/view_layer/test_layer_linking.py
View File

@ -67,7 +67,7 @@ class UnitTesting(ViewLayerTesting):
self.assertTrue(compare_files(
filepath_nested_json,
filepath_json,
),
),
"Scene dump files differ")
def test_syncing_layer_new(self):

2
tests/python/view_layer/test_layer_syncing.py
View File

@ -68,7 +68,7 @@ class UnitTesting(ViewLayerTesting):
self.assertTrue(compare_files(
filepath_nested_json,
filepath_json,
),
),
"Scene dump files differ")
def test_syncing_link(self):

2
tests/python/view_layer/test_make_single_user.py
View File

@ -33,7 +33,7 @@ class UnitTesting(ViewLayerTesting):
while master_collection.collections:
master_collection.collections.remove(
master_collection.collections[0])
master_collection.collections[0])
view_layer.collections.link(master_collection)
ob.select_set('SELECT')

52
tests/python/view_layer/test_move_above_below_layer_collection_f.py
View File

@ -16,36 +16,36 @@ from view_layer_common import *
class UnitTesting(MoveLayerCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['3', [
['dog', None],
['cat', None],
]],
['2', None],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['3', [
['dog', None],
['cat', None],
]],
['2', None],
]],
]
return reference_tree_map
def get_reference_layers_tree_map(self):
reference_layers_map = [
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'dog',
'cat',
]],
]
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'dog',
'cat',
]],
]
return reference_layers_map
def test_layer_collection_move_a(self):

30
tests/python/view_layer/test_move_above_below_layer_collection_g.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveLayerCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['cat', None],
['dog', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['cat', None],
['dog', None],
]],
]],
]
return reference_tree_map
def get_reference_layers_tree_map(self):

24
tests/python/view_layer/test_move_above_below_layer_collection_i.py
View File

@ -20,18 +20,18 @@ class UnitTesting(MoveLayerCollectionTesting):
def get_reference_layers_tree_map(self):
reference_layers_map = [
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'3',
'C',
'dog',
'cat',
]],
]
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'3',
'C',
'dog',
'cat',
]],
]
return reference_layers_map
def test_layer_collection_move_a(self):

24
tests/python/view_layer/test_move_above_below_layer_collection_l.py
View File

@ -20,18 +20,18 @@ class UnitTesting(MoveLayerCollectionTesting):
def get_reference_layers_tree_map(self):
reference_layers_map = [
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'cat',
'3',
'dog',
]],
]
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'cat',
'3',
'dog',
]],
]
return reference_layers_map
def test_layer_collection_move_a(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_a.py
View File

@ -17,21 +17,21 @@ class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
# original tree, no changes
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_move_a(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_b.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['3', [
['dog', None],
['cat', None],
]],
['1', None],
['2', None],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['3', [
['dog', None],
['cat', None],
]],
['1', None],
['2', None],
]],
]
return reference_tree_map
def test_scene_collection_move_a(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_c.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['3', [
['dog', None],
['cat', None],
]],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
]],
]
['A', [
['i', None],
['ii', None],
['3', [
['dog', None],
['cat', None],
]],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
]],
]
return reference_tree_map
def test_scene_collection_move(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_d.py
View File

@ -17,21 +17,21 @@ class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
# original tree, no changes
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['B', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['B', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_move_a(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_e.py
View File

@ -17,21 +17,21 @@ class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
# original tree, no changes
reference_tree_map = [
['A', [
['i', None],
['ii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['iii', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['iii', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_move_a(self):

28
tests/python/view_layer/test_move_above_below_scene_collection_f.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['dog', None],
['cat', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
]
['dog', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_move(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_sync_a.py
View File

@ -17,21 +17,21 @@ class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
# original tree, no changes
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_move_a(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_sync_b.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['3', [
['dog', None],
['cat', None],
]],
['1', None],
['2', None],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['3', [
['dog', None],
['cat', None],
]],
['1', None],
['2', None],
]],
]
return reference_tree_map
def test_scene_collection_move_a(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_sync_c.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['3', [
['dog', None],
['cat', None],
]],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
]],
]
['A', [
['i', None],
['ii', None],
['3', [
['dog', None],
['cat', None],
]],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
]],
]
return reference_tree_map
def test_scene_collection_move(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_sync_d.py
View File

@ -17,21 +17,21 @@ class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
# original tree, no changes
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['B', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['B', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_move_a(self):

30
tests/python/view_layer/test_move_above_below_scene_collection_sync_e.py
View File

@ -17,21 +17,21 @@ class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
# original tree, no changes
reference_tree_map = [
['A', [
['i', None],
['ii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['iii', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['iii', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_move_a(self):

28
tests/python/view_layer/test_move_above_below_scene_collection_sync_f.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['dog', None],
['cat', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
]
['dog', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_move(self):

54
tests/python/view_layer/test_move_into_layer_collection_a.py
View File

@ -17,38 +17,38 @@ class UnitTesting(MoveLayerCollectionTesting):
def get_reference_scene_tree_map(self):
# original tree, no changes
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
return reference_tree_map
def get_reference_layers_tree_map(self):
# original tree, no changes
reference_layers_map = [
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'3',
'dog',
'cat',
]],
]
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'3',
'dog',
'cat',
]],
]
return reference_layers_map
def test_layer_collection_into(self):

52
tests/python/view_layer/test_move_into_layer_collection_f.py
View File

@ -16,36 +16,36 @@ from view_layer_common import *
class UnitTesting(MoveLayerCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
['3', [
['dog', None],
['cat', None],
]],
]],
['B', None],
['C', [
['1', None],
['2', None],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
['3', [
['dog', None],
['cat', None],
]],
]],
['B', None],
['C', [
['1', None],
['2', None],
]],
]
return reference_tree_map
def get_reference_layers_tree_map(self):
reference_layers_map = [
['Layer 1', [
'Master Collection',
'C',
]],
['Layer 2', [
'C',
'3',
'dog',
'cat',
]],
]
['Layer 1', [
'Master Collection',
'C',
]],
['Layer 2', [
'C',
'3',
'dog',
'cat',
]],
]
return reference_layers_map
def test_layer_collection_into_a(self):

22
tests/python/view_layer/test_move_into_layer_collection_g.py
View File

@ -20,17 +20,17 @@ class UnitTesting(MoveLayerCollectionTesting):
def get_reference_layers_tree_map(self):
reference_layers_map = [
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'dog',
'cat',
]],
]
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'dog',
'cat',
]],
]
return reference_layers_map
def test_layer_collection_into_a(self):

32
tests/python/view_layer/test_move_into_layer_collection_h.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveLayerCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', [
['dog', None],
]],
['2', None],
['3', [
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', [
['dog', None],
]],
['2', None],
['3', [
['cat', None],
]],
]],
]
return reference_tree_map
def get_reference_layers_tree_map(self):

30
tests/python/view_layer/test_move_into_scene_collection_a.py
View File

@ -17,21 +17,21 @@ class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
# original tree, no changes
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

32
tests/python/view_layer/test_move_into_scene_collection_b.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', [
['3', [
['dog', None],
['cat', None],
]],
]],
['C', [
['1', None],
['2', None],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', [
['3', [
['dog', None],
['cat', None],
]],
]],
['C', [
['1', None],
['2', None],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

28
tests/python/view_layer/test_move_into_scene_collection_c.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['cat', None],
]],
]],
]],
]
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

28
tests/python/view_layer/test_move_into_scene_collection_e.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', [
['B', None],
]],
]],
]],
]
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

30
tests/python/view_layer/test_move_into_scene_collection_f.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
['B', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
['B', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

20
tests/python/view_layer/test_move_into_scene_collection_g.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
]],
['cat', None],
]],
]],
]
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

32
tests/python/view_layer/test_move_into_scene_collection_h.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', [
['ii', None],
]],
['3', [
['dog', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', [
['ii', None],
]],
['3', [
['dog', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

28
tests/python/view_layer/test_move_into_scene_collection_i.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['A', [
['i', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['ii', None],
]],
['cat', None],
]],
]],
]
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

32
tests/python/view_layer/test_move_into_scene_collection_sync_b.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', [
['3', [
['dog', None],
['cat', None],
]],
]],
['C', [
['1', None],
['2', None],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', [
['3', [
['dog', None],
['cat', None],
]],
]],
['C', [
['1', None],
['2', None],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

28
tests/python/view_layer/test_move_into_scene_collection_sync_c.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['cat', None],
]],
]],
]],
]
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

28
tests/python/view_layer/test_move_into_scene_collection_sync_e.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', [
['B', None],
]],
]],
]],
]
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

30
tests/python/view_layer/test_move_into_scene_collection_sync_f.py
View File

@ -16,21 +16,21 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
['B', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
['B', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

20
tests/python/view_layer/test_move_into_scene_collection_sync_g.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
]],
['cat', None],
]],
]],
]
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

32
tests/python/view_layer/test_move_into_scene_collection_sync_h.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', [
['ii', None],
]],
['3', [
['dog', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', [
['ii', None],
]],
['3', [
['dog', None],
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

28
tests/python/view_layer/test_move_into_scene_collection_sync_i.py
View File

@ -16,22 +16,22 @@ from view_layer_common import *
class UnitTesting(MoveSceneCollectionSyncTesting):
def get_reference_scene_tree_map(self):
reference_tree_map = [
['A', [
['i', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['A', [
['i', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', [
['ii', None],
]],
['cat', None],
]],
]],
]
['cat', None],
]],
]],
]
return reference_tree_map
def test_scene_collection_into(self):

2
tests/python/view_layer/test_object_copy.py
View File

@ -68,7 +68,7 @@ class UnitTesting(ViewLayerTesting):
self.assertTrue(compare_files(
filepath_objects_json,
filepath_json,
),
),
"Scene dump files differ")
def test_copy_object(self):

18
tests/python/view_layer/test_operator_context.py
View File

@ -27,19 +27,19 @@ class UnitTesting(ViewLayerTesting):
bl_label = "Sample Operator"
view_layer = bpy.props.StringProperty(
default="Not Set",
options={'SKIP_SAVE'},
)
default="Not Set",
options={'SKIP_SAVE'},
)
scene_collection = bpy.props.StringProperty(
default="",
options={'SKIP_SAVE'},
)
default="",
options={'SKIP_SAVE'},
)
use_verbose = bpy.props.BoolProperty(
default=False,
options={'SKIP_SAVE'},
)
default=False,
options={'SKIP_SAVE'},
)
def execute(self, context):
view_layer = context.view_layer

6
tests/python/view_layer/test_scene_copy_a.py
View File

@ -23,9 +23,9 @@ class UnitTesting(ViewLayerTesting):
filepath_layers_json_copy = os.path.join(ROOT, 'layers_copy_full_simple.json')
self.do_scene_copy(
filepath_layers_json_copy,
'FULL_COPY',
(get_scene_collections,))
filepath_layers_json_copy,
'FULL_COPY',
(get_scene_collections,))
# ############################################################

6
tests/python/view_layer/test_scene_copy_b.py
View File

@ -24,9 +24,9 @@ class UnitTesting(ViewLayerTesting):
# note: nothing should change, so using `layers_simple.json`
filepath_layers_json_copy = os.path.join(ROOT, 'layers_simple.json')
self.do_scene_copy(
filepath_layers_json_copy,
'LINK_OBJECTS',
(get_scene_collections,))
filepath_layers_json_copy,
'LINK_OBJECTS',
(get_scene_collections,))
# ############################################################

6
tests/python/view_layer/test_scene_copy_c.py
View File

@ -23,9 +23,9 @@ class UnitTesting(ViewLayerTesting):
filepath_layers_json_copy = os.path.join(ROOT, 'layers_copy_full.json')
self.do_scene_copy(
filepath_layers_json_copy,
'FULL_COPY',
(get_scene_collections, get_layers))
filepath_layers_json_copy,
'FULL_COPY',
(get_scene_collections, get_layers))
# ############################################################

6
tests/python/view_layer/test_scene_copy_d.py
View File

@ -23,9 +23,9 @@ class UnitTesting(ViewLayerTesting):
filepath_layers_json_copy = os.path.join(ROOT, 'layers_copy_link.json')
self.do_scene_copy(
filepath_layers_json_copy,
'LINK_OBJECTS',
(get_scene_collections, get_layers))
filepath_layers_json_copy,
'LINK_OBJECTS',
(get_scene_collections, get_layers))
# ############################################################

36
tests/python/view_layer/test_scene_write_read.py
View File

@ -46,7 +46,7 @@ class UnitTesting(ViewLayerTesting):
self.assertTrue(compare_files(
filepath_doversion_json,
filepath_layers_json,
),
),
"Run: test_scene_write_layers")
if do_read:
@ -65,7 +65,7 @@ class UnitTesting(ViewLayerTesting):
self.assertTrue(compare_files(
filepath_read_json,
filepath_layers_json,
),
),
"Scene dump files differ")
def test_scene_write_collections(self):
@ -79,10 +79,10 @@ class UnitTesting(ViewLayerTesting):
filepath_layers_json = os.path.join(ROOT, 'layers_simple.json')
self.do_scene_write_read(
filepath_layers,
filepath_layers_json,
(get_scene_collections,),
False)
filepath_layers,
filepath_layers_json,
(get_scene_collections,),
False)
def test_scene_write_layers(self):
"""
@ -95,10 +95,10 @@ class UnitTesting(ViewLayerTesting):
filepath_layers_json = os.path.join(ROOT, 'layers.json')
self.do_scene_write_read(
filepath_layers,
filepath_layers_json,
(get_scene_collections, get_layers),
False)
filepath_layers,
filepath_layers_json,
(get_scene_collections, get_layers),
False)
def test_scene_read_collections(self):
"""
@ -112,10 +112,10 @@ class UnitTesting(ViewLayerTesting):
filepath_layers_json = os.path.join(ROOT, 'layers_simple.json')
self.do_scene_write_read(
filepath_layers,
filepath_layers_json,
(get_scene_collections,),
True)
filepath_layers,
filepath_layers_json,
(get_scene_collections,),
True)
def test_scene_read_layers(self):
"""
@ -129,10 +129,10 @@ class UnitTesting(ViewLayerTesting):
filepath_layers_json = os.path.join(ROOT, 'layers.json')
self.do_scene_write_read(
filepath_layers,
filepath_layers_json,
(get_scene_collections, get_layers),
True)
filepath_layers,
filepath_layers_json,
(get_scene_collections, get_layers),
True)
# ############################################################

114
tests/python/view_layer/view_layer_common.py
View File

@ -157,11 +157,11 @@ def query_scene(filepath, name, callbacks):
def dump(data):
import json
return json.dumps(
data,
sort_keys=True,
indent=4,
separators=(',', ': '),
)
data,
sort_keys=True,
indent=4,
separators=(',', ': '),
)
# ############################################################
@ -170,7 +170,7 @@ def dump(data):
PDB = False
DUMP_DIFF = True
UPDATE_DIFF = False # HACK used to update tests when something change
UPDATE_DIFF = False # HACK used to update tests when something change
def compare_files(file_a, file_b):
@ -188,7 +188,6 @@ def compare_files(file_a, file_b):
import subprocess
subprocess.call(["cp", "-u", file_a, file_b])
if PDB:
import pdb
print("Files differ:", file_b, file_a)
@ -239,8 +238,8 @@ class ViewLayerTesting(unittest.TestCase):
def path_exists(self, filepath):
import os
self.assertTrue(
os.path.exists(filepath),
"Test file \"{0}\" not found".format(filepath))
os.path.exists(filepath),
"Test file \"{0}\" not found".format(filepath))
def do_object_add(self, filepath_json, add_mode):
"""
@ -307,7 +306,7 @@ class ViewLayerTesting(unittest.TestCase):
self.assertTrue(compare_files(
filepath_objects_json,
filepath_json,
),
),
"Scene dump files differ")
def do_object_add_no_collection(self, add_mode):
@ -356,7 +355,7 @@ class ViewLayerTesting(unittest.TestCase):
(self.path_exists(f) for f in (
filepath_layers,
filepath_json_reference,
))
))
filepath_saved = os.path.join(dirpath, '{0}.blend'.format(copy_mode))
filepath_json = os.path.join(dirpath, "{0}.json".format(copy_mode))
@ -376,7 +375,7 @@ class ViewLayerTesting(unittest.TestCase):
self.assertTrue(compare_files(
filepath_json,
filepath_json_reference,
),
),
"Scene copy \"{0}\" test failed".format(copy_mode.title()))
def do_object_delete(self, del_mode):
@ -437,7 +436,7 @@ class ViewLayerTesting(unittest.TestCase):
self.assertTrue(compare_files(
filepath_generated_json,
filepath_reference_json,
),
),
"Scene dump files differ")
def do_visibility_object_add(self, add_mode):
@ -517,23 +516,24 @@ class MoveSceneCollectionTesting(ViewLayerTesting):
"""
To be used by tests of view_layer_move_into_scene_collection
"""
def get_initial_scene_tree_map(self):
collections_map = [
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
['A', [
['i', None],
['ii', None],
['iii', None],
]],
['B', None],
['C', [
['1', None],
['2', None],
['3', [
['dog', None],
['cat', None],
]],
]],
]
return collections_map
def build_scene_tree(self, tree_map, collection=None, ret_dict=None):
@ -565,8 +565,8 @@ class MoveSceneCollectionTesting(ViewLayerTesting):
"""
self.cleanup_tree()
self.assertTrue(
hasattr(self, "get_initial_scene_tree_map"),
"Test class has no get_initial_scene_tree_map method implemented")
hasattr(self, "get_initial_scene_tree_map"),
"Test class has no get_initial_scene_tree_map method implemented")
return self.build_scene_tree(self.get_initial_scene_tree_map())
@ -605,20 +605,21 @@ class MoveSceneCollectionSyncTesting(MoveSceneCollectionTesting):
"""
To be used by tests of view_layer_move_into_scene_collection_sync
"""
def get_initial_layers_tree_map(self):
layers_map = [
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'3',
'dog',
'cat',
]],
]
['Layer 1', [
'Master Collection',
'C',
'3',
]],
['Layer 2', [
'C',
'3',
'dog',
'cat',
]],
]
return layers_map
def get_reference_layers_tree_map(self):
@ -634,8 +635,8 @@ class MoveSceneCollectionSyncTesting(MoveSceneCollectionTesting):
scene = bpy.context.scene
self.assertTrue(
hasattr(self, "get_initial_layers_tree_map"),
"Test class has no get_initial_layers_tree_map method implemented")
hasattr(self, "get_initial_layers_tree_map"),
"Test class has no get_initial_layers_tree_map method implemented")
layers_map = self.get_initial_layers_tree_map()
@ -684,6 +685,7 @@ class MoveLayerCollectionTesting(MoveSceneCollectionSyncTesting):
"""
To be used by tests of view_layer_move_into_layer_collection
"""
def parse_move(self, path, sep='.'):
"""
convert 'Layer 1.C.2' into:
@ -739,15 +741,15 @@ class Clay:
# store the variables
self._scene_collections = {
'grandma': scene_collection_grandma,
'mom': scene_collection_mom,
'kid': scene_collection_kid,
}
'grandma': scene_collection_grandma,
'mom': scene_collection_mom,
'kid': scene_collection_kid,
}
self._layer_collections = {
'grandma': layer_collection_grandma,
'mom': layer_collection_mom,
'kid': layer_collection_kid,
}
'grandma': layer_collection_grandma,
'mom': layer_collection_mom,
'kid': layer_collection_kid,
}
if extra_kid_layer:
layer_collection_extra = self._layer.collections.link(scene_collection_kid)
@ -765,7 +767,7 @@ class Clay:
# remove all the other collections
while self._scene.master_collection.collections:
self._scene.master_collection.collections.remove(
self._scene.master_collection.collections[0])
self._scene.master_collection.collections[0])
layer = self._scene.view_layers.new('Evaluation Test')
layer.collections.unlink(layer.collections[0])
@ -790,9 +792,9 @@ class Clay:
# change scene settings
self._properties = {
'scene': self._scene.collection_properties[ENGINE],
'object': self._object.collection_properties[ENGINE],
}
'scene': self._scene.collection_properties[ENGINE],
'object': self._object.collection_properties[ENGINE],
}
for key, value in self._layer_collections.items():
self._properties[key] = self._layer_collections[key].engine_overrides[ENGINE]