def test(self):

        field = Text(title=u"Foo thing")

        class I(Interface):

            getFoo, setFoo = accessors(field)

        class Bad(object):
            implements(I)

        class Good(object):
            implements(I)
            
            def __init__(self):
                self.set = 0

            def getFoo(self):
                return u"foo"

            def setFoo(self, v):
                self.set += 1

        names = I.names()
        names.sort()
        self.assertEqual(names, ['getFoo', 'setFoo'])
        self.assertEqual(I['getFoo'].field, field)
        self.assertEqual(I['getFoo'].__name__, 'getFoo')
        self.assertEqual(I['getFoo'].__doc__, u'get Foo thing')
        self.assertEqual(I['getFoo'].__class__, FieldReadAccessor)
        self.assertEqual(I['getFoo'].writer, I['setFoo'])

        # test some field attrs
        for attr in ('title', 'description', 'readonly'):
            self.assertEqual(getattr(I['getFoo'], attr), getattr(field, attr))

        self.assert_(IText.providedBy(I['getFoo']))
        
        self.assert_(IMethod.providedBy(I['getFoo']))
        self.assert_(IMethod.providedBy(I['setFoo']))

        self.assertEqual(I['setFoo'].field, field)
        self.assertEqual(I['setFoo'].__name__, 'setFoo')
        self.assertEqual(I['setFoo'].__doc__, u'set Foo thing')
        self.assertEqual(I['setFoo'].__class__, FieldWriteAccessor)

        self.assertRaises(Exception, verifyClass, I, Bad)
        self.assertRaises(Exception, verifyObject, I, Bad())
        
        self.assertEquals(I['getFoo'].query(Bad(), 42), 42)
        self.assertRaises(AttributeError, I['getFoo'].get, Bad())

        verifyClass(I, Good)
        verifyObject(I, Good())

        self.assertEquals(I['getFoo'].query(Good(), 42), u'foo')
        self.assertEquals(I['getFoo'].get(Good()), u'foo')
        instance = Good()
        I['getFoo'].set(instance, u'whatever')
        self.assertEquals(instance.set, 1)

    def test_z3interfaces(self):
        from zope.interface.verify import verifyClass
        from Products.CMFDefault.interfaces import ILink
        from Products.CMFDefault.interfaces import IMutableLink

        verifyClass(ILink, self._getTargetClass())
        verifyClass(IMutableLink, self._getTargetClass())

    def test_z3interfaces(self):
        from Products.PluginIndexes.interfaces import IPluggableIndex
        from Products.ZCTextIndex.interfaces import IZCTextIndex
        from zope.interface.verify import verifyClass

        verifyClass(IPluggableIndex, ZCTextIndex)
        verifyClass(IZCTextIndex, ZCTextIndex)

    def test_interfaces(self):
        from Products.CMFCore.interfaces import IContentish
        from Products.CMFCore.interfaces import IDynamicType
        from Products.CMFCore.PortalContent import PortalContent

        verifyClass(IContentish, PortalContent)
        verifyClass(IDynamicType, PortalContent)

    def test_interfaces(self):
        from Products.CMFCore.MemberDataTool import MemberDataFactory
        from Products.CMFCore.interfaces import IMemberData
        from zope.component import IFactory

        verifyClass(IFactory, MemberDataFactory)
        verifyClass(IMemberData, MemberDataFactory)

 def test_interface_conformance(self):
     from zope.interface.verify import verifyClass, verifyObject
     from ..interfaces import IShadowTreeTool
     verifyClass(IShadowTreeTool, self._get_target_class())
     util = self._make_one()
     verifyObject(IShadowTreeTool, util)
     IShadowTreeTool.validateInvariants(util)

    def test_interfaces(self):
        from Products.CMFCore.DiscussionTool import DiscussionTool
        from Products.CMFCore.interfaces import IActionProvider
        from Products.CMFCore.interfaces import IOldstyleDiscussionTool

        verifyClass(IActionProvider, DiscussionTool)
        verifyClass(IOldstyleDiscussionTool, DiscussionTool)

    def test_data_provider_implements(self):
        self.replay()

        self.assertTrue(i.IMopageEventDataProvider.implementedBy(
            data_provider.MopageEventDataProvider))

        verifyClass(i.IMopageEventObjectLookup, object_lookup.MopageEventObjectLookup)

