rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,328 @@
+"""Tests for binary operators on subtypes of built-in types."""
+
+import test_support
+import unittest
+
+def gcd(a, b):
+    """Greatest common divisor using Euclid's algorithm."""
+    while a:
+        a, b = b%a, a
+    return b
+
+def isint(x):
+    """Test whether an object is an instance of int or long."""
+    return isinstance(x, int) or isinstance(x, long)
+
+def isnum(x):
+    """Test whether an object is an instance of a built-in numeric type."""
+    for T in int, long, float, complex:
+        if isinstance(x, T):
+            return 1
+    return 0
+
+def isRat(x):
+    """Test wheter an object is an instance of the Rat class."""
+    return isinstance(x, Rat)
+
+class Rat(object):
+
+    """Rational number implemented as a normalized pair of longs."""
+
+    __slots__ = ['_Rat__num', '_Rat__den']
+
+    def __init__(self, num=0L, den=1L):
+        """Constructor: Rat([num[, den]]).
+
+        The arguments must be ints or longs, and default to (0, 1)."""
+        if not isint(num):
+            raise TypeError, "Rat numerator must be int or long (%r)" % num
+        if not isint(den):
+            raise TypeError, "Rat denominator must be int or long (%r)" % den
+        # But the zero is always on
+        if den == 0:
+            raise ZeroDivisionError, "zero denominator"
+        g = gcd(den, num)
+        self.__num = long(num//g)
+        self.__den = long(den//g)
+
+    def _get_num(self):
+        """Accessor function for read-only 'num' attribute of Rat."""
+        return self.__num
+    num = property(_get_num, None)
+
+    def _get_den(self):
+        """Accessor function for read-only 'den' attribute of Rat."""
+        return self.__den
+    den = property(_get_den, None)
+
+    def __repr__(self):
+        """Convert a Rat to an string resembling a Rat constructor call."""
+        return "Rat(%d, %d)" % (self.__num, self.__den)
+
+    def __str__(self):
+        """Convert a Rat to a string resembling a decimal numeric value."""
+        return str(float(self))
+
+    def __float__(self):
+        """Convert a Rat to a float."""
+        return self.__num*1.0/self.__den
+
+    def __int__(self):
+        """Convert a Rat to an int; self.den must be 1."""
+        if self.__den == 1:
+            try:
+                return int(self.__num)
+            except OverflowError:
+                raise OverflowError, ("%s too large to convert to int" %
+                                      repr(self))
+        raise ValueError, "can't convert %s to int" % repr(self)
+
+    def __long__(self):
+        """Convert a Rat to an long; self.den must be 1."""
+        if self.__den == 1:
+            return long(self.__num)
+        raise ValueError, "can't convert %s to long" % repr(self)
+
+    def __add__(self, other):
+        """Add two Rats, or a Rat and a number."""
+        if isint(other):
+            other = Rat(other)
+        if isRat(other):
+            return Rat(self.__num*other.__den + other.__num*self.__den,
+                       self.__den*other.__den)
+        if isnum(other):
+            return float(self) + other
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        """Subtract two Rats, or a Rat and a number."""
+        if isint(other):
+            other = Rat(other)
+        if isRat(other):
+            return Rat(self.__num*other.__den - other.__num*self.__den,
+                       self.__den*other.__den)
+        if isnum(other):
+            return float(self) - other
+        return NotImplemented
+
+    def __rsub__(self, other):
+        """Subtract two Rats, or a Rat and a number (reversed args)."""
+        if isint(other):
+            other = Rat(other)
+        if isRat(other):
+            return Rat(other.__num*self.__den - self.__num*other.__den,
+                       self.__den*other.__den)
+        if isnum(other):
+            return other - float(self)
+        return NotImplemented
+
+    def __mul__(self, other):
+        """Multiply two Rats, or a Rat and a number."""
+        if isRat(other):
+            return Rat(self.__num*other.__num, self.__den*other.__den)
+        if isint(other):
+            return Rat(self.__num*other, self.__den)
+        if isnum(other):
+            return float(self)*other
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, other):
+        """Divide two Rats, or a Rat and a number."""
+        if isRat(other):
+            return Rat(self.__num*other.__den, self.__den*other.__num)
+        if isint(other):
+            return Rat(self.__num, self.__den*other)
+        if isnum(other):
+            return float(self) / other
+        return NotImplemented
+
+    __div__ = __truediv__
+
+    def __rtruediv__(self, other):
+        """Divide two Rats, or a Rat and a number (reversed args)."""
+        if isRat(other):
+            return Rat(other.__num*self.__den, other.__den*self.__num)
+        if isint(other):
+            return Rat(other*self.__den, self.__num)
+        if isnum(other):
+            return other / float(self)
+        return NotImplemented
+
+    __rdiv__ = __rtruediv__
+
+    def __floordiv__(self, other):
+        """Divide two Rats, returning the floored result."""
+        if isint(other):
+            other = Rat(other)
+        elif not isRat(other):
+            return NotImplemented
+        x = self/other
+        return x.__num // x.__den
+
+    def __rfloordiv__(self, other):
+        """Divide two Rats, returning the floored result (reversed args)."""
+        x = other/self
+        return x.__num // x.__den
+
+    def __divmod__(self, other):
+        """Divide two Rats, returning quotient and remainder."""
+        if isint(other):
+            other = Rat(other)
+        elif not isRat(other):
+            return NotImplemented
+        x = self//other
+        return (x, self - other * x)
+
+    def __rdivmod__(self, other):
+        "Divide two Rats, returning quotient and remainder (reversed args)."""
+        if isint(other):
+            other = Rat(other)
+        elif not isRat(other):
+            return NotImplemented
+        return divmod(other, self)
+
+    def __mod__(self, other):
+        """Take one Rat modulo another."""
+        return divmod(self, other)[1]
+
+    def __rmod__(self, other):
+        """Take one Rat modulo another (reversed args)."""
+        return divmod(other, self)[1]
+
+    def __eq__(self, other):
+        """Compare two Rats for equality."""
+        if isint(other):
+            return self.__den == 1 and self.__num == other
+        if isRat(other):
+            return self.__num == other.__num and self.__den == other.__den
+        if isnum(other):
+            return float(self) == other
+        return NotImplemented
+
+    def __ne__(self, other):
+        """Compare two Rats for inequality."""
+        return not self == other
+
+class RatTestCase(unittest.TestCase):
+    """Unit tests for Rat class and its support utilities."""
+
+    def test_gcd(self):
+        self.assertEqual(gcd(10, 12), 2)
+        self.assertEqual(gcd(10, 15), 5)
+        self.assertEqual(gcd(10, 11), 1)
+        self.assertEqual(gcd(100, 15), 5)
+        self.assertEqual(gcd(-10, 2), -2)
+        self.assertEqual(gcd(10, -2), 2)
+        self.assertEqual(gcd(-10, -2), -2)
+        for i in range(1, 20):
+            for j in range(1, 20):
+                self.assert_(gcd(i, j) > 0)
+                self.assert_(gcd(-i, j) < 0)
+                self.assert_(gcd(i, -j) > 0)
+                self.assert_(gcd(-i, -j) < 0)
+
+    def test_constructor(self):
+        a = Rat(10, 15)
+        self.assertEqual(a.num, 2)
+        self.assertEqual(a.den, 3)
+        a = Rat(10L, 15L)
+        self.assertEqual(a.num, 2)
+        self.assertEqual(a.den, 3)
+        a = Rat(10, -15)
+        self.assertEqual(a.num, -2)
+        self.assertEqual(a.den, 3)
+        a = Rat(-10, 15)
+        self.assertEqual(a.num, -2)
+        self.assertEqual(a.den, 3)
+        a = Rat(-10, -15)
+        self.assertEqual(a.num, 2)
+        self.assertEqual(a.den, 3)
+        a = Rat(7)
+        self.assertEqual(a.num, 7)
+        self.assertEqual(a.den, 1)
+        try:
+            a = Rat(1, 0)
+        except ZeroDivisionError:
+            pass
+        else:
+            self.fail("Rat(1, 0) didn't raise ZeroDivisionError")
+        for bad in "0", 0.0, 0j, (), [], {}, None, Rat, unittest:
+            try:
+                a = Rat(bad)
+            except TypeError:
+                pass
+            else:
+                self.fail("Rat(%r) didn't raise TypeError" % bad)
+            try:
+                a = Rat(1, bad)
+            except TypeError:
+                pass
+            else:
+                self.fail("Rat(1, %r) didn't raise TypeError" % bad)
+
+    def test_add(self):
+        self.assertEqual(Rat(2, 3) + Rat(1, 3), 1)
+        self.assertEqual(Rat(2, 3) + 1, Rat(5, 3))
+        self.assertEqual(1 + Rat(2, 3), Rat(5, 3))
+        self.assertEqual(1.0 + Rat(1, 2), 1.5)
+        self.assertEqual(Rat(1, 2) + 1.0, 1.5)
+
+    def test_sub(self):
+        self.assertEqual(Rat(7, 2) - Rat(7, 5), Rat(21, 10))
+        self.assertEqual(Rat(7, 5) - 1, Rat(2, 5))
+        self.assertEqual(1 - Rat(3, 5), Rat(2, 5))
+        self.assertEqual(Rat(3, 2) - 1.0, 0.5)
+        self.assertEqual(1.0 - Rat(1, 2), 0.5)
+
+    def test_mul(self):
+        self.assertEqual(Rat(2, 3) * Rat(5, 7), Rat(10, 21))
+        self.assertEqual(Rat(10, 3) * 3, 10)
+        self.assertEqual(3 * Rat(10, 3), 10)
+        self.assertEqual(Rat(10, 5) * 0.5, 1.0)
+        self.assertEqual(0.5 * Rat(10, 5), 1.0)
+
+    def test_div(self):
+        self.assertEqual(Rat(10, 3) / Rat(5, 7), Rat(14, 3))
+        self.assertEqual(Rat(10, 3) / 3, Rat(10, 9))
+        self.assertEqual(2 / Rat(5), Rat(2, 5))
+        self.assertEqual(3.0 * Rat(1, 2), 1.5)
+        self.assertEqual(Rat(1, 2) * 3.0, 1.5)
+
+    def test_floordiv(self):
+        self.assertEqual(Rat(10) // Rat(4), 2)
+        self.assertEqual(Rat(10, 3) // Rat(4, 3), 2)
+        self.assertEqual(Rat(10) // 4, 2)
+        self.assertEqual(10 // Rat(4), 2)
+
+    def test_eq(self):
+        self.assertEqual(Rat(10), Rat(20, 2))
+        self.assertEqual(Rat(10), 10)
+        self.assertEqual(10, Rat(10))
+        self.assertEqual(Rat(10), 10.0)
+        self.assertEqual(10.0, Rat(10))
+
+    def test_future_div(self):
+        exec future_test
+
+    # XXX Ran out of steam; TO DO: divmod, div, future division
+
+future_test = """
+from __future__ import division
+self.assertEqual(Rat(10, 3) / Rat(5, 7), Rat(14, 3))
+self.assertEqual(Rat(10, 3) / 3, Rat(10, 9))
+self.assertEqual(2 / Rat(5), Rat(2, 5))
+self.assertEqual(3.0 * Rat(1, 2), 1.5)
+self.assertEqual(Rat(1, 2) * 3.0, 1.5)
+self.assertEqual(eval('1/2'), 0.5)
+"""
+
+def test_main():
+    test_support.run_unittest(RatTestCase)
+
+
+if __name__ == "__main__":
+    test_main()

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

@@ -0,0 +1,127 @@
+from test_support import TestFailed
+
+import bisect
+import sys
+
+nerrors = 0
+
+def check_bisect(func, list, elt, expected):
+    global nerrors
+    got = func(list, elt)
+    if got != expected:
+        print >> sys.stderr, \
+            "expected %s(%s, %s) -> %s, but got %s" % (func.__name__,
+                                                       list,
+                                                       elt,
+                                                       expected,
+                                                       got)
+        nerrors += 1
+
+# XXX optional slice arguments need tests.
+
+check_bisect(bisect.bisect_right, [], 1, 0)
+check_bisect(bisect.bisect_right, [1], 0, 0)
+check_bisect(bisect.bisect_right, [1], 1, 1)
+check_bisect(bisect.bisect_right, [1], 2, 1)
+check_bisect(bisect.bisect_right, [1, 1], 0, 0)
+check_bisect(bisect.bisect_right, [1, 1], 1, 2)
+check_bisect(bisect.bisect_right, [1, 1], 2, 2)
+check_bisect(bisect.bisect_right, [1, 1, 1], 0, 0)
+check_bisect(bisect.bisect_right, [1, 1, 1], 1, 3)
+check_bisect(bisect.bisect_right, [1, 1, 1], 2, 3)
+check_bisect(bisect.bisect_right, [1, 1, 1, 1], 0, 0)
+check_bisect(bisect.bisect_right, [1, 1, 1, 1], 1, 4)
+check_bisect(bisect.bisect_right, [1, 1, 1, 1], 2, 4)
+check_bisect(bisect.bisect_right, [1, 2], 0, 0)
+check_bisect(bisect.bisect_right, [1, 2], 1, 1)
+check_bisect(bisect.bisect_right, [1, 2], 1.5, 1)
+check_bisect(bisect.bisect_right, [1, 2], 2, 2)
+check_bisect(bisect.bisect_right, [1, 2], 3, 2)
+check_bisect(bisect.bisect_right, [1, 1, 2, 2], 0, 0)
+check_bisect(bisect.bisect_right, [1, 1, 2, 2], 1, 2)
+check_bisect(bisect.bisect_right, [1, 1, 2, 2], 1.5, 2)
+check_bisect(bisect.bisect_right, [1, 1, 2, 2], 2, 4)
+check_bisect(bisect.bisect_right, [1, 1, 2, 2], 3, 4)
+check_bisect(bisect.bisect_right, [1, 2, 3], 0, 0)
+check_bisect(bisect.bisect_right, [1, 2, 3], 1, 1)
+check_bisect(bisect.bisect_right, [1, 2, 3], 1.5, 1)
+check_bisect(bisect.bisect_right, [1, 2, 3], 2, 2)
+check_bisect(bisect.bisect_right, [1, 2, 3], 2.5, 2)
+check_bisect(bisect.bisect_right, [1, 2, 3], 3, 3)
+check_bisect(bisect.bisect_right, [1, 2, 3], 4, 3)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 1)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 3)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 6)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 10)
+check_bisect(bisect.bisect_right, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10)
+
+check_bisect(bisect.bisect_left, [], 1, 0)
+check_bisect(bisect.bisect_left, [1], 0, 0)
+check_bisect(bisect.bisect_left, [1], 1, 0)
+check_bisect(bisect.bisect_left, [1], 2, 1)
+check_bisect(bisect.bisect_left, [1, 1], 0, 0)
+check_bisect(bisect.bisect_left, [1, 1], 1, 0)
+check_bisect(bisect.bisect_left, [1, 1], 2, 2)
+check_bisect(bisect.bisect_left, [1, 1, 1], 0, 0)
+check_bisect(bisect.bisect_left, [1, 1, 1], 1, 0)
+check_bisect(bisect.bisect_left, [1, 1, 1], 2, 3)
+check_bisect(bisect.bisect_left, [1, 1, 1, 1], 0, 0)
+check_bisect(bisect.bisect_left, [1, 1, 1, 1], 1, 0)
+check_bisect(bisect.bisect_left, [1, 1, 1, 1], 2, 4)
+check_bisect(bisect.bisect_left, [1, 2], 0, 0)
+check_bisect(bisect.bisect_left, [1, 2], 1, 0)
+check_bisect(bisect.bisect_left, [1, 2], 1.5, 1)
+check_bisect(bisect.bisect_left, [1, 2], 2, 1)
+check_bisect(bisect.bisect_left, [1, 2], 3, 2)
+check_bisect(bisect.bisect_left, [1, 1, 2, 2], 0, 0)
+check_bisect(bisect.bisect_left, [1, 1, 2, 2], 1, 0)
+check_bisect(bisect.bisect_left, [1, 1, 2, 2], 1.5, 2)
+check_bisect(bisect.bisect_left, [1, 1, 2, 2], 2, 2)
+check_bisect(bisect.bisect_left, [1, 1, 2, 2], 3, 4)
+check_bisect(bisect.bisect_left, [1, 2, 3], 0, 0)
+check_bisect(bisect.bisect_left, [1, 2, 3], 1, 0)
+check_bisect(bisect.bisect_left, [1, 2, 3], 1.5, 1)
+check_bisect(bisect.bisect_left, [1, 2, 3], 2, 1)
+check_bisect(bisect.bisect_left, [1, 2, 3], 2.5, 2)
+check_bisect(bisect.bisect_left, [1, 2, 3], 3, 2)
+check_bisect(bisect.bisect_left, [1, 2, 3], 4, 3)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 0, 0)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1, 0)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 1.5, 1)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2, 1)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 2.5, 3)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3, 3)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 3.5, 6)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 4, 6)
+check_bisect(bisect.bisect_left, [1, 2, 2, 3, 3, 3, 4, 4, 4, 4], 5, 10)
+
+def check_insort(n):
+    global nerrors
+    from random import choice
+    import sys
+    digits = "0123456789"
+    raw = []
+    insorted = []
+    for i in range(n):
+        digit = choice(digits)
+        raw.append(digit)
+        if digit in "02468":
+            f = bisect.insort_left
+        else:
+            f = bisect.insort_right
+        f(insorted, digit)
+    sorted = raw[:]
+    sorted.sort()
+    if sorted == insorted:
+        return
+    print >> sys.stderr, "insort test failed: raw %s got %s" % (raw, insorted)
+    nerrors += 1
+
+check_insort(500)
+
+if nerrors:
+    raise TestFailed("%d errors in test_bisect" % nerrors)

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

