rubyfox-server 2.3.0.pre2

data/lib/rubyfox/server/data/lib/Lib/test/test_sundry.py

@@ -0,0 +1,102 @@
+"""Do a minimal test of all the modules that aren't otherwise tested."""
+
+import warnings
+warnings.filterwarnings('ignore', '', DeprecationWarning, 'posixfile')
+
+from test_support import verbose
+
+import BaseHTTPServer
+import CGIHTTPServer
+import Queue
+import SimpleHTTPServer
+import SocketServer
+import aifc
+import anydbm
+import audiodev
+import bdb
+import cmd
+import code
+import codeop
+import colorsys
+import commands
+import compileall
+try:
+    import curses   # not available on Windows
+except ImportError:
+    if verbose:
+        print "skipping curses"
+import dircache
+import dis
+import distutils
+import doctest
+import dumbdbm
+import encodings
+import filecmp
+import fnmatch
+import formatter
+import fpformat
+import ftplib
+import getpass
+import glob
+import gopherlib
+import htmlentitydefs
+import htmllib
+import httplib
+import imaplib
+import imghdr
+import imputil
+import keyword
+#import knee
+import macpath
+import macurl2path
+import mailcap
+import mhlib
+import mimetypes
+import mimify
+import multifile
+import mutex
+import nntplib
+import nturl2path
+import pdb
+import pipes
+#import poplib
+import posixfile
+import pre
+import profile
+import pstats
+import py_compile
+import pyclbr
+#import reconvert
+import repr
+try:
+    import rlcompleter   # not available on Windows
+except ImportError:
+    if verbose:
+        print "skipping rlcompleter"
+import robotparser
+import sched
+import sgmllib
+import shelve
+import shlex
+import shutil
+import smtplib
+import sndhdr
+import statcache
+import statvfs
+import stringold
+import sunau
+import sunaudio
+import symbol
+import tabnanny
+import telnetlib
+import test
+import toaiff
+#import tzparse
+import urllib2
+# Can't test the "user" module -- if the user has a ~/.pythonrc.py, it
+# can screw up all sorts of things (esp. if it prints!).
+#import user
+import webbrowser
+import whichdb
+import xdrlib
+import xml

data/lib/rubyfox/server/data/lib/Lib/test/test_support.py

