secret="secret")    for k in cookies:        Cookie.add_cookie(req, cookies[k])    req.write("test ok")        return apache.OK    def global_lock(req):    import _apache    _apache._global_lock(req.server, 1)    time.sleep(1)    _apache._global_unlock(req.server, 1)    req.write("test ok")        return apache.OKdef Session_Session(req):    from mod_python import Session, Cookie    s = Session.Session(req)    if s.is_new():        s.save()            cookies = Cookie.get_cookies(req)    if cookies.has_key(Session.COOKIE_NAME) and s.is_new():        req.write(str(cookies[Session.COOKIE_NAME]))    else:        req.write("test ok")    return apache.OKdef files_directive(req):    req.write(str(req.hlist.directory))    return apache.OKnone_handler = Nonedef server_return_1(req):    raise apache.SERVER_RETURN, apache.OKdef server_return_2(req):    req.write("test ok")    return apache.OKdef phase_status_1(req):    apache.log_error("phase_status_1")    req.phases = [1]    return apache.DECLINEDdef phase_status_2(req):    apache.log_error("phase_status_2")    req.phases.append(2)    req.user = "bogus"    req.ap_auth_type = "bogus"    return apache.OKdef phase_status_3(req):    apache.log_error("phase_status_3")    req.phases.append(3)    return apache.OKdef phase_status_4(req):    apache.log_error("phase_status_4")    #req.phases.append(4)    return apache.OKdef phase_status_5(req):    apache.log_error("phase_status_5")    req.phases.append(5)    return apache.DECLINEDdef phase_status_6(req):    apache.log_error("phase_status_6")    req.phases.append(6)    return apache.OKdef phase_status_7(req):    apache.log_error("phase_status_7")    req.phases.append(7)    return apache.OKdef phase_status_8(req):    apache.log_error("phase_status_8")    apache.log_error("phases = %s" % req.phases)    if req.phases != [1, 2, 5, 6, 7]:        req.write("test failed")    else:        req.write("test ok")    return apache.OKdef test_sys_argv(req):    import sys    req.write(repr(sys.argv))    return apache.OK        def PythonOption_items(req):    options = req.get_options().items()        # The tests may using PythonOption mod_python.* in the test configuration    # We need to remove those particular options so they don't interfer    # with this test result.    options = [ o for o in options if not o[0].startswith('mod_python') ]        options.sort()    req.write(str(options))    return apache.OKdef interpreter(req):    if req.phase == "PythonFixupHandler":        if req.filename[-1] != '/' and os.path.isdir(req.filename):            req.write(req.interpreter)            return apache.DONE        return apache.OK    else:        req.write(req.interpreter)        return apache.DONEdef index(req):    return "test ok, interpreter=%s" % req.interpreterdef test_publisher(req):    return "test ok, interpreter=%s" % req.interpreterdef test_publisher_auth_nested(req):    def __auth__(req, user, password):        test_globals = test_publisher        req.notes["auth_called"] = "1"        return user == "spam" and password == "eggs"    def __access__(req, user):        req.notes["access_called"] = "1"        return 1    assert(int(req.notes.get("auth_called",0)))    assert(int(req.notes.get("access_called",0)))    return "test ok, interpreter=%s" % req.interpreterclass _test_publisher_auth_method_nested:    def method(self, req):        def __auth__(req, user, password):            test_globals = test_publisher            req.notes["auth_called"] = "1"            return user == "spam" and password == "eggs"        def __access__(req, user):            req.notes["access_called"] = "1"            return 1        assert(int(req.notes.get("auth_called",0)))        assert(int(req.notes.get("access_called",0)))        return "test ok, interpreter=%s" % req.interpretertest_publisher_auth_method_nested = _test_publisher_auth_method_nested()class OldStyleClassTest:    def __init__(self):        pass    def __call__(self, req):        return "test callable old-style instance ok"    def traverse(self, req):        return "test traversable old-style instance ok"old_instance = OldStyleClassTest()test_dict = {1:1, 2:2, 3:3}test_dict_keys = test_dict.keysdef test_dict_iteration(req):    return test_dict_keys()    def test_generator(req):    c = 0    while c < 10:        yield c        c += 1def server_side_include(req):    req.ssi_globals = { "data": "test" }    return apache.OKclass InstanceTest(object):    def __call__(self, req):        return "test callable instance ok"    def traverse(self, req):        return "test traversable instance ok"instance = InstanceTest()# Hierarchy traversal testsclass Mapping(object):    def __init__(self,name):        self.name = name    def __call__(self,req):        return "Called %s"%self.namehierarchy_root = Mapping("root");hierarchy_root.page1 = Mapping("page1")hierarchy_root.page1.subpage1 = Mapping("subpage1")hierarchy_root.page2 = Mapping("page2")class Mapping2:    passhierarchy_root_2 = Mapping2()hierarchy_root_2.__call__ = indexhierarchy_root_2.page1 = indexhierarchy_root_2.page2 = indexdef _test_table():    log = apache.log_error    log("    starting _test_table")    d = apache.table()    if d.keys() != []: raise TestFailed, '{}.keys()'    if d.has_key('a') != 0: raise TestFailed, '{}.has_key(\'a\')'    if ('a' in d) != 0: raise TestFailed, "'a' in {}"    if ('a' not in d) != 1: raise TestFailed, "'a' not in {}"    if len(d) != 0: raise TestFailed, 'len({})'    d = {'a': 1, 'b': 2}    if len(d) != 2: raise TestFailed, 'len(dict)'    k = d.keys()    k.sort()    if k != ['a', 'b']: raise TestFailed, 'dict keys()'    if d.has_key('a') and d.has_key('b') and not d.has_key('c'): pass    else: raise TestFailed, 'dict keys()'    if 'a' in d and 'b' in d and 'c' not in d: pass    else: raise TestFailed, 'dict keys() # in/not in version'    if d['a'] != 1 or d['b'] != 2: raise TestFailed, 'dict item'    d['c'] = 3    d['a'] = 4    if d['c'] != 3 or d['a'] != 4: raise TestFailed, 'dict item assignment'    del d['b']    if d != {'a': 4, 'c': 3}: raise TestFailed, 'dict item deletion'        # dict.clear()    log("    table.clear()")    d = apache.table()    d['1'] = '1'    d['2'] = '2'    d['3'] = '3'    d.clear()    if d != apache.table(): raise TestFailed, 'dict clear'        # dict.update()    log("    table.update()")    d.update({'1':'100'})    d.update({'2':'20'})    d.update({'1':'1', '2':'2', '3':'3'})    if d != apache.table({'1':'1', '2':'2', '3':'3'}): raise TestFailed, 'dict update'    d.clear()    try: d.update(None)    except AttributeError: pass    else: raise TestFailed, 'dict.update(None), AttributeError expected'    class SimpleUserDict:        def __init__(self):            self.d = {1:1, 2:2, 3:3}        def keys(self):            return self.d.keys()        def __getitem__(self, i):            return self.d[i]    d.update(SimpleUserDict())    if d != apache.table({1:1, 2:2, 3:3}): raise TestFailed, 'dict.update(instance)'    d.clear()    class FailingUserDict:        def keys(self):            raise ValueError    try: d.update(FailingUserDict())    except ValueError: pass    else: raise TestFailed, 'dict.keys() expected ValueError'    class FailingUserDict:        def keys(self):            class BogonIter:                def __iter__(self):                    raise ValueError            return BogonIter()    try: d.update(FailingUserDict())    except ValueError: pass    else: raise TestFailed, 'iter(dict.keys()) expected ValueError'    class FailingUserDict:        def keys(self):            class BogonIter:                def __init__(self):                    self.i = 1                def __iter__(self):                    return self                def next(self):                    if self.i:                        self.i = 0                        return 'a'                    raise ValueError            return BogonIter()        def __getitem__(self, key):            return key    try: d.update(FailingUserDict())    except ValueError: pass    else: raise TestFailed, 'iter(dict.keys()).next() expected ValueError'    class FailingUserDict:        def keys(self):            class BogonIter:                def __init__(self):                    self.i = ord('a')                def __iter__(self):                    return self                def next(self):                    if self.i <= ord('z'):                        rtn = chr(self.i)                        self.i += 1                        return rtn                    raise StopIteration            return BogonIter()        def __getitem__(self, key):            raise ValueError    try: d.update(FailingUserDict())    except ValueError: pass    else: raise TestFailed, 'dict.update(), __getitem__ expected ValueError'    # dict.copy()    log("    table.copy()")    d = {1:1, 2:2, 3:3}    if d.copy() != {1:1, 2:2, 3:3}: raise TestFailed, 'dict copy'    if apache.table().copy() != apache.table(): raise TestFailed, 'empty dict copy'    # dict.get()    log("    table.get()")    d = apache.table()    if d.get('c') is not None: raise TestFailed, 'missing {} get, no 2nd arg'    if d.get('c', '3') != '3': raise TestFailed, 'missing {} get, w/ 2nd arg'    d = apache.table({'a' : '1', 'b' : '2'})    if d.get('c') is not None: raise TestFailed, 'missing dict get, no 2nd arg'    if d.get('c', '3') != '3': raise TestFailed, 'missing dict get, w/ 2nd arg'    if d.get('a') != '1': raise TestFailed, 'present dict get, no 2nd arg'    if d.get('a', '3') != '1': raise TestFailed, 'present dict get, w/ 2nd arg'    # dict.setdefault()    log("    table.setdefault()")    d = apache.table()    d.setdefault('key0')    if d.setdefault('key0') is not "":        raise TestFailed, 'missing {} setdefault, no 2nd arg'    if d.setdefault('key0') is not "":        raise TestFailed, 'present {} setdefault, no 2nd arg'    # dict.popitem()    log("    table.popitem()")    for copymode in -1, +1:        # -1: b has same structure as a        # +1: b is a.copy()        for log2size in range(12):            size = 2**log2size            a = apache.table()            b = apache.table()            for i in range(size):                a[`i`] = str(i)                if copymode < 0:                    b[`i`] = str(i)            if copymode > 0:                b = a.copy()            for i in range(size):                ka, va = ta = a.popitem()                if va != ka: raise TestFailed, "a.popitem: %s" % str(ta)                kb, vb = tb = b.popitem()                if vb != kb: raise TestFailed, "b.popitem: %s" % str(tb)                if copymode < 0 and ta != tb:                    raise TestFailed, "a.popitem != b.popitem: %s, %s" % (                        str(ta), str(tb))            if a: raise TestFailed, 'a not empty after popitems: %s' % str(a)            if b: raise TestFailed, 'b not empty after popitems: %s' % str(b)    # iteration (just make sure we can iterate without a segfault)    d = apache.table({'a' : '1', 'b' : '2', 'c' : '3'})    log("    for k in table")    for k in d:        pass    log("    _test_table test finished")