[Zope3-checkins] CVS: Zope3/src/zope/interface/tests - __init__.py:1.2 dummy.py:1.2 iadapter.py:1.2 ifoo.py:1.2 iimplementor.py:1.2 test_adapter.py:1.2 test_document.py:1.2 test_implementor.py:1.2 test_implements.py:1.2 test_interface.py:1.2 test_sorting.py:1.2 test_type.py:1.2 test_verify.py:1.2 test_visitimplements.py:1.2 unitfixtures.py:1.2

Jim Fulton jim@zope.com
Wed, 25 Dec 2002 09:15:43 -0500


Update of /cvs-repository/Zope3/src/zope/interface/tests
In directory cvs.zope.org:/tmp/cvs-serv20790/src/zope/interface/tests

Added Files:
	__init__.py dummy.py iadapter.py ifoo.py iimplementor.py 
	test_adapter.py test_document.py test_implementor.py 
	test_implements.py test_interface.py test_sorting.py 
	test_type.py test_verify.py test_visitimplements.py 
	unitfixtures.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/interface/tests/__init__.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/__init__.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,2 @@
+#
+# This file is necessary to make this directory a package.


=== Zope3/src/zope/interface/tests/dummy.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/dummy.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,19 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+from zope.interface.tests.ifoo import IFoo
+
+__implements__ = IFoo
+
+def bar( baz ):
+    pass