@@ -0,0 +1,76 @@
+#! /usr/bin/env python
+"""Test script for the bsddb C module
+   Roger E. Masse
+"""
+
+import os
+import bsddb
+import dbhash # Just so we know it's imported
+import tempfile
+from test_support import verbose, verify
+
+def test(openmethod, what):
+
+    if verbose:
+        print '\nTesting: ', what
+
+    fname = tempfile.mktemp()
+    f = openmethod(fname, 'c')
+    verify(f.keys() == [])
+    if verbose:
+        print 'creation...'
+    f['0'] = ''
+    f['a'] = 'Guido'
+    f['b'] = 'van'
+    f['c'] = 'Rossum'
+    f['d'] = 'invented'
+    f['f'] = 'Python'
+    if verbose:
+        print '%s %s %s' % (f['a'], f['b'], f['c'])
+
+    if what == 'BTree' :
+        if verbose:
+            print 'key ordering...'
+        f.set_location(f.first()[0])
+        while 1:
+            try:
+                rec = f.next()
+            except KeyError:
+                if rec != f.last():
+                    print 'Error, last != last!'
+                f.previous()
+                break
+            if verbose:
+                print rec
+        if not f.has_key('a'):
+            print 'Error, missing key!'
+
+    f.sync()
+    f.close()
+    if verbose:
+        print 'modification...'
+    f = openmethod(fname, 'w')
+    f['d'] = 'discovered'
+
+    if verbose:
+        print 'access...'
+    for key in f.keys():
+        word = f[key]
+        if verbose:
+            print word
+
+    f.close()
+    try:
+        os.remove(fname)
+    except os.error:
+        pass
+
+types = [(bsddb.btopen, 'BTree'),
+         (bsddb.hashopen, 'Hash Table'),
+         # (bsddb.rnopen,'Record Numbers'), 'put' for RECNO for bsddb 1.85
+         #                                   appears broken... at least on
+         #                                   Solaris Intel - rmasse 1/97
+         ]
+
+for type in types:
+    test(type[0], type[1])

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

