[Zope3-checkins] CVS: Zope3/src/zope/proxy/context/tests - __init__.py:1.2 test_containmentiterator.py:1.2 test_simplemethodwrapper.py:1.2 test_wrapper.py:1.2
Jim Fulton
jim@zope.com
Wed, 25 Dec 2002 09:15:48 -0500
Update of /cvs-repository/Zope3/src/zope/proxy/context/tests
In directory cvs.zope.org:/tmp/cvs-serv20790/src/zope/proxy/context/tests
Added Files:
__init__.py test_containmentiterator.py
test_simplemethodwrapper.py test_wrapper.py
Log Message:
Grand renaming:
- Renamed most files (especially python modules) to lower case.
- Moved views and interfaces into separate hierarchies within each
project, where each top-level directory under the zope package
is a separate project.
- Moved everything to src from lib/python.
lib/python will eventually go away. I need access to the cvs
repository to make this happen, however.
There are probably some bits that are broken. All tests pass
and zope runs, but I haven't tried everything. There are a number
of cleanups I'll work on tomorrow.
=== Zope3/src/zope/proxy/context/tests/__init__.py 1.1 => 1.2 ===
--- /dev/null Wed Dec 25 09:15:47 2002
+++ Zope3/src/zope/proxy/context/tests/__init__.py Wed Dec 25 09:15:17 2002
@@ -0,0 +1,2 @@
+#
+# This file is necessary to make this directory a package.
=== Zope3/src/zope/proxy/context/tests/test_containmentiterator.py 1.1 => 1.2 ===
--- /dev/null Wed Dec 25 09:15:47 2002
+++ Zope3/src/zope/proxy/context/tests/test_containmentiterator.py Wed Dec 25 09:15:17 2002
@@ -0,0 +1,44 @@
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""
+
+$Id$
+"""
+
+import unittest, sys
+
+from zope.proxy.context import Wrapper, getbaseobject
+from zope.proxy.context.containmentiterator import ContainmentIterator
+
+class Test(unittest.TestCase):
+
+ def testWrapped(self):
+ ob1 = 1
+ ob2 = 2
+ ob3 = 3
+ ob4 = 4
+
+ ob = Wrapper(Wrapper(ob3, Wrapper(ob2, ob1)), ob4)
+ self.assertEqual(map(getbaseobject, ContainmentIterator(ob)),
+ [ 3, 2, 1 ])
+
+ def testUnWrapped(self):
+ self.assertEqual(map(getbaseobject, ContainmentIterator(9)), [ 9 ])
+
+def test_suite():
+ loader=unittest.TestLoader()
+ return loader.loadTestsFromTestCase(Test)
+
+if __name__=='__main__':
+ unittest.TextTestRunner().run(test_suite())
=== Zope3/src/zope/proxy/context/tests/test_simplemethodwrapper.py 1.1 => 1.2 ===
--- /dev/null Wed Dec 25 09:15:47 2002
+++ Zope3/src/zope/proxy/context/tests/test_simplemethodwrapper.py Wed Dec 25 09:15:17 2002
@@ -0,0 +1,451 @@
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+import sys
+import unittest
+
+# Note that this is testing both that SimpleMethodWrapper works,
+# and that SimpleMethodWrapper is available as
+# from zope.proxy.context import Wrapper
+#
+# However, this test suite can form the basis of a test for the improved C
+# implementation, when that lands.
+#
+from zope.proxy.context import \
+ Wrapper, wrapperTypes, ContextMethod, \
+ ContextProperty, ContextGetProperty, ContextSetProperty, \
+ ContextSuper
+
+class NewStyleClass(object):
+
+ result = None
+
+ def thisIsAContextMethod(wrapped_self, val=None):
+ wrapped_self.result = wrapped_self
+ return val
+ thisIsAContextMethod = ContextMethod(thisIsAContextMethod)
+
+ def __call__(wrapped_self, a, b=None):
+ wrapped_self.result = wrapped_self, a, b
+ return a
+ __call__ = ContextMethod(__call__)
+
+ def __getitem__(wrapped_self, a, b=None):
+ wrapped_self.result = wrapped_self, a, b
+ return a
+ __getitem__ = ContextMethod(__getitem__)
+
+ def thisIsNotAContextMethod(self, val=None):
+ self.result = self
+ return val
+
+ def _getter(wrapped_self):
+ wrapped_self.result = wrapped_self
+ return True
+
+ def _setter(wrapped_self, value):
+ wrapped_self.result = wrapped_self, value
+ thisIsAContextProperty = ContextProperty(_getter, _setter)
+ thisIsAContextGetProperty = ContextGetProperty(_getter, _setter)
+ thisIsAContextSetProperty = ContextSetProperty(_getter, _setter)
+
+ def this_is_any_old_method(self):
+ return 'base', self
+
+class NewStyleClassWithSlots(object):
+ __slots__ = ['result']
+
+ def __init__(self):
+ self.result = None
+
+ def thisIsAContextMethod(wrapped_self, val=None):
+ wrapped_self.result = wrapped_self
+ return val
+ thisIsAContextMethod = ContextMethod(thisIsAContextMethod)
+
+ def __call__(wrapped_self, a, b=None):
+ wrapped_self.result = wrapped_self, a, b
+ return a
+ __call__ = ContextMethod(__call__)
+
+ def __getitem__(wrapped_self, a, b=None):
+ wrapped_self.result = wrapped_self, a, b
+ return a
+ __getitem__ = ContextMethod(__getitem__)
+
+ def thisIsNotAContextMethod(self, val=None):
+ self.result = self
+ return val
+
+ def _getter(wrapped_self):
+ wrapped_self.result = wrapped_self
+ return True
+
+ def _setter(wrapped_self, value):
+ wrapped_self.result = wrapped_self, value
+
+ thisIsAContextProperty = ContextProperty(_getter, _setter)
+ thisIsAContextGetProperty = ContextGetProperty(_getter, _setter)
+ thisIsAContextSetProperty = ContextSetProperty(_getter, _setter)
+
+ def this_is_any_old_method(self):
+ return 'base', self
+
+
+class ClassicClass:
+
+ result = None
+
+ def thisIsAContextMethod(wrapped_self, val=None):
+ wrapped_self.result = wrapped_self
+ return val
+ thisIsAContextMethod = ContextMethod(thisIsAContextMethod)
+
+ def __call__(wrapped_self, a, b=None):
+ wrapped_self.result = wrapped_self, a, b
+ return a
+ __call__ = ContextMethod(__call__)
+
+ def __getitem__(wrapped_self, a, b=None):
+ wrapped_self.result = wrapped_self, a, b
+ return a
+ __getitem__ = ContextMethod(__getitem__)
+
+ def thisIsNotAContextMethod(self, val=None):
+ self.result = self
+ return val
+
+ def _getter(wrapped_self):
+ wrapped_self.result = wrapped_self
+ return True
+
+ # not using a setter, as this is a classic class, and so
+ # setting an attribute that is a property results in overwriting
+ # that property.
+ thisIsAContextProperty = ContextProperty(_getter)
+ thisIsAContextGetProperty = ContextGetProperty(_getter)
+
+
+class TestClassicClass(unittest.TestCase):
+
+ _class = ClassicClass
+
+ def createObject(self):
+ # to be overridden in tests that subclass this one
+ return self._class()
+
+ def setUp(self):
+ unittest.TestCase.setUp(self)
+ self.obj = self.createObject()
+ self.wrapped = Wrapper(self.obj)
+ self.assertEqual(self.obj.result, None)
+
+ def testContextMethod(self):
+ value = object()
+ self.assertEqual(self.wrapped.thisIsAContextMethod(value), value)
+ self.assert_(self.obj.result is self.wrapped)
+
+ self.assertEqual(self.obj.thisIsAContextMethod(value), value)
+ self.assert_(self.obj.result is self.obj)
+
+ def testNotContextMethod(self):
+ value = object()
+ self.assertEqual(self.wrapped.thisIsNotAContextMethod(value), value)
+ self.assert_(self.obj.result is self.obj)
+
+ def testCall(self):
+ value_a = object()
+ value_b = object()
+
+ self.assertRaises(TypeError, self.wrapped)
+
+ self.assertEqual(self.wrapped(value_a), value_a)
+ result_obj, result_a, result_b = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_a is value_a)
+ self.assert_(result_b is None)
+
+ self.assertEqual(self.wrapped(value_a, value_b), value_a)
+ result_obj, result_a, result_b = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_a is value_a)
+ self.assert_(result_b is value_b)
+
+ self.assertEqual(self.wrapped(value_a, b=value_b), value_a)
+ result_obj, result_a, result_b = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_a is value_a)
+ self.assert_(result_b is value_b)
+
+ self.assertEqual(self.wrapped(a=value_a, b=value_b), value_a)
+ result_obj, result_a, result_b = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_a is value_a)
+ self.assert_(result_b is value_b)
+
+ def testGetitem(self):
+ value_a = object()
+ value_b = object()
+
+ self.assertRaises(TypeError, self.wrapped)
+
+ self.assertEqual(self.wrapped[value_a], value_a)
+ result_obj, result_a, result_b = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_a is value_a)
+ self.assert_(result_b is None)
+
+ self.assertEqual(self.wrapped.__getitem__(value_a, value_b), value_a)
+ result_obj, result_a, result_b = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_a is value_a)
+ self.assert_(result_b is value_b)
+
+ self.assertEqual(self.wrapped.__getitem__(value_a, b=value_b), value_a)
+ result_obj, result_a, result_b = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_a is value_a)
+ self.assert_(result_b is value_b)
+
+ self.assertEqual(self.wrapped.__getitem__(a=value_a, b=value_b),
+ value_a)
+ result_obj, result_a, result_b = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_a is value_a)
+ self.assert_(result_b is value_b)
+
+ def testGetContextProperty(self):
+ self.assertEqual(self.wrapped.thisIsAContextProperty, True)
+ self.assert_(self.obj.result is self.wrapped)
+
+ def testGetContextGetProperty(self):
+ self.assertEqual(self.wrapped.thisIsAContextGetProperty, True)
+ self.assert_(self.obj.result is self.wrapped)
+
+ def testNotFound(self):
+ self.assertRaises(AttributeError,
+ getattr, self.wrapped, 'noSuchAttribute')
+
+
+class TestNewStyleClassWithSlots(TestClassicClass):
+
+ _class = NewStyleClassWithSlots
+
+ # Setting properties doesn't work with classic classes,
+ # so this class has extra tests for setting properties in
+ # new-style classes.
+
+ def testSetContextProperty(self):
+ value = 23
+ self.wrapped.thisIsAContextProperty = value
+ result_obj, result_value = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_value is value)
+
+ def testSetContextGetProperty(self):
+ value = 23
+ self.wrapped.thisIsAContextGetProperty = value
+ result_obj, result_value = self.obj.result
+ self.assert_(result_obj is self.obj)
+ self.assert_(result_value is value)
+
+ def testGetContextSetProperty(self):
+ self.assertEqual(self.wrapped.thisIsAContextSetProperty, True)
+ self.assert_(self.obj.result is self.obj)
+
+ def testSetContextSetProperty(self):
+ value = 23
+ self.wrapped.thisIsAContextSetProperty = value
+ result_obj, result_value = self.obj.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_value is value)
+
+
+ def testContextSuper(self):
+
+ def this_is_any_old_method(self):
+ return 'sub', self
+
+ Sub = type('sub', (self._class, ), {
+ 'this_is_any_old_method': this_is_any_old_method,
+ })
+
+ inst = Wrapper(Sub())
+ name, rinst = inst.this_is_any_old_method()
+ self.assertEqual(name, 'sub')
+ self.assert_(rinst is not inst)
+
+ name, rinst = ContextSuper(Sub, inst).this_is_any_old_method()
+ self.assertEqual(name, 'base')
+ self.assert_(rinst is inst)
+
+
+class TestNewStyleClass(TestNewStyleClassWithSlots):
+
+ _class = NewStyleClass
+
+ def testGetContextProperty_w_name_in_dict(self):
+ self.obj.__dict__['thisIsAContextProperty'] = False
+ self.assertEqual(self.obj.thisIsAContextProperty, True)
+ self.assert_(self.obj.result is self.obj)
+ self.assertEqual(self.wrapped.thisIsAContextProperty, True)
+ self.assert_(self.obj.result is self.wrapped)
+
+ def testSetContextProperty_w_name_in_dict(self):
+ self.obj.__dict__['thisIsAContextProperty'] = False
+ value = 23
+ self.obj.thisIsAContextProperty = value
+ result_obj, result_value = self.obj.result
+ self.assert_(result_obj is self.obj)
+ self.assert_(result_value is value)
+
+ self.wrapped.thisIsAContextProperty = value
+ result_obj, result_value = self.wrapped.result
+ self.assert_(result_obj is self.wrapped)
+ self.assert_(result_value is value)
+
+
+class SimpleClass(object):
+ pass
+
+class CallableClass(object):
+ called = False
+ def __call__(self):
+ self.called = True
+ __call__ = ContextMethod(__call__)
+
+class ClassWithGetitem(object):
+ gotitem = False
+ def __getitem__(self, key):
+ self.gotitem = True
+ return key*2
+ __getitem__ = ContextMethod(__getitem__)
+
+class CallableClassWithGetitem(CallableClass, ClassWithGetitem):
+ pass
+
+class CallableGetitemNoContextMethods:
+ def __call__(self):
+ pass
+ def __getitem__(self, key):
+ pass
+
+class TestWrapperTypeSelection(unittest.TestCase):
+
+ def testSelection(self):
+
+ from zope.proxy.context \
+ import SimpleMethodWrapper, SimpleCallableMethodWrapper, \
+ SimpleGetitemMethodWrapper, SimpleCallableGetitemMethodWrapper
+
+ self.assert_(type(Wrapper({})) is SimpleMethodWrapper)
+ self.assert_(type(Wrapper(SimpleClass())) is SimpleMethodWrapper)
+ self.assert_(type(Wrapper(CallableClass())) is
+ SimpleCallableMethodWrapper)
+ self.assert_(type(Wrapper(ClassWithGetitem())) is
+ SimpleGetitemMethodWrapper)
+ self.assert_(type(Wrapper(CallableClassWithGetitem())) is
+ SimpleCallableGetitemMethodWrapper)
+ self.assert_(type(Wrapper(CallableGetitemNoContextMethods())) is
+ SimpleMethodWrapper)
+
+ def testSimpleClass(self):
+ obj = SimpleClass()
+ wrapped = Wrapper(obj)
+ self.assertRaises(TypeError, obj) # call as obj()
+ self.assertRaises(TypeError, wrapped) # call as wrapped()
+ self.assertRaises(TypeError, lambda: wrapped[23])
+ self.assert_(not callable(obj))
+ # This fails, because the base proxy c class in zope/proxy/proxy.c
+ # fills the tp_call slot.
+ #
+ # self.assert_(not callable(wrapped))
+ #
+ # let's just check that the (slightly broken) converse is true
+ self.assert_(callable(wrapped))
+
+ def testCallableClass(self):
+ obj = CallableClass()
+ wrapped = Wrapper(obj)
+ self.assert_(callable(obj))
+ self.assert_(callable(wrapped))
+ wrapped()
+ self.assertEqual(obj.called, True)
+
+ self.assertRaises(TypeError, lambda: wrapped[23])
+ self.assertRaises(AttributeError, getattr, wrapped, '__getitem__')
+
+ def testGetitemClass(self):
+ obj = ClassWithGetitem()
+ wrapped = Wrapper(obj)
+ self.assert_(not callable(obj))
+ # This fails, because the base proxy c class in zope/proxy/proxy.c
+ # fills the tp_call slot.
+ #
+ # self.assert_(not callable(wrapped))
+ #
+ # let's just check that the (slightly broken) converse is true
+ self.assert_(callable(wrapped))
+ self.assertRaises(TypeError, wrapped)
+
+ self.assert_(hasattr(obj, '__getitem__'))
+ self.assert_(hasattr(wrapped, '__getitem__'))
+ self.assertEqual(wrapped[23], 46)
+ self.assertEqual(wrapped.__getitem__(23), 46)
+
+ def testCallableGetitemClass(self):
+ obj = CallableClassWithGetitem()
+ wrapped = Wrapper(obj)
+ self.assert_(callable(obj))
+ self.assert_(callable(wrapped))
+ wrapped()
+ self.assertEqual(obj.called, True)
+
+ self.assert_(hasattr(obj, '__getitem__'))
+ self.assert_(hasattr(wrapped, '__getitem__'))
+ self.assertEqual(wrapped[23], 46)
+ self.assertEqual(wrapped.__getitem__(23), 46)
+
+ def testBuiltinMethod(self):
+ obj = {0:23}
+ wrapped = Wrapper(obj)
+ self.assert_(not callable(obj))
+ # This fails, because the base proxy c class in zope/proxy/proxy.c
+ # fills the tp_call slot.
+ #
+ # self.assert_(not callable(wrapped))
+ #
+ # let's just check that the (slightly broken) converse is true
+ self.assert_(callable(wrapped))
+ self.assertRaises(TypeError, wrapped)
+
+ self.assert_(hasattr(obj, '__getitem__'))
+ self.assert_(hasattr(wrapped, '__getitem__'))
+ self.assertEqual(wrapped[0], 23)
+ self.assertEqual(wrapped.__getitem__(0), 23)
+
+
+def test_suite():
+ return unittest.TestSuite((
+ unittest.makeSuite(TestNewStyleClass),
+ unittest.makeSuite(TestNewStyleClassWithSlots),
+ unittest.makeSuite(TestClassicClass),
+ unittest.makeSuite(TestWrapperTypeSelection),
+ ))
+
+
+if __name__ == "__main__":
+ runner = unittest.TextTestRunner(sys.stdout)
+ result = runner.run(test_suite())
+ newerrs = len(result.errors) + len(result.failures)
+ sys.exit(newerrs and 1 or 0)
=== Zope3/src/zope/proxy/context/tests/test_wrapper.py 1.1 => 1.2 ===
--- /dev/null Wed Dec 25 09:15:47 2002
+++ Zope3/src/zope/proxy/context/tests/test_wrapper.py Wed Dec 25 09:15:17 2002
@@ -0,0 +1,191 @@
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+import pickle
+import unittest
+
+from zope.proxy.context import wrapper
+from zope.proxy.tests.test_proxy import Comparable, Thing, ProxyTestCase
+
+
+class WrapperTestCase(ProxyTestCase):
+ def new_proxy(self, o, c=None):
+ return wrapper.Wrapper(o, c)
+
+ def test_constructor(self):
+ o1 = object()
+ o2 = object()
+ o3 = object()
+ w = self.new_proxy((o1, o2), o3)
+ self.assertEquals(wrapper.getobject(w), (o1, o2))
+ self.assert_(wrapper.getcontext(w) is o3)
+
+
+ def test_subclass_constructor(self):
+ class MyWrapper(wrapper.Wrapper):
+ def __init__(self, *args, **kwds):
+ super(MyWrapper, self).__init__('foo', **kwds)
+
+ w = MyWrapper(1, 2, key='value')
+ self.assertEquals(wrapper.getobject(w), 'foo')
+ self.assertEquals(wrapper.getdict(w), {'key': 'value'})
+
+ # __new__ catches too many positional args:
+ self.assertRaises(TypeError, MyWrapper, 1, 2, 3)
+
+ def test_wrapper_basics(self):
+ o1 = 1
+ o2 = 12
+ w = self.new_proxy(o1)
+ self.assert_(o1 is wrapper.getobject(w))
+ self.assert_(wrapper.getdict(w) is None)
+ d = wrapper.getdictcreate(w)
+ self.assert_(wrapper.getdictcreate(w) is d)
+
+ c = 'context'
+ wrapper.setcontext(w, c)
+ self.assert_(wrapper.getcontext(w) is c)
+ wrapper.setcontext(w, None)
+ self.assert_(wrapper.getcontext(w) is None)
+
+ wrapper.setobject(w, o2)
+ self.assert_(wrapper.getobject(w) is o2)
+
+ # test 2-argument version of constructor
+ o = object()
+ w = self.new_proxy(o, c)
+ self.assert_(wrapper.getobject(w) is o)
+ self.assert_(wrapper.getcontext(w) is c)
+
+ def test_wrapper_subclass_attributes(self):
+ class MyWrapper(wrapper.Wrapper):
+ def __init__(self, ob):
+ super(MyWrapper, self).__init__(ob)
+ self.foo = 1
+
+ o = Thing()
+ o.foo = 'not 1'
+ o.bar = 2
+ w = MyWrapper(o)
+ self.assert_(w.foo == 1)
+ self.assert_(w.bar == 2)
+
+ def test_getobject(self):
+ obj1 = object()
+ obj2 = object()
+ w = self.new_proxy(obj1)
+ self.assert_(wrapper.getobject(w) is obj1)
+ wrapper.setobject(w, obj2)
+ self.assert_(wrapper.getobject(w) is obj2)
+ self.assert_(wrapper.getobject(None) is None)
+ self.assert_(wrapper.getobject(obj1) is obj1)
+
+ def test_getbaseobject(self):
+ obj = object()
+ self.assert_(wrapper.getbaseobject(obj) is obj)
+ w1 = self.new_proxy(obj)
+ self.assert_(wrapper.getbaseobject(w1) is obj)
+ w = self.new_proxy(w1)
+ w = self.new_proxy(w)
+ w = self.new_proxy(w)
+ w = self.new_proxy(w)
+ w = self.new_proxy(w)
+ self.assert_(wrapper.getbaseobject(w) is obj)
+ wrapper.setobject(w1, None)
+ self.assert_(wrapper.getbaseobject(w) is None)
+ obj = object()
+ wrapper.setobject(w1, obj)
+ self.assert_(wrapper.getbaseobject(w) is obj)
+
+ def test_getcontext(self):
+ context = object()
+ w = self.new_proxy(None, context)
+ self.assert_(wrapper.getcontext(w) is context)
+ self.assert_(wrapper.getcontext(self.new_proxy(None)) is None)
+ self.assert_(wrapper.getcontext(object()) is None)
+
+ def check_getinnercontext(self, context):
+ obj = object()
+ self.assert_(wrapper.getinnercontext(obj) is None)
+ w1 = self.new_proxy(obj, context)
+ self.assert_(wrapper.getinnercontext(w1) is context)
+ w = self.new_proxy(w1, object())
+ w = self.new_proxy(w)
+ w = self.new_proxy(w, object())
+ w = self.new_proxy(w)
+ w = self.new_proxy(w, object())
+ self.assert_(wrapper.getinnercontext(w) is context)
+ wrapper.setcontext(w1, None)
+ self.assert_(wrapper.getinnercontext(w) is None)
+ context = object()
+ wrapper.setcontext(w1, context)
+ self.assert_(wrapper.getinnercontext(w) is context)
+
+ def test_getinnercontext(self):
+ self.check_getinnercontext(None)
+ self.check_getinnercontext(object())
+
+ def test_getinnerwrapper(self):
+ context = object()
+ o = object()
+ w1 = self.new_proxy(o)
+ w2 = self.new_proxy(w1, context)
+ x = wrapper.getinnerwrapper(w2)
+ self.assert_(x is w1)
+ self.assert_(wrapper.getinnerwrapper(o) is o)
+
+ def test_getdict(self):
+ w = self.new_proxy(None)
+ self.assert_(wrapper.getdict(w) is None)
+ d = wrapper.getdictcreate(w)
+ self.assert_(wrapper.getdict(w) is d)
+ self.assert_(wrapper.getdictcreate(w) is d)
+ self.assert_(wrapper.getdict(w) is d)
+
+ w = wrapper.Wrapper(None, name="myobject")
+ d = wrapper.getdict(w)
+ self.assert_(d is not None)
+ self.assert_(wrapper.getdictcreate(w) is d)
+ self.assert_(wrapper.getdictcreate(w) is d)
+ self.assert_(len(d) == 1)
+
+ def test_setobject(self):
+ obj1 = object()
+ obj2 = object()
+ w = self.new_proxy(obj1)
+ self.assert_(wrapper.getobject(w) is obj1)
+ wrapper.setobject(w, obj2)
+ self.assert_(wrapper.getobject(w) is obj2)
+
+ def test_setcontext(self):
+ w = self.new_proxy(None)
+ context = object()
+ wrapper.setcontext(w, context)
+ self.assert_(wrapper.getcontext(w) is context)
+
+ def test_pickle_prevention(self):
+ w = self.new_proxy(Thing())
+ self.assertRaises(pickle.PicklingError,
+ pickle.dumps, w)
+
+
+def test_suite():
+ return unittest.makeSuite(WrapperTestCase)
+
+
+if __name__ == "__main__":
+ import sys
+ runner = unittest.TextTestRunner(sys.stdout)
+ result = runner.run(test_suite())
+ newerrs = len(result.errors) + len(result.failures)
+ sys.exit(newerrs and 1 or 0)