=== Zope3/src/zope/interface/tests/iadapter.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/iadapter.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,274 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+import unittest
+
+from zope.interface import Interface
+
+class R1(Interface): pass
+class R12(Interface): pass
+class R2(R1): pass
+class R3(R2): pass
+class R4(R3): pass
+
+class P1(Interface): pass
+class P2(P1): pass
+class P3(P2): pass
+class P4(P3): pass
+
+class TestIAdapterRegistry(unittest.TestCase):
+
+    def _new(self):
+        # subclass should override to return registry to test
+        pass
+
+    def testImplementsIAdapterRegistry(self):
+        from zope.interface.verify import verifyObject
+        from zope.interface.interfaces import IAdapterRegistry
+
+        registry = self._new()
+
+        verifyObject(IAdapterRegistry, registry)
+
+    def __registery(self):
+        registry = self._new()
+
+        registry.register(None, P3, 'default P3')
+        registry.register(Interface, P3, 'any P3')
+        registry.register(R2, P3, 'R2 P3')
+
+        return registry
+
+    def testBadRequire(self):
+        registry = self._new()
+        self.assertRaises(TypeError, registry.register, 42, P3, '')
+
+    def testBadProvide(self):
+        registry = self._new()
+        self.assertRaises(TypeError, registry.register, R2, None, '')
+
+
+    def test_get(self):
+        registry = self.__registery()
+
+        for R in [R2, R3, R4, (R12, R2), (R12, R4)]:
+            for P in [P1, P2, P3]:
+                self.assertEqual(registry.get((R, P)), 'R2 P3')
+
+        for R in [None, R1, R2, R3, R4, (R12, R2), (R12, R4)]:
+            self.assertEqual(registry.get((R, P4)), None)
+
+        for P in [P1, P2, P3]:
+            self.assertEqual(registry.get((R1, P)), 'any P3')
+
+        for P in [P1, P2, P3]:
+            self.assertEqual(registry.get((None, P)), 'default P3')
+
+    def test_getForObject(self):
+        registry = self.__registery()
+
+        class C: pass
+        c = C()
+
+        for R in [R2, R3, R4, (R12, R2), (R12, R4)]:
+            c.__implements__ = R
+            for P in [P1, P2, P3]:
+                self.assertEqual(registry.getForObject(c, P), 'R2 P3')
+
+        for R in [None, R1, R2, R3, R4, (R12, R2), (R12, R4)]:
+            c.__implements__ = R
+            self.assertEqual(registry.getForObject(c, None), None)
+
+        c.__implements__ = R1
+        for P in [P1, P2, P3]:
+            self.assertEqual(registry.getForObject(c, P), 'any P3')
+
+        c = C()
+        for P in [P1, P2, P3]:
+            self.assertEqual(registry.getForObject(c, P), 'default P3')
+
+    def test_get_w_filter(self):
+        registry = self.__registery()
+
+        for R in [R2, R3, R4, (R12, R2), (R12, R4)]:
+            for P in [P1, P2, P3]:
+                self.assertEqual(
+                    registry.get((R, P), filter=lambda o: o.startswith('a')),
+                    'any P3')
+                self.assertEqual(
+                    registry.get((R, P), filter=lambda o: o.startswith('d')),
+                    'default P3')
+                self.assertEqual(
+                    registry.get((R, P), filter=lambda o: o.startswith('z')),
+                    None)
+
+    def test_getForObject_w_filter(self):
+        registry = self.__registery()
+
+        class C: pass
+        c = C()
+
+        for R in [R2, R3, R4, (R12, R2), (R12, R4)]:
+            c.__implements__ = R
+            for P in [P1, P2, P3]:
+                self.assertEqual(
+                    registry.getForObject(c, P,
+                                          filter=lambda o: o.startswith('a')),
+                    'any P3')
+                self.assertEqual(
+                    registry.getForObject(c, P,
+                                          filter=lambda o: o.startswith('d')),
+                    'default P3')
+                self.assertEqual(
+                    registry.getForObject(c, P,
+                                          filter=lambda o: o.startswith('z')),
+                    None)
+
+    def test_getRegistered(self):
+        registry = self.__registery()
+
+        # Get something that was registered directly
+        self.assertEqual(registry.getRegistered(R2, P3), 'R2 P3')
+        self.assertEqual(registry.getRegistered(Interface, P3), 'any P3')
+        self.assertEqual(registry.getRegistered(None, P3), 'default P3')
+
+        # this mustn't return anything that was not registered directly
+        self.assertEqual(registry.getRegistered(R3, P3), None)
+        self.assertEqual(registry.getRegistered(R2, P2), None)
+
+    def test_getRegisteredMatching_all(self):
+        registry = self.__registery()
+
+        got = list(registry.getRegisteredMatching())
+        got.sort()
+        expect = [
+            (None, P3, 'default P3'),
+            (Interface, P3, 'any P3'),
+            (R2, P3, 'R2 P3'),
+            ]
+        expect.sort()
+        self.assertEqual(got, expect)
+
+    def test_getRegisteredMatching_required_R1(self):
+        registry = self.__registery()
+
+        got = list(registry.getRegisteredMatching(
+            required_interfaces = (R1, )
+            ))
+        got.sort()
+        expect = [
+            (None, P3, 'default P3'),
+            (Interface, P3, 'any P3'),
+            ]
+        expect.sort()
+        self.assertEqual(got, expect)
+
+    def test_getRegisteredMatching_required_multiple(self):
+        registry = self.__registery()
+
+        got = list(registry.getRegisteredMatching(
+            required_interfaces = (R12, R2)
+            ))
+        got.sort()
+        expect = [
+            (None, P3, 'default P3'),
+            (Interface, P3, 'any P3'),
+            (R2, P3, 'R2 P3'),
+            ]
+        expect.sort()
+        self.assertEqual(got, expect)
+
+    def test_getRegisteredMatching_provided_P1(self):
+        registry = self.__registery()
+
+        got = list(registry.getRegisteredMatching(
+            provided_interfaces = (P1, )
+            ))
+        got.sort()
+        expect = [
+            (None, P3, 'default P3'),
+            (Interface, P3, 'any P3'),
+            (R2, P3, 'R2 P3'),
+            ]
+        expect.sort()
+        self.assertEqual(got, expect)
+
+    def test_getRegisteredMatching_provided_P2(self):
+        registry = self.__registery()
+
+        got = list(registry.getRegisteredMatching(
+            provided_interfaces = (P3, )
+            ))
+        got.sort()
+        expect = [
+            (None, P3, 'default P3'),
+            (Interface, P3, 'any P3'),
+            (R2, P3, 'R2 P3'),
+            ]
+        expect.sort()
+        self.assertEqual(got, expect)
+
+    def test_getRegisteredMatching_required_and_provided_1(self):
+        registry = self.__registery()
+
+        got = list(registry.getRegisteredMatching(
+            required_interfaces = (R4, R12),
+            provided_interfaces = (P1, ),
+            ))
+        got.sort()
+        expect = [
+            (None, P3, 'default P3'),
+            (Interface, P3, 'any P3'),
+            (R2, P3, 'R2 P3'),
+            ]
+        expect.sort()
+        self.assertEqual(got, expect)
+
+    def test_getRegisteredMatching_required_and_provided_2(self):
+        registry = self.__registery()
+
+        got = list(registry.getRegisteredMatching(
+            required_interfaces = (R4, R12),
+            provided_interfaces = (P3, ),
+            ))
+        got.sort()
+        expect = [
+            (None, P3, 'default P3'),
+            (Interface, P3, 'any P3'),
+            (R2, P3, 'R2 P3'),
+            ]
+        expect.sort()
+        self.assertEqual(got, expect)
+
+
+    def test_getRegisteredMatching_required_and_provided_exact(self):
+        registry = self.__registery()
+
+        got = list(registry.getRegisteredMatching(
+            required_interfaces = (R2, ),
+            provided_interfaces = (P3, ),
+            ))
+        got.sort()
+        expect = [
+            (None, P3, 'default P3'),
+            (Interface, P3, 'any P3'),
+            (R2, P3, 'R2 P3'),
+            ]
+        expect.sort()
+        self.assertEqual(got, expect)