@@ -0,0 +1,265 @@
+"""Supporting definitions for the Python regression test."""
+
+import sys
+
+class Error(Exception):
+    """Base class for regression test exceptions."""
+
+class TestFailed(Error):
+    """Test failed."""
+
+class TestSkipped(Error):
+    """Test skipped.
+
+    This can be raised to indicate that a test was deliberatly
+    skipped, but not because a feature wasn't available.  For
+    example, if some resource can't be used, such as the network
+    appears to be unavailable, this should be raised instead of
+    TestFailed.
+    """
+
+verbose = 1              # Flag set to 0 by regrtest.py
+use_resources = None       # Flag set to [] by regrtest.py
+
+# _original_stdout is meant to hold stdout at the time regrtest began.
+# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.
+# The point is to have some flavor of stdout the user can actually see.
+_original_stdout = None
+def record_original_stdout(stdout):
+    global _original_stdout
+    _original_stdout = stdout
+
+def get_original_stdout():
+    return _original_stdout or sys.stdout
+
+def unload(name):
+    try:
+        del sys.modules[name]
+    except KeyError:
+        pass
+
+def forget(modname):
+    unload(modname)
+    import os
+    for dirname in sys.path:
+        try:
+            os.unlink(os.path.join(dirname, modname + '.pyc'))
+        except os.error:
+            pass
+
+def requires(resource, msg=None):
+    if use_resources is not None and resource not in use_resources:
+        if msg is None:
+            msg = "Use of the `%s' resource not enabled" % resource
+        raise TestSkipped(msg)
+
+FUZZ = 1e-6
+
+def fcmp(x, y): # fuzzy comparison function
+    if type(x) == type(0.0) or type(y) == type(0.0):
+        try:
+            x, y = coerce(x, y)
+            fuzz = (abs(x) + abs(y)) * FUZZ
+            if abs(x-y) <= fuzz:
+                return 0
+        except:
+            pass
+    elif type(x) == type(y) and type(x) in (type(()), type([])):
+        for i in range(min(len(x), len(y))):
+            outcome = fcmp(x[i], y[i])
+            if outcome != 0:
+                return outcome
+        return cmp(len(x), len(y))
+    return cmp(x, y)
+
+try:
+    unicode
+    have_unicode = 1
+except NameError:
+    have_unicode = 0
+
+is_jython = sys.platform.startswith('java')
+
+underlying_system = sys.platform
+if is_jython:
+    import java.lang.System
+    underlying_system = java.lang.System.getProperty('os.name').lower()
+
+import os
+# Filename used for testing
+if os.name == 'java':
+    # Jython disallows @ in module names
+    TESTFN = '__test' # xxx mmh, something good and that works on unix too
+elif os.name != 'riscos':
+    TESTFN = '@test'
+    # Unicode name only used if TEST_FN_ENCODING exists for the platform.
+    if have_unicode:
+        TESTFN_UNICODE=unicode("@test-\xe0\xf2", "latin-1") # 2 latin characters.
+        if os.name=="nt":
+            TESTFN_ENCODING="mbcs"
+else:
+    TESTFN = 'test'
+del os
+
+from os import unlink
+
+def findfile(file, here=__file__):
+    import os
+    if os.path.isabs(file):
+        return file
+    path = sys.path
+    path = [os.path.dirname(here)] + path
+    for dn in path:
+        fn = os.path.join(dn, file)
+        if os.path.exists(fn): return fn
+    return file
+
+def verify(condition, reason='test failed'):
+    """Verify that condition is true. If not, raise TestFailed.
+
+       The optional argument reason can be given to provide
+       a better error text.
+    """
+
+    if not condition:
+        raise TestFailed(reason)
+
+def vereq(a, b):
+    if not (a == b):
+        raise TestFailed, "%r == %r" % (a, b)
+
+def sortdict(dict):
+    "Like repr(dict), but in sorted order."
+    items = dict.items()
+    items.sort()
+    reprpairs = ["%r: %r" % pair for pair in items]
+    withcommas = ", ".join(reprpairs)
+    return "{%s}" % withcommas
+
+def check_syntax(statement):
+    try:
+        compile(statement, '<string>', 'exec')
+    except SyntaxError:
+        pass
+    else:
+        print 'Missing SyntaxError: "%s"' % statement
+
+
+
+#=======================================================================
+# Preliminary PyUNIT integration.
+
+import unittest
+
+
+class BasicTestRunner:
+    def run(self, test):
+        result = unittest.TestResult()
+        test(result)
+        return result
+
+
+def run_suite(suite, testclass=None):
+    """Run tests from a unittest.TestSuite-derived class."""
+    if verbose:
+        runner = unittest.TextTestRunner(sys.stdout, verbosity=2)
+    else:
+        runner = BasicTestRunner()
+
+    result = runner.run(suite)
+    if not result.wasSuccessful():
+        if len(result.errors) == 1 and not result.failures:
+            err = result.errors[0][1]
+        elif len(result.failures) == 1 and not result.errors:
+            err = result.failures[0][1]
+        else:
+            if testclass is None:
+                msg = "errors occurred; run in verbose mode for details"
+            else:
+                msg = "errors occurred in %s.%s" \
+                      % (testclass.__module__, testclass.__name__)
+            raise TestFailed(msg)
+        raise TestFailed(err)
+
+
+def run_unittest(testclass):
+    """Run tests from a unittest.TestCase-derived class."""
+    run_suite(unittest.makeSuite(testclass), testclass)
+
+
+#=======================================================================
+# doctest driver.
+
+def run_doctest(module, verbosity=None):
+    """Run doctest on the given module.  Return (#failures, #tests).
+
+    If optional argument verbosity is not specified (or is None), pass
+    test_support's belief about verbosity on to doctest.  Else doctest's
+    usual behavior is used (it searches sys.argv for -v).
+    """
+
+    import doctest
+
+    if verbosity is None:
+        verbosity = verbose
+    else:
+        verbosity = None
+
+    # Direct doctest output (normally just errors) to real stdout; doctest
+    # output shouldn't be compared by regrtest.
+    save_stdout = sys.stdout
+    sys.stdout = get_original_stdout()
+    try:
+        f, t = doctest.testmod(module, verbose=verbosity)
+        if f:
+            raise TestFailed("%d of %d doctests failed" % (f, t))
+        return f, t
+    finally:
+        sys.stdout = save_stdout
+
+#=======================================================================
+# Old Jython test functions
+# test_support.py above this line is just a copy from the current Python
+# release. Other functions needed by Jython tests go here until no longer
+# needed
+import string
+
+roman = ['i', 'ii', 'iii', 'iv', 'v', 'vi', 'vii', 'viii', 'ix', 'x', 'xi', 'xii']
+symbols = [
+	map(string.upper, roman),
+	string.uppercase,
+	range(1, 50),
+	string.lowercase,
+	roman,
+	]
+	
+def symbol(n, level):
+	return str(symbols[level][n-1])
+
+levels = [0]*20
+currentLevel = 0
+def print_test(txt, level=-1):
+    print txt
+    return level
+	
+oldStdout = None
+
+from StringIO import StringIO
+def beginCapture():
+	global oldStdout
+	
+	if oldStdout is not None:
+		raise TestError, "Internal error"
+		
+	oldStdout = sys.stdout
+	sys.stdout = StringIO()
+	
+def endCapture():
+	global oldStdout
+	
+	txt = sys.stdout.getvalue()
+	sys.stdout = oldStdout
+	oldStdout = None
+	
+	return txt
+

