rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,268 @@
+from test_support import verify, verbose, TestFailed, sortdict
+from UserList import UserList
+
+def f(*a, **k):
+    print a, sortdict(k)
+
+def g(x, *y, **z):
+    print x, y, sortdict(z)
+
+def h(j=1, a=2, h=3):
+    print j, a, h
+
+f()
+f(1)
+f(1, 2)
+f(1, 2, 3)
+
+f(1, 2, 3, *(4, 5))
+f(1, 2, 3, *[4, 5])
+f(1, 2, 3, *UserList([4, 5]))
+f(1, 2, 3, **{'a':4, 'b':5})
+f(1, 2, 3, *(4, 5), **{'a':6, 'b':7})
+f(1, 2, 3, x=4, y=5, *(6, 7), **{'a':8, 'b':9})
+
+try:
+    g()
+except TypeError, err:
+    print "TypeError:", err
+else:
+    print "should raise TypeError: not enough arguments; expected 1, got 0"
+
+try:
+    g(*())
+except TypeError, err:
+    print "TypeError:", err
+else:
+    print "should raise TypeError: not enough arguments; expected 1, got 0"
+
+try:
+    g(*(), **{})
+except TypeError, err:
+    print "TypeError:", err
+else:
+    print "should raise TypeError: not enough arguments; expected 1, got 0"
+
+g(1)
+g(1, 2)
+g(1, 2, 3)
+g(1, 2, 3, *(4, 5))
+class Nothing: pass
+try:
+    g(*Nothing())
+except TypeError, attr:
+    pass
+else:
+    print "should raise TypeError"
+
+class Nothing:
+    def __len__(self):
+        return 5
+try:
+    g(*Nothing())
+except TypeError, attr:
+    pass
+else:
+    print "should raise TypeError"
+
+class Nothing:
+    def __len__(self):
+        return 5
+    def __getitem__(self, i):
+        if i < 3:
+            return i
+        else:
+            raise IndexError, i
+g(*Nothing())
+
+class Nothing:
+    def __init__(self):
+        self.c = 0
+    def __iter__(self):
+        return self
+try:
+    g(*Nothing())
+except TypeError, attr:
+    pass
+else:
+    print "should raise TypeError"
+
+class Nothing:
+    def __init__(self):
+        self.c = 0
+    def __iter__(self):
+        return self
+    def next(self):
+        if self.c == 4:
+            raise StopIteration
+        c = self.c
+        self.c += 1
+        return c
+g(*Nothing())
+
+# make sure the function call doesn't stomp on the dictionary?
+d = {'a': 1, 'b': 2, 'c': 3}
+d2 = d.copy()
+verify(d == d2)
+g(1, d=4, **d)
+print sortdict(d)
+print sortdict(d2)
+verify(d == d2, "function call modified dictionary")
+
+# what about willful misconduct?
+def saboteur(**kw):
+    kw['x'] = locals() # yields a cyclic kw
+    return kw
+d = {}
+kw = saboteur(a=1, **d)
+verify(d == {})
+# break the cycle
+del kw['x']
+
+try:
+    g(1, 2, 3, **{'x':4, 'y':5})
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: keyword parameter redefined"
+
+try:
+    g(1, 2, 3, a=4, b=5, *(6, 7), **{'a':8, 'b':9})
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: keyword parameter redefined"
+
+try:
+    f(**{1:2})
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: keywords must be strings"
+
+try:
+    h(**{'e': 2})
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: unexpected keyword argument: e"
+
+try:
+    h(*h)
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: * argument must be a tuple"
+
+try:
+    dir(*h)
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: * argument must be a tuple"
+
+try:
+    None(*h)
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: * argument must be a tuple"
+
+try:
+    h(**h)
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: ** argument must be a dictionary"
+
+try:
+    dir(**h)
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: ** argument must be a dictionary"
+
+try:
+    None(**h)
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: ** argument must be a dictionary"
+
+try:
+    dir(b=1,**{'b':1})
+except TypeError, err:
+    print err
+else:
+    print "should raise TypeError: dir() got multiple values for keyword argument 'b'"
+
+def f2(*a, **b):
+    return a, b
+
+d = {}
+for i in range(512):
+    key = 'k%d' % i
+    d[key] = i
+a, b = f2(1, *(2, 3), **d)
+print len(a), len(b), b == d
+
+class Foo:
+    def method(self, arg1, arg2):
+        return arg1 + arg2
+
+x = Foo()
+print Foo.method(*(x, 1, 2))
+print Foo.method(x, *(1, 2))
+try:
+    print Foo.method(*(1, 2, 3))
+except TypeError, err:
+    pass
+else:
+    print 'expected a TypeError for unbound method call'
+try:
+    print Foo.method(1, *(2, 3))
+except TypeError, err:
+    pass
+else:
+    print 'expected a TypeError for unbound method call'
+
+# A PyCFunction that takes only positional parameters should allow an
+# empty keyword dictionary to pass without a complaint, but raise a
+# TypeError if the dictionary is non-empty.
+id(1, **{})
+try:
+    id(1, **{"foo": 1})
+except TypeError:
+    pass
+else:
+    raise TestFailed, 'expected TypeError; no exception raised'
+
+a, b, d, e, v, k = 'A', 'B', 'D', 'E', 'V', 'K'
+funcs = []
+maxargs = {}
+for args in ['', 'a', 'ab']:
+    for defargs in ['', 'd', 'de']:
+        for vararg in ['', 'v']:
+            for kwarg in ['', 'k']:
+                name = 'z' + args + defargs + vararg + kwarg
+                arglist = list(args) + map(
+                    lambda x: '%s="%s"' % (x, x), defargs)
+                if vararg: arglist.append('*' + vararg)
+                if kwarg: arglist.append('**' + kwarg)
+                decl = (('def %s(%s): print "ok %s", a, b, d, e, v, ' +
+                         'type(k) is type ("") and k or sortdict(k)')
+                         % (name, ', '.join(arglist), name))
+                exec(decl)
+                func = eval(name)
+                funcs.append(func)
+                maxargs[func] = len(args + defargs)
+
+for name in ['za', 'zade', 'zabk', 'zabdv', 'zabdevk']:
+    func = eval(name)
+    for args in [(), (1, 2), (1, 2, 3, 4, 5)]:
+        for kwargs in ['', 'a', 'd', 'ad', 'abde']:
+            kwdict = {}
+            for k in kwargs: kwdict[k] = k + k
+            print func.func_name, args, sortdict(kwdict), '->',
+            try: apply(func, args, kwdict)
+            except TypeError, err: print err

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