=== Zope3/src/zope/interface/tests/ifoo.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/ifoo.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,24 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+from zope.interface import Interface
+
+class IFoo( Interface ):
+    """
+        Dummy interface for unit tests.
+    """
+
+    def bar( baz ):
+        """
+            Just a note.
+        """


=== Zope3/src/zope/interface/tests/iimplementor.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/iimplementor.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,66 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+import unittest
+from zope.interface import Interface
+
+class R1(Interface): pass
+class R12(Interface): pass
+class R2(R1): pass
+class R3(R2): pass
+class R4(R3): pass
+
+class P1(Interface): pass
+class P2(P1): pass
+class P3(P2): pass
+class P4(P3): pass
+
+class TestIImplementorRegistry(unittest.TestCase):
+
+    def _new(self):
+        # subclass must define method to return registry
+        raise NotImplementedError
+
+    def testImplementsIImplementorRegistry(self):
+        from zope.interface.verify import verifyObject
+        from zope.interface.interfaces \
+             import IImplementorRegistry
+
+        registry = self._new()
+        verifyObject(IImplementorRegistry, registry)
+
+    def __registry(self):
+        registry = self._new()
+        registry.register(P3, 'C3')
+        return registry
+
+    def test_get(self):
+        registry = self.__registry()
+
+        for P in [P1, P2, P3]:
+            self.assertEqual(registry.get(P), 'C3')
+
+        self.assertEqual(registry.get(P4), None)
+
+        registry.register(P1, 'C1')
+        registry.register(P2, 'C3')
+
+    def testBadProvide(self):
+        registry = self.__registry()
+        self.assertRaises(TypeError, registry.register, None, '')


=== Zope3/src/zope/interface/tests/test_adapter.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_adapter.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,33 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from unittest import TestCase, main, makeSuite
+from zope.interface.tests.iadapter import TestIAdapterRegistry
+
+class Test(TestIAdapterRegistry, TestCase):
+
+    def _new(self):
+        from zope.interface.adapter import AdapterRegistry
+        return AdapterRegistry()
+
+def test_suite():
+    return makeSuite(Test)
+
+if __name__=='__main__':
+    main(defaultTest='test_suite')


=== Zope3/src/zope/interface/tests/test_document.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_document.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,73 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from unittest import TestCase, TestSuite, main, makeSuite
+from zope.interface import Interface
+from zope.interface.interface import Attribute
+
+class Test(TestCase):
+
+    def testBlech(self):
+        from zope.interface.document import asStructuredText
+
+        self.assertEqual(asStructuredText(I2), '''\
+I2
+
+ I2 doc
+
+ This interface extends:
+
+  o _I1
+
+ Attributes:
+
+  a1 -- no documentation
+
+  a2 -- a2 doc
+
+ Methods:
+
+  f21() -- f21 doc
+
+  f22() -- no documentation
+
+  f23() -- f23 doc
+
+''')
+
+
+def test_suite():
+    return makeSuite(Test)
+
+class _I1(Interface):
+    def f11(): pass
+    def f12(): pass
+
+class I2(_I1):
+    "I2 doc"
+
+    a1 = Attribute('a1')
+    a2 = Attribute('a2', 'a2 doc')
+
+    def f21(): "f21 doc"
+    def f22(): pass
+    def f23(): "f23 doc"
+
+if __name__=='__main__':
+    main(defaultTest='test_suite')


