def test_update(self):
"""Test if update method calls the handlers in order."""
registry = version_registry.registry
# First an elementary test.
c = Classic()
state = state_pickler.get_state(c)
h = Handler()
registry.register('Classic', '__main__', h.upgrade)
c1 = state_pickler.create_instance(state)
state_pickler.set_state(c1, state)
self.assertEqual(h.calls, [('upgrade', state, 0)])
# Remove the handler.
registry.unregister('Classic', '__main__')
# Now check to see if this works for inheritance trees.
t = Test()
state = state_pickler.get_state(t)
h = Handler()
registry.register('Classic', '__main__', h.upgrade)
registry.register('New', '__main__', h.upgrade)
registry.register('Test', '__main__', h.upgrade1)
t1 = state_pickler.create_instance(state)
state_pickler.set_state(t1, state)
# This should call New handler, then the Test and then
# Classic.
self.assertEqual(h.calls, [('upgrade', state, 0),
('upgrade1', state, 1),
('upgrade', state.a, 0)])
def test_state_setter(self):
"""Test some of the features of the set_state method."""
t = TestClassic()
self.set_object(t)
# Get the saved state.
res = state_pickler.get_state(t)
# Now create a new instance and test the setter.
t1 = state_pickler.create_instance(res)
keys = ['c', 'b', 'f', 'i', 'tuple', 'list', 'l', 'numeric',
'n', 's', 'u', 'pure_list', 'inst', 'ref', 'dict']
ignore = list(keys)
ignore.remove('b')
first = ['b']
last = []
state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last)
# Only 'b' should have been set.
self.assertEqual(t1.b, True)
# Rest are unchanged.
self.assertEqual(t1.i, 7)
self.assertEqual(t1.s, 'String')
self.assertEqual(t1.u, u'Unicode')
self.assertEqual(t1.inst.a, 'a')
self.assertEqual(t1.list[0], 1)
self.assertEqual(t1.tuple[-1].a, 'a')
self.assertEqual(t1.dict['a'], 1)
# Check if last works.
last = ignore
ignore = []
first = []
state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last)
# Check everything.
self.verify_unpickled(t1, res)
def test_state_is_saveable(self):
"""Test if the state can be saved like the object itself."""
t = TestClassic()
self.set_object(t)
state = state_pickler.get_state(t)
# Now get the state of the state itself.
state1 = state_pickler.get_state(state)
self.verify_state(state1, state)
# Same thing for the traited class.
t = TestTraits()
self.set_object(t)
state = state_pickler.get_state(t)
# Now get the state of the state itself.
state1 = state_pickler.get_state(state)
self.verify_state(state1, state)
def test_state_is_saveable(self):
"""Test if the state can be saved like the object itself."""
t = TestClassic()
self.set_object(t)
state = state_pickler.get_state(t)
# Now get the state of the state itself.
state1 = state_pickler.get_state(state)
self.verify_state(state1, state)
# Same thing for the traited class.
t = TestTraits()
self.set_object(t)
state = state_pickler.get_state(t)
# Now get the state of the state itself.
state1 = state_pickler.get_state(state)
self.verify_state(state1, state)
def test_unpickle_classic(self):
"""Test if classic classes can be unpickled."""
t = TestClassic()
self.set_object(t)
# Get the pickled state.
res = state_pickler.get_state(t)
# Check each attribute.
self.verify_unpickled(t, res)
def test_unpickle_classic(self):
"""Test if classic classes can be unpickled."""
t = TestClassic()
self.set_object(t)
# Get the pickled state.
res = state_pickler.get_state(t)
# Check each attribute.
self.verify_unpickled(t, res)
def test_get_pure_state(self):
"""Test if get_pure_state is called first."""
class B:
def __init__(self):
self.a = 'dict'
def __get_pure_state__(self):
return {'a':'get_pure_state'}
def __getstate__(self):
return {'a':'getstate'}
b = B()
s = state_pickler.get_state(b)
self.assertEqual(s.a, 'get_pure_state')
del B.__get_pure_state__
s = state_pickler.get_state(b)
self.assertEqual(s.a, 'getstate')
del B.__getstate__
s = state_pickler.get_state(b)
self.assertEqual(s.a, 'dict')
def test_state_setter_classic(self):
"""Test if classic classes' state can be set."""
t = TestClassic()
self.set_object(t)
# Get the pickled state.
res = state_pickler.get_state(t)
# Now create a new instance and set its state.
t1 = state_pickler.create_instance(res)
state_pickler.set_state(t1, res)
# Check each attribute.
self.verify_unpickled(t1, res)
def test_state_setter_classic(self):
"""Test if classic classes' state can be set."""
t = TestClassic()
self.set_object(t)
# Get the pickled state.
res = state_pickler.get_state(t)
# Now create a new instance and set its state.
t1 = state_pickler.create_instance(res)
state_pickler.set_state(t1, res)
# Check each attribute.
self.verify_unpickled(t1, res)
def test_get_pure_state(self):
"""Test if get_pure_state is called first."""
class B:
def __init__(self):
self.a = 'dict'
def __get_pure_state__(self):
return {'a': 'get_pure_state'}
def __getstate__(self):
return {'a': 'getstate'}
b = B()
s = state_pickler.get_state(b)
self.assertEqual(s.a, 'get_pure_state')
del B.__get_pure_state__
s = state_pickler.get_state(b)
self.assertEqual(s.a, 'getstate')
del B.__getstate__
s = state_pickler.get_state(b)
self.assertEqual(s.a, 'dict')
def test_reference_cycle(self):
"""Test if reference cycles are handled when setting the state."""
class A: pass
class B: pass
a = A()
b = B()
a.a = b
b.b = a
state = state_pickler.get_state(a)
z = A()
z.a = B()
z.a.b = z
state_pickler.set_state(z, state)
def test_get_version(self):
"""Test the get_version function."""
c = Classic()
v = version_registry.get_version(c)
res = [(('Classic', '__main__'), 0)]
self.assertEqual(v, res)
state = state_pickler.get_state(c)
self.assertEqual(state.__metadata__['version'], res)
n = New()
v = version_registry.get_version(n)
res = [(('New', '__main__'), 0)]
self.assertEqual(v, res)
state = state_pickler.get_state(n)
self.assertEqual(state.__metadata__['version'], res)
t = TraitClass()
v = version_registry.get_version(t)
res = [(('HasTraits', 'enthought.traits.has_traits'), -1),
(('TraitClass', '__main__'), 0)]
self.assertEqual(v, res)
state = state_pickler.get_state(t)
self.assertEqual(state.__metadata__['version'], res)
def test_has_instance(self):
"""Test to check has_instance correctness."""
a = A()
r = state_pickler.get_state(a)
self.assertEqual(r.__metadata__['has_instance'], True)
l = [1, a]
r = state_pickler.get_state(l)
self.assertEqual(r.has_instance, True)
self.assertEqual(r[1].__metadata__['has_instance'], True)
d = {'a': l, 'b': 1}
r = state_pickler.get_state(d)
self.assertEqual(r.has_instance, True)
self.assertEqual(r['a'].has_instance, True)
self.assertEqual(r['a'][1].__metadata__['has_instance'], True)
class B:
def __init__(self):
self.a = [1, A()]
b = B()
r = state_pickler.get_state(b)
self.assertEqual(r.__metadata__['has_instance'], True)
self.assertEqual(r.a.has_instance, True)
self.assertEqual(r.a[1].__metadata__['has_instance'], True)
def test_has_instance(self):
"""Test to check has_instance correctness."""
a = A()
r = state_pickler.get_state(a)
self.assertEqual(r.__metadata__['has_instance'], True)
l = [1, a]
r = state_pickler.get_state(l)
self.assertEqual(r.has_instance, True)
self.assertEqual(r[1].__metadata__['has_instance'], True)
d = {'a': l, 'b':1}
r = state_pickler.get_state(d)
self.assertEqual(r.has_instance, True)
self.assertEqual(r['a'].has_instance, True)
self.assertEqual(r['a'][1].__metadata__['has_instance'], True)
class B:
def __init__(self):
self.a = [1, A()]
b = B()
r = state_pickler.get_state(b)
self.assertEqual(r.__metadata__['has_instance'], True)
self.assertEqual(r.a.has_instance, True)
self.assertEqual(r.a[1].__metadata__['has_instance'], True)
def test_reference_cycle(self):
"""Test if reference cycles are handled when setting the state."""
class A:
pass
class B:
pass
a = A()
b = B()
a.a = b
b.b = a
state = state_pickler.get_state(a)
z = A()
z.a = B()
z.a.b = z
state_pickler.set_state(z, state)
def __deepcopy__(self, memo):
"""Method used by copy.deepcopy(). This also uses the
state_pickler to work correctly.
"""
# Create a new instance.
new = self.__class__()
# If we have a saved state, use it for the new instance. If
# not, get our state and save that.
saved_state = self._saved_state
if len(saved_state) == 0:
state = state_pickler.get_state(self)
saved_state = cPickle.dumps(state)
new._saved_state = saved_state
# In the unlikely case that a new instance is running, load
# the saved state.
if new.running:
new._load_saved_state()
return new
def test_state_setter(self):
"""Test some of the features of the set_state method."""
t = TestClassic()
self.set_object(t)
# Get the saved state.
res = state_pickler.get_state(t)
# Now create a new instance and test the setter.
t1 = state_pickler.create_instance(res)
keys = [
'c', 'b', 'f', 'i', 'tuple', 'list', 'l', 'numeric', 'n', 's', 'u',
'pure_list', 'inst', 'ref', 'dict'
]
ignore = list(keys)
ignore.remove('b')
first = ['b']
last = []
state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last)
# Only 'b' should have been set.
self.assertEqual(t1.b, True)
# Rest are unchanged.
self.assertEqual(t1.i, 7)
self.assertEqual(t1.s, 'String')
self.assertEqual(t1.u, u'Unicode')
self.assertEqual(t1.inst.a, 'a')
self.assertEqual(t1.list[0], 1)
self.assertEqual(t1.tuple[-1].a, 'a')
self.assertEqual(t1.dict['a'], 1)
# Check if last works.
last = ignore
ignore = []
first = []
state_pickler.set_state(t1, res, ignore=ignore, first=first, last=last)
# Check everything.
self.verify_unpickled(t1, res)
