def test_nestedSitesDontConflictButStillAcquire(self):
        # let's register a dummy utility in the dummy site
        dummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, dummy)

        # let's also create a subsite and make that our site
        manage_addDummySite(self.folder.site, 'subsite')
        enableLocalSiteHook(self.folder.site.subsite)
        setSite(self.folder.site.subsite)

        # we should still be able to lookup the original utility from
        # the site one level above
        self.assertEqual(zapi.getUtility(IDummyUtility), dummy)

        # now we register a dummy utility in the subsite and see that
        # its registration doesn't conflict
        subdummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, subdummy)

        # when we look it up we get the more local one now because the
        # more local one shadows the less local one
        self.assertEqual(zapi.getUtility(IDummyUtility), subdummy)

        # getAllUtilitiesFor gives us both the more local and the less
        # local utility (XXX not sure if this is the right semantics
        # for getAllUtilitiesFor)
        self.assertEqual(sets.Set(zapi.getAllUtilitiesRegisteredFor(IDummyUtility)),
                         sets.Set([subdummy, dummy]))

        # getUtilitiesFor will only find one, because the more local
        # one shadows the less local one
        self.assertEqual(list(zapi.getUtilitiesFor(IDummyUtility)),
                         [('', subdummy)])

 def uninstall(self):
     type_names = self.request['selected']
     self.request.form['selected'] = [u'']
     for name, tool in zapi.getUtilitiesFor(IToolConfiguration):
         if name in type_names:
             self.activeTool = tool
             self.delete()
     self.activeTool = None

 def items(self):
     results = [
         (name, TypeInterface(iface, self, name))
         for name, iface in zapi.getUtilitiesFor(IInterface)
         if iface.extends(IInterface)
     ]
     results.sort(lambda x, y: cmp(x[1].interface.getName(), y[1].interface.getName()))
     return results

    def _getUtilitiesFor(self, iface):
        """ return everything registered for an interface """

        try:
            from zope.app import zapi
            return zapi.getUtilitiesFor(iface)
        except ImportError:
            from zope.component import getUtilitiesFor
            return getUtilitiesFor(iface)

 def items(self):
     """See zope.app.container.interfaces.IReadContainer"""
     items = list(zapi.getUtilitiesFor(IDocumentationModule))
     items.sort()
     utils = []
     for key, value in items:
         locate(value, self, key)
         utils.append((key, value))
     return utils

 def setup(self):
     """Setup module and class tree."""
     if self.__isSetup:
         return
     for name, mod in zapi.getUtilitiesFor(IAPIDocRootModule):
         module = safe_import(mod)
         if module is not None:
             self._children[name] = Module(self, name, module)
     self.__isSetup = True

    def test_registerUtilityOnUtilityService(self):
        utils = zapi.getService(Utilities)
        dummy = DummyUtility()
        utils.registerUtility(IDummyUtility, dummy, 'dummy')

        self.assertEquals(zapi.getUtility(IDummyUtility, name='dummy'), dummy)
        self.assertEquals(list(zapi.getUtilitiesFor(IDummyUtility)), 
                          [('dummy', dummy)])
        self.assertEquals(list(zapi.getAllUtilitiesRegisteredFor(
            IDummyUtility)), [dummy])