=== Zope3/src/zope/interface/tests/test_implementor.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_implementor.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,33 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+from unittest import TestCase, main, makeSuite
+from zope.interface.tests.iimplementor import TestIImplementorRegistry
+
+class Test(TestIImplementorRegistry, TestCase):
+
+    def _new(self):
+        from zope.interface.implementor import ImplementorRegistry
+        return ImplementorRegistry()
+
+def test_suite():
+    return makeSuite(Test)
+
+if __name__=='__main__':
+    main(defaultTest='test_suite')


=== Zope3/src/zope/interface/tests/test_implements.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_implements.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,70 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+
+from zope.interface import Interface
+from zope.interface.implements import implements
+from zope.interface.exceptions import DoesNotImplement, BrokenImplementation
+from zope.interface.exceptions import BrokenMethodImplementation
+
+import unittest, sys
+
+class Test(unittest.TestCase):
+
+    def testSimple(self):
+
+        class I(Interface):
+            def f(): pass
+
+        class C: pass
+
+        self.assertRaises(BrokenImplementation, implements, C, I)
+
+        C.f=lambda self: None
+
+        implements(C, I)
+
+        self.assertEqual(C.__implements__, I)
+
+    def testAdd(self):
+
+        class I(Interface):
+            def f(): pass
+
+        class I2(Interface):
+            def g(): pass
+
+        class C:
+            __implements__=I2
+
+        self.assertRaises(BrokenImplementation, implements, C, I)
+        self.assertRaises(BrokenImplementation, implements, C, I2)
+
+        C.f=lambda self: None
+
+        implements(C, I)
+
+        self.assertEqual(C.__implements__, (I2, I))
+        self.assertRaises(BrokenImplementation, implements, C, I2)
+
+        C.g=C.f
+        implements(C, I)
+        implements(C, I2)
+
+
+def test_suite():
+    loader=unittest.TestLoader()
+    return loader.loadTestsFromTestCase(Test)
+
+if __name__=='__main__':
+    unittest.TextTestRunner().run(test_suite())


