def test_transportInterfaces(self):
        """
        The transport wrapper passed to the wrapped protocol's
        C{makeConnection} provides the same interfaces as are provided by the
        original transport.
        """
        class IStubTransport(Interface):
            pass

        class StubTransport:
            implements(IStubTransport)

        # Looking up what ProtocolWrapper implements also mutates the class.
        # It adds __implemented__ and __providedBy__ attributes to it.  These
        # prevent __getattr__ from causing the IStubTransport.providedBy call
        # below from returning True.  If, by accident, nothing else causes
        # these attributes to be added to ProtocolWrapper, the test will pass,
        # but the interface will only be provided until something does trigger
        # their addition.  So we just trigger it right now to be sure.
        implementedBy(policies.ProtocolWrapper)

        proto = protocol.Protocol()
        wrapper = policies.ProtocolWrapper(policies.WrappingFactory(None), proto)

        wrapper.makeConnection(StubTransport())
        self.assertTrue(IStubTransport.providedBy(proto.transport))

    def test_provider(self):
        from z3c.pt.pagetemplate import ViewPageTemplateFile

        class Context(object):
            pass

        class Request(object):
            response = None

        class View(object):
            __call__ = ViewPageTemplateFile("provider.pt")

        from zope.interface import Interface
        from zope.schema import Field
        from zope.interface import implementer
        from zope.interface import directlyProvides
        from zope.contentprovider.interfaces import ITALNamespaceData

        class ITestProvider(Interface):
            context = Field(u"Provider context.")

        directlyProvides(ITestProvider, ITALNamespaceData)
        assert ITALNamespaceData.providedBy(ITestProvider)

        @implementer(ITestProvider)
        class Provider(object):

            def __init__(self, *args):
                data.extend(list(args))

            def update(self):
                data.extend("updated")

            def render(self):
                return """<![CDATA[ %r, %r]]>""" % (
                    data, self.__dict__)

        view = View()
        data = []

        from zope.interface import implementedBy
        from zope.component import provideAdapter
        from zope.contentprovider.interfaces import IContentProvider

        provideAdapter(
            Provider, (
                implementedBy(Context),
                implementedBy(Request),
                implementedBy(View)
                ),
            IContentProvider,
            name="content"
            )

        context = Context()
        request = Request()

        result = view(context=context, request=request)
        self.failUnless(repr(data) in result)
        self.failUnless(repr({'context': context}) in result)

    def test_provider(self):
        class Context(object):
            pass

        class Request(object):
            response = None

        class View(object):
            __call__ = ViewPageTemplateFile("provider.pt")

        # Test binding descriptor behaviour.
        self.assertIsInstance(View.__call__, ViewPageTemplateFile)

        from zope.interface import Interface
        from zope.schema import Field
        from zope.interface import implementer
        from zope.interface import directlyProvides
        from zope.contentprovider.interfaces import ITALNamespaceData

        class ITestProvider(Interface):
            context = Field(u"Provider context.")

        directlyProvides(ITestProvider, ITALNamespaceData)
        assert ITALNamespaceData.providedBy(ITestProvider)

        @implementer(ITestProvider)
        class Provider(object):
            def __init__(self, *args):
                data.extend(list(args))

            def update(self):
                data.extend("updated")

            def render(self):
                return """<![CDATA[ %r, %r]]>""" % (data, self.__dict__)

        view = View()
        data = []

        from zope.interface import implementedBy
        from zope.component import provideAdapter
        from zope.contentprovider.interfaces import IContentProvider

        provideAdapter(
            Provider,
            (
                implementedBy(Context),
                implementedBy(Request),
                implementedBy(View),
            ),
            IContentProvider,
            name="content",
        )

        context = Context()
        request = Request()

        result = view(context=context, request=request)
        self.assertIn(repr(data), result)
        self.assertIn(repr({"context": context}), result)

    def test_pickle_zodb_lookup_utility(self):
        # Now, we can register a couple utilities in the base, save everything,
        # and look it up in the sub (when the classes don't match)
        storage = DemoStorage()
        self._store_base_subs_in_zodb(storage)

        db = DB(storage)
        conn = db.open()
        new_base = conn.root()['base']
        new_base._p_activate()
        new_sub = conn.root()['sub']


        new_base.utilities.btree_provided_threshold = 0
        new_base.utilities.btree_map_threshold = 0

        new_base.registerUtility(MockSite(),
                                 provided=IFoo)
        provided1 = new_base.adapters._provided
        # Previously this would fail. Now it works.
        new_base.registerUtility(MockSite(),
                                 provided=implementedBy(object),
                                 name=u'foo')

        new_base.registerUtility(MockSite(),
                                 provided=IMock,
                                 name=u'foo')

        provided2 = new_base.adapters._provided
        # Make sure that it only converted once
        assert_that(provided1, is_(same_instance(provided2)))
        assert_that(new_base._utility_registrations, is_(BTrees.OOBTree.OOBTree))

        assert_that(new_base._utility_registrations.keys(),
                    contains(
                        (IFoo, u''),
                        (IMock, u'foo'),
                        (implementedBy(object), u'foo'),
                    ))
        assert_that(new_base.utilities._provided, is_(BTrees.family64.OI.BTree))
        assert_that(new_base.utilities._adapters[0], is_(BTrees.family64.OO.BTree))

        assert_that(new_base.utilities._adapters[0][IFoo], is_(BTrees.family64.OO.BTree))


        transaction.commit()
        conn.close()
        db.close()

        db = DB(storage)
        conn = db.open()
        new_sub = conn.root()['sub']

        x = new_sub.queryUtility(IFoo)
        assert_that(x, is_(MockSite))

        x = new_sub.queryUtility(IMock, u'foo')
        assert_that(x, is_(MockSite))

    def __init__(self, module, name, klass):
        self.__parent__ = module
        self.__name__ = name
        self.__klass = klass

        # Setup interfaces that are implemented by this class.
        self.__interfaces = tuple(implementedBy(klass))
        self.__all_ifaces = tuple(implementedBy(klass).flattened())

        # Register the class with the global class registry.
        classRegistry[self.getPath()] = klass

    def test_register_implemented_by_lookup_utility(self):
        storage = DemoStorage()
        self._store_base_subs_in_zodb(storage)

        db = DB(storage)
        conn = db.open()
        new_base = conn.root()['base']
        new_base._p_activate()
        new_sub = conn.root()['sub']


        new_base.utilities.btree_provided_threshold = 0
        new_base.utilities.btree_map_threshold = 0

        new_base.registerUtility(MockSite(),
                                 provided=IFoo)
        provided1 = new_base.adapters._provided
        # In the past, we couldn't register by implemented, but now we can.
        new_base.registerUtility(MockSite(),
                                 provided=implementedBy(MockSite),
                                 name=u'foo')

        provided2 = new_base.adapters._provided
        # Make sure that it only converted once
        assert_that(provided1, is_(same_instance(provided2)))
        assert_that(new_base._utility_registrations, is_(BTrees.OOBTree.OOBTree))

        assert_that(new_base._utility_registrations.keys(),
                    contains(
                        (IFoo, u''),
                        ((implementedBy(MockSite), u'foo')),
                    ))
        assert_that(new_base.utilities._provided, is_(BTrees.family64.OI.BTree))
        assert_that(new_base.utilities._adapters[0], is_(BTrees.family64.OO.BTree))

        assert_that(new_base.utilities._adapters[0][IFoo], is_(BTrees.family64.OO.BTree))


        transaction.commit()
        conn.close()
        db.close()

        db = DB(storage)
        conn = db.open()
        new_sub = conn.root()['sub']

        x = new_sub.queryUtility(IFoo)
        assert_that(x, is_(MockSite))

        # But it can't actually be looked up, regardless of whether we
        # convert to btrees or not
        x = new_sub.queryUtility(MockSite, u'foo')
        assert_that(x, is_(none()))

    def testUtil(self):
        self.assert_(IC in implementedBy(C))
        self.assert_(I1 in implementedBy(A))
        self.assert_(not I1 in implementedBy(C))
        self.assert_(I2 in implementedBy(B))
        self.assert_(not I2 in implementedBy(C))

        self.assert_(IC in providedBy(C()))
        self.assert_(I1 in providedBy(A()))
        self.assert_(not I1 in providedBy(C()))
        self.assert_(I2 in providedBy(B()))
        self.assert_(not I2 in providedBy(C()))

