def test_hit_via_sm(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from zope.interface.registry import Components
     from zope.component import getGlobalSiteManager
     from zope.component.tests.examples import ConformsToIComponentLookup
     class IFoo(Interface):
         pass
     class IBar(Interface):
         pass
     @implementer(IFoo)
     class Global(object):
         __init__ = fails_if_called(self)
     @implementer(IFoo)
     class Local(object):
         def __init__(self, context):
             self.context = context
     @implementer(IBar)
     class Bar(object):
         pass
     class Context(ConformsToIComponentLookup):
         def __init__(self, sm):
             self.sitemanager = sm
     gsm = getGlobalSiteManager()
     gsm.registerAdapter(Global, (IBar,), IFoo, '')
     sm1 = Components('sm1', bases=(gsm, ))
     sm1.registerAdapter(Local, (IBar,), IFoo, '')
     bar = Bar()
     adapted = self._callFUT(bar, IFoo, context=Context(sm1))
     self.assertTrue(adapted.__class__ is Local)
     self.assertTrue(adapted.context is bar)

 def __init__(self, *arg, **kw):
     # add a registry-instance-specific lock, which is used when the lookup
     # cache is mutated
     self._lock = threading.Lock()
     # add a view lookup cache
     self._clear_view_lookup_cache()
     Components.__init__(self, *arg, **kw)

def initialize(packages=None, excludes=(), reg=None):
    """ Load memphis packages, scan and execute all configuration
    directives. """

    if reg is None:
        reg = Components('memphis')
        reg.registerHandler(objectEventNotify, (IObjectEvent,))

    sys.modules['memphis.config'].registry = reg
    sys.modules['memphis.config.api'].registry = reg

    def exclude_filter(modname):
        if modname in packages:
            return True
        return exclude(modname, excludes)

    # list all packages
    if packages is None:
        packages = loadPackages(excludes=excludes)
        packages.extend([mod for mod in mods if exclude_filter(mod)])
    else:
        packages = loadPackages(packages, excludes=excludes)

    # scan packages and load all actions
    seen = set()
    actions = []

    for pkg in packages:
        actions.extend(directives.scan(pkg, seen, exclude_filter))

    # execute actions
    actions = directives.resolveConflicts(actions)
    for action in actions:
        action()

    class JSON(object):

        def __init__(self, serializer=json.dumps, adapters=(), **kw):
            """ Any keyword arguments will be passed to the ``serializer``
            function."""
            self.serializer = serializer
            self.kw = kw
            self.components = Components()

        def add_adapter(self, type_or_iface, adapter):
            self.components.registerAdapter(adapter, (type_or_iface,),
                                            IJSONAdapter)

        def __call__(self, info):
            def _render(value, system):
                request = system.get('request')
                if request is not None:
                    response = request.response
                    ct = response.content_type
                    if ct == response.default_content_type:
                        response.content_type = 'application/json'
                default = self._make_default(request)
                return self.serializer(value, default=default, **self.kw)

            return _render

        def _make_default(self, request):
            def default(obj):
                obj_iface = providedBy(obj)
                adapters = self.components.adapters
                result = adapters.lookup((obj_iface,), IJSONAdapter,
                                         default=None)
                return result(obj, request)
            return default

 def test_init_forwards_kw(self):
     from zope.interface import Interface
     from zope.interface.registry import Components
     dummy = object()
     c = Components()
     c.registerUtility(dummy, Interface)
     registry = self._makeOne(bases=(c,))
     self.assertEqual(registry.getUtility(Interface), dummy)

 def __init__(self, package_name=CALLER_PACKAGE, *args, **kw):
     # add a registry-instance-specific lock, which is used when the lookup
     # cache is mutated
     self._lock = threading.Lock()
     # add a view lookup cache
     self._clear_view_lookup_cache()
     if package_name is CALLER_PACKAGE:
         package_name = caller_package().__name__
     Components.__init__(self, package_name, *args, **kw)
     dict.__init__(self)

    def test_uses_configured_site_manager(self):
        from zope.interface.registry import Components
        from zope.component import getSiteManager
        from zope.component.testfiles.components import comp, IApp

        registry = Components()
        def dummy(context=None):
            return registry
        getSiteManager.sethook(dummy)

        try:
            self._callFUT('registerUtility', comp, IApp, u'')
            self.assertTrue(registry.getUtility(IApp) is comp)
        finally:
            getSiteManager.reset()

 def __init__(self, serializer=json.dumps, adapters=(), **kw):
     """ Any keyword arguments will be passed to the ``serializer``
     function."""
     self.serializer = serializer
     self.kw = kw
     self.components = Components()
     for type, adapter in adapters:
         self.add_adapter(type, adapter)

class PackageConfigurator(object):
    default_depth = 3

    def __init__(self, registry, resolve=None, target='includeme'):
        self.registry = registry
        self._resolve = resolve
        self._target = target
        self._depth = self.default_depth
        self._configurator_registry = Components()

    def add_configurator(self, configurator, name=''):
        self._configurator_registry.registerUtility(configurator, IConfigurator, name)

    def include(self, name, *args, **kwargs):
        _logger.debug('start include: name=%s, args=%s, kwds=%s', name, args, kwargs)
        includeme = name if callable(name) else get_includeme(name, resolve=self._resolve, depth=self._depth)
        _logger.debug('include -> %s.%s', includeme.__module__, includeme.__name__)
        return includeme(self)

    def scan(self, package=None, **kw):
        name = 'scan'
        if package is None:
            package = '.'

        if isinstance(package, (six.string_types, six.text_type, six.binary_type)):
            package = get_abs_dotted_name_caller_module(package, **kw)

        for cfg in self._configurator_registry.getAllUtilitiesRegisteredFor(IConfigurator):
            if hasattr(cfg, name) and callable(getattr(cfg, name)):
                _logger.debug('scanning...: %s: %s', cfg.__module__, package)
                cfg.scan(package)

    def __getattr__(self, name):
        if name.startswith('_'):
            raise AttributeError(name)

        configs = [cfg
                   for cfg in self._configurator_registry.getAllUtilitiesRegisteredFor(IConfigurator)
                   if hasattr(cfg, name) and callable(getattr(cfg, name))]

        if configs:
            for config in configs:
                return getattr(config, name)
        else:
            raise AttributeError(name)

def main():
    registry = Components()
    bootstrap(registry)

    session_factory = registry.queryUtility(IDBSessionFactory, "master")
    session = session_factory()
    a = MainTable()
    a.name = "test"
    session.add(a)
    print(session.get_bind())
    session.commit()

    session_factory = registry.queryUtility(IDBSessionFactory, "other")
    session = session_factory()
    a = OtherTable()
    a.name_other = "test"
    session.add(a)
    print(session.get_bind())
    session.commit()

 def test_nested(self):
     from zope.component import getGlobalSiteManager
     from zope.interface.registry import Components
     gsm = getGlobalSiteManager()
     gutil = _makeMyUtility('global', gsm)
     gsm.registerUtility(gutil, IMyUtility, 'myutil')
     sm1 = Components('sm1', bases=(gsm, ))
     sm1_1 = Components('sm1_1', bases=(sm1, ))
     util1 = _makeMyUtility('one', sm1)
     sm1.registerUtility(util1, IMyUtility, 'myutil')
     util1_1 = _makeMyUtility('one-one', sm1_1)
     sm1_1.registerUtility(util1_1, IMyUtility, 'myutil')
     myregistry = Components()
     custom_util = _makeMyUtility('my_custom_util', myregistry)
     myregistry.registerUtility(custom_util, IMyUtility, 'my_custom_util')
     sm1.__bases__ = (myregistry,) + sm1.__bases__
     # Both the ``myregistry`` and global utilities should be available:
     self.assertTrue(self._callFUT(sm1, IMyUtility, 'my_custom_util')
                                         is custom_util)
     self.assertTrue(self._callFUT(sm1, IMyUtility, 'myutil') is gutil)

 def test_passwords(self):
     from zope.interface.registry import Components
     from alpaca.common.domain.user import User
     from alpaca.common.utilities.interfaces import IPasswordProcessor
     from alpaca.common.utilities.pbkdf2_password_processor import (
         PBKDF2PasswordProcessor
     )
     processor = PBKDF2PasswordProcessor()
     registry = Components()
     registry.registerUtility(
         processor,
         IPasswordProcessor,
         'pbkdf2'
     )
     user = User()
     user.set_password('łąki łan 123', 'pbkdf2', processor)
     self.assertEqual(user.password_processor, 'pbkdf2')
     self.assertTrue(bool(user.password_hash))
     self.assertLessEqual(len(user.password_hash), 100)
     self.assertFalse(user.password_equals('łąki łany 123', registry))
     self.assertTrue(user.password_equals('łąki łan 123', registry))

 def test_nested(self):
     from zope.interface import Interface
     from zope.interface import implementer
     from zope.interface.registry import Components
     from zope.component import getGlobalSiteManager
     from zope.component.tests.examples import ConformsToIComponentLookup
     class IFoo(Interface):
         pass
     class IBar(Interface):
         pass
     class IBaz(Interface):
         pass
     @implementer(IBar)
     class Bar(object):
         pass
     @implementer(IBaz)
     class Baz(object):
         pass
     @implementer(IFoo)
     class Global(object):
         def __init__(self, first, second):
             self.first, self.second = first, second
     @implementer(IFoo)
     class Local(object):
         def __init__(self, first, second):
             self.first, self.second = first, second
     class Context(ConformsToIComponentLookup):
         def __init__(self, sm):
             self.sitemanager = sm
     gsm = getGlobalSiteManager()
     gsm.registerAdapter(Global, (IBar, IBaz), IFoo, '')
     sm1 = Components('sm1', bases=(gsm, ))
     sm1.registerAdapter(Local, (IBar, IBaz), IFoo, '')
     bar = Bar()
     baz = Baz()
     adapted = self._callFUT((bar, baz), IFoo, '', context=Context(sm1))
     self.assertTrue(adapted.__class__ is Local)
     self.assertTrue(adapted.first is bar)
     self.assertTrue(adapted.second is baz)

def main(argv=sys.argv[1:]):
    reg = Components()
    reg.registerUtility(GoogleVisionAPIFaceDetection(),
                        IDetection, 'gcp')
    reg.registerUtility(MSProjectoxfordDetection(get_ms_param()['API_TOKEN']),
                        IDetection, 'ms')
    reg.registerUtility(AkamaiCrop(),
                        ICrop, 'akamai')

    parser = argparse.ArgumentParser()
    parser.add_argument('mode', help='gcp or ms')
    parser.add_argument('target', help='url or path')
    parser.add_argument('--crop', default='akamai')
    args = parser.parse_args(argv)

    detect = reg.queryUtility(IDetection, args.mode)
    result = detect(args.target)
    crop = AkamaiCrop()
    url = crop(result)
    print(url)

class TestAdapter(unittest.TestCase):

    def setUp(self):
        self.components = Components('comps')

    def test_register_and_unregister_adapter(self):
        self.components.registerAdapter(A12_1)

        multi_adapter = self.components.getMultiAdapter(
            (U1(1), U12(2)), IA1)
        self.assertEqual(multi_adapter.__class__, A12_1)
        self.assertEqual(repr(multi_adapter), 'A12_1(U1(1), U12(2))')

        self.assertTrue(self.components.unregisterAdapter(A12_1))
        self.assertRaises(
            ComponentLookupError,
            self.components.getMultiAdapter,
            (U1(1), U12(2)),
            IA1
            )

    def test_register_and_unregister_adapter_with_two_interfaces(self):
        self.assertRaises(TypeError, self.components.registerAdapter,
                          A1_12)
        self.components.registerAdapter(A1_12,
                                        provided=IA2)

        multi_adapter = self.components.getMultiAdapter((U1(1),), IA2)
        self.assertEqual(multi_adapter.__class__, A1_12)
        self.assertEqual(repr(multi_adapter), 'A1_12(U1(1))')

        self.assertRaises(TypeError, self.components.unregisterAdapter, A1_12)
        self.assertTrue(self.components.unregisterAdapter(A1_12, provided=IA2))
        self.assertRaises(ComponentLookupError,
                          self.components.getMultiAdapter, (U1(1),), IA2)

    def test_register_and_unregister_adapter_with_no_interfaces(self):
        self.assertRaises(TypeError, self.components.registerAdapter, A12_)

        self.components.registerAdapter(A12_, provided=IA2)
        multi_adapter = self.components.getMultiAdapter((U1(1), U12(2)), IA2)
        self.assertEqual(multi_adapter.__class__, A12_)
        self.assertEqual(repr(multi_adapter), 'A12_(U1(1), U12(2))')

        self.assertRaises(TypeError, self.components.unregisterAdapter, A12_)
        self.assertTrue(self.components.unregisterAdapter(A12_, provided=IA2))
        self.assertRaises(ComponentLookupError,
                          self.components.getMultiAdapter, (U1(1), U12(2)), IA2)

    def test_reg_and_unreg_adp_with_no___component_adapts___attribute(self):
        self.assertRaises(TypeError, self.components.registerAdapter, A_2)
        self.components.registerAdapter(A_2, required=[I3])
        self.assertTrue(self.components.unregisterAdapter(A_2, required=[I3]))

    def test_register_and_unregister_class_specific(self):
        self.components.registerAdapter(A_3, required=[U],
                                        info=u'Really class specific')
        self.assertTrue(self.components.unregisterAdapter(required=[U],
                                                          provided=IA3))
      
    def test_registered_adapters_and_sorting(self):
        self.components.registerAdapter(A12_1)
        self.components.registerAdapter(A1_12, provided=IA2)
        self.components.registerAdapter(A12_, provided=IA2)
        self.components.registerAdapter(A_2, required=[I3])
        self.components.registerAdapter(A_3, required=[U],
                                        info=u'Really class specific')

        sorted_adapters = sorted(self.components.registeredAdapters())
        sorted_adapters_name = map(lambda x: getattr(x, 'name'),
                                   sorted_adapters)
        sorted_adapters_provided = map(lambda x: getattr(x, 'provided'),
                                       sorted_adapters) 
        sorted_adapters_required = map(lambda x: getattr(x, 'required'),
                                       sorted_adapters)
        sorted_adapters_info = map(lambda x: getattr(x, 'info'),
                                   sorted_adapters)

        self.assertEqual(len(sorted_adapters), 5)
        self.assertEqual(sorted_adapters_name, [u'', u'', u'', u'', u''])
        self.assertEqual(sorted_adapters_provided, [IA1,
                                                    IA2,
                                                    IA2,
                                                    IA2,
                                                    IA3])

        self.assertEqual(sorted_adapters_required, [(I1, I2),
                                                    (I1, I2),
                                                    (I1,),
                                                    (I3,),
                                                    (implementedBy(U),)])
        self.assertEqual(sorted_adapters_info,
                         [u'', u'', u'', u'', u'Really class specific'])

    def test_get_none_existing_adapter(self):
        self.assertRaises(ComponentLookupError,
                          self.components.getMultiAdapter, (U(1),), IA1)

    def test_query_none_existing_adapter(self):
        self.assertTrue(self.components.queryMultiAdapter((U(1),), IA1) is None)
#.........这里部分代码省略.........

class JSON(object):
    """ Renderer that returns a JSON-encoded string.

    Configure a custom JSON renderer using the
    :meth:`~pyramid.config.Configurator.add_renderer` API at application
    startup time:

    .. code-block:: python

       from pyramid.config import Configurator

       config = Configurator()
       config.add_renderer('myjson', JSON(indent=4))

    Once this renderer is registered as above, you can use
    ``myjson`` as the ``renderer=`` parameter to ``@view_config`` or
    :meth:`~pyramid.config.Configurator.add_view``:

    .. code-block:: python

       from pyramid.view import view_config

       @view_config(renderer='myjson')
       def myview(request):
           return {'greeting':'Hello world'}

    Custom objects can be serialized using the renderer by either
    implementing the ``__json__`` magic method, or by registering
    adapters with the renderer.  See
    :ref:`json_serializing_custom_objects` for more information.

    .. note::

        The default serializer uses ``json.JSONEncoder``. A different
        serializer can be specified via the ``serializer`` argument.  Custom
        serializers should accept the object, a callback ``default``, and any
        extra ``kw`` keyword arguments passed during renderer construction.
        This feature isn't widely used but it can be used to replace the
        stock JSON serializer with, say, simplejson.  If all you want to
        do, however, is serialize custom objects, you should use the method
        explained in :ref:`json_serializing_custom_objects` instead
        of replacing the serializer.

    .. versionadded:: 1.4
       Prior to this version, there was no public API for supplying options
       to the underlying serializer without defining a custom renderer.
    """

    def __init__(self, serializer=json.dumps, adapters=(), **kw):
        """ Any keyword arguments will be passed to the ``serializer``
        function."""
        self.serializer = serializer
        self.kw = kw
        self.components = Components()
        for type, adapter in adapters:
            self.add_adapter(type, adapter)

    def add_adapter(self, type_or_iface, adapter):
        """ When an object of the type (or interface) ``type_or_iface`` fails
        to automatically encode using the serializer, the renderer will use
        the adapter ``adapter`` to convert it into a JSON-serializable
        object.  The adapter must accept two arguments: the object and the
        currently active request.

        .. code-block:: python

           class Foo(object):
               x = 5

           def foo_adapter(obj, request):
               return obj.x

           renderer = JSON(indent=4)
           renderer.add_adapter(Foo, foo_adapter)

        When you've done this, the JSON renderer will be able to serialize
        instances of the ``Foo`` class when they're encountered in your view
        results."""
        
        self.components.registerAdapter(adapter, (type_or_iface,),
                                        IJSONAdapter)

    def __call__(self, info):
        """ Returns a plain JSON-encoded string with content-type
        ``application/json``. The content-type may be overridden by
        setting ``request.response.content_type``."""
        def _render(value, system):
            request = system.get('request')
            if request is not None:
                response = request.response
                ct = response.content_type
                if ct == response.default_content_type:
                    response.content_type = 'application/json'
            default = self._make_default(request)
            return self.serializer(value, default=default, **self.kw)
        
        return _render

    def _make_default(self, request):
        def default(obj):
#.........这里部分代码省略.........

 def registerSubscriptionAdapter(self, *arg, **kw):
     result = Components.registerSubscriptionAdapter(self, *arg, **kw)
     self.has_listeners = True
     return result

class TestSubscriber(unittest.TestCase):

    def setUp(self):
        self.components = Components('comps')

    def test_register_subscriber(self):
        self.components.registerSubscriptionAdapter(A1_2)
        self.components.registerSubscriptionAdapter(A1_12, provided=IA2)
        self.components.registerSubscriptionAdapter(
            A, [I1], IA2, info='a sample comment')
        subscribers = self.components.subscribers((U1(1),), IA2)
        self.assertEqual(len(subscribers), 3)
        self.assertEqual(repr(subscribers[0]), 'A1_2(U1(1))')
        self.assertEqual(repr(subscribers[1]), 'A1_12(U1(1))')
        self.assertEqual(repr(subscribers[2]), 'A(U1(1),)') 

    def test_register_noncompliant_subscriber(self):
        self.assertRaises(TypeError,
                          self.components.registerSubscriptionAdapter, A1_12)
        self.assertRaises(TypeError,
                          self.components.registerSubscriptionAdapter, A)
        self.assertRaises(
            TypeError,
            self.components.registerSubscriptionAdapter, A, required=[IA1])

    def test_register_named_subscriber(self):
        self.components.registerSubscriptionAdapter(
            A, [I1], IA2, u'', u'a sample comment')
        self.assertRaises(TypeError,
                          self.components.registerSubscriptionAdapter, 
                          A, [I1], IA2, u'oops', u'a sample comment')
        subscribers = self.components.subscribers((U1(1),), IA2)
        self.assertEqual(len(subscribers), 1)
        self.assertEqual(repr(subscribers[0]), 'A(U1(1),)')

    def test_register_no_factory(self):
        self.components.registerSubscriptionAdapter(noop, [I1], IA2)
        subscribers = self.components.subscribers((U1(1),), IA2)
        self.assertEqual(len(subscribers), 0)

    def test_sorting_registered_subscription_adapters(self):
        self.components.registerSubscriptionAdapter(A1_2)
        self.components.registerSubscriptionAdapter(A1_12, provided=IA2)
        self.components.registerSubscriptionAdapter(
            A, [I1], IA2, info=u'a sample comment')
        self.components.registerSubscriptionAdapter(
            A, [I1], IA2, u'', u'a sample comment')
        self.components.registerSubscriptionAdapter(noop, [I1], IA2)

        sorted_subscribers = sorted(
            self.components.registeredSubscriptionAdapters())
        sorted_subscribers_name = map(lambda x: getattr(x, 'name'),
                                      sorted_subscribers)
        sorted_subscribers_provided = map(lambda x: getattr(x, 'provided'),
                                          sorted_subscribers) 
        sorted_subscribers_required = map(lambda x: getattr(x, 'required'),
                                          sorted_subscribers)
        sorted_subscribers_factory = map(lambda x: getattr(x, 'factory'),
                                         sorted_subscribers)
        sorted_subscribers_info = map(lambda x: getattr(x, 'info'),
                                      sorted_subscribers)

        self.assertEqual(len(sorted_subscribers), 5)
        self.assertEqual(sorted_subscribers_name, [u'', u'', u'', u'', u''])
        self.assertEqual(sorted_subscribers_provided,
                         [IA2, IA2, IA2, IA2, IA2])
        self.assertEqual(sorted_subscribers_required,
                         [(I1,), (I1,), (I1,),(I1,), (I1,)])
        self.assertEqual(sorted_subscribers_factory,
                         [A, A, A1_12, A1_2, noop])
        self.assertEqual(
            sorted_subscribers_info,
            [u'a sample comment', u'a sample comment', u'', u'', u''])

    def test_unregister(self):
        self.components.registerSubscriptionAdapter(A1_2)
        self.assertEqual(len(self.components.subscribers((U1(1),), IA2)), 1)
        self.assertTrue(self.components.unregisterSubscriptionAdapter(A1_2))
        self.assertEqual(len(self.components.subscribers((U1(1),), IA2)), 0)

    def test_unregister_multiple(self):
        self.components.registerSubscriptionAdapter(A1_2)
        self.components.registerSubscriptionAdapter(A1_12, provided=IA2)
        self.components.registerSubscriptionAdapter(
            A, [I1], IA2, info=u'a sample comment')
        self.components.registerSubscriptionAdapter(
            A, [I1], IA2, u'', u'a sample comment')
        self.components.registerSubscriptionAdapter(noop, [I1], IA2)
        self.assertEqual(len(self.components.subscribers((U1(1),), IA2)), 4)
        self.assertEqual(
            len(list(self.components.registeredSubscriptionAdapters())), 5)

        self.assertTrue(
            self.components.unregisterSubscriptionAdapter(A, [I1], IA2))
        self.assertEqual(len(self.components.subscribers((U1(1),), IA2)), 2)
        self.assertEqual(
            len(list(self.components.registeredSubscriptionAdapters())), 3)

    def test_unregister_no_factory(self):
        self.components.registerSubscriptionAdapter(A1_2)
#.........这里部分代码省略.........

 def registerHandler(self, *arg, **kw):
     result = Components.registerHandler(self, *arg, **kw)
     self.has_listeners = True
     return result

class TestUtility(unittest.TestCase):

    def setUp(self):
        self.components = Components('comps')

    def test_register_utility(self):
        test_object = U1(1)
        self.components.registerUtility(test_object)
        self.assertEqual(self.components.getUtility(I1), test_object)

    def test_register_utility_with_factory(self):
        test_object = U1(1)
        def factory():
           return test_object
        self.components.registerUtility(factory=factory)
        self.assertEqual(self.components.getUtility(I1), test_object)
        self.assertTrue(self.components.unregisterUtility(factory=factory))

    def test_register_utility_with_component_and_factory(self):
        def factory():
            return U1(1)
        self.assertRaises(
            TypeError,
            self.components.registerUtility, U1(1), factory=factory)

    def test_unregister_utility_with_and_without_component_and_factory(self):
        def factory():
            return U1(1)
        self.assertRaises(
            TypeError,
            self.components.unregisterUtility, U1(1), factory=factory)
        self.assertRaises(TypeError, self.components.unregisterUtility)

    def test_register_utility_with_no_interfaces(self):
        self.assertRaises(TypeError, self.components.registerUtility, A)

    def test_register_utility_with_two_interfaces(self):
        self.assertRaises(TypeError, self.components.registerUtility, U12(1))

    def test_register_utility_with_arguments(self):
        test_object1 = U12(1)
        test_object2 = U12(2)
        self.components.registerUtility(test_object1, I2)
        self.components.registerUtility(test_object2, I2, 'name')
        self.assertEqual(self.components.getUtility(I2), test_object1)
        self.assertEqual(self.components.getUtility(I2, 'name'), test_object2)

    def test_get_none_existing_utility(self):
        from zope.interface.interfaces import ComponentLookupError
        self.assertRaises(ComponentLookupError, self.components.getUtility, I3)

    def test_query_none_existing_utility(self):
        self.assertTrue(self.components.queryUtility(I3) is None)
        self.assertEqual(self.components.queryUtility(I3, default=42), 42)

    def test_registered_utilities_and_sorting(self):
        test_object1 = U1(1)
        test_object2 = U12(2)
        test_object3 = U12(3)
        self.components.registerUtility(test_object1)
        self.components.registerUtility(test_object3, I2, u'name')
        self.components.registerUtility(test_object2, I2)

        sorted_utilities = sorted(self.components.registeredUtilities())
        sorted_utilities_name = map(lambda x: getattr(x, 'name'),
                                    sorted_utilities)
        sorted_utilities_component = map(lambda x: getattr(x, 'component'),
                                         sorted_utilities)
        sorted_utilities_provided = map(lambda x: getattr(x, 'provided'),
                                        sorted_utilities)

        self.assertEqual(len(sorted_utilities), 3)
        self.assertEqual(sorted_utilities_name, [u'', u'', u'name'])
        self.assertEqual(
            sorted_utilities_component,
            [test_object1, test_object2, test_object3])
        self.assertEqual(sorted_utilities_provided, [I1, I2, I2])

    def test_duplicate_utility(self):
        test_object1 = U1(1)
        test_object2 = U12(2)
        test_object3 = U12(3)
        test_object4 = U1(4)
        self.components.registerUtility(test_object1)
        self.components.registerUtility(test_object2, I2)
        self.components.registerUtility(test_object3, I2, u'name')
        self.assertEqual(self.components.getUtility(I1), test_object1)

        self.components.registerUtility(test_object4, info=u'use 4 now')
        self.assertEqual(self.components.getUtility(I1), test_object4)

    def test_unregister_utility(self):
        test_object = U1(1)
        self.components.registerUtility(test_object)
        self.assertEqual(self.components.getUtility(I1), test_object)
        self.assertTrue(self.components.unregisterUtility(provided=I1))
        self.assertFalse(self.components.unregisterUtility(provided=I1))

    def test_unregister_utility_extended(self):
        test_object = U1(1)
#.........这里部分代码省略.........