def add_metadata_field(config, metadata_cls):
    verifyClass(IMetadata, metadata_cls)
    for ar in config.registry.registeredAdapters():
        if ar.provided == IMetadata and ar.name == metadata_cls.name: #pragma : no coverage
            logger.warn("Metadata adapter %r already registered with name %r. "
                        "Registering %r might override it." % (ar.factory, ar.name, metadata_cls))
    config.registry.registerAdapter(metadata_cls, name = metadata_cls.name)

    def test_z3interfaces(self):
        from Products.PluginIndexes.interfaces import IPathIndex
        from Products.PluginIndexes.interfaces import IUniqueValueIndex
        from zope.interface.verify import verifyClass

        verifyClass(IPathIndex, PathIndex)
        verifyClass(IUniqueValueIndex, PathIndex)

 def test_class_conforms_to_IWriteLock(self):
     from zope.interface.verify import verifyClass
     try:
         from OFS.interfaces import IWriteLock
     except ImportError:
         from webdav.interfaces import IWriteLock
     verifyClass(IWriteLock, PythonScript)

    def test_conformance(self):
        from zope.interface.verify import verifyClass
        from zope.interface.verify import verifyObject
        from pyramid.interfaces import IIntrospectable

        verifyClass(IIntrospectable, self._getTargetClass())
        verifyObject(IIntrospectable, self._makeOnePopulated())

    def test_interfaces(self):
        from ..interfaces import IContentish
        from ..interfaces import IDynamicType
        from ..PortalContent import PortalContent

        verifyClass(IContentish, PortalContent)
        verifyClass(IDynamicType, PortalContent)

 def test_alias_class_implements(self):
     from pyramid.events import WSGIApplicationCreatedEvent
     from pyramid.interfaces import IWSGIApplicationCreatedEvent
     from pyramid.interfaces import IApplicationCreated
     from zope.interface.verify import verifyClass
     verifyClass(IWSGIApplicationCreatedEvent, WSGIApplicationCreatedEvent)
     verifyClass(IApplicationCreated, WSGIApplicationCreatedEvent)

    def test_xml_generator_implements(self):
        self.replay()

        self.assertTrue(i.IMopageEventXMLGenerator.implementedBy(
           xml_generator.MopageEventXMLGenerator))

        verifyClass(i.IMopageEventXMLGenerator, xml_generator.MopageEventXMLGenerator)

    def test_implements_interface(self):
        self.replay()
        utility = getUtility(IBridgeRequest)
        klass = type(utility)

        self.assertTrue(IBridgeRequest.implementedBy(klass))
        verifyClass(IBridgeRequest, klass)

 def _load_entry(self, entry):
     # pylint: disable=W0703
     if self._check_extras:
         try:
             entry.require()
         except Exception as err:
             raise PluginDBError('Requirements are not satisfied '
                                 'for %s:%s: %s' % (self._group,
                                                    entry.name,
                                                    str(err)))
     try:
         result = entry.load()
     except Exception as err:
         # log full traceback of the bad entry to help support
         traceback.print_exc()
         raise PluginDBError('Unable to load %s:%s: %s' %
                             (self._group, entry.name, str(err)))
     if self._interface:
         try:
             verifyClass(self._interface, result)
         except Invalid as err:
             raise PluginDBError('Plugin %s:%s does not implement %s: %s' %
                                 (self._group, entry.name,
                                  self._interface.__name__, str(err)))
     return result

    def test_interfaces(self):
        from Products.CMFCore.interfaces import IActionProvider
        from Products.CMFCore.interfaces import ITypesTool
        from Products.CMFCore.TypesTool import TypesTool

        verifyClass(IActionProvider, TypesTool)
        verifyClass(ITypesTool, TypesTool)

    def test_z2interfaces(self):
        from Interface.Verify import verifyClass
        from Products.CMFCore.CachingPolicyManager import CachingPolicyManager
        from Products.CMFCore.interfaces.CachingPolicyManager \
                import CachingPolicyManager as ICachingPolicyManager

        verifyClass(ICachingPolicyManager, CachingPolicyManager)

    def test_z3interfaces(self):
        from zope.interface.verify import verifyClass
        from Products.CMFCalendar.interfaces import IEvent
        from Products.CMFCalendar.interfaces import IMutableEvent

        verifyClass(IEvent, self._getTargetClass())
        verifyClass(IMutableEvent, self._getTargetClass())