updated

lib/Components/ExtensionClass/test/testExtensionClass.py

 """ExtensionClass unit tests."""
 
 from operator import truth
-import unittest, string
+import sys, unittest, string
 import ExtensionClass
 
 
 class MagicMethodTests(unittest.TestCase):
-    """Test delegation to magic methods."""
+    """Test delegation to magic methods - organized roughly along the
+       lines of the documentation in the Python language reference."""
 
     BaseClass = ExtensionClass.Base
 
@@ -14,66 +15,49 @@ class MagicMethodTests(unittest.TestCase):
         """A hook to allow acquisition tests based on this fixture."""
         return object
 
+
+
     #########################################################################
-    # Test delegation of magic methods for attribute management.
+    # Test delegation of magic methods for basic customization.
     #########################################################################
 
-    def test__getattr__(self):
-        """Test __getattr__ delegation."""
+    def test__del__(self):
+        """Test __del__ delegation."""
 
         class PythonClass:
-            def __getattr__(self, name):
-                return 'bruce'
+            def __del__(self):
+                setattr(sys, 'result', 1)
 
         class DerivedClass(self.BaseClass, PythonClass):
             pass
 
         object = PythonClass()
-        assert object.foo == 'bruce'
+        del object
+        assert sys.result == 1
+        del sys.result
 
         object = self.fixup_inst(DerivedClass())
-        assert object.foo == 'bruce'
-
+        del object
+        assert sys.result == 1
+        del sys.result
 