def register(implementor, orig, *interfaceClasses):
    if orig in fakeimplementeds:
        origInterface = fakeimplementeds[orig]
    elif not isinstance(orig, InterfaceClass):
        origInterface = implementedBy(orig)
    else:
        origInterface = orig

    if not interfaceClasses:
        interfaceClasses = tuple(implementedBy(implementor))

    for interfaceClass in interfaceClasses:
        registry.register([origInterface], interfaceClass, '', implementor)

def register(implementor, orig, *target_interfaces):
    """
    Register an implementor to map from one interface to another

    .. python::
        from zope.interface import implementer
        # implement*e*r is a typo in zope.interface, unfortunately

        @implementer(ITarget)
        class Implementor(stuff):
            stuff

        register(Implementor, IOriginal)

    .. python::
        from zope.interface import implementer

        @implementer(ITarget1)
        @implementer(ITarget2)
        @implementer(INotTarget)
        class Implementor(stuff):
            stuff

        register(Implementor, IOriginal, ITarget1, ITarget2, ITargetNotImplemented)

    :Parameters:
      implementor
        Factory which returns an object which provides the target interface; if no interfaces
        are passed in, then the target interfaces will be inferred from the list of interfaces
        that the implementor implements.

        Note that this means that if you pass in any target interfaces, they will override the
        inferred ones
      orig
        Interface or class to map from. If it's a class, it must implement exactly one interface.
      target_interfaces
        zero or more target interfaces to map to
    """
    if orig in fakeimplementeds:
        orig_interface = fakeimplementeds[orig]
    elif not isinstance(orig, InterfaceClass):
        orig_interface = implementedBy(orig)
    else:
        orig_interface = orig

    if not target_interfaces:
        target_interfaces = tuple(implementedBy(implementor))

    for target_interface in target_interfaces:
        registry.register([orig_interface], target_interface, '', implementor)
    return implementor

    def test_add_inheriteddelegatei(self):
        @add_delegate(InheritedDelegateI)
        class Delegator2(object):
            def __init__(self):
                self.x = 1

        mems = set([n for n, v in getmembers(Delegator2, ismethod) if not n.startswith("_")])
        self.assertEqual(mems, set(["i"]))
        interfaces = list(implementedBy(Delegator2))
        self.assertEqual(interfaces, list(implementedBy(InheritedDelegateI)))
        delegator = Delegator2()
        for interface in interfaces:
            self.assertTrue(obj_has_interface(delegator, interface))
        self.assertEqual(delegator.i(delegator.x), 2)

    def test_classImplements(self):
        class A(Odd):
            implements(I3)

        class B(Odd):
            implements(I4)

        class C(A, B):
            pass

        classImplements(C, I1, I2)
        self.assertEqual([i.getName() for i in implementedBy(C)], ["I1", "I2", "I3", "I4"])
        classImplements(C, I5)
        self.assertEqual([i.getName() for i in implementedBy(C)], ["I1", "I2", "I5", "I3", "I4"])

    def test_add_delegatej(self):
        @add_delegate(DelegateJ)
        class Delegator1(object):
            def __init__(self):
                self.x = 1

        mems = set([n for n, v in getmembers(Delegator1, ismethod) if not n.startswith("_")])
        self.assertEqual(mems, set(["i", "j"]))
        interfaces = list(implementedBy(Delegator1))
        self.assertEqual(interfaces, list(implementedBy(DelegateJ)))
        delegator = Delegator1()
        for interface in interfaces:
            self.assertTrue(obj_has_interface(delegator, interface))
        self.assertEqual(delegator.i(delegator.x), 2)
        self.assertEqual(delegator.j(delegator.x), 3)

    def test_classImplements(self):
        class A(Odd):
          implements(I3)

        class B(Odd):
          implements(I4)

        class C(A, B):
          pass
        classImplements(C, I1, I2)
        self.assertEqual([i.getName() for i in implementedBy(C)],
                         ['I1', 'I2', 'I3', 'I4'])
        classImplements(C, I5)
        self.assertEqual([i.getName() for i in implementedBy(C)],
                         ['I1', 'I2', 'I5', 'I3', 'I4'])

 def __get__(self, inst, cls=None):
     
     # We're looking at a class - fall back on default
     if inst is None:
         return getObjectSpecification(cls)
     
     # Find the cached value and return it if possible
     cached = getattr(inst, '_v__providedBy__', None)
     if cached is not None:
         return cached
     
     # Get interfaces directly provided by the draft proxy
     provided = getattr(inst, '__provides__', None)
     
     # If the draft proxy doesn't have a __provides__ attribute, get the
     # interfaces implied by the class as a starting point.
     if provided is None:
         provided = implementedBy(cls)
     
     # Add the interfaces provided by the target 
     target = aq_base(inst._DraftProxy__target)
     if target is None:
         return provided
     
     provided += providedBy(target)
     
     inst._v__providedBy__ = provided
     return provided

 def _get_components(self,cont,pathname=None):
     ''' get a heierarchical list of all the components in the given
         container or dictionary.  the name of the root container, if
         specified, is prepended to all pathnames
     '''
     
     comps = []
     for k,v in cont.items():                        
         if is_instance(v,Component):
             comp = {}
             if cont == self.proj.__dict__:
                 comp['pathname'] = k
                 children = self._get_components(v,k)
             else:
                 comp['pathname'] = pathname+'.'+ k if pathname else k
                 children = self._get_components(v,comp['pathname'])
             if len(children) > 0:
                 comp['children'] = children
             comp['type'] = str(v.__class__.__name__)
             inames = []
             for klass in list(implementedBy(v.__class__)):
                 inames.append(klass.__name__)
             comp['interfaces'] = inames
             comps.append(comp)
     return comps

    def test_it(self):
        from zope.interface import implementedBy
        from pyramid.threadlocal import get_current_registry
        from pyramid.interfaces import IRequest
        from pyramid.interfaces import IView
        from pyramid.interfaces import IViewClassifier
        from pyramid.exceptions import Forbidden
        context = DummyContext()
        def view(request):
            return 'OK'
        self._callFUT(context, view)
        actions = context.actions

        self.assertEqual(len(actions), 1)

        discrim = ('view', Forbidden, '', None, IView, None, None, None, None,
                   None, False, None, None, None)
        regadapt = actions[0]
        self.assertEqual(regadapt['discriminator'], discrim)
        register = regadapt['callable']
        register()
        reg = get_current_registry()
        derived_view = reg.adapters.lookup(
            (IViewClassifier, IRequest, implementedBy(Forbidden)),
            IView, default=None)

        self.assertNotEqual(derived_view, None)
        self.assertEqual(derived_view(None, None), 'OK')
        self.assertEqual(derived_view.__name__, 'bwcompat_view')

