149 lines
5.8 KiB
Python
149 lines
5.8 KiB
Python
#-******************************************************************************
|
|
#
|
|
# Copyright (c) 2016,
|
|
# Sony Pictures Imageworks Inc. and
|
|
# Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.
|
|
#
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are
|
|
# met:
|
|
# * Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# * Redistributions in binary form must reproduce the above
|
|
# copyright notice, this list of conditions and the following disclaimer
|
|
# in the documentation and/or other materials provided with the
|
|
# distribution.
|
|
# * Neither the name of Sony Pictures Imageworks, nor
|
|
# Industrial Light & Magic, nor the names of their contributors may be used
|
|
# to endorse or promote products derived from this software without specific
|
|
# prior written permission.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
#
|
|
#-******************************************************************************
|
|
|
|
import unittest
|
|
from alembic.Abc import *
|
|
from alembic.AbcCoreAbstract import *
|
|
|
|
class LayerTest(unittest.TestCase):
|
|
def testObjExport(self):
|
|
"""write a few oarchives to test layering on objects"""
|
|
|
|
# writing the boring base
|
|
layerA = OArchive( 'layerObjA.abc' )
|
|
objAA = OObject( layerA.getTop(), "A" )
|
|
objAAA = OObject( objAA, "A" )
|
|
|
|
objAB = OObject( layerA.getTop(), "B" )
|
|
objABA = OObject( objAB, "A" )
|
|
objABB = OObject( objAB, "B" )
|
|
|
|
objAC = OObject( layerA.getTop(), "C" )
|
|
objACA = OObject( objAC, "A" )
|
|
objACB = OObject( objAC, "B" )
|
|
|
|
# writing the more exciting layer
|
|
layerB = OArchive( 'layerObjB.abc' )
|
|
objBA = OObject( layerB.getTop(), "A" )
|
|
objBAA = OObject( objBA, "A" )
|
|
objBAAB = OObject( objBAA, "B" ) # newly added
|
|
objBAB = OObject( objBA, "B" ) # newly added
|
|
|
|
md = MetaData()
|
|
SetReplace(md, True)
|
|
objBB = OObject( layerB.getTop(), "B", md)
|
|
objBBC = OObject( objBB, "C" ) # with replace A and B will be gone
|
|
|
|
md = MetaData()
|
|
SetPrune(md, True)
|
|
objBC = OObject( layerB.getTop(), "C", md )
|
|
|
|
def testObjImport(self):
|
|
"""read the archives as layered to test layering on objects"""
|
|
|
|
arch = IArchive(['layerObjB.abc', 'layerObjA.abc'])
|
|
obj = arch.getTop()
|
|
self.assertEqual(obj.getNumChildren(), 2)
|
|
|
|
objA = IObject(obj, 'A')
|
|
self.assertEqual(objA.getNumChildren(), 2)
|
|
|
|
objAA = IObject(objA, 'A')
|
|
self.assertEqual(objAA.getNumChildren(), 1)
|
|
|
|
objAAB = IObject(objAA, 'B')
|
|
self.assertEqual(objAAB.getNumChildren() == 0, objAAB.valid())
|
|
|
|
objAB = IObject(objA, 'B')
|
|
self.assertTrue(objAB.valid() and objAB.getNumChildren() == 0)
|
|
|
|
objB = IObject(obj, 'B')
|
|
self.assertTrue(objB.getNumChildren() == 1 and IObject(objB, 'C').valid())
|
|
|
|
def testPropExport(self):
|
|
"""write a few oarchives to test property layering"""
|
|
|
|
# writing the boring base
|
|
layerA = OArchive( 'layerPropA.abc' )
|
|
propAA = OCompoundProperty( layerA.getTop().getProperties(), "A" )
|
|
propAAA = OCompoundProperty( propAA, "A" )
|
|
|
|
propAB = OCompoundProperty( layerA.getTop().getProperties(), "B" )
|
|
propABA = OCompoundProperty( propAB, "A" )
|
|
propABB = OCompoundProperty( propAB, "B" )
|
|
|
|
propAC = OCompoundProperty( layerA.getTop().getProperties(), "C" )
|
|
propACA = OCompoundProperty( propAC, "A" )
|
|
propACB = OCompoundProperty( propAC, "B" )
|
|
|
|
# writing the more exciting layer
|
|
layerB = OArchive( 'layerPropB.abc' )
|
|
propBA = OCompoundProperty( layerB.getTop().getProperties(), "A" )
|
|
propBAA = OCompoundProperty( propBA, "A" )
|
|
propBAAB = OCompoundProperty( propBAA, "B" ) # newly added
|
|
propBAB = OCompoundProperty( propBA, "B" ) # newly added
|
|
|
|
md = MetaData()
|
|
SetReplace(md, True)
|
|
propBB = OCompoundProperty( layerB.getTop().getProperties(), "B", md)
|
|
propBBC = OCompoundProperty( propBB, "C" )
|
|
|
|
md = MetaData()
|
|
SetPrune(md, True)
|
|
propBC = OCompoundProperty( layerB.getTop().getProperties(), "C", md )
|
|
|
|
def testPropImport(self):
|
|
"""read the archives as layered to test property layering"""
|
|
|
|
arch = IArchive(['layerPropB.abc', 'layerPropA.abc'])
|
|
prop = arch.getTop().getProperties()
|
|
self.assertEqual(prop.getNumProperties(), 2)
|
|
|
|
propA = ICompoundProperty(prop, 'A')
|
|
self.assertEqual(propA.getNumProperties(), 2)
|
|
|
|
propAA = ICompoundProperty(propA, 'A')
|
|
self.assertEqual(propAA.getNumProperties(), 1)
|
|
|
|
propAAB = ICompoundProperty(propAA, 'B')
|
|
self.assertTrue(propAAB.getNumProperties() == 0 and propAAB.valid())
|
|
|
|
propAB = ICompoundProperty(propA, 'B')
|
|
self.assertTrue(propAB.valid() and propAB.getNumProperties() == 0)
|
|
|
|
propB = ICompoundProperty(prop, 'B')
|
|
self.assertTrue(propB.getNumProperties() == 1 and ICompoundProperty(propB, 'C').valid())
|