=== Zope3/src/zope/interface/tests/test_interface.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_interface.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,168 @@
+##############################################################################
+#
+# 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 unittest
+import zope.interface
+from zope.interface.tests.unitfixtures import *  # hehehe
+from zope.interface.exceptions import BrokenImplementation
+from zope.interface.implements import instancesOfObjectImplements
+from zope.interface.implements import objectImplements
+from zope.interface import Interface
+from zope.interface.interface import Attribute
+
+class InterfaceTests(unittest.TestCase):
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def testClassImplements(self):
+        assert IC.isImplementedByInstancesOf(C)
+
+        assert I1.isImplementedByInstancesOf(A)
+        assert I1.isImplementedByInstancesOf(B)
+        assert not I1.isImplementedByInstancesOf(C)
+        assert I1.isImplementedByInstancesOf(D)
+        assert I1.isImplementedByInstancesOf(E)
+
+        assert not I2.isImplementedByInstancesOf(A)
+        assert I2.isImplementedByInstancesOf(B)
+        assert not I2.isImplementedByInstancesOf(C)
+        assert not I2.isImplementedByInstancesOf(D)
+        assert not I2.isImplementedByInstancesOf(E)
+
+    def testUtil(self):
+        f = instancesOfObjectImplements
+        assert IC in f(C)
+        assert I1 in f(A)
+        assert not I1 in f(C)
+        assert I2 in f(B)
+        assert not I2 in f(C)
+
+        f = objectImplements
+        assert IC in f(C())
+        assert I1 in f(A())
+        assert not I1 in f(C())
+        assert I2 in f(B())
+        assert not I2 in f(C())
+
+
+    def testObjectImplements(self):
+        assert IC.isImplementedBy(C())
+
+        assert I1.isImplementedBy(A())
+        assert I1.isImplementedBy(B())
+        assert not I1.isImplementedBy(C())
+        assert I1.isImplementedBy(D())
+        assert I1.isImplementedBy(E())
+
+        assert not I2.isImplementedBy(A())
+        assert I2.isImplementedBy(B())
+        assert not I2.isImplementedBy(C())
+        assert not I2.isImplementedBy(D())
+        assert not I2.isImplementedBy(E())
+
+    def testDeferredClass(self):
+        a = A()
+        self.assertRaises(BrokenImplementation, a.ma)
+
+
+    def testInterfaceExtendsInterface(self):
+        assert BazInterface.extends(BobInterface)
+        assert BazInterface.extends(BarInterface)
+        assert BazInterface.extends(FunInterface)
+        assert not BobInterface.extends(FunInterface)
+        assert not BobInterface.extends(BarInterface)
+        assert BarInterface.extends(FunInterface)
+        assert not BarInterface.extends(BazInterface)
+
+    def testVerifyImplementation(self):
+        from zope.interface.verify import verifyClass
+        assert verifyClass(FooInterface, Foo)
+        assert Interface.isImplementedBy(I1)
+
+    def test_names(self):
+        names = list(_I2.names()); names.sort()
+        self.assertEqual(names, ['f21', 'f22', 'f23'])
+        names = list(_I2.names(1)); names.sort()
+        self.assertEqual(names, ['a1', 'f11', 'f12', 'f21', 'f22', 'f23'])
+
+    def test_namesAndDescriptions(self):
+        names = [nd[0] for nd in _I2.namesAndDescriptions()]; names.sort()
+        self.assertEqual(names, ['f21', 'f22', 'f23'])
+        names = [nd[0] for nd in _I2.namesAndDescriptions(1)]; names.sort()
+        self.assertEqual(names, ['a1', 'f11', 'f12', 'f21', 'f22', 'f23'])
+
+        for name, d in _I2.namesAndDescriptions(1):
+            self.assertEqual(name, d.__name__)
+
+    def test_getDescriptionFor(self):
+        self.assertEqual(_I2.getDescriptionFor('f11').__name__, 'f11')
+        self.assertEqual(_I2.getDescriptionFor('f22').__name__, 'f22')
+        self.assertEqual(_I2.queryDescriptionFor('f33', self), self)
+        self.assertRaises(KeyError, _I2.getDescriptionFor, 'f33')
+
+    def test___getitem__(self):
+        self.assertEqual(_I2['f11'].__name__, 'f11')
+        self.assertEqual(_I2['f22'].__name__, 'f22')
+        self.assertEqual(_I2.get('f33', self), self)
+        self.assertRaises(KeyError, _I2.__getitem__, 'f33')
+
+    def test___contains__(self):
+        self.failUnless('f11' in _I2)
+        self.failIf('f33' in _I2)
+
+    def test___iter__(self):
+        names = list(iter(_I2))
+        names.sort()
+        self.assertEqual(names, ['a1', 'f11', 'f12', 'f21', 'f22', 'f23'])
+
+    def testAttr(self):
+        description = _I2.getDescriptionFor('a1')
+        self.assertEqual(description.__name__, 'a1')
+        self.assertEqual(description.__doc__, 'This is an attribute')
+
+
+    def testFunctionAttributes(self):
+        # Make sure function attributes become tagged values.
+        meth = _I1['f12']
+        self.assertEqual(meth.getTaggedValue('optional'), 1)
+
+class _I1(Interface):
+
+    a1 = Attribute("This is an attribute")
+
+    def f11(): pass
+    def f12(): pass
+    f12.optional = 1
+
+class _I1_(_I1): pass
+class _I1__(_I1_): pass
+
+class _I2(_I1__):
+    def f21(): pass
+    def f22(): pass
+    f23 = f22
+
+
+def test_suite():
+    return unittest.makeSuite(InterfaceTests)
+
+def main():
+    unittest.TextTestRunner().run(test_suite())
+
+if __name__=="__main__":
+    main()


