def listProcedures(self):
        """
        Return a list of the names of all xmlrpc procedures.

        @since: 11.1
        """
        return reflect.prefixedMethodNames(self.__class__, "xmlrpc_")

    def ctcpQuery_CLIENTINFO(self, user, channel, data):
        """A master index of what CTCP tags this client knows.

        If no arguments are provided, respond with a list of known tags.
        If an argument is provided, provide human-readable help on
        the usage of that tag.
        """

        nick = string.split(user,"!")[0]
        if not data:
            # XXX: prefixedMethodNames gets methods from my *class*,
            # but it's entirely possible that this *instance* has more
            # methods.
            names = reflect.prefixedMethodNames(self.__class__,
                                                'ctcpQuery_')

            self.ctcpMakeReply(nick, [('CLIENTINFO',
                                       string.join(names, ' '))])
        else:
            args = string.split(data)
            method = getattr(self, 'ctcpQuery_%s' % (args[0],), None)
            if not method:
                self.ctcpMakeReply(nick, [('ERRMSG',
                                           "CLIENTINFO %s :"
                                           "Unknown query '%s'"
                                           % (data, args[0]))])
                return
            doc = getattr(method, '__doc__', '')
            self.ctcpMakeReply(nick, [('CLIENTINFO', doc)])

    def _get_provider_names(self):
        """
        Find the names of all supported "providers" (eg Vagrant, Rackspace).

        :return: A ``list`` of ``str`` giving all such names.
        """
        return prefixedMethodNames(self.__class__, "_runner_")

    def testTests(self):
        suite = unittest.TestSuite()
        suffixes = reflect.prefixedMethodNames(TestTests.Tests, "test")
        for suffix in suffixes:
            method = "test" + suffix
            testCase = self.Tests()

            # if one of these test cases fails, switch to TextReporter to
            # see what happened

            rep = reporter.Reporter()
            #reporter = reporter.TextReporter()
            #print "running '%s'" % method

            rep.start(1)

            result = unittest.Tester(testCase.__class__, testCase,
                                     getattr(testCase, method),
                                     lambda x: x()).run()
            rep.reportResults(testCase.__class__, getattr(self.Tests, method),
                              *result)
            # TODO: verify that case.setUp == 1 and case.tearDown == 1
            try:
                self.checkResults(rep, method)
            except unittest.FailTest:
                # with TextReporter, this will show the traceback
                print
                print "problem in method '%s'" % method
                reporter.stop()
                raise

 def __init__(self, textView):
     self.textView=textView
     self.rkeymap = {}
     self.history = History()
     for name in prefixedMethodNames(self.__class__, "key_"):
         keysymName = name.split("_")[-1]
         self.rkeymap[getattr(gtk.keysyms, keysymName)] = keysymName

 def __init__(self, testClass):
     self.testClass = testClass
     self.methodNames = []
     for prefix in self.methodPrefixes:
         self.methodNames.extend([ "%s%s" % (prefix, name) for name in
                                   reflect.prefixedMethodNames(testClass, prefix)])
     # N.B.: --random will shuffle testClasses but not our methodNames[]
     self.methodNames.sort()

 def test_inheritedMethod(self):
     """
     L{prefixedMethodNames} returns a list included methods with the given
     prefix defined on base classes of the class passed to it.
     """
     class Child(Separate):
         pass
     self.assertEqual(["method"], prefixedMethodNames(Child, "good_"))

 def test_reverseKeymap(self):
     """
     Verify that a L{ConsoleInput} has a reverse mapping of the keysym names
     it needs for event handling to their corresponding keysym.
     """
     ci = ConsoleInput(None)
     for eventName in prefixedMethodNames(ConsoleInput, 'key_'):
         keysymName = eventName.split("_")[-1]
         keysymValue = getattr(gtk.keysyms, keysymName)
         self.assertEqual(ci.rkeymap[keysymValue], keysymName)

def _computeAllowedMethods(resource):
    """
    Compute the allowed methods on a C{Resource} based on defined render_FOO
    methods. Used when raising C{UnsupportedMethod} but C{Resource} does
    not define C{allowedMethods} attribute.
    """
    allowedMethods = []
    for name in prefixedMethodNames(resource.__class__, "render_"):
        allowedMethods.append(name)
    return allowedMethods

 def applyTo(self, item):
     headers = {}
     for hdr in item.impl.getAllHeaders():
         headers.setdefault(hdr.name, []).append(hdr.value)
     matchers = reflect.prefixedMethodNames(self.__class__, 'match_')
     for m in matchers:
         tag = getattr(self, 'match_' + m)(headers)
         if tag is not None:
             self.matchedMessages += 1
             assert type(tag) is unicode, "%r was not unicode, came from %r" % (tag, m)
             return True, True, {"mailingListName": tag}
     return False, True, None