@@ -0,0 +1,60 @@
+from test_support import verify, TestFailed, TESTFN
+
+# Simple test to ensure that optimizations in fileobject.c deliver
+# the expected results.  For best testing, run this under a debug-build
+# Python too (to exercise asserts in the C code).
+
+# Repeat string 'pattern' as often as needed to reach total length
+# 'length'.  Then call try_one with that string, a string one larger
+# than that, and a string one smaller than that.  The main driver
+# feeds this all small sizes and various powers of 2, so we exercise
+# all likely stdio buffer sizes, and "off by one" errors on both
+# sides.
+def drive_one(pattern, length):
+    q, r = divmod(length, len(pattern))
+    teststring = pattern * q + pattern[:r]
+    verify(len(teststring) == length)
+    try_one(teststring)
+    try_one(teststring + "x")
+    try_one(teststring[:-1])
+
+# Write s + "\n" + s to file, then open it and ensure that successive
+# .readline()s deliver what we wrote.
+def try_one(s):
+    # Since C doesn't guarantee we can write/read arbitrary bytes in text
+    # files, use binary mode.
+    f = open(TESTFN, "wb")
+    # write once with \n and once without
+    f.write(s)
+    f.write("\n")
+    f.write(s)
+    f.close()
+    f = open(TESTFN, "rb")
+    line = f.readline()
+    if line != s + "\n":
+        raise TestFailed("Expected %r got %r" % (s + "\n", line))
+    line = f.readline()
+    if line != s:
+        raise TestFailed("Expected %r got %r" % (s, line))
+    line = f.readline()
+    if line:
+        raise TestFailed("Expected EOF but got %r" % line)
+    f.close()
+
+# A pattern with prime length, to avoid simple relationships with
+# stdio buffer sizes.
+primepat = "1234567890\00\01\02\03\04\05\06"
+
+nullpat = "\0" * 1000
+
+try:
+    for size in range(1, 257) + [512, 1000, 1024, 2048, 4096, 8192, 10000,
+                      16384, 32768, 65536, 1000000]:
+        drive_one(primepat, size)
+        drive_one(nullpat, size)
+finally:
+    try:
+        import os
+        os.unlink(TESTFN)
+    except:
+        pass

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

