import subprocess
import sys
+
def setup():
import bpy
mat.use_screen_refraction = True
mat.use_screen_subsurface = True
+
# When run from inside Blender, render and exit.
try:
import bpy
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))
# ############################################################
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'})
# ############################################################
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:
self.assertTrue(compare_files(
filepath_nested_json,
filepath_json,
- ),
+ ),
"Scene dump files differ")
def test_syncing_layer_new(self):
self.assertTrue(compare_files(
filepath_nested_json,
filepath_json,
- ),
+ ),
"Scene dump files differ")
def test_syncing_link(self):
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')
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
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):
self.assertTrue(compare_files(
filepath_objects_json,
filepath_json,
- ),
+ ),
"Scene dump files differ")
def test_copy_object(self):
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
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,))
# ############################################################
# 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,))
# ############################################################
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))
# ############################################################
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))
# ############################################################
self.assertTrue(compare_files(
filepath_doversion_json,
filepath_layers_json,
- ),
+ ),
"Run: test_scene_write_layers")
if do_read:
self.assertTrue(compare_files(
filepath_read_json,
filepath_layers_json,
- ),
+ ),
"Scene dump files differ")
def test_scene_write_collections(self):
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):
"""
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):
"""
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):
"""
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)
# ############################################################
def dump(data):
import json
return json.dumps(
- data,
- sort_keys=True,
- indent=4,
- separators=(',', ': '),
- )
+ data,
+ sort_keys=True,
+ indent=4,
+ separators=(',', ': '),
+ )
# ############################################################
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):
import subprocess
subprocess.call(["cp", "-u", file_a, file_b])
-
if PDB:
import pdb
print("Files differ:", file_b, file_a)
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):
"""
self.assertTrue(compare_files(
filepath_objects_json,
filepath_json,
- ),
+ ),
"Scene dump files differ")
def do_object_add_no_collection(self, add_mode):
(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))
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):
self.assertTrue(compare_files(
filepath_generated_json,
filepath_reference_json,
- ),
+ ),
"Scene dump files differ")
def do_visibility_object_add(self, add_mode):
"""
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):
"""
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())
"""
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):
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()
"""
To be used by tests of view_layer_move_into_layer_collection
"""
+
def parse_move(self, path, sep='.'):
"""
convert 'Layer 1.C.2' into:
# 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)
# 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])
# 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]