def _computeAllowedMethods(resource):
    """
    Compute the allowed methods on a C{Resource} based on defined render_FOO
    methods. Used when raising C{UnsupportedMethod} but C{Resource} does
    not define C{allowedMethods} attribute.
    """
    allowedMethods = []
    for name in prefixedMethodNames(resource.__class__, "render_"):
        # Potentially there should be an API for encode('ascii') in this
        # situation - an API for taking a Python native string (bytes on Python
        # 2, text on Python 3) and returning a socket-compatible string type.
        allowedMethods.append(name.encode('ascii'))
    return allowedMethods

 def do_EHLO(self, rest):
     extensions = reflect.prefixedMethodNames(self.__class__, 'ext_')
     peer = self.transport.getPeer()[1]
     self.__helo = (rest, peer)
     self.__from = None
     self.__to = []
     self.sendCode(
         250,
         '%s\n%s Hello %s, nice to meet you' % (
             '\n'.join([
                 '%s %s' % (e, ' '.join(self.extArgs.get(e, []))) for e in extensions
             ]),
             self.host, peer
         )
     )

 def _get_test_methods(self, item):
     """
     Look for test_ methods in subclasses of NetTestCase
     """
     test_cases = []
     try:
         assert issubclass(item, NetTestCase)
         methods = reflect.prefixedMethodNames(item, self.method_prefix)
         test_methods = []
         for method in methods:
             test_methods.append(self.method_prefix + method)
         if test_methods:
             test_cases.append((item, test_methods))
     except (TypeError, AssertionError):
         pass
     return test_cases

def loadTestsAndOptions(classes, cmd_line_options):
    """
    Takes a list of test classes and returns their testcases and options.
    """
    method_prefix = 'test'
    options = None
    test_cases = []

    for klass in classes:
        tests = reflect.prefixedMethodNames(klass, method_prefix)
        if tests:
            test_cases = makeTestCases(klass, tests, method_prefix)

        test_klass = klass()
        options = test_klass._processOptions(cmd_line_options)

    return test_cases, options

 def _allowed_methods(self):
     """
     Compute allowable http methods to return in an Allowed-Methods header.
     This is to adhere to the HTTP standard.
     """
     allowed_methods = ['HEAD']  # we always allow head
     fq_name = self.__module__ + '.' + self.__class__.__name__
     name = '?'
     try:
         resource = self
         for n in prefixedMethodNames(resource.__class__, REST_METHOD_PREFIX):
             name = n
             allowed_methods.append(n.encode('ascii'))
     except UnicodeEncodeError:
         log.err('Resource (%s) method (%s) contains non-ascii characters' % (fq_name, name))
     except Exception as e:
         log.err('Resource (%s) error resolving method names (%s)' % (fq_name, e))
     return allowed_methods

    def decorator(test_case):
        test_method_names = [
            test_prefix + name
            for name
            in prefixedMethodNames(test_case, test_prefix)
        ]
        for test_method_name in test_method_names:
            if test_method_name not in supported_tests:
                test_method = getattr(test_case, test_method_name)
                new_message = []
                existing_message = getattr(test_method, skip_or_todo, None)
                if existing_message is not None:
                    new_message.append(existing_message)
                new_message.append('Not implemented yet')
                new_message = ' '.join(new_message)

                @wraps(test_method)
                def wrapper(*args, **kwargs):
                    return test_method(*args, **kwargs)
                setattr(wrapper, skip_or_todo, new_message)
                setattr(test_case, test_method_name, wrapper)

        return test_case

 def listProcedures(self):
     a = set(self._methods)
     b = set(reflect.prefixedMethodNames(self.__class__, 'dumbrpc_'))
     return sorted(a | b)

def prefixedMethodClassDict(clazz, prefix):
    return dict([(name, getattr(clazz, prefix + name)) for name in prefixedMethodNames(clazz, prefix)])

 def listFunctions(self):
     """
     Return a list of the names of all jsonrpc methods.
     """
     return reflect.prefixedMethodNames(self.__class__, self.prefix)

def prefixedMethodObjDict(obj, prefix):
    return dict([(name, getattr(obj, prefix + name)) for name in prefixedMethodNames(obj.__class__, prefix)])