data/lib/rubyfox/server/data/lib/Lib/test/test_symtable.py

@@ -0,0 +1,8 @@
+from test_support import verify
+
+import _symtable
+
+symbols = _symtable.symtable("def f(x): return x", "?", "exec")
+
+verify(symbols[0].name == "global")
+verify(len([ste for ste in symbols.values() if ste.name == "f"]) == 1)

data/lib/rubyfox/server/data/lib/Lib/test/test_tempfile.py

@@ -0,0 +1,10 @@
+# SF bug #476138: tempfile behavior across platforms
+# Ensure that a temp file can be closed any number of times without error.
+
+import tempfile
+
+f = tempfile.TemporaryFile("w+b")
+f.write('abc\n')
+f.close()
+f.close()
+f.close()

data/lib/rubyfox/server/data/lib/Lib/test/test_thread.py

@@ -0,0 +1,116 @@
+# Very rudimentary test of thread module
+
+# Create a bunch of threads, let each do some work, wait until all are done
+
+from test_support import *
+import whrandom
+import thread
+import time
+
+print_test('thread (test_thread.py)', 1)
+
+mutex = thread.allocate_lock()
+whmutex = thread.allocate_lock() # for calls to whrandom
+running = 0
+done = thread.allocate_lock()
+done.acquire()
+verbose = 0
+
+numtasks = 5
+
+
+def task(ident):
+	global running
+	whmutex.acquire()
+	delay = whrandom.random() * numtasks
+	whmutex.release()
+	if verbose:
+	    print 'task', ident, 'will run for', round(delay, 1), 'sec'
+	time.sleep(delay)
+	if verbose:
+	    print 'task', ident, 'done'
+	mutex.acquire()
+	running = running - 1
+	if running == 0:
+		done.release()
+	mutex.release()
+
+next_ident = 0
+def newtask():
+	global next_ident, running
+	mutex.acquire()
+	next_ident = next_ident + 1
+	if verbose:
+	    print 'creating task', next_ident
+	thread.start_new_thread(task, (next_ident,))
+	running = running + 1
+	mutex.release()
+
+print_test('concurrent threads', 2)
+
+for i in range(numtasks):
+	newtask()
+
+done.acquire()
+
+class barrier:
+	def __init__(self, n):
+		self.n = n
+		self.waiting = 0
+		self.checkin  = thread.allocate_lock()
+		self.checkout = thread.allocate_lock()
+		self.checkout.acquire()
+
+	def enter(self):
+		checkin, checkout = self.checkin, self.checkout
+
+		checkin.acquire()
+		self.waiting = self.waiting + 1
+		if self.waiting == self.n:
+			self.waiting = self.n - 1
+			checkout.release()
+			return
+		checkin.release()
+
+		checkout.acquire()
+		self.waiting = self.waiting - 1
+		if self.waiting == 0:
+			checkin.release()
+			return
+		checkout.release()
+
+numtrips = 3
+def task2(ident):
+	global running
+	for i in range(numtrips):
+		if ident == 0:
+			# give it a good chance to enter the next
+			# barrier before the others are all out
+			# of the current one
+			delay = 0.001
+		else:
+			whmutex.acquire()
+			delay = whrandom.random() * numtasks
+			whmutex.release()
+		if verbose:
+		    print 'task', ident, 'will run for', round(delay, 1), 'sec'
+		time.sleep(delay)
+		if verbose:
+		    print 'task', ident, 'entering barrier', i
+		bar.enter()
+		if verbose:
+		    print 'task', ident, 'leaving barrier', i
+	mutex.acquire()
+	running = running - 1
+	if running == 0:
+		done.release()
+	mutex.release()
+
+print_test('locks', 2)
+if done.acquire(0):
+	raise ValueError, "'done' should have remained acquired"
+bar = barrier(numtasks)
+running = numtasks
+for i in range(numtasks):
+	thread.start_new_thread(task2, (i,))
+done.acquire()