=== Zope3/src/zope/interface/tests/test_sorting.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_sorting.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,49 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+"""Test interface sorting
+
+$Id$
+"""
+
+from unittest import TestCase, TestSuite, main, makeSuite
+
+from zope.interface import Interface
+
+class I1(Interface): pass
+class I2(I1): pass
+class I3(I1): pass
+class I4(Interface): pass
+class I5(I4): pass
+class I6(I2): pass
+
+
+class Test(TestCase):
+
+    def test(self):
+        l = [I1, I3, I5, I6, I4, I2]
+        l.sort()
+        self.assertEqual(l, [I1, I2, I3, I4, I5, I6])
+
+    def test_w_None(self):
+        l = [I1, None, I3, I5, None, I6, I4, I2]
+        l.sort()
+        self.assertEqual(l, [I1, I2, I3, I4, I5, I6, None, None])
+
+def test_suite():
+    return TestSuite((
+        makeSuite(Test),
+        ))
+
+if __name__=='__main__':
+    main(defaultTest='test_suite')


=== Zope3/src/zope/interface/tests/test_type.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_type.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,117 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+import unittest, sys
+from zope.interface.type import TypeRegistry
+from zope.interface import Interface
+
+def getAllForObject(reg, ob):
+    all = list(reg.getAllForObject(ob))
+    all.sort()
+    return all
+
+class Test(unittest.TestCase):
+
+    def test(self):
+        class I1(Interface): pass
+        class I2(I1): pass
+        class I3(I2): pass
+
+        reg = TypeRegistry()
+        reg.register(I2, 2)
+
+        class C1: __implements__ = I1
+        class C2: __implements__ = I2
+        class C3: __implements__ = I3
+        class C: pass
+
+        self.assertEqual(getAllForObject(reg, C1()), [])
+        self.assertEqual(getAllForObject(reg, C2()), [2])
+        self.assertEqual(getAllForObject(reg, C3()), [2])
+        self.assertEqual(getAllForObject(reg,  C()), [])
+
+        self.assertEqual(reg.get(I1), None)
+        self.assertEqual(reg.get(I2), 2)
+        self.assertEqual(reg.get(I3), None)
+
+        reg.register(I1, 1)
+
+        self.assertEqual(getAllForObject(reg, C1()), [1])
+        self.assertEqual(getAllForObject(reg, C2()), [1, 2])
+        self.assertEqual(getAllForObject(reg, C3()), [1, 2])
+        self.assertEqual(getAllForObject(reg,  C()), [])
+
+        self.assertEqual(reg.get(I1), 1)
+        self.assertEqual(reg.get(I2), 2)
+        self.assertEqual(reg.get(I3), None)
+
+        reg.register(I3, 3)
+
+        self.assertEqual(getAllForObject(reg, C1()), [1])
+        self.assertEqual(getAllForObject(reg, C2()), [1, 2])
+        self.assertEqual(getAllForObject(reg, C3()), [1, 2, 3])
+        self.assertEqual(getAllForObject(reg,  C()), [])
+
+        self.assertEqual(reg.get(I1), 1)
+        self.assertEqual(reg.get(I2), 2)
+        self.assertEqual(reg.get(I3), 3)
+
+    def testSetdefault(self):
+        class I(Interface):
+            pass
+        reg = TypeRegistry()
+        x = reg.setdefault(I, 1)
+        y = reg.setdefault(I, 2)
+        self.assertEqual(x, y)
+        self.assertEqual(x, 1)
+
+    def testDup(self):
+        class I1(Interface): pass
+        class I2(I1): pass
+        class I3(I1): pass
+        class I4(I2, I3): pass
+        class C1: __implements__ = I1
+        class C2: __implements__ = I2
+        class C3: __implements__ = I3
+        class C4: __implements__ = I4
+        class C5: __implements__ = I1, I2, I3, I4
+        class C: pass
+
+        reg = TypeRegistry()
+        reg.register(I1, 1)
+        reg.register(I2, 2)
+        reg.register(I3, 3)
+
+        self.assertEqual(getAllForObject(reg, C1()), [1])
+        self.assertEqual(getAllForObject(reg, C2()), [1, 2])
+        self.assertEqual(getAllForObject(reg, C3()), [1, 3])
+        self.assertEqual(getAllForObject(reg, C4()), [1, 2, 3])
+        self.assertEqual(getAllForObject(reg, C5()), [1, 2, 3])
+        self.assertEqual(getAllForObject(reg,  C()), [])
+
+    def testBadRequire(self):
+        registry = TypeRegistry()
+        self.assertRaises(TypeError, registry.register, 42, '')
+
+def test_suite():
+    loader=unittest.TestLoader()
+    return loader.loadTestsFromTestCase(Test)
+
+if __name__=='__main__':
+    unittest.TextTestRunner().run(test_suite())


