def _duplicateAdapterForClassOrInterfaceAllowed(self, original):
        """
        Verify that when C{components.ALLOW_DUPLICATES} is set to C{True}, new
        adapter registrations for a particular from-type/interface and
        to-interface pair replace older registrations.
        """
        firstAdapter = lambda o: False
        secondAdapter = lambda o: True
        class TheInterface(Interface):
            pass
        components.registerAdapter(firstAdapter, original, TheInterface)
        components.ALLOW_DUPLICATES = True
        try:
            components.registerAdapter(secondAdapter, original, TheInterface)
            self.assertIs(
                components.getAdapterFactory(original, TheInterface, None),
                secondAdapter)
        finally:
            components.ALLOW_DUPLICATES = False

        # It should be rejected again at this point
        self.assertRaises(
            ValueError,
            components.registerAdapter,
            firstAdapter, original, TheInterface)

        self.assertIs(
            components.getAdapterFactory(original, TheInterface, None),
            secondAdapter)

def run():
    args = PARSER.parse_args()

    # Unpack values. Each should be a list of one item (hence the
    # comma. Yay list unpacking)
    private_key, = args.private_key
    public_key, = args.public_key
    webserver_address, = args.webserver_address
    webserver_user, = args.webserver_user
    webserver_password, = args.webserver_password
    port = int(args.port)

    log.startLogging(sys.stderr)
    log.startLogging(open('gitssh.log', 'w'))

    components.registerAdapter(GitSession, GitConchUser, ISession)

    # Set up authorization
    GitServer.meta = GitMeta(webserver_address,
                             webserver_user, webserver_password)
    GitServer.portal = Portal(GitRealm(GitServer.meta))
    GitServer.portal.registerChecker(TeamPasswordChecker(GitServer.meta))

    # Instantiate a server
    server = GitServer(os.path.abspath(private_key),
                       os.path.abspath(public_key))

    # Start listening
    reactor.listenTCP(port, server)
    reactor.run()

def makeService(config):
    components.registerAdapter(
        GitSession,
        GitAvatar,
        session.ISession)

    with open(config['conf']) as f:
        conf = yaml.load(f.read())

    port = int(conf.get('port', 22))
    host_key = conf.get('host_key')
    driver_key = conf.get('driver', 'example')

    log.msg('Using driver: \'%s\'' % driver_key)

    mgr = driver.DriverManager(
        namespace='gitserver.driver',
        name=driver_key,
        invoke_on_load=False
    )

    portal = Portal(GitRealm(mgr))
    portal.registerChecker(GitPublicKeyChecker(mgr))

    # factory.SSHFactory takes no arguments, so unlike the
    # websocket server, we will assign portal on the class
    # rather than through the constructor.
    # TypeError: this constructor takes no arguments
    # is raised if we pass portal GitFactory(portal)
    GitFactory.portal = portal
    GitSession.driver_key = driver_key

    return internet.TCPServer(port, GitFactory(host_key=host_key))

def start():
    from checker import PublicKeyCredentialsChecker
    from factory import ForwardFactory
    from realm import ForwardRealm
    from session import ForwardSession
    from twisted.conch.ssh import session
    from twisted.cred import portal
    from twisted.internet import reactor
    from twisted.python import components, log
    from twisted.web import server
    
    import sys
    
    from user import ForwardUser
    from conf import config
    import web
    
    log.startLogging(sys.stderr)
    
    components.registerAdapter(ForwardSession, ForwardUser, session.ISession)

    portal = portal.Portal(ForwardRealm())
    portal.registerChecker(PublicKeyCredentialsChecker())
    ForwardFactory.portal = portal
    print "running server on %s:%s" % (config['SSH_INTERFACE'],config['SSH_PORT'])
    reactor.listenTCP(
                  port=config['SSH_PORT'], 
                  interface=config['SSH_INTERFACE'], 
                  factory=ForwardFactory()
        )
    reactor.listenTCP(port=config['WEB_PORT'],
                      interface=config['WEB_INTERFACE'],
                      factory=server.Site(web.MainSite()))
    reactor.run()

    def setUp(self):
        db = inmemory.ReadOnlyInMemoryLDAPEntry("", {})
        com = db.addChild("dc=com", {"objectClass": ["dcObject"], "dc": ["com"]})
        com.addChild("dc=example", {"objectClass": ["dcObject"], "dc": ["example"], "subschemaSubentry": ["cn=schema"]})
        db.addChild(
            "cn=schema",
            {
                "objectClass": ["TODO"],
                "cn": ["schema"],
                "attributeTypes": [test_schema.AttributeType_KnownValues.knownValues[0][0]],
                "objectClasses": [
                    test_schema.OBJECTCLASSES["organization"],
                    test_schema.OBJECTCLASSES["organizationalUnit"],
                ],
            },
        )

        class LDAPServerFactory(protocol.ServerFactory):
            protocol = ldapserver.LDAPServer

            def __init__(self, root):
                self.root = root

        components.registerAdapter(lambda x: x.root, LDAPServerFactory, interfaces.IConnectedLDAPEntry)
        serverFactory = LDAPServerFactory(db)

        self.client = ldapclient.LDAPClient()
        server = serverFactory.buildProtocol(address.IPv4Address("TCP", "localhost", "1024"))
        util.returnConnected(server, self.client)