@@ -0,0 +1,53 @@
+#! /usr/bin/env python
+"""Test program for the fcntl C module.
+   Roger E. Masse
+"""
+import struct
+import fcntl
+import os, sys
+from test_support import verbose, TESTFN
+
+filename = TESTFN
+
+try:
+    os.O_LARGEFILE
+except AttributeError:
+    start_len = "ll"
+else:
+    start_len = "qq"
+
+if sys.platform in ('netbsd1', 'Darwin1.2', 'darwin',
+                    'freebsd2', 'freebsd3', 'freebsd4', 'freebsd5',
+                    'bsdos2', 'bsdos3', 'bsdos4',
+                    'openbsd', 'openbsd2', 'openbsd3'):
+    lockdata = struct.pack('lxxxxlxxxxlhh', 0, 0, 0, fcntl.F_WRLCK, 0)
+elif sys.platform in ['aix3', 'aix4', 'hp-uxB', 'unixware7']:
+    lockdata = struct.pack('hhlllii', fcntl.F_WRLCK, 0, 0, 0, 0, 0, 0)
+else:
+    lockdata = struct.pack('hh'+start_len+'hh', fcntl.F_WRLCK, 0, 0, 0, 0, 0)
+if verbose:
+    print 'struct.pack: ', `lockdata`
+
+
+# the example from the library docs
+f = open(filename, 'w')
+rv = fcntl.fcntl(f.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
+if verbose:
+    print 'Status from fnctl with O_NONBLOCK: ', rv
+
+rv = fcntl.fcntl(f.fileno(), fcntl.F_SETLKW, lockdata)
+if verbose:
+    print 'String from fcntl with F_SETLKW: ', `rv`
+
+f.close()
+os.unlink(filename)
+
+
+# Again, but pass the file rather than numeric descriptor:
+f = open(filename, 'w')
+rv = fcntl.fcntl(f, fcntl.F_SETFL, os.O_NONBLOCK)
+
+rv = fcntl.fcntl(f, fcntl.F_SETLKW, lockdata)
+
+f.close()
+os.unlink(filename)

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

@@ -0,0 +1,63 @@
+import os
+
+from test_support import verify, TESTFN
+from UserList import UserList
+
+# verify writelines with instance sequence
+l = UserList(['1', '2'])
+f = open(TESTFN, 'wb')
+f.writelines(l)
+f.close()
+f = open(TESTFN, 'rb')
+buf = f.read()
+f.close()
+verify(buf == '12')
+
+# verify writelines with integers
+f = open(TESTFN, 'wb')
+try:
+    f.writelines([1, 2, 3])
+except TypeError:
+    pass
+else:
+    print "writelines accepted sequence of integers"
+f.close()
+
+# verify writelines with integers in UserList
+f = open(TESTFN, 'wb')
+l = UserList([1,2,3])
+try:
+    f.writelines(l)
+except TypeError:
+    pass
+else:
+    print "writelines accepted sequence of integers"
+f.close()
+
+# verify writelines with non-string object
+class NonString: pass
+
+f = open(TESTFN, 'wb')
+try:
+    f.writelines([NonString(), NonString()])
+except TypeError:
+    pass
+else:
+    print "writelines accepted sequence of non-string objects"
+f.close()
+
+# verify that we get a sensible error message for bad mode argument
+bad_mode = "qwerty"
+try:
+    open(TESTFN, bad_mode)
+except IOError, msg:
+    if msg[0] != 0:
+        s = str(msg)
+        if s.find(TESTFN) != -1 or s.find(bad_mode) == -1:
+            print "bad error message for invalid mode: %s" % s
+    # if msg[0] == 0, we're probably on Windows where there may be
+    # no obvious way to discover why open() failed.
+else:
+    print "no error for invalid mode: %s" % bad_mode
+
+os.unlink(TESTFN)

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

@@ -0,0 +1,159 @@
+'''
+Tests for fileinput module.
+Nick Mathewson
+'''
+
+from test_support import verify, verbose, TESTFN
+import sys, os, re
+from StringIO import StringIO
+from fileinput import FileInput
+
+# The fileinput module has 2 interfaces: the FileInput class which does
+# all the work, and a few functions (input, etc.) that use a global _state
+# variable.  We only test the FileInput class, since the other functions
+# only provide a thin facade over FileInput.
+
+# Write lines (a list of lines) to temp file number i, and return the
+# temp file's name.
+def writeTmp(i, lines):
+    name = TESTFN + str(i)
+    f = open(name, 'w')
+    f.writelines(lines)
+    f.close()
+    return name
+
+pat = re.compile(r'LINE (\d+) OF FILE (\d+)')
+
+def remove_tempfiles(*names):
+    for name in names:
+        try:
+            os.unlink(name)
+        except:
+            pass
+
+def runTests(t1, t2, t3, t4, bs=0, round=0):
+    start = 1 + round*6
+    if verbose:
+        print '%s. Simple iteration (bs=%s)' % (start+0, bs)
+    fi = FileInput(files=(t1, t2, t3, t4), bufsize=bs)
+    lines = list(fi)
+    fi.close()
+    verify(len(lines) == 31)
+    verify(lines[4] == 'Line 5 of file 1\n')
+    verify(lines[30] == 'Line 1 of file 4\n')
+    verify(fi.lineno() == 31)
+    verify(fi.filename() == t4)
+
+    if verbose:
+        print '%s. Status variables (bs=%s)' % (start+1, bs)
+    fi = FileInput(files=(t1, t2, t3, t4), bufsize=bs)
+    s = "x"
+    while s and s != 'Line 6 of file 2\n':
+        s = fi.readline()
+    verify(fi.filename() == t2)
+    verify(fi.lineno() == 21)
+    verify(fi.filelineno() == 6)
+    verify(not fi.isfirstline())
+    verify(not fi.isstdin())
+
+    if verbose:
+        print '%s. Nextfile (bs=%s)' % (start+2, bs)
+    fi.nextfile()
+    verify(fi.readline() == 'Line 1 of file 3\n')
+    verify(fi.lineno() == 22)
+    fi.close()
+
+    if verbose:
+        print '%s. Stdin (bs=%s)' % (start+3, bs)
+    fi = FileInput(files=(t1, t2, t3, t4, '-'), bufsize=bs)
+    savestdin = sys.stdin
+    try:
+        sys.stdin = StringIO("Line 1 of stdin\nLine 2 of stdin\n")
+        lines = list(fi)
+        verify(len(lines) == 33)
+        verify(lines[32] == 'Line 2 of stdin\n')
+        verify(fi.filename() == '<stdin>')
+        fi.nextfile()
+    finally:
+        sys.stdin = savestdin
+
+    if verbose:
+        print '%s. Boundary conditions (bs=%s)' % (start+4, bs)
+    fi = FileInput(files=(t1, t2, t3, t4), bufsize=bs)
+    verify(fi.lineno() == 0)
+    verify(fi.filename() == None)
+    fi.nextfile()
+    verify(fi.lineno() == 0)
+    verify(fi.filename() == None)
+
+    if verbose:
+        print '%s. Inplace (bs=%s)' % (start+5, bs)
+    savestdout = sys.stdout
+    try:
+        fi = FileInput(files=(t1, t2, t3, t4), inplace=1, bufsize=bs)
+        for line in fi:
+            line = line[:-1].upper()
+            print line
+        fi.close()
+    finally:
+        sys.stdout = savestdout
+
+    fi = FileInput(files=(t1, t2, t3, t4), bufsize=bs)
+    for line in fi:
+        verify(line[-1] == '\n')
+        m = pat.match(line[:-1])
+        verify(m != None)
+        verify(int(m.group(1)) == fi.filelineno())
+    fi.close()
+
+
+def writeFiles():
+    global t1, t2, t3, t4
+    t1 = writeTmp(1, ["Line %s of file 1\n" % (i+1) for i in range(15)])
+    t2 = writeTmp(2, ["Line %s of file 2\n" % (i+1) for i in range(10)])
+    t3 = writeTmp(3, ["Line %s of file 3\n" % (i+1) for i in range(5)])
+    t4 = writeTmp(4, ["Line %s of file 4\n" % (i+1) for i in range(1)])
+
+# First, run the tests with default and teeny buffer size.
+for round, bs in (0, 0), (1, 30):
+    try:
+        writeFiles()
+        runTests(t1, t2, t3, t4, bs, round)
+    finally:
+        remove_tempfiles(t1, t2, t3, t4)
+
+# Next, check for proper behavior with 0-byte files.
+if verbose:
+    print "13. 0-byte files"
+try:
+    t1 = writeTmp(1, [""])
+    t2 = writeTmp(2, [""])
+    t3 = writeTmp(3, ["The only line there is.\n"])
+    t4 = writeTmp(4, [""])
+    fi = FileInput(files=(t1, t2, t3, t4))
+    line = fi.readline()
+    verify(line == 'The only line there is.\n')
+    verify(fi.lineno() == 1)
+    verify(fi.filelineno() == 1)
+    verify(fi.filename() == t3)
+    line = fi.readline()
+    verify(not line)
+    verify(fi.lineno() == 1)
+    verify(fi.filelineno() == 0)
+    verify(fi.filename() == t4)
+    fi.close()
+finally:
+    remove_tempfiles(t1, t2, t3, t4)
+
+if verbose:
+    print "14. Files that don't end with newline"
+try:
+    t1 = writeTmp(1, ["A\nB\nC"])
+    t2 = writeTmp(2, ["D\nE\nF"])
+    fi = FileInput(files=(t1, t2))
+    lines = list(fi)
+    verify(lines == ["A\n", "B\n", "C", "D\n", "E\n", "F"])
+    verify(fi.filelineno() == 3)
+    verify(fi.lineno() == 6)
+finally:
+    remove_tempfiles(t1, t2)

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

@@ -0,0 +1,46 @@
+"""Test cases for the fnmatch module."""
+
+import test_support
+import unittest
+
+from fnmatch import fnmatch, fnmatchcase
+
+
+class FnmatchTestCase(unittest.TestCase):
+    def check_match(self, filename, pattern, should_match=1):
+        if should_match:
+            self.assert_(fnmatch(filename, pattern),
+                         "expected %r to match pattern %r"
+                         % (filename, pattern))
+        else:
+            self.assert_(not fnmatch(filename, pattern),
+                         "expected %r not to match pattern %r"
+                         % (filename, pattern))
+
+    def test_fnmatch(self):
+        check = self.check_match
+        check('abc', 'abc')
+        check('abc', '?*?')
+        check('abc', '???*')
+        check('abc', '*???')
+        check('abc', '???')
+        check('abc', '*')
+        check('abc', 'ab[cd]')
+        check('abc', 'ab[!de]')
+        check('abc', 'ab[de]', 0)
+        check('a', '??', 0)
+        check('a', 'b', 0)
+
+        # these test that '\' is handled correctly in character sets;
+        # see SF bug #???
+        check('\\', r'[\]')
+        check('a', r'[!\]')
+        check('\\', r'[!\]', 0)
+
+
+def test_main():
+    test_support.run_unittest(FnmatchTestCase)
+
+
+if __name__ == "__main__":
+    test_main()

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

@@ -0,0 +1,75 @@
+"""This test checks for correct fork() behavior.
+
+We want fork1() semantics -- only the forking thread survives in the
+child after a fork().
+
+On some systems (e.g. Solaris without posix threads) we find that all
+active threads survive in the child after a fork(); this is an error.
+
+While BeOS doesn't officially support fork and native threading in
+the same application, the present example should work just fine.  DC
+"""
+
+import os, sys, time, thread
+from test_support import verify, verbose, TestSkipped
+
+try:
+    os.fork
+except AttributeError:
+    raise TestSkipped, "os.fork not defined -- skipping test_fork1"
+
+LONGSLEEP = 2
+
+SHORTSLEEP = 0.5
+
+NUM_THREADS = 4
+
+alive = {}
+
+stop = 0
+
+def f(id):
+    while not stop:
+        alive[id] = os.getpid()
+        try:
+            time.sleep(SHORTSLEEP)
+        except IOError:
+            pass
+
+def main():
+    for i in range(NUM_THREADS):
+        thread.start_new(f, (i,))
+
+    time.sleep(LONGSLEEP)
+
+    a = alive.keys()
+    a.sort()
+    verify(a == range(NUM_THREADS))
+
+    prefork_lives = alive.copy()
+
+    if sys.platform in ['unixware7']:
+        cpid = os.fork1()
+    else:
+        cpid = os.fork()
+
+    if cpid == 0:
+        # Child
+        time.sleep(LONGSLEEP)
+        n = 0
+        for key in alive.keys():
+            if alive[key] != prefork_lives[key]:
+                n = n+1
+        os._exit(n)
+    else:
+        # Parent
+        spid, status = os.waitpid(cpid, 0)
+        verify(spid == cpid)
+        verify(status == 0,
+                "cause = %d, exit = %d" % (status&0xff, status>>8) )
+        global stop
+        # Tell threads to die
+        stop = 1
+        time.sleep(2*SHORTSLEEP) # Wait for threads to die
+
+main()