def get_default_language():
    language_providers = getUtilitiesFor(ILanguageProvider)
    provider_list = [(p[0], p[1]) for p in language_providers]
    sorted_providers = sorted(provider_list, key=lambda p: p[1].PRECEDENCE)
    for name, provider in sorted_providers:
        _language = provider()
        log.debug("Looking for language in %s found %s", name, _language)
        if _language and (_language in capi.zope_i18n_allowed_languages):
            log.debug("Got default language as %s from provider %s", _language, name)
            return _language

    def test_registerUtilityOnUtilityRegistry(self):
        utils = zapi.getSiteManager().utilities
        dummy = DummyUtility()
        utils.registerUtility(IDummyUtility, dummy, 'dummy')

        self.assertEquals(zapi.getUtility(IDummyUtility, name='dummy'), dummy)
        self.assertEquals(list(zapi.getUtilitiesFor(IDummyUtility)), 
                          [('dummy', dummy)])
        self.assertEquals(list(zapi.getAllUtilitiesRegisteredFor(
            IDummyUtility)), [dummy])

 def getCatalogsInfo(self):
     info = []
     for name, domain in zapi.getUtilitiesFor(ITranslationDomain):
         if not hasattr(domain, 'getCatalogsInfo'):
             continue
         lang_info = []
         info.append({'domain': name, 'languagesInfo': lang_info})
         for language, fileNames in domain.getCatalogsInfo().items():
             lang_info.append({'language': language,
                          'fileNames': fileNames})
     return info

    def test_registerUtilityOnSiteManager(self):
        sm = zapi.getSiteManager()
        self.failUnless(IRegisterUtilitySimply.providedBy(sm))
        dummy = DummyUtility()
        sm.registerUtility(IDummyUtility, dummy, 'dummy')

        self.assertEquals(zapi.getUtility(IDummyUtility, name='dummy'), dummy)
        self.assertEquals(list(zapi.getUtilitiesFor(IDummyUtility)), 
                          [('dummy', dummy)])
        self.assertEquals(list(zapi.getAllUtilitiesRegisteredFor(
            IDummyUtility)), [dummy])

 def getUniqueTools(self):
     """Get unique tools info for display."""
     results = [{'name': tool.interface.getName(),
                 'title': tool.title,
                 'description': tool.description,
                 'exists': self.toolExists(tool.interface)
                 }
                for name, tool in zapi.getUtilitiesFor(IToolConfiguration)
                if tool.unique]
     results.sort(lambda x, y: cmp(x['title'], y['title']))
     return results

    def test_derivedInterfaceRegistration(self):
        # Utilities providing a derived interface should be listed
        # when you ask for an interface. So ask for IDummmyInterace, and
        # anything registered for IDummyInterface of ISuperDummyInterface
        # should come back.

        sm = zapi.getServices()
        self.failUnless(IRegisterUtilitySimply.providedBy(sm))
        dummy = DummyUtility()
        superdummy = DummyUtility()
        directlyProvides(superdummy, ISuperDummyUtility)
        uts = list(zapi.getUtilitiesFor(IDummyUtility))
        self.failUnlessEqual(uts, [])

        sm.registerUtility(ISuperDummyUtility, superdummy)
        
        # We should be able to access this utility both with 
        # IDummyUtility and ISuperDummyUtility interfaces:
        uts = list(zapi.getUtilitiesFor(IDummyUtility))
        self.failUnless(uts[0][1].aq_base is superdummy)
        uts = list(zapi.getUtilitiesFor(ISuperDummyUtility))
        self.failUnless(uts[0][1].aq_base is superdummy)
        
        # Also try that the standard zapi call works:
        ut = zapi.getUtility(IDummyUtility, context=self.folder.site)
        self.failUnless(ut.aq_base is superdummy)
        ut = zapi.getUtility(ISuperDummyUtility, context=self.folder.site)
        self.failUnless(ut.aq_base is superdummy)
    
        # If we register a second utility we should find both utilities
        # when looking for the base interface
        sm.registerUtility(IDummyUtility, dummy)

        uts = list(zapi.getAllUtilitiesRegisteredFor(IDummyUtility))
        self.failUnless(dummy in uts)
        self.failUnless(superdummy in uts)

        # But we should find only one when looking for the derived interface
        uts = list(zapi.getAllUtilitiesRegisteredFor(ISuperDummyUtility))
        self.failUnless(dummy not in uts)
        self.failUnless(superdummy in uts)

 def test_registerUtilityWithZopeComponentAPI4(self):
     # The Full kabob:
     sm = getSiteManager()
     dummy = DummyUtility()
     
     sm.registerUtility(component=dummy, provided=IDummyUtility, 
                        name='dummy', info=u'The Dummy', event=True)
     self.assertEquals(zapi.getUtility(IDummyUtility, name='dummy'), dummy)
     self.assertEquals(list(zapi.getUtilitiesFor(IDummyUtility)), 
                       [('dummy', dummy)])
     self.assertEquals(list(zapi.getAllUtilitiesRegisteredFor(
         IDummyUtility)), [dummy])

    def test_registerUtilityWithZopeComponentAPI3(self):
        # With keyword arguments
        sm = getSiteManager()
        dummy = DummyUtility()

        sm.registerUtility(component=dummy, provided=IDummyUtility, 
                           name='dummy')
        self.assertEquals(zapi.getUtility(IDummyUtility, name='dummy'), dummy)
        self.assertEquals(list(zapi.getUtilitiesFor(IDummyUtility)), 
                          [('dummy', dummy)])
        self.assertEquals(list(zapi.getAllUtilitiesRegisteredFor(
            IDummyUtility)), [dummy])

    def test_registerUtilityWithZopeComponentAPI1(self):
        # Without name
        sm = getSiteManager()
        dummy = DummyUtility()

        sm.registerUtility(dummy, IDummyUtility)

        self.assertEquals(zapi.getUtility(IDummyUtility), dummy)
        self.assertEquals(list(zapi.getUtilitiesFor(IDummyUtility)), 
                          [('', dummy)])
        self.assertEquals(list(zapi.getAllUtilitiesRegisteredFor(
            IDummyUtility)), [dummy])

 def getTools(self):
     """Return a list of all tools"""
     results = [{'name': tool.interface.getName(),
                 'title': tool.title,
                 'description': tool.description,
                 'instances': self.getToolInstances(tool),
                 'add': tool is self.activeTool and self.addTool,
                 'rename': tool is self.activeTool and self.renameList
                 }
                for name, tool in zapi.getUtilitiesFor(IToolConfiguration)
                if not tool.unique]
     results.sort(lambda x, y: cmp(x['title'], y['title']))
     return results