=== Zope3/src/zope/interface/tests/test_verify.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_verify.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,179 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+"""
+
+Revision information:
+$Id$
+"""
+
+
+from zope.interface import Interface
+from zope.interface.verify import verifyClass, verifyObject
+from zope.interface.exceptions import DoesNotImplement, BrokenImplementation
+from zope.interface.exceptions import BrokenMethodImplementation
+
+import unittest, sys
+
+class Test(unittest.TestCase):
+
+    def testNotImplemented(self):
+
+        class C: pass
+
+        class I(Interface): pass
+
+        self.assertRaises(DoesNotImplement, verifyClass, I, C)
+
+        C.__implements__=I
+
+        verifyClass(I, C)
+
+    def testMissingAttr(self):
+
+        class I(Interface):
+            def f(): pass
+
+        class C:
+
+            __implements__=I
+
+        self.assertRaises(BrokenImplementation, verifyClass, I, C)
+
+        C.f=lambda self: None
+
+        verifyClass(I, C)
+
+    def testMissingAttr_with_Extended_Interface(self):
+
+        class II(Interface):
+            def f():
+                pass
+
+        class I(II):
+            pass
+
+        class C:
+
+            __implements__=I
+
+        self.assertRaises(BrokenImplementation, verifyClass, I, C)
+
+        C.f=lambda self: None
+
+        verifyClass(I, C)
+
+    def testWrongArgs(self):
+
+        class I(Interface):
+            def f(a): pass
+
+        class C:
+
+            def f(self, b): pass
+
+            __implements__=I
+
+        # We no longer require names to match.
+        #self.assertRaises(BrokenMethodImplementation, verifyClass, I, C)
+
+        C.f=lambda self, a: None
+
+        verifyClass(I, C)
+
+        C.f=lambda self, **kw: None
+
+        self.assertRaises(BrokenMethodImplementation, verifyClass, I, C)
+
+        C.f=lambda self, a, *args: None
+
+        verifyClass(I, C)
+
+        C.f=lambda self, a, *args, **kw: None
+
+        verifyClass(I, C)
+
+        C.f=lambda self, *args: None
+
+        verifyClass(I, C)
+
+    def testExtraArgs(self):
+
+        class I(Interface):
+            def f(a): pass
+
+        class C:
+
+            def f(self, a, b): pass
+
+            __implements__=I
+
+        self.assertRaises(BrokenMethodImplementation, verifyClass, I, C)
+
+        C.f=lambda self, a: None
+
+        verifyClass(I, C)
+
+        C.f=lambda self, a, b=None: None
+
+        verifyClass(I, C)
+
+    def testNoVar(self):
+
+        class I(Interface):
+            def f(a, *args): pass
+
+        class C:
+
+            def f(self, a): pass
+
+            __implements__=I
+
+        self.assertRaises(BrokenMethodImplementation, verifyClass, I, C)
+
+        C.f=lambda self, a, *foo: None
+
+        verifyClass(I, C)
+
+    def testNoKW(self):
+
+        class I(Interface):
+            def f(a, **args): pass
+
+        class C:
+
+            def f(self, a): pass
+
+            __implements__=I
+
+        self.assertRaises(BrokenMethodImplementation, verifyClass, I, C)
+
+        C.f=lambda self, a, **foo: None
+
+        verifyClass(I, C)
+
+    def testModule(self):
+
+        from zope.interface.tests.ifoo import IFoo
+        from zope.interface.tests import dummy
+
+        verifyObject(IFoo, dummy)
+
+
+
+def test_suite():
+    loader=unittest.TestLoader()
+    return loader.loadTestsFromTestCase(Test)
+
+if __name__=='__main__':
+    unittest.TextTestRunner().run(test_suite())