def classDoesNotImplement(class_, *interfaces):
    # convert any Zope 2 interfaces to Zope 3 using fromZ2Interface
    interfaces = flatten(interfaces)
    implemented = implementedBy(class_)
    for iface in interfaces:
        implemented = implemented - iface
    return zope.interface.classImplementsOnly(class_, implemented)

def interfaces_implementedBy_class_for(obj):
    """Dump out list of interfaces implementedBy an object's class."""
    return """  interfaces implementedBy %s:
    %s""" % (obj.__class__, 
          "\n    ".join(
          ["%s %s"%(i, id(i)) for i in interface.implementedBy(obj.__class__)]
          or [ "</>" ] ))

def utility(_context, provides=None, component=None, factory=None, name=''):
    if factory and component:
        raise TypeError("Can't specify factory and component.")

    if provides is None:
        if factory:
            provides = list(implementedBy(factory))
        else:
            provides = list(providedBy(component))
        if len(provides) == 1:
            provides = provides[0]
        else:
            raise TypeError("Missing 'provides' attribute")

    if name == '':
        if factory:
            name = getName(factory)
        else:
            name = getName(component)

    _context.action(
        discriminator=('utility', provides, name),
        callable=handler,
        args=('registerUtility', component, provides, name),
        kw=dict(factory=factory))
    _context.action(
        discriminator=None,
        callable=provide_interface,
        args=('', provides))

def utility(_context, provides=None, component=None, factory=None, name=''):
    if factory and component:
        raise TypeError("Can't specify factory and component.")

    if provides is None:
        if factory:
            provides = list(implementedBy(factory))
        else:
            provides = list(providedBy(component))
        if len(provides) == 1:
            provides = provides[0]
        else:
            raise TypeError("Missing 'provides' attribute")

    if factory:
        kw = dict(factory=factory)
    else:
        # older component registries don't accept factory as a kwarg,
        # so if we don't need it, we don't pass it
        kw = {}

    try:
        registry = _context.registry
    except AttributeError: # pragma: no cover (b/c)
        registry = get_current_registry()
        
    _context.action(
        discriminator = ('utility', provides, name),
        callable = registry.registerUtility,
        args = (component, provides, name, _context.info),
        kw = kw,
        )