data/lib/rubyfox/server/data/lib/Lib/test/test_threaded_import.py

@@ -0,0 +1,56 @@
+# This is a variant of the very old (early 90's) file
+# Demo/threads/bug.py.  It simply provokes a number of threads into
+# trying to import the same module "at the same time".
+# There are no pleasant failure modes -- most likely is that Python
+# complains several times about module random having no attribute
+# randrange, and then Python hangs.
+
+import thread
+from test_support import verbose, TestSkipped
+
+critical_section = thread.allocate_lock()
+done = thread.allocate_lock()
+
+def task():
+    global N, critical_section, done
+    import random
+    x = random.randrange(1, 3)
+    critical_section.acquire()
+    N -= 1
+    # Must release critical_section before releasing done, else the main
+    # thread can exit and set critical_section to None as part of global
+    # teardown; then critical_section.release() raises AttributeError.
+    finished = N == 0
+    critical_section.release()
+    if finished:
+        done.release()
+
+# Tricky:  When regrtest imports this module, the thread running regrtest
+# grabs the import lock and won't let go of it until this module returns.
+# All other threads attempting an import hang for the duration.  Since
+# this test spawns threads that do little *but* import, we can't do that
+# successfully until after this module finishes importing and regrtest
+# regains control.  To make this work, a special case was added to
+# regrtest to invoke a module's "test_main" function (if any) after
+# importing it.
+
+def test_main():        # magic name!  see above
+    global N, done
+
+    import imp
+    if imp.lock_held():
+        # This triggers on, e.g., from test import autotest.
+        raise TestSkipped("can't run when import lock is held")
+
+    done.acquire()
+    for N in (20, 50) * 3:
+        if verbose:
+            print "Trying", N, "threads ...",
+        for i in range(N):
+            thread.start_new_thread(task, ())
+        done.acquire()
+        if verbose:
+            print "OK."
+
+if __name__ == "__main__":
+    test_main()

data/lib/rubyfox/server/data/lib/Lib/test/test_threadedtempfile.py

