[Zodb-checkins] CVS: Zope2/lib/Components/ExtensionClass - testExtensionClass.py:1.1 testAcquisition.py:1.2

Brian Lloyd brian@digicool.com
Fri, 6 Apr 2001 17:01:41 -0400 (EDT)


Update of /cvs-repository/Zope2/lib/Components/ExtensionClass/test
In directory korak:/home/brian/temp/mainline-python-21/lib/Components/ExtensionClass/test

Modified Files:
	testAcquisition.py 
Added Files:
	testExtensionClass.py 
Log Message:
save start on 2.1 unit tests for EC, Acquisition



--- Added File testExtensionClass.py in package Zope2/lib/Components/ExtensionClass ---
"""ExtensionClass unit tests."""

from operator import truth
import unittest, string
import ExtensionClass


class MagicMethodTests(unittest.TestCase):
    """Test delegation to magic methods."""

    BaseClass = ExtensionClass.Base

    def fixup_inst(self, object):
        """A hook to allow acquisition tests based on this fixture."""
        return object

    #########################################################################
    # Test delegation of magic methods for attribute management.
    #########################################################################

    def test__getattr__(self):
        """Test __getattr__ delegation."""

        class PythonClass:
            def __getattr__(self, name):
                return 'bruce'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert object.foo == 'bruce'

        object = self.fixup_inst(DerivedClass())
        assert object.foo == 'bruce'


    def test__setattr__(self):
        """Test __setattr__ delegation."""

        class PythonClass:
            def __setattr__(self, name, value):
                self.__dict__['bruce_%s' % name] = value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        object.attr = 'value'
        assert object.bruce_attr == 'value'

        object = self.fixup_inst(DerivedClass())
        object.attr = 'value'
        assert object.bruce_attr == 'value'


    def test__delattr__(self):
        """Test __delattr__ delegation."""

        class PythonClass:
            def __delattr__(self, name):
                return

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        del object.foo

        object = self.fixup_inst(DerivedClass())
        del object.foo


    #########################################################################
    # Test delegation of magic methods for basic customization.
    #########################################################################

    def test__str__(self):
        """Test __str__ delegation."""

        class PythonClass:
            def __str__(self):
                return 'bruce'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert str(object) == 'bruce'

        object = self.fixup_inst(DerivedClass())
        assert str(object) == 'bruce'


    def test__repr__(self):
        """Test __repr__ delegation."""

        class PythonClass:
            def __repr__(self):
                return 'bruce'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert repr(object) == 'bruce'

        object = self.fixup_inst(DerivedClass())
        assert repr(object) == 'bruce'


    def test__cmp__(self):
        """Test __cmp__ delegation."""

        class PythonClass:
            def __cmp__(self, other):
                return 1

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert object > 1

        object = self.fixup_inst(DerivedClass())
        assert object > 1


    def test__hash__(self):
        """Test __hash__ delegation."""

        class PythonClass:
            def __hash__(self):
                return hash('bruce')

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert hash(object) == hash('bruce')

        object = self.fixup_inst(DerivedClass())
        assert hash(object) == hash('bruce')


    #########################################################################
    # Test delegation of rich comparison methods (new in Python 2.1).
    #########################################################################

    def test__lt__(self):
        """Test __lt__ delegation."""

        class PythonClass:
            def __lt__(self, other):
                return 1

            def __cmp__(self, other):
                raise AssertionError, 'Rich comparison not used!'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert object < 1

        object = self.fixup_inst(DerivedClass())
        assert object < 1


    def test__le__(self):
        """Test __le__ delegation."""

        class PythonClass:
            def __le__(self, other):
                return 1

            def __cmp__(self, other):
                raise AssertionError, 'Rich comparison not used!'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert object <= 1

        object = self.fixup_inst(DerivedClass())
        assert object <= 1


    def test__eq__(self):
        """Test __eq__ delegation."""

        class PythonClass:
            def __eq__(self, other):
                return 1

            def __cmp__(self, other):
                raise AssertionError, 'Rich comparison not used!'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert object == 1

        object = self.fixup_inst(DerivedClass())
        assert object == 1


    def test__ne__(self):
        """Test __ne__ delegation."""

        class PythonClass:
            def __ne__(self, other):
                return 1

            def __cmp__(self, other):
                raise AssertionError, 'Rich comparison not used!'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert object != 1

        object = self.fixup_inst(DerivedClass())
        assert object != 1


    def test__gt__(self):
        """Test __gt__ delegation."""

        class PythonClass:
            def __gt__(self, other):
                return 1

            def __cmp__(self, other):
                raise AssertionError, 'Rich comparison not used!'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert object > 1

        object = self.fixup_inst(DerivedClass())
        assert object > 1


    def test__ge__(self):
        """Test __ge__ delegation."""

        class PythonClass:
            def __ge__(self, other):
                return 1

            def __cmp__(self, other):
                raise AssertionError, 'Rich comparison not used!'

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert object >= 1

        object = self.fixup_inst(DerivedClass())
        assert object >= 1


    #########################################################################
    # Test delegation of truth semantics, use of __nonzero__ and __len__.
    #########################################################################

    def testTruthSemanticsDefault(self):
        """Test truth semantics (default)."""

        class PythonClass:
            pass

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert truth(object) == 1

        object = self.fixup_inst(DerivedClass())
        assert truth(object) == 1


    def testTruthSemanticsWithNonZero(self):
        """Test truth semantics with __nonzero__."""

        class PythonClass:
            result = 0
            def __nonzero__(self):
                return self.result

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert truth(object) == 0

        object = self.fixup_inst(DerivedClass())
        assert truth(object) == 0

        PythonClass.result = 1

        object = PythonClass()
        assert truth(object) == 1

        object = self.fixup_inst(DerivedClass())
        assert truth(object) == 1


    def testTruthSemanticsWithLen(self):
        """Test truth semantics with __len__."""

        class PythonClass:
            result = 0
            def __len__(self):
                return self.result

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert truth(object) == 0

        object = self.fixup_inst(DerivedClass())
        assert truth(object) == 0

        PythonClass.result = 1

        object = PythonClass()
        assert truth(object) == 1

        object = self.fixup_inst(DerivedClass())
        assert truth(object) == 1


    def testTruthSemanticsWithNonZeroAndLen(self):
        """Test truth semantics with __nonzero__ and __len__."""

        class PythonClass:
            nn = 0
            ll = 1
            def __nonzero__(self):
                return self.nn

            def __len__(self):
                return self.ll

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert truth(object) == 0
        assert len(object) == 1

        object = self.fixup_inst(DerivedClass())
        assert truth(object) == 0
        assert len(object) == 1

        PythonClass.nn = 1
        PythonClass.ll = 0

        object = PythonClass()
        assert truth(object) == 1
        assert len(object) == 0

        object = self.fixup_inst(DerivedClass())
        assert truth(object) == 1
        assert len(object) == 0


    #########################################################################
    # Test delegation of overridable binary arithmetic operations.
    #########################################################################

    def test__add__(self):
        """Test __add__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __add__(self, other):
                return self.value + other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert object + 1 == 2

        object = self.fixup_inst(DerivedClass(1))
        assert object + 1 == 2


    def test__sub__(self):
        """Test __sub__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __sub__(self, other):
                return self.value - other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(2)
        assert object - 1 == 1

        object = self.fixup_inst(DerivedClass(2))
        assert object - 1 == 1


    def test__mul__(self):
        """Test __mul__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __mul__(self, other):
                return self.value * other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(2)
        assert object * 2 == 4

        object = self.fixup_inst(DerivedClass(2))
        assert object * 2 == 4


    def test__div__(self):
        """Test __div__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __div__(self, other):
                return self.value / other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(4)
        assert object / 2 == 2

        object = self.fixup_inst(DerivedClass(4))
        assert object / 2 == 2


    def test__mod__(self):
        """Test __mod__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __mod__(self, other):
                return self.value % other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(101)
        assert object % 10 == 1

        object = self.fixup_inst(DerivedClass(101))
        assert object % 10 == 1


    def test__divmod__(self):
        """Test __divmod__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __divmod__(self, other):
                return divmod(self.value, other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(101)
        assert divmod(object, 10) == (10, 1)

        object = self.fixup_inst(DerivedClass(101))
        assert divmod(object, 10) == (10, 1)


    def test__pow__(self):
        """Test __pow__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __pow__(self, other, modulo=None):
                return self.value ** other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(10)
        assert object ** 2 == 100

        object = self.fixup_inst(DerivedClass(10))
        assert object ** 2 == 100


    def test__lshift__(self):
        """Test __lshift__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __lshift__(self, other):
                return self.value << other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(100)
        assert object << 2 == 400

        object = self.fixup_inst(DerivedClass(100))
        assert object << 2 == 400


    def test__rshift__(self):
        """Test __rshift__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rshift__(self, other):
                return self.value >> other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(100)
        assert object >> 2  == 25

        object = self.fixup_inst(DerivedClass(100))
        assert object >> 2 == 25


    def test__and__(self):
        """Test __and__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __and__(self, other):
                return self.value & other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert object & 1 == 1

        object = self.fixup_inst(DerivedClass(1))
        assert object & 1 == 1


    def test__xor__(self):
        """Test __xor__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __xor__(self, other):
                return self.value ^ other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert object ^ 1 == 0

        object = self.fixup_inst(DerivedClass(1))
        assert object ^ 1 == 0


    def test__or__(self):
        """Test __or__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __or__(self, other):
                return self.value | other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert object | 1 == 1

        object = self.fixup_inst(DerivedClass(1))
        assert object | 1 == 1


    #########################################################################
    # Test delegation of reflected binary arithmetic operations.
    #########################################################################

    def test__radd__(self):
        """Test __radd__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __radd__(self, other):
                return self.value + other

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert 1 + object == 2

        object = self.fixup_inst(DerivedClass(1))
        assert 1 + object == 2


    def test__rsub__(self):
        """Test __rsub__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rsub__(self, other):
                return other - self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(2)
        assert 2 - object == 0

        object = self.fixup_inst(DerivedClass(2))
        assert 2 - object == 0


    def test__rmul__(self):
        """Test __rmul__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rmul__(self, other):
                return other * self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(2)
        assert 2 * object == 4

        object = self.fixup_inst(DerivedClass(2))
        assert 2 * object == 4


    def test__rdiv__(self):
        """Test __rdiv__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rdiv__(self, other):
                return other / self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(4)
        assert 12 / object == 3

        object = self.fixup_inst(DerivedClass(4))
        assert 12 / object == 3


    def test__rmod__(self):
        """Test __rmod__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rmod__(self, other):
                return other % self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(10)
        assert 101 % object == 1

        object = self.fixup_inst(DerivedClass(10))
        assert 101 % object == 1


    def test__rdivmod__(self):
        """Test __rdivmod__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rdivmod__(self, other):
                return divmod(other, self.value)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(10)
        assert divmod(101, object) == (10, 1)

        object = self.fixup_inst(DerivedClass(10))
        assert divmod(101, object) == (10, 1)


    def test__rpow__(self):
        """Test __rpow__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rpow__(self, other):
                return other ** self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(10)
        assert 2 ** object == 100

        object = self.fixup_inst(DerivedClass(10))
        assert 2 ** object == 100


    def test__rlshift__(self):
        """Test __rlshift__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rlshift__(self, other):
                return other << self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(2)
        assert 100 << object == 400

        object = self.fixup_inst(DerivedClass(2))
        assert 100 << object == 400


    def test__rrshift__(self):
        """Test __rrshift__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rrshift__(self, other):
                return other >> self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(2)
        assert 100 >> object  == 25

        object = self.fixup_inst(DerivedClass(2))
        assert 100 >> object  == 25


    def test__rand__(self):
        """Test __rand__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rand__(self, other):
                return other & self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert 1 & object == 1

        object = self.fixup_inst(DerivedClass(1))
        assert 1 & object == 1


    def test__rxor__(self):
        """Test __rxor__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __rxor__(self, other):
                return other ^ self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert 1 ^ object == 0

        object = self.fixup_inst(DerivedClass(1))
        assert 1 ^ object == 0


    def test__ror__(self):
        """Test __ror__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __ror__(self, other):
                return other | self.value

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert 1 | object == 1

        object = self.fixup_inst(DerivedClass(1))
        assert 1 | object == 1


    #########################################################################
    # Test delegation of augmented assignment operations.
    #########################################################################

    def test__iadd__(self):
        """Test __iadd__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __iadd__(self, other):
                return self.__class__(self.value + other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        object += 1
        assert object.value == 2

        object = self.fixup_inst(DerivedClass(1))
        object += 1
        assert object.value == 2


    def test__isub__(self):
        """Test __isub__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __isub__(self, other):
                return self.__class__(self.value - other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(2)
        object -= 1
        assert object.value == 1

        object = self.fixup_inst(DerivedClass(2))
        object -= 1
        assert object.value == 1


    def test__imul__(self):
        """Test __imul__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __imul__(self, other):
                return self.__class__(self.value * other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(2)
        object *= 2
        assert object.value == 4

        object = self.fixup_inst(DerivedClass(2))
        object *= 2
        assert object.value == 4


    def test__idiv__(self):
        """Test __idiv__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __idiv__(self, other):
                return self.__class__(self.value / other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(4)
        object /= 2
        assert object.value == 2

        object = self.fixup_inst(DerivedClass(4))
        object /= 2
        assert object.value == 2


    def test__imod__(self):
        """Test __imod__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __imod__(self, other):
                return self.__class__(self.value % other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(101)
        object %= 10
        assert object.value == 1

        object = self.fixup_inst(DerivedClass(101))
        object %= 10
        assert object.value == 1


    def test__ipow__(self):
        """Test __ipow__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __ipow__(self, other):
                return self.__class__(self.value ** other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(10)
        object **= 2
        assert object.value == 100

        object = self.fixup_inst(DerivedClass(10))
        object **= 2
        assert object.value == 100


    def test__ilshift__(self):
        """Test __ilshift__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __ilshift__(self, other):
                return self.__class__(self.value << other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(100)
        object <<= 2
        assert object.value == 400

        object = self.fixup_inst(DerivedClass(100))
        object <<= 2
        assert object.value == 400


    def test__irshift__(self):
        """Test __irshift__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __irshift__(self, other):
                return self.__class__(self.value >> other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(100)
        object >>= 2
        assert object.value == 25

        object = self.fixup_inst(DerivedClass(100))
        object >>= 2
        assert object.value == 25


    def test__iand__(self):
        """Test __iand__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __iand__(self, other):
                return self.__class__(self.value & other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        object &= 1
        assert object.value == 1

        object = self.fixup_inst(DerivedClass(1))
        object &= 1
        assert object.value == 1


    def test__ixor__(self):
        """Test __ixor__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __ixor__(self, other):
                return self.__class__(self.value ^ other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        object ^= 1
        assert object.value == 0

        object = self.fixup_inst(DerivedClass(1))
        object ^= 1
        assert object.value == 0


    def test__ior__(self):
        """Test __ior__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __ior__(self, other):
                return self.__class__(self.value | other)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        object |= 1
        assert object.value == 1

        object = self.fixup_inst(DerivedClass(1))
        object |= 1
        assert object.value == 1


    #########################################################################
    # Test delegation of unary arithmetic operations.
    #########################################################################

    def test__pos__(self):
        """Test __pos__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __pos__(self):
                if self.value < 0:
                    return self.__class__(-(self.value))
                return self.__class__(self.value)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(-1)
        object = +(object)
        assert object.value == 1

        object = self.fixup_inst(DerivedClass(-1))
        object = +(object)
        assert object.value == 1


    def test__neg__(self):
        """Test __neg__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __neg__(self):
                return self.__class__(-(self.value))

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        object = -(object)
        assert object.value == -1

        object = self.fixup_inst(DerivedClass(1))
        object = -(object)
        assert object.value == -1


    def test__abs__(self):
        """Test __abs__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __abs__(self):
                return self.__class__(abs(self.value))

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(-1)
        object = abs(object)
        assert object.value == 1

        object = self.fixup_inst(DerivedClass(-1))
        object = abs(object)
        assert object.value == 1


    def test__invert__(self):
        """Test __invert__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __invert__(self):
                return self.__class__(~(self.value))

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(9)
        object = ~(object)
        assert object.value == -10

        object = self.fixup_inst(DerivedClass(9))
        object = ~(object)
        assert object.value == -10


    #########################################################################
    # Test delegation of numeric type coercion.
    #########################################################################

    def test__int__(self):
        """Test __int__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __int__(self):
                return int(self.value)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert int(object) == 1

        object = self.fixup_inst(DerivedClass(1))
        assert int(object) == 1


    def test__long__(self):
        """Test __long__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __long__(self):
                return long(self.value)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert long(object) == long(1)

        object = self.fixup_inst(DerivedClass(1))
        assert long(object) == long(1)


    def test__float__(self):
        """Test __float__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __float__(self):
                return float(self.value)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert float(object) == float(1)

        object = self.fixup_inst(DerivedClass(1))
        assert float(object) == float(1)


    def test__complex__(self):
        """Test __complex__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __complex__(self):
                return complex(self.value)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(1)
        assert complex(object) == complex(1)

        object = self.fixup_inst(DerivedClass(1))
        assert complex(object) == complex(1)


    #########################################################################
    # Test delegation of overridable __oct__ and __hex__
    #########################################################################

    def test__oct__(self):
        """Test __oct__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __oct__(self):
                return oct(self.value)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(10)
        assert oct(object) == '012'

        object = self.fixup_inst(DerivedClass(10))
        assert oct(object) == '012'


    def test__hex__(self):
        """Test __hex__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __hex__(self):
                return hex(self.value)

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(10)
        assert hex(object) == '0xa'

        object = self.fixup_inst(DerivedClass(10))
        assert hex(object) == '0xa'


    #########################################################################
    # Test delegation of mixed-mode coercion
    #########################################################################

    def test__coerce__(self):
        """Test __coerce__ delegation."""

        class PythonClass:
            def __init__(self, value):
                self.value = value
                
            def __coerce__(self, other):
                return (self.value, int(other))

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass(10)
        assert coerce(object, 10.0) == (10, 10)

        object = self.fixup_inst(DerivedClass(10))
        assert coerce(object, 10.0) == (10, 10)



    #########################################################################
    # Test delegation of overridable sequence protocol methods.
    #########################################################################

    def test__contains__(self):
        """Test __contains__ delegation."""

        class PythonClass:
            def __contains__(self, item):
                return 1

        class DerivedClass(self.BaseClass, PythonClass):
            pass

        object = PythonClass()
        assert 's' in object

        object = self.fixup_inst(DerivedClass())
        assert 's' in object





class ExtensionClassTests(MagicMethodTests):
    """Test ExtensionClass"""
    pass







def test_suite():
    suite_01 = unittest.makeSuite(ExtensionClassTests)
    return unittest.TestSuite((suite_01,))

def main():
    unittest.TextTestRunner().run(test_suite())

if __name__ == '__main__':
    main()

--- Updated File testAcquisition.py in package Zope2/lib/Components/ExtensionClass --
--- testAcquisition.py	2001/03/27 03:38:15	1.1
+++ testAcquisition.py	2001/04/06 21:01:40	1.2
@@ -1,293 +1,43 @@
 """Acquisition unit tests."""
 
-import unittest, string
-from operator import truth
+from testExtensionClass import MagicMethodTests
 from Acquisition import Implicit
 from Acquisition import Explicit
+from operator import truth
+import unittest, string
 
-class AcquisitionTests (unittest.TestCase):
-
-    def testImplicitTruthSemanticsDefault(self):
-        """Check wrapper truth semantics against those of python objects
-           without __len__ or __nonzero__ definitions."""
-
-        class PyObject:
-            # plain object, no __len__ or __nonzero__
-            pass
-
-        class AqObject(Implicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 1
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 1
-
-
-    def testImplicitTruthSemanticsWithNonZero(self):
-        """Check wrapper truth semantics against those of python objects
-           with __nonzero__ defined."""
-
-        class PyObject:
-            def __nonzero__(self):
-                return 0
-
-        class AqObject(Implicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 0
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 0
-
-
-        class PyObject:
-            def __nonzero__(self):
-                return 1
-
-        class AqObject(Implicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 1
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 1
-
-
-    def testImplicitTruthSemanticsWithLen(self):
-        """Check wrapper truth semantics against those of python objects
-           with __len__ defined."""
-
-        class PyObject:
-            def __len__(self):
-                return 0
-
-        class AqObject(Implicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 0
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 0
-
-
-        class PyObject:
-            def __len__(self):
-                return 1
-
-        class AqObject(Implicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 1
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 1
-
-
-    def testImplicitTruthSemanticsWithNonZeroAndLen(self):
-        """Check wrapper truth semantics against those of python objects
-           with __nonzero__ and __len__ defined."""
-
-        class PyObject:
-            def __nonzero__(self):
-                return 0
-
-            def __len__(self):
-                return 1
-
-        class AqObject(Implicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 0
-        assert len(object) == 1
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 0
-        assert len(object) == 1
-
-
-        class PyObject:
-            def __nonzero__(self):
-                return 1
-
-            def __len__(self):
-                return 0
-
-        class AqObject(Implicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 1
-        assert len(object) == 0
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 1
-        assert len(object) == 0
-
-
-    def testExplicitTruthSemanticsDefault(self):
-        """Check wrapper truth semantics against those of python objects
-           without __len__ or __nonzero__ definitions."""
-
-        class PyObject:
-            # plain object, no __len__ or __nonzero__
-            pass
-
-        class AqObject(Explicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 1
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 1
-
-
-    def testExplicitTruthSemanticsWithNonZero(self):
-        """Check wrapper truth semantics against those of python objects
-           with __nonzero__ defined."""
-
-        class PyObject:
-            def __nonzero__(self):
-                return 0
-
-        class AqObject(Explicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 0
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 0
-
-
-        class PyObject:
-            def __nonzero__(self):
-                return 1
-
-        class AqObject(Explicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 1
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 1
-
-
-    def testExplicitTruthSemanticsWithLen(self):
-        """Check wrapper truth semantics against those of python objects
-           with __len__ defined."""
-
-        class PyObject:
-            def __len__(self):
-                return 0
-
-        class AqObject(Explicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 0
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 0
-
-
-        class PyObject:
-            def __len__(self):
-                return 1
-
-        class AqObject(Explicit, PyObject):
-            pass
-
-        object = PyObject()
-        assert truth(object) == 1
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 1
-
-
-    def testExplicitTruthSemanticsWithNonZeroAndLen(self):
-        """Check wrapper truth semantics against those of python objects
-           with __nonzero__ and __len__ defined."""
 
-        class PyObject:
-            def __nonzero__(self):
-                return 0
+class ImplicitWrapperTests(MagicMethodTests):
+    """Implicit acquisition wrapper tests."""
 
-            def __len__(self):
-                return 1
+    BaseClass = Implicit
 
-        class AqObject(Explicit, PyObject):
+    def fixup_inst(self, object):
+        """Create a simple acquisition chain."""
+        class GenericWrapper(self.BaseClass):
             pass
+        parent = GenericWrapper()
+        parent.object = object
+        return parent.object
 
-        object = PyObject()
-        assert truth(object) == 0
-        assert len(object) == 1
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 0
-        assert len(object) == 1
 
+class ExplicitWrapperTests(ImplicitWrapperTests):
+    """Explicit acquisition wrapper tests."""
 
-        class PyObject:
-            def __nonzero__(self):
-                return 1
+    BaseClass = Explicit
 
-            def __len__(self):
-                return 0
 
-        class AqObject(Explicit, PyObject):
-            pass
 
-        object = PyObject()
-        assert truth(object) == 1
-        assert len(object) == 0
-
-        parent = AqObject()
-        parent.object = AqObject()
-        object = parent.object
-        assert truth(object) == 1
-        assert len(object) == 0
 
 
 
-
-
-
+def test_suite():
+    suite_01 = unittest.makeSuite(ImplicitWrapperTests)
+    suite_02 = unittest.makeSuite(ExplicitWrapperTests)
+    return unittest.TestSuite((suite_01, suite_02))
 
+def main():
+    unittest.TextTestRunner().run(test_suite())
 
-def test_suite():
-    return unittest.makeSuite(AcquisitionTests)
+if __name__ == '__main__':
+    main()