def check_config_base():
    from mypkg import config, interfaces, usesconfig

    components.registerAdapter(
        AdaptRunningConfigToMyConfig, config.MyConfig, IMyConfig)

    print usesconfig.do_a_config_thing()

    def setUp(self):
        db = inmemory.ReadOnlyInMemoryLDAPEntry('', {})
        com = db.addChild('dc=com',
                          {'objectClass': ['dcObject'],
                           'dc': ['com'],
                           })
        com.addChild('dc=example',
                     {'objectClass': ['dcObject'],
                      'dc': ['example'],
                      'subschemaSubentry': ['cn=schema'],
                      })
        db.addChild('cn=schema',
                    {'objectClass': ['TODO'],
                     'cn': ['schema'],
                     'attributeTypes': [test_schema.AttributeType_KnownValues.knownValues[0][0]],
                     'objectClasses': [test_schema.OBJECTCLASSES['organization'],
                                       test_schema.OBJECTCLASSES['organizationalUnit'],
                                       ],
                     })

        class LDAPServerFactory(protocol.ServerFactory):
            protocol = ldapserver.LDAPServer

            def __init__(self, root):
                self.root = root

        components.registerAdapter(lambda x: x.root,
                                   LDAPServerFactory,
                                   interfaces.IConnectedLDAPEntry)
        serverFactory = LDAPServerFactory(db)

        self.client = ldapclient.LDAPClient()
        server = serverFactory.buildProtocol(address.IPv4Address('TCP', 'localhost', '1024'))
        util.returnConnected(server, self.client)

 def test_basic(self):
     """
     Registered adapters can be used to adapt classes to an interface.
     """
     components.registerAdapter(MetaAdder, MetaNumber, IMeta)
     n = MetaNumber(1)
     self.assertEqual(IMeta(n).add(1), 2)

def main(argv=sys.argv[1:]):
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '-c',
        '--config',
        help=(
            'Path to the configuration file. If not specified then the '
            'lookup order will check for a HADOUKN_GIT_CONFIG environ '
            'variable, then fallback to .hadoukngitrc in the CWD.'
        ),
        default='hadoukngit.ini'
    )
    args = parser.parse_args(args=argv)

    cfg_path = args.config
    if cfg_path is not None and not os.path.exists(cfg_path):
        print('Invalid path "{}" specified for the config file.'
              .format(cfg_path), file=sys.stderr)
        return 1

    config = get_config(cfg_path)
    settings = config.get_dict()

    factory = SSHFactory(settings)

    # adapting User to GitSession which implements ISession
    components.registerAdapter(GitSession, User, ISession)

    port = int(settings['hadoukngit']['port'])

    # Run the server
    logger.info('Serving on localhost:%s...' % port)
    reactor.listenTCP(port, factory)
    reactor.run()

def registerCustomFieldSerializer(serializerClass, typeClass):
    """Register a custom field serializer for a specific type.
    """
    registerAdapter(
        serializerClass, typeClass, igwt.ICustomFieldSerializer
        )
    registerTypeClass(typeClass)

 def _registerAdapterForClassOrInterface(self, original):
     adapter = lambda o: None
     class TheInterface(Interface):
         pass
     components.registerAdapter(adapter, original, TheInterface)
     self.assertIdentical(
         components.getAdapterFactory(original, TheInterface, None),
         adapter)

def load(S):
    for line in S.split('\n'):
        line = line.strip()
        if line and not line.startswith('#'):
            (a, o, i) = line.split()
            registerAdapter(_namedAnyWithBuiltinTranslation(a),
                            _namedAnyWithBuiltinTranslation(clean(o)),
                            _namedAnyWithBuiltinTranslation(i))

    def testComponentized(self):
        components.registerAdapter(Adept, Compo, IAdept)
        components.registerAdapter(Elapsed, Compo, IElapsed)

        c = Compo()
        assert c.getComponent(IAdept).adaptorFunc() == (1, 1)
        assert c.getComponent(IAdept).adaptorFunc() == (2, 2)
        assert IElapsed(IAdept(c)).elapsedFunc() == 1

def check_app_inherited():
    from otherpkg import config

    class OtherApp(object):
        def get_config(self):
            return "config.name = 'other app'"

    components.registerAdapter(
        AdaptRunningAppToMyApp, OtherApp, IMyApp)

    def register():
        """Register this component
        """

        try:
            components.registerAdapter(MambaSQLAdapter, MySQL, IMambaSQL)
        except ValueError:
            # component already registered
            pass

def registerTypeAdapter(typeClass, instanceClass):
    """Associate a value class with an type.

    This enables us to lookup the type for a value by simply adopting
    it to IType.  This is mostly used for exceptions.
    """
    def adapter(original):
        return typeClass()
    registerAdapter(adapter, instanceClass, igwt.IType)

 def __init__(self, cfg, tls_options, *args):
     self.debug = True
     self.tree = Tree()
     self.root = self.tree.db
     self.options = tls_options
     registerAdapter(
         lambda x: x.root,
         LdapProtocolFactory,
         IConnectedLDAPEntry)

    def run(self, port=5022):
        components.registerAdapter(self.SSHSession, self.User, session.ISession)

        p = portal.Portal(self.SSHRealm())
        p.registerChecker(self.KeyChecker())
        self.SSHFactory.portal = p

        reactor.listenTCP(int(port), self.SSHFactory())
        reactor.run()

 def callback(instanceClass):
     class InstanceFactory:
         def __init__(self, protocolClass):
             pass
         def buildInstance(self):
             return instanceClass()
     components.registerAdapter(InstanceFactory, typeClass, 
                                igwt.IInstanceFactory)
     annotation.registerTypeAdapter(typeClass, instanceClass)
     return instanceClass

 def _multipleInterfacesForClassOrInterface(self, original):
     """
     Verify that an adapter can be registered for multiple to-interfaces at a
     time.
     """
     adapter = lambda o: None
     components.registerAdapter(adapter, original, ITest, ITest2)
     self.assertIs(
         components.getAdapterFactory(original, ITest, None), adapter)
     self.assertIs(
         components.getAdapterFactory(original, ITest2, None), adapter)