=== Zope3/src/zope/interface/tests/test_visitimplements.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/test_visitimplements.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,54 @@
+##############################################################################
+#
+# 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 unittest, sys
+
+from zope.interface.implements import visitImplements
+from zope.interface import Interface
+from zope.interface.exceptions import BadImplements
+
+class I1(Interface): pass
+class I2(Interface): pass
+class I3(Interface): pass
+
+class Test(unittest.TestCase):
+
+    def testSimpleImplements(self):
+        data=[]
+        visitImplements(I1, None, data.append)
+        self.assertEqual(data, [I1])
+
+    def testSimpleBadImplements(self):
+        data=[]
+        self.assertRaises(BadImplements,
+                          visitImplements, unittest, None, data.append)
+
+    def testComplexImplements(self):
+        data=[]
+        visitImplements((I1, (I2, I3)), None, data.append)
+        data = map(lambda i: i.__name__, data)
+        self.assertEqual(data, ['I1', 'I2', 'I3'])
+
+    def testComplexBadImplements(self):
+        data=[]
+        self.assertRaises(BadImplements,
+                          visitImplements, (I1, (I2, unittest)),
+                          None, data.append)
+
+
+def test_suite():
+    loader=unittest.TestLoader()
+    return loader.loadTestsFromTestCase(Test)
+
+if __name__=='__main__':
+    unittest.TextTestRunner().run(test_suite())


=== Zope3/src/zope/interface/tests/unitfixtures.py 1.1 => 1.2 ===
--- /dev/null	Wed Dec 25 09:15:43 2002
+++ Zope3/src/zope/interface/tests/unitfixtures.py	Wed Dec 25 09:15:12 2002
@@ -0,0 +1,117 @@
+##############################################################################
+#
+# 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.
+#
+##############################################################################
+from zope.interface import Interface
+from zope.interface.interface import Attribute
+
+class mytest(Interface):
+    pass
+
+class C:
+    def m1(self, a, b):
+        "return 1"
+        return 1
+
+    def m2(self, a, b):
+        "return 2"
+        return 2
+
+# testInstancesOfClassImplements
+
+
+
+
+#  YAGNI IC=Interface.impliedInterface(C)
+class IC(Interface):
+    def m1(a, b):
+        "return 1"
+
+    def m2(a, b):
+        "return 2"
+
+
+
+C.__implements__=IC
+
+class I1(Interface):
+    def ma():
+        "blah"
+
+class I2(I1): pass
+
+class I3(Interface): pass
+
+class I4(Interface): pass
+
+class A(I1.deferred()):
+    __implements__=I1
+
+class B:
+    __implements__=I2, I3
+
+class D(A, B): pass
+
+class E(A, B):
+    __implements__ = A.__implements__, C.__implements__
+
+
+class FooInterface(Interface):
+    """ This is an Abstract Base Class """
+
+    foobar = Attribute("fuzzed over beyond all recognition")
+
+    def aMethod(foo, bar, bingo):
+        """ This is aMethod """
+
+    def anotherMethod(foo=6, bar="where you get sloshed", bingo=(1,3,)):
+        """ This is anotherMethod """
+
+    def wammy(zip, *argues):
+        """ yadda yadda """
+
+    def useless(**keywords):
+        """ useless code is fun! """
+
+class Foo:
+    """ A concrete class """
+
+    __implements__ = FooInterface,
+
+    foobar = "yeah"
+
+    def aMethod(self, foo, bar, bingo):
+        """ This is aMethod """
+        return "barf!"
+
+    def anotherMethod(self, foo=6, bar="where you get sloshed", bingo=(1,3,)):
+        """ This is anotherMethod """
+        return "barf!"
+
+    def wammy(self, zip, *argues):
+        """ yadda yadda """
+        return "barf!"
+
+    def useless(self, **keywords):
+        """ useless code is fun! """
+        return "barf!"
+
+foo_instance = Foo()
+
+class Blah:
+    pass
+
+new = Interface.__class__
+FunInterface = new('FunInterface')
+BarInterface = new('BarInterface', [FunInterface])
+BobInterface = new('BobInterface')
+BazInterface = new('BazInterface', [BobInterface, BarInterface])