def get_default_language():
    # !+LANGUAGE(murithi, mar2011) need to integrate weights in registration
    # of utilities but overriding/new classes can also reorder negotiation
    default_language = None
    language_providers = getUtilitiesFor(ILanguageProvider)
    provider_list = [(p[0], p[1]) for p in language_providers]
    sorted_providers = sorted(provider_list, key=lambda p: p[1].WEIGHT)
    for name, provider in sorted_providers:
        _language = provider()
        log.debug("Looking for language in %s found %s", name, _language)
        if _language and (_language in capi.zope_i18n_allowed_languages):
            default_language = _language
            log.debug("Got default language as %s from provider %s",
                        _language, name)
            break
    return default_language

    def test_utilitiesHaveProperAcquisitionContext(self):
        dummy = DummyUtility()
        sm = zapi.getSiteManager()
        sm.registerUtility(IDummyUtility, dummy)

        # let's see if we can acquire something all the way from the
        # root (Application) object; we need to be careful to choose
        # something that's only available from the root object
        from Acquisition import aq_acquire
        dummy = zapi.getUtility(IDummyUtility)
        acquired = aq_acquire(dummy, 'ZopeAttributionButton', None)
        self.failUnless(acquired is not None)

        name, dummy = zapi.getUtilitiesFor(IDummyUtility).next()
        acquired = aq_acquire(dummy, 'ZopeAttributionButton', None)
        self.failUnless(acquired is not None)

        dummy = zapi.getAllUtilitiesRegisteredFor(IDummyUtility).next()
        acquired = aq_acquire(dummy, 'ZopeAttributionButton', None)
        self.failUnless(acquired is not None)        

def get_default_language():
    # !+LANGUAGE(murithi, mar2011) need to integrate precedence values in registration
    # of utilities but overriding/new classes can also reorder negotiation
    # !+LANGUAGE(mr, apr-2011) what is the relation of this with:
    #   a) capi.default_language ?
    #   b) request.get("language") ?
    #   c) request.getCookies().get("I18N_LANGUAGE") ?
    default_language = None
    language_providers = getUtilitiesFor(ILanguageProvider)
    provider_list = [(p[0], p[1]) for p in language_providers]
    sorted_providers = sorted(provider_list, key=lambda p: p[1].PRECEDENCE)
    for name, provider in sorted_providers:
        _language = provider()
        log.debug("Looking for language in %s found %s", name, _language)
        if _language and (_language in capi.zope_i18n_allowed_languages):
            default_language = _language
            log.debug(
                "Got default language as %s from provider %s", _language, name)
            break
    return default_language