@@ -0,0 +1,31 @@
+
+import unittest
+from test_support import run_suite
+
+class C:
+  def __str__(self):
+    raise Exception("E")
+  def __repr__(self):
+    raise Exception("S")
+
+class ExceptionHandling(unittest.TestCase):
+  def testBugFix1149372(self):
+    try:
+      c = C()
+      str(c)
+    except Exception, e:
+      assert e.args[0] == "E"
+      return
+    unittest.fail("if __str__ raises an exception, re-raise")
+
+def test_main():
+  test_suite = unittest.TestSuite()
+  test_loader = unittest.TestLoader()
+  def suite_add(case):
+    test_suite.addTest(test_loader.loadTestsFromTestCase(case))
+  suite_add(ExceptionHandling)
+  run_suite(test_suite)
+
+if __name__ == "__main__":
+  test_main()
+

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

@@ -0,0 +1,13 @@
+# Python test set -- part 4, built-in functions
+
+from test_support import *
+
+print '4. Built-in functions'
+
+print 'test_b1'
+unload('test_b1')
+import test_b1
+
+print 'test_b2'
+unload('test_b2')
+import test_b2

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

@@ -0,0 +1,61 @@
+import calendar
+import unittest
+
+from test_support import run_unittest
+
+
+class CalendarTestCase(unittest.TestCase):
+    def test_isleap(self):
+        # Make sure that the return is right for a few years, and
+        # ensure that the return values are 1 or 0, not just true or
+        # false (see SF bug #485794).  Specific additional tests may
+        # be appropriate; this tests a single "cycle".
+        self.assertEqual(calendar.isleap(2000), 1)
+        self.assertEqual(calendar.isleap(2001), 0)
+        self.assertEqual(calendar.isleap(2002), 0)
+        self.assertEqual(calendar.isleap(2003), 0)
+
+    def test_setfirstweekday(self):
+        self.assertRaises(ValueError, calendar.setfirstweekday, 'flabber')
+        self.assertRaises(ValueError, calendar.setfirstweekday, -1)
+        self.assertRaises(ValueError, calendar.setfirstweekday, 200)
+        orig = calendar.firstweekday()
+        calendar.setfirstweekday(calendar.SUNDAY)
+        self.assertEqual(calendar.firstweekday(), calendar.SUNDAY)
+        calendar.setfirstweekday(calendar.MONDAY)
+        self.assertEqual(calendar.firstweekday(), calendar.MONDAY)
+        calendar.setfirstweekday(orig)
+
+    def test_enumerateweekdays(self):
+        self.assertRaises(IndexError, calendar.day_abbr.__getitem__, -10)
+        self.assertRaises(IndexError, calendar.day_name.__getitem__, 10)
+        self.assertEqual(len([d for d in calendar.day_abbr]), 7)
+
+    def test_days(self):
+        for attr in "day_name", "day_abbr":
+            value = getattr(calendar, attr)
+            self.assertEqual(len(value), 7)
+            self.assertEqual(len(value[:]), 7)
+            # ensure they're all unique
+            d = {}
+            for v in value:
+                d[v] = 1
+            self.assertEqual(len(d), 7)
+
+    def test_months(self):
+        for attr in "month_name", "month_abbr":
+            value = getattr(calendar, attr)
+            self.assertEqual(len(value), 13)
+            self.assertEqual(len(value[:]), 13)
+            self.assertEqual(value[0], "")
+            # ensure they're all unique
+            d = {}
+            for v in value:
+                d[v] = 1
+            self.assertEqual(len(d), 13)
+
+def test_main():
+    run_unittest(CalendarTestCase)
+
+if __name__ == "__main__":
+    test_main()