@@ -0,0 +1,86 @@
+"""
+Create and delete FILES_PER_THREAD temp files (via tempfile.TemporaryFile)
+in each of NUM_THREADS threads, recording the number of successes and
+failures.  A failure is a bug in tempfile, and may be due to:
+
++ Trying to create more than one tempfile with the same name.
++ Trying to delete a tempfile that doesn't still exist.
++ Something we've never seen before.
+
+By default, NUM_THREADS == 20 and FILES_PER_THREAD == 50.  This is enough to
+create about 150 failures per run under Win98SE in 2.0, and runs pretty
+quickly. Guido reports needing to boost FILES_PER_THREAD to 500 before
+provoking a 2.0 failure under Linux.  Run the test alone to boost either
+via cmdline switches:
+
+-f  FILES_PER_THREAD (int)
+-t  NUM_THREADS (int)
+"""
+
+NUM_THREADS = 20        # change w/ -t option
+FILES_PER_THREAD = 50   # change w/ -f option
+
+import thread # If this fails, we can't test this module
+import threading
+from test_support import TestFailed
+import StringIO
+from traceback import print_exc
+
+startEvent = threading.Event()
+
+import tempfile
+tempfile.gettempdir() # Do this now, to avoid spurious races later
+
+class TempFileGreedy(threading.Thread):
+    error_count = 0
+    ok_count = 0
+
+    def run(self):
+        self.errors = StringIO.StringIO()
+        startEvent.wait()
+        for i in range(FILES_PER_THREAD):
+            try:
+                f = tempfile.TemporaryFile("w+b")
+                f.close()
+            except:
+                self.error_count += 1
+                print_exc(file=self.errors)
+            else:
+                self.ok_count += 1
+
+def _test():
+    threads = []
+
+    print "Creating"
+    for i in range(NUM_THREADS):
+        t = TempFileGreedy()
+        threads.append(t)
+        t.start()
+
+    print "Starting"
+    startEvent.set()
+
+    print "Reaping"
+    ok = errors = 0
+    for t in threads:
+        t.join()
+        ok += t.ok_count
+        errors += t.error_count
+        if t.error_count:
+            print '%s errors:\n%s' % (t.getName(), t.errors.getvalue())
+
+    msg = "Done: errors %d ok %d" % (errors, ok)
+    print msg
+    if errors:
+        raise TestFailed(msg)
+
+if __name__ == "__main__":
+    import sys, getopt
+    opts, args = getopt.getopt(sys.argv[1:], "t:f:")
+    for o, v in opts:
+        if o == "-f":
+            FILES_PER_THREAD = int(v)
+        elif o == "-t":
+            NUM_THREADS = int(v)
+
+_test()

data/lib/rubyfox/server/data/lib/Lib/test/test_threading.py

@@ -0,0 +1,55 @@
+# Very rudimentary test of threading module
+
+# Create a bunch of threads, let each do some work, wait until all are done
+
+from test_support import verbose
+import random
+import threading
+import time
+
+# This takes about n/3 seconds to run (about n/3 clumps of tasks, times
+# about 1 second per clump).
+numtasks = 10
+
+# no more than 3 of the 10 can run at once
+sema = threading.BoundedSemaphore(value=3)
+mutex = threading.RLock()
+running = 0
+
+class TestThread(threading.Thread):
+    def run(self):
+        global running
+        delay = random.random() * 2
+        if verbose:
+            print 'task', self.getName(), 'will run for', delay, 'sec'
+        sema.acquire()
+        mutex.acquire()
+        running = running + 1
+        if verbose:
+            print running, 'tasks are running'
+        mutex.release()
+        time.sleep(delay)
+        if verbose:
+            print 'task', self.getName(), 'done'
+        mutex.acquire()
+        running = running - 1
+        if verbose:
+            print self.getName(), 'is finished.', running, 'tasks are running'
+        mutex.release()
+        sema.release()
+
+threads = []
+def starttasks():
+    for i in range(numtasks):
+        t = TestThread(name="<thread %d>"%i)
+        threads.append(t)
+        t.start()
+
+starttasks()
+
+if verbose:
+    print 'waiting for all tasks to complete'
+for t in threads:
+    t.join()
+if verbose:
+    print 'all tasks done'