-    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."""
+    def test__repr__(self):
+        """Test __repr__ delegation."""
 
         class PythonClass:
-            def __delattr__(self, name):
-                return
+            def __repr__(self):
+                return 'bruce'
 
         class DerivedClass(self.BaseClass, PythonClass):
             pass
 
         object = PythonClass()
-        del object.foo
+        assert repr(object) == 'bruce'
 
         object = self.fixup_inst(DerivedClass())
-        del object.foo
-
+        assert repr(object) == 'bruce'
 
-    #########################################################################
-    # Test delegation of magic methods for basic customization.
-    #########################################################################
 
     def test__str__(self):
         """Test __str__ delegation."""
@@ -92,28 +76,13 @@ class MagicMethodTests(unittest.TestCase):
         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:
+            called = 0
             def __cmp__(self, other):
+                self.called = 1
                 return 1
 
         class DerivedClass(self.BaseClass, PythonClass):
@@ -121,9 +90,11 @@ class MagicMethodTests(unittest.TestCase):
 
         object = PythonClass()
         assert object > 1
+        assert object.called == 1
 
         object = self.fixup_inst(DerivedClass())
         assert object > 1
+        assert object.called == 1
 
 
     def test__hash__(self):
@@ -155,7 +126,7 @@ class MagicMethodTests(unittest.TestCase):
                 return 1
 
             def __cmp__(self, other):
-                raise AssertionError, 'Rich comparison not used!'
+                raise AssertionError('Rich comparison not used!')
 
         class DerivedClass(self.BaseClass, PythonClass):
             pass
@@ -175,7 +146,7 @@ class MagicMethodTests(unittest.TestCase):
                 return 1
 
             def __cmp__(self, other):
-                raise AssertionError, 'Rich comparison not used!'
+                raise AssertionError('Rich comparison not used!')
 
         class DerivedClass(self.BaseClass, PythonClass):
             pass
@@ -195,7 +166,7 @@ class MagicMethodTests(unittest.TestCase):
                 return 1
 
             def __cmp__(self, other):
-                raise AssertionError, 'Rich comparison not used!'
+                raise AssertionError('Rich comparison not used!')
 
         class DerivedClass(self.BaseClass, PythonClass):
             pass
@@ -215,7 +186,7 @@ class MagicMethodTests(unittest.TestCase):
                 return 1
 
             def __cmp__(self, other):
-                raise AssertionError, 'Rich comparison not used!'
+                raise AssertionError('Rich comparison not used!')
 
         class DerivedClass(self.BaseClass, PythonClass):
             pass
@@ -235,7 +206,7 @@ class MagicMethodTests(unittest.TestCase):
                 return 1
 
             def __cmp__(self, other):
-                raise AssertionError, 'Rich comparison not used!'
+                raise AssertionError('Rich comparison not used!')
 
         class DerivedClass(self.BaseClass, PythonClass):
             pass
@@ -255,7 +226,7 @@ class MagicMethodTests(unittest.TestCase):
                 return 1
 
             def __cmp__(self, other):
-                raise AssertionError, 'Rich comparison not used!'
+                raise AssertionError('Rich comparison not used!')
 
         class DerivedClass(self.BaseClass, PythonClass):
             pass
@@ -375,7 +346,178 @@ class MagicMethodTests(unittest.TestCase):
 
 
     #########################################################################
-    # Test delegation of overridable binary arithmetic operations.
+    # Test delegation of attribute access methods
+    #########################################################################
+
+    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:
+            called = 0
+            def __delattr__(self, name):
+                self.called = 1
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass()
+        del object.foo
+        assert object.called == 1
+
+        object = self.fixup_inst(DerivedClass())
+        del object.foo
+        assert object.called == 1
+
+
+    def test__call__(self):
+        """Test __call__ delegation."""
+
+        class PythonClass:
+            def __call__(self, arg):
+                return arg
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass()
+        assert object('bruce') == 'bruce'
+
+        object = self.fixup_inst(DerivedClass())
+        assert object('bruce') == 'bruce'
+
+
+    #########################################################################
+    # Test delegation of sequence and mapping operations. 
+    #########################################################################
+
+    def test__len__(self):
+        """Test __len__ delegation."""
+
+        class PythonClass:
+            def __len__(self):
+                return 42
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass()
+        assert len(object) == 42
+
+        object = self.fixup_inst(DerivedClass(1))
+        assert len(object) == 42
+
+
+    def test__getitem__(self):
+        """Test __getitem__ delegation."""
+
+        class PythonClass:
+            def __getitem__(self, key):
+                return key
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass()
+        assert object['bruce'] == 'bruce'
+
+        object = self.fixup_inst(DerivedClass(1))
+        assert object['bruce'] == 'bruce'
+
+
+    def test__setitem__(self):
+        """Test __setitem__ delegation."""
+
+        class PythonClass:
+            def __setitem__(self, key, value):
+                setattr(self, key, value)
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass()
+        object['bruce'] = 'bruce'
+        assert object.bruce == 'bruce'
+
+        object = self.fixup_inst(DerivedClass(1))
+        object['bruce'] = 'bruce'
+        assert object.bruce == 'bruce'
+
+
+    def test__delitem__(self):
+        """Test __delitem__ delegation."""
+
+        class PythonClass:
+            called = 0
+            def __delitem__(self, key):
+                self.called = 1
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass()
+        del object['bruce']
+        assert object.called == 1
+
+        object = self.fixup_inst(DerivedClass(1))
+        del object['bruce']
+        assert object.called == 1
+
+
+    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
+
+
+    #########################################################################
+    # Test delegation of numeric operations.
     #########################################################################
 
     def test__add__(self):
@@ -384,7 +526,7 @@ class MagicMethodTests(unittest.TestCase):
         class PythonClass:
             def __init__(self, value):
                 self.value = value
-                
+
             def __add__(self, other):
                 return self.value + other
 
@@ -398,13 +540,35 @@ class MagicMethodTests(unittest.TestCase):
         assert object + 1 == 2
 
 
+    def test__add__seq(self):
+        """Test __add__ (sequence) delegation."""
+
+        class PythonClass:
+            def __init__(self, value):
+                self.value = value
+
+            def __add__(self, other):
+                return self.__class__(self.value + other)
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass([1, 2])
+        object = object + [3, 4]
+        assert object.value == [1, 2, 3, 4]
+
+        object = self.fixup_inst(DerivedClass([1, 2]))
+        object = object + [3, 4]
+        assert object.value == [1, 2, 3, 4]
+
+
     def test__sub__(self):
         """Test __sub__ delegation."""
 
         class PythonClass:
             def __init__(self, value):
                 self.value = value
-                
+
             def __sub__(self, other):
                 return self.value - other
 
@@ -424,7 +588,7 @@ class MagicMethodTests(unittest.TestCase):
         class PythonClass:
             def __init__(self, value):
                 self.value = value
-                
+
             def __mul__(self, other):
                 return self.value * other
 
@@ -438,13 +602,35 @@ class MagicMethodTests(unittest.TestCase):
         assert object * 2 == 4
 
 
+    def test__mul__seq(self):
+        """Test __mul__ (sequence) delegation."""
+
+        class PythonClass:
+            def __init__(self, value):
+                self.value = value
+
+            def __mul__(self, other):
+                return self.__class__(self.value * other)
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass([1, 2])
+        object = object * 2
+        assert object.value == [1, 2, 1, 2]
+
+        object = self.fixup_inst(DerivedClass([1, 2]))
+        object = object * 2
+        assert object.value == [1, 2, 1, 2]
+
+
     def test__div__(self):
         """Test __div__ delegation."""
 
         class PythonClass:
             def __init__(self, value):
                 self.value = value
-                
+
             def __div__(self, other):
                 return self.value / other
 
@@ -464,7 +650,7 @@ class MagicMethodTests(unittest.TestCase):
         class PythonClass:
             def __init__(self, value):
                 self.value = value
-                
+
             def __mod__(self, other):
                 return self.value % other
 
@@ -618,10 +804,6 @@ class MagicMethodTests(unittest.TestCase):
         assert object | 1 == 1
 
 
-    #########################################################################
-    # Test delegation of reflected binary arithmetic operations.
-    #########################################################################
-
     def test__radd__(self):
         """Test __radd__ delegation."""
 
@@ -682,6 +864,28 @@ class MagicMethodTests(unittest.TestCase):
         assert 2 * object == 4
 
 
+    def test__rmul__seq(self):
+        """Test __rmul__ (sequence) delegation."""
+
+        class PythonClass:
+            def __init__(self, value):
+                self.value = value
+                
+            def __rmul__(self, other):
+                return self.__class__(other * self.value)
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass([1, 2])
+        object = 2 * object
+        assert object.value == [1, 2, 1, 2]
+
+        object = self.fixup_inst(DerivedClass([1, 2]))
+        object = 2 * object
+        assert object.value == [1, 2, 1, 2]
+
+
     def test__rdiv__(self):
         """Test __rdiv__ delegation."""
 
@@ -749,7 +953,7 @@ class MagicMethodTests(unittest.TestCase):
             def __init__(self, value):
                 self.value = value
                 
-            def __rpow__(self, other):
+            def __rpow__(self, other, modulo=None):
                 return other ** self.value
 
         class DerivedClass(self.BaseClass, PythonClass):
@@ -862,10 +1066,6 @@ class MagicMethodTests(unittest.TestCase):
         assert 1 | object == 1
 
 
-    #########################################################################
-    # Test delegation of augmented assignment operations.
-    #########################################################################
-
     def test__iadd__(self):
         """Test __iadd__ delegation."""
 
@@ -888,6 +1088,29 @@ class MagicMethodTests(unittest.TestCase):
         assert object.value == 2
 
 
+    def test__iadd__seq(self):
+        """Test __iadd__ (sequence) delegation."""
+
+        class PythonClass:
+            def __init__(self, value):
+                self.value = value
+                
+            def __iadd__(self, other):
+                self.value += other
+                return self
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass([1, 2])
+        object += [3, 4]
+        assert object.value == [1, 2, 3, 4]
+
+        object = self.fixup_inst(DerivedClass([1, 2]))
+        object += [3, 4]
+        assert object.value == [1, 2, 3, 4]
+
+
     def test__isub__(self):
         """Test __isub__ delegation."""
 
@@ -932,6 +1155,29 @@ class MagicMethodTests(unittest.TestCase):
         assert object.value == 4
 
 
+    def test__imul__seq(self):
+        """Test __imul__ (sequence) delegation."""
+
+        class PythonClass:
+            def __init__(self, value):
+                self.value = value
+                
+            def __imul__(self, other):
+                self.value *= other
+                return self
+
+        class DerivedClass(self.BaseClass, PythonClass):
+            pass
+
+        object = PythonClass([1, 2])
+        object *= 2
+        assert object.value == [1, 2, 1, 2]
+
+        object = self.fixup_inst(DerivedClass([1, 2]))
+        object *= 2
+        assert object.value == [1, 2, 1, 2]
+
+
     def test__idiv__(self):
         """Test __idiv__ delegation."""
 
@@ -983,7 +1229,7 @@ class MagicMethodTests(unittest.TestCase):
             def __init__(self, value):
                 self.value = value
                 
-            def __ipow__(self, other):
+            def __ipow__(self, other, modulo=None):
                 return self.__class__(self.value ** other)
 
         class DerivedClass(self.BaseClass, PythonClass):
@@ -1108,10 +1354,6 @@ class MagicMethodTests(unittest.TestCase):
         assert object.value == 1
 
 
-    #########################################################################
-    # Test delegation of unary arithmetic operations.
-    #########################################################################
-
     def test__pos__(self):
         """Test __pos__ delegation."""
 
@@ -1202,10 +1444,6 @@ class MagicMethodTests(unittest.TestCase):
         assert object.value == -10
 
 
-    #########################################################################
-    # Test delegation of numeric type coercion.
-    #########################################################################
-
     def test__int__(self):
         """Test __int__ delegation."""
 
@@ -1286,10 +1524,6 @@ class MagicMethodTests(unittest.TestCase):
         assert complex(object) == complex(1)
 
 
-    #########################################################################
-    # Test delegation of overridable __oct__ and __hex__
-    #########################################################################
-
     def test__oct__(self):
         """Test __oct__ delegation."""
 
@@ -1330,10 +1564,6 @@ class MagicMethodTests(unittest.TestCase):
         assert hex(object) == '0xa'
 
 
-    #########################################################################
-    # Test delegation of mixed-mode coercion
-    #########################################################################
-
     def test__coerce__(self):
         """Test __coerce__ delegation."""
 
@@ -1355,28 +1585,6 @@ class MagicMethodTests(unittest.TestCase):
 
 
 
-    #########################################################################
-    # 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):