self.fail("get_options() should contain 'testing':'123', contains %s"%req.get_options().items())    def test_req_get_remote_host(self):        # simulating this test for real is too complex...        req = self.req        log = req.log_error        log("req.get_get_remote_host(): %s" % `req.get_remote_host(apache.REMOTE_HOST)`)        log("req.get_get_remote_host(): %s" % `req.get_remote_host()`)        if (req.get_remote_host(apache.REMOTE_HOST) != None) or \           (req.get_remote_host() != "127.0.0.1"):            self.fail("remote host test failed")    def test_server_members(self):        req = self.req        log = req.log_error        server = req.server        log("Examining server memebers:")        log("    server.defn_name: %s" % `server.defn_name`)        if server.defn_name[-9:] != "test.conf":            self.fail("server.defn_name does not end in 'test.conf'")                log("    server.defn_line_number: %s" % `server.defn_line_number`)        if server.defn_line_number == 0:            self.fail("server.defn_line_number should not be 0")                log("    server.server_admin: %s" % `server.server_admin`)        if server.server_admin != "serveradmin@somewhere.com":            self.fail("server.server_admin must be 'serveradmin@somewhere.com'")                log("    server.server_hostname: %s" % `server.server_hostname`)        if server.server_hostname != "test_internal":            self.fail("server.server_hostname must be 'test_internal'")                log("    server.port: %s" % `server.port`)        # hmm it really is 0...        #if server.port == 0:        #    self.fail("server.port should not be 0")                    log("    server.error_fname: %s" % `server.error_fname`)        if server.error_fname != "logs/error_log":            self.fail("server.error_fname should be 'logs/error_log'")                log("    server.loglevel: %s" % `server.loglevel`)        if server.loglevel != 7:            self.fail("server.loglevel should be 7")                log("    server.is_virtual: %s" % `server.is_virtual`)        if server.is_virtual != 1:            self.fail("server.is_virtual should be 1")                log("    server.timeout: %s" % `server.timeout`)        if not server.timeout in (5.0, 300.0):            self.fail("server.timeout should be 5.0 or 300.0")                log("    server.keep_alive_timeout: %s" % `server.keep_alive_timeout`)        if server.keep_alive_timeout != 15.0:            self.fail("server.keep_alive_timeout should be 15.0")                    log("    server.keep_alive_max: %s" % `server.keep_alive_max`)        if server.keep_alive_max != 100:            self.fail("server.keep_alive_max should be 100")                    log("    server.keep_alive: %s" % `server.keep_alive`)        if server.keep_alive != 1:            self.fail("server.keep_alive should be 1")                log("    server.path: %s" % `server.path`)        if server.path != "some/path":            self.fail("server.path should be 'some/path'")                log("    server.pathlen: %s" % `server.pathlen`)        if server.pathlen != len('some/path'):            self.fail("server.pathlen should be %d" % len('some/path'))                log("    server.limit_req_line: %s" % `server.limit_req_line`)        if server.limit_req_line != 8190:            self.fail("server.limit_req_line should be 8190")                    log("    server.limit_req_fieldsize: %s" % `server.limit_req_fieldsize`)        if server.limit_req_fieldsize != 8190:            self.fail("server.limit_req_fieldsize should be 8190")                    log("    server.limit_req_fields: %s" % `server.limit_req_fields`)        if server.limit_req_fields != 100:            self.fail("server.limit_req_fields should be 100")          log("    server.names: %s" % `server.names`)        if server.names != ():            self.fail("server.names should be an empty tuple")                    log("    server.wild_names: %s" % `server.wild_names`)        if server.wild_names != ():            self.fail("server.wild_names should be an empty tuple")                def test_connection_members(self):        req = self.req        log = req.log_error        conn = req.connection        try:             import socket            localip = socket.gethostbyname("localhost")         except:             localip = "127.0.0.1"        log("Examining connection memebers:")        log("    connection.base_server: %s" % `conn.base_server`)        if type(conn.base_server) is not type(req.server):            self.fail("conn.base_server should be same type as req.server")                log("    connection.local_addr: %s" % `conn.local_addr`)        if not conn.local_addr[0] in ("127.0.0.1", "0.0.0.0", localip):            self.fail("conn.local_addr[0] should be '127.0.0.1' or '0.0.0.0'")                log("    connection.remote_addr: %s" % `conn.remote_addr`)        if not conn.remote_addr[0] in ("127.0.0.1", "0.0.0.0", localip):            self.fail("conn.remote_addr[0] should be '127.0.0.1' or '0.0.0.0'")        log("    connection.remote_ip: %s" % `conn.remote_ip`)        if not conn.remote_ip in ("127.0.0.1", localip):            self.fail("conn.remote_ip should be '127.0.0.1'")        log("    connection.remote_host: %s" % `conn.remote_host`)        if conn.remote_host is not None:            self.fail("conn.remote_host should be None")        log("    connection.remote_logname: %s" % `conn.remote_logname`)        if conn.remote_logname is not None:            self.fail("conn.remote_logname should be None")                log("    connection.aborted: %s" % `conn.aborted`)        if conn.aborted != 0:            self.fail("conn.aborted should be 0")        log("    connection.keepalive: %s" % `conn.keepalive`)        if conn.keepalive != 2:            self.fail("conn.keepalive should be 2")                log("    connection.double_reverse: %s" % `conn.double_reverse`)        if conn.double_reverse != 0:            self.fail("conn.double_reverse should be 0")                log("    connection.keepalives: %s" % `conn.keepalives`)        if conn.keepalives != 1:            self.fail("conn.keepalives should be 1")        log("    connection.local_ip: %s" % `conn.local_ip`)        if not conn.local_ip in ("127.0.0.1", localip):            self.fail("conn.local_ip should be '127.0.0.1'")        log("    connection.local_host: %s" % `conn.local_host`)        if conn.local_host is not None:            self.fail("conn.local_host should be None")        log("    connection.id: %s" % `conn.id`)        if conn.id > 100:            self.fail("conn.id should not be this high")                log("    connection.notes: %s" % `conn.notes`)        if `conn.notes` != '{}':            self.fail("conn.notes should be {}")def make_suite(req):    mpTestSuite = unittest.TestSuite()    mpTestSuite.addTest(SimpleTestCase("test_apache_log_error", req))    mpTestSuite.addTest(SimpleTestCase("test_apache_table", req))    mpTestSuite.addTest(SimpleTestCase("test_req_add_common_vars", req))    mpTestSuite.addTest(SimpleTestCase("test_req_members", req))    mpTestSuite.addTest(SimpleTestCase("test_req_get_config", req))    mpTestSuite.addTest(SimpleTestCase("test_req_get_remote_host", req))    mpTestSuite.addTest(SimpleTestCase("test_server_members", req))    mpTestSuite.addTest(SimpleTestCase("test_connection_members", req))    return mpTestSuitedef handler(req):    out = cStringIO.StringIO()    tr = unittest.TextTestRunner(out)    result = tr.run(make_suite(req))    req.log_error(out.getvalue())    if result.wasSuccessful():        req.write("test ok")    else:        req.write("test failed")    return apache.OKdef simple_handler(req):    # for req_add_handler()    if (req.secret_message == "foo"):        req.write("test ok")            return apache.OKdef req_add_handler(req):    req.secret_message = "foo"    req.add_handler("PythonHandler", "tests::simple_handler")    req.add_handler("PythonHandler", simple_handler)    return apache.OKdef req_add_bad_handler(req):    # bad_handler does not exist so adding it should     # should raise an AttributeError exception        req.log_error("req_add_bad_handler")    req.add_handler("PythonHandler", "tests::bad_handler")    req.write("test ok")    return apache.OKdef req_add_empty_handler_string(req):    # Adding an empty string as a handler should should     # should raise an exception        req.log_error("req_add_empty_handler_string")    req.add_handler("PythonHandler", "")    req.write("no exception")    return apache.OKdef req_add_handler_empty_phase(req):    req.log_error("req_add_handler_empty_phase")    req.log_error("phase=%s" % req.phase)    req.log_error("interpreter=%s" % req.interpreter)    req.log_error("directory=%s" % req.hlist.directory)    if req.phase != "PythonHandler":        directory = os.path.dirname(__file__)        req.add_handler("PythonHandler", "tests::req_add_handler_empty_phase", directory)    else:        req.write("test ok")    return apache.OKdef accesshandler_add_handler_to_empty_hl(req):    # Prior to version 3.2.6, adding a python handler     # to and empty handler list would cause a segfault     req.secret_message = "foo"    req.log_error("accesshandler_add_handler_to_empty_hl")    req.add_handler("PythonHandler", "tests::simple_handler")    return apache.OKdef test_req_add_handler_directory(req):    # dir1 will not have a trailing slash and on Win32    # will use back slashes and not forward slashes.    dir1 = os.path.dirname(__file__)    if req.phase == "PythonFixupHandler":        req.add_handler("PythonHandler", "tests::test_req_add_handler_directory", dir1)    else:	# dir2 should only use forward slashes and	# should have a trailing forward slash added by	# call to req.add_handler(). When dir1 and dir2	# are normalised for current operating system,        # they should be equivalent.        dir2 = req.hlist.directory        if dir2[-1] != '/' or dir2.count('\\') != 0:            req.write('test failed')        else:            dir1 = os.path.normpath(dir1)            dir2 = os.path.normpath(dir2)            if dir2 != dir1:                req.write('test failed')            else:                req.write('test ok')            return apache.OKdef req_allow_methods(req):    req.allow_methods(["PYTHONIZE"])    return apache.HTTP_METHOD_NOT_ALLOWEDdef req_get_basic_auth_pw(req):    pw = req.get_basic_auth_pw()    if req.user != "spam" or pw != "eggs":        req.write("test failed")    else:        req.write("test ok")    return apache.OKdef req_auth_type(req):    if req.phase == "PythonAuthenHandler":        if req.auth_type() != "dummy":            req.log_error("auth_type check failed")            req.write("test failed")            return apache.DONE        if req.auth_name() != "blah":            req.log_error("auth_name check failed")            req.write("test failed")            return apache.DONE        req.user = "dummy"        req.ap_auth_type = req.auth_type()    elif req.phase == "PythonAuthzHandler":        if req.ap_auth_type != "dummy":            req.log_error("ap_auth_type check failed")            req.write("test failed")            return apache.DONE        if req.user != "dummy":            req.log_error("user check failed")            req.write("test failed")            return apache.DONE    else:        if req.ap_auth_type != "dummy":            req.log_error("ap_auth_type check failed")            req.write("test failed")            return apache.DONE        if req.user != "dummy":            req.log_error("user check failed")            req.write("test failed")            return apache.DONE        req.write("test ok")    return apache.OKdef req_requires(req):    if req.requires() == ('valid-user',):        req.write("test ok")        return apache.DONE    req.write("test failed")    return apache.DONEdef req_document_root(req):    req.write(req.document_root())    return apache.OKdef req_internal_redirect(req):    req.internal_redirect("/test.int")    return apache.OKdef req_internal_redirect_int(req):    # used by req_internal_redirect    req.prev.write("test ")    req.write("ok")    return apache.OKdef req_construct_url(req):    url = req.construct_url("/index.html")    if not re.match("^http://test_req_construct_url:[0-9]+/index.html$",url):        req.write("test failed")    else:        req.write("test ok")    return apache.OKdef req_read(req):    s = req.read()    req.write(s)    return apache.OK