rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,118 @@
+import copy
+import sys
+import warnings
+
+# Fake a number that implements numeric methods through __coerce__
+class CoerceNumber:
+    def __init__(self, arg):
+        self.arg = arg
+
+    def __repr__(self):
+        return '<CoerceNumber %s>' % repr(self.arg)
+
+    def __coerce__(self, other):
+        if isinstance(other, CoerceNumber):
+            return self.arg, other.arg
+        else:
+            return (self.arg, other)
+
+
+# Fake a number that implements numeric ops through methods.
+class MethodNumber:
+
+    def __init__(self,arg):
+        self.arg = arg
+
+    def __repr__(self):
+        return '<MethodNumber %s>' % repr(self.arg)
+
+    def __add__(self,other):
+        return self.arg + other
+
+    def __radd__(self,other):
+        return other + self.arg
+
+    def __sub__(self,other):
+        return self.arg - other
+
+    def __rsub__(self,other):
+        return other - self.arg
+
+    def __mul__(self,other):
+        return self.arg * other
+
+    def __rmul__(self,other):
+        return other * self.arg
+
+    def __div__(self,other):
+        return self.arg / other
+
+    def __rdiv__(self,other):
+        return other / self.arg
+
+    def __pow__(self,other):
+        return self.arg ** other
+
+    def __rpow__(self,other):
+        return other ** self.arg
+
+    def __mod__(self,other):
+        return self.arg % other
+
+    def __rmod__(self,other):
+        return other % self.arg
+
+    def __cmp__(self, other):
+        return cmp(self.arg, other)
+
+
+candidates = [ 2, 4.0, 2L, 2+0j, [1], (2,), None,
+               MethodNumber(1), CoerceNumber(2)]
+
+infix_binops = [ '+', '-', '*', '/', '**', '%' ]
+prefix_binops = [ 'divmod' ]
+
+def do_infix_binops():
+    for a in candidates:
+        for b in candidates:
+            for op in infix_binops:
+                print '%s %s %s' % (a, op, b),
+                try:
+                    x = eval('a %s b' % op)
+                except:
+                    error = sys.exc_info()[:2]
+                    print '... %s' % error[0]
+                else:
+                    print '=', x
+                try:
+                    z = copy.copy(a)
+                except copy.Error:
+                    z = a # assume it has no inplace ops
+                print '%s %s= %s' % (a, op, b),
+                try:
+                    exec('z %s= b' % op)
+                except:
+                    error = sys.exc_info()[:2]
+                    print '... %s' % error[0]
+                else:
+                    print '=>', z
+
+def do_prefix_binops():
+    for a in candidates:
+        for b in candidates:
+            for op in prefix_binops:
+                print '%s(%s, %s)' % (op, a, b),
+                try:
+                    x = eval('%s(a, b)' % op)
+                except:
+                    error = sys.exc_info()[:2]
+                    print '... %s' % error[0]
+                else:
+                    print '=', x
+
+warnings.filterwarnings("ignore",
+                        r'complex divmod\(\), // and % are deprecated',
+                        DeprecationWarning,
+                        r'test_coercion$')
+do_infix_binops()
+do_prefix_binops()

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

@@ -0,0 +1,52 @@
+'''
+   Tests for commands module
+   Nick Mathewson
+'''
+import unittest
+import os, tempfile, re
+
+from test_support import TestSkipped, run_unittest
+from commands import *
+
+# The module says:
+#   "NB This only works (and is only relevant) for UNIX."
+#
+# Actually, getoutput should work on any platform with an os.popen, but
+# I'll take the comment as given, and skip this suite.
+
+if os.name != 'posix':
+    raise TestSkipped('Not posix; skipping test_commands')
+
+
+class CommandTests(unittest.TestCase):
+
+    def test_getoutput(self):
+        self.assertEquals(getoutput('echo xyzzy'), 'xyzzy')
+        self.assertEquals(getstatusoutput('echo xyzzy'), (0, 'xyzzy'))
+
+        # we use mktemp in the next line to get a filename which we
+        # _know_ won't exist.  This is guaranteed to fail.
+        status, output = getstatusoutput('cat ' + tempfile.mktemp())
+        self.assertNotEquals(status, 0)
+
+    def test_getstatus(self):
+        # This pattern should match 'ls -ld /.' on any posix
+        # system, however perversely configured.
+        pat = r'''d.........   # It is a directory.
+                  \s+\d+       # It has some number of links.
+                  \s+\w+\s+\w+ # It has a user and group, which may
+                               #     be named anything.
+                  \s+\d+       # It has a size.
+                  [^/]*        # Skip the date.
+                  /.           # and end with the name of the file.
+               '''
+
+        self.assert_(re.match(pat, getstatus("/."), re.VERBOSE))
+
+
+def test_main():
+    run_unittest(CommandTests)
+
+
+if __name__ == "__main__":
+    test_main()

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

@@ -0,0 +1,56 @@
+import sys
+
+from test_support import *
+
+class Empty:
+    def __repr__(self):
+        return '<Empty>'
+
+class Coerce:
+    def __init__(self, arg):
+        self.arg = arg
+
+    def __repr__(self):
+        return '<Coerce %s>' % self.arg
+
+    def __coerce__(self, other):
+        if isinstance(other, Coerce):
+            return self.arg, other.arg
+        else:
+            return self.arg, other
+
+class Cmp:
+    def __init__(self,arg):
+        self.arg = arg
+
+    def __repr__(self):
+        return '<Cmp %s>' % self.arg
+
+    def __cmp__(self, other):
+        return cmp(self.arg, other)
+
+
+candidates = [2, 2.0, 2L, 2+0j, [1], (3,), None, Empty(), Coerce(2), Cmp(2.0)]
+
+def test():
+    for a in candidates:
+        for b in candidates:
+            try:
+                x = a == b
+            except:
+                print 'cmp(%s, %s) => %s' % (a, b, sys.exc_info()[0])
+            else:
+                if x:
+                    print "%s == %s" % (a, b)
+                else:
+                    print "%s != %s" % (a, b)
+    # Ensure default comparison compares id() of args
+    L = []
+    for i in range(10):
+        L.insert(len(L)//2, Empty())
+    for a in L:
+        for b in L:
+            if cmp(a, b) != cmp(id(a), id(b)):
+                print "ERROR:", cmp(a, b), cmp(id(a), id(b)), id(a), id(b)
+
+test()

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

@@ -0,0 +1,129 @@
+from test_support import verbose, TestFailed
+
+if verbose:
+    print "Testing whether compiler catches assignment to __debug__"
+
+try:
+    compile('__debug__ = 1', '?', 'single')
+except SyntaxError:
+    pass
+
+import __builtin__
+prev = __builtin__.__debug__
+setattr(__builtin__, '__debug__', 'sure')
+setattr(__builtin__, '__debug__', prev)
+
+if verbose:
+    print 'Running tests on argument handling'
+
+try:
+    exec 'def f(a, a): pass'
+    raise TestFailed, "duplicate arguments"
+except SyntaxError:
+    pass
+
+try:
+    exec 'def f(a = 0, a = 1): pass'
+    raise TestFailed, "duplicate keyword arguments"
+except SyntaxError:
+    pass
+
+try:
+    exec 'def f(a): global a; a = 1'
+    raise TestFailed, "variable is global and local"
+except SyntaxError:
+    pass
+
+if verbose:
+    print "testing complex args"
+
+def comp_args((a, b)):
+    print a,b
+
+comp_args((1, 2))
+
+def comp_args((a, b)=(3, 4)):
+    print a, b
+
+comp_args((1, 2))
+comp_args()
+
+def comp_args(a, (b, c)):
+    print a, b, c
+
+comp_args(1, (2, 3))
+
+def comp_args(a=2, (b, c)=(3, 4)):
+    print a, b, c
+
+comp_args(1, (2, 3))
+comp_args()
+
+try:
+    exec 'def f(a=1, (b, c)): pass'
+    raise TestFailed, "non-default args after default"
+except SyntaxError:
+    pass
+
+if verbose:
+    print "testing bad float literals"
+
+def expect_error(s):
+    try:
+        eval(s)
+        raise TestFailed("%r accepted" % s)
+    except SyntaxError:
+        pass
+
+expect_error("2e")
+expect_error("2.0e+")
+expect_error("1e-")
+expect_error("3-4e/21")
+
+
+if verbose:
+    print "testing literals with leading zeroes"
+
+def expect_same(test_source, expected):
+    got = eval(test_source)
+    if got != expected:
+        raise TestFailed("eval(%r) gave %r, but expected %r" %
+                         (test_source, got, expected))
+
+expect_error("077787")
+expect_error("0xj")
+expect_error("0x.")
+expect_error("0e")
+expect_same("0777", 511)
+expect_same("0777L", 511)
+expect_same("000777", 511)
+expect_same("0xff", 255)
+expect_same("0xffL", 255)
+expect_same("0XfF", 255)
+expect_same("0777.", 777)
+expect_same("0777.0", 777)
+expect_same("000000000000000000000000000000000000000000000000000777e0", 777)
+expect_same("0777e1", 7770)
+expect_same("0e0", 0)
+expect_same("0000E-012", 0)
+expect_same("09.5", 9.5)
+expect_same("0777j", 777j)
+expect_same("00j", 0j)
+expect_same("00.0", 0)
+expect_same("0e3", 0)
+expect_same("090000000000000.", 90000000000000.)
+expect_same("090000000000000.0000000000000000000000", 90000000000000.)
+expect_same("090000000000000e0", 90000000000000.)
+expect_same("090000000000000e-0", 90000000000000.)
+expect_same("090000000000000j", 90000000000000j)
+expect_error("090000000000000")  # plain octal literal w/ decimal digit
+expect_error("080000000000000")  # plain octal literal w/ decimal digit
+expect_error("000000000000009")  # plain octal literal w/ decimal digit
+expect_error("000000000000008")  # plain octal literal w/ decimal digit
+expect_same("000000000000007", 7)
+expect_same("000000000000008.", 8.)
+expect_same("000000000000009.", 9.)
+
+# Verify treatment of unary minus on negative numbers SF bug #660455
+expect_same("0xffffffff", -1)
+expect_same("-0xffffffff", 1)

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

@@ -0,0 +1,68 @@
+from test_support import TestFailed
+from random import random
+
+# These tests ensure that complex math does the right thing; tests of
+# the complex() function/constructor are in test_b1.py.
+
+# XXX need many, many more tests here.
+
+nerrors = 0
+
+def check_close_real(x, y, eps=1e-9):
+    """Return true iff floats x and y "are close\""""
+    # put the one with larger magnitude second
+    if abs(x) > abs(y):
+        x, y = y, x
+    if y == 0:
+        return abs(x) < eps
+    if x == 0:
+        return abs(y) < eps
+    # check that relative difference < eps
+    return abs((x-y)/y) < eps
+
+def check_close(x, y, eps=1e-9):
+    """Return true iff complexes x and y "are close\""""
+    return check_close_real(x.real, y.real, eps) and \
+           check_close_real(x.imag, y.imag, eps)
+
+def test_div(x, y):
+    """Compute complex z=x*y, and check that z/x==y and z/y==x."""
+    global nerrors
+    z = x * y
+    if x != 0:
+        q = z / x
+        if not check_close(q, y):
+            nerrors += 1
+            print "%r / %r == %r but expected %r" % (z, x, q, y)
+    if y != 0:
+        q = z / y
+        if not check_close(q, x):
+            nerrors += 1
+            print "%r / %r == %r but expected %r" % (z, y, q, x)
+
+simple_real = [float(i) for i in range(-5, 6)]
+simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
+for x in simple_complex:
+    for y in simple_complex:
+        test_div(x, y)
+
+# A naive complex division algorithm (such as in 2.0) is very prone to
+# nonsense errors for these (overflows and underflows).
+test_div(complex(1e200, 1e200), 1+0j)
+test_div(complex(1e-200, 1e-200), 1+0j)
+
+# Just for fun.
+for i in range(100):
+    test_div(complex(random(), random()),
+             complex(random(), random()))
+
+try:
+    z = 1.0 / (0+0j)
+except ZeroDivisionError:
+    pass
+else:
+    nerrors += 1
+    raise TestFailed("Division by complex 0 didn't raise ZeroDivisionError")
+
+if nerrors:
+    raise TestFailed("%d tests failed" % nerrors)

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

@@ -0,0 +1,133 @@
+from test.test_support import TestFailed, have_unicode
+
+class base_set:
+
+    def __init__(self, el):
+        self.el = el
+
+class set(base_set):
+
+    def __contains__(self, el):
+        return self.el == el
+
+class seq(base_set):
+
+    def __getitem__(self, n):
+        return [self.el][n]
+
+def check(ok, *args):
+    if not ok:
+        raise TestFailed, " ".join(map(str, args))
+
+a = base_set(1)
+b = set(1)
+c = seq(1)
+
+check(1 in b, "1 not in set(1)")
+check(0 not in b, "0 in set(1)")
+check(1 in c, "1 not in seq(1)")
+check(0 not in c, "0 in seq(1)")
+
+try:
+    1 in a
+    check(0, "in base_set did not raise error")
+except TypeError:
+    pass
+
+try:
+    1 not in a
+    check(0, "not in base_set did not raise error")
+except TypeError:
+    pass
+
+# Test char in string
+
+check('c' in 'abc', "'c' not in 'abc'")
+check('d' not in 'abc', "'d' in 'abc'")
+
+check('' in '', "'' not in ''")
+check('' in 'abc', "'' not in 'abc'")
+
+try:
+    None in 'abc'
+    check(0, "None in 'abc' did not raise error")
+except TypeError:
+    pass
+
+
+if have_unicode:
+
+    # Test char in Unicode
+
+    check('c' in unicode('abc'), "'c' not in u'abc'")
+    check('d' not in unicode('abc'), "'d' in u'abc'")
+
+    check('' in unicode(''), "'' not in u''")
+    check(unicode('') in '', "u'' not in ''")
+    check(unicode('') in unicode(''), "u'' not in u''")
+    check('' in unicode('abc'), "'' not in u'abc'")
+    check(unicode('') in 'abc', "u'' not in 'abc'")
+    check(unicode('') in unicode('abc'), "u'' not in u'abc'")
+
+    try:
+        None in unicode('abc')
+        check(0, "None in u'abc' did not raise error")
+    except TypeError:
+        pass
+
+    # Test Unicode char in Unicode
+
+    check(unicode('c') in unicode('abc'), "u'c' not in u'abc'")
+    check(unicode('d') not in unicode('abc'), "u'd' in u'abc'")
+
+    # Test Unicode char in string
+
+    check(unicode('c') in 'abc', "u'c' not in 'abc'")
+    check(unicode('d') not in 'abc', "u'd' in 'abc'")
+
+# A collection of tests on builtin sequence types
+a = range(10)
+for i in a:
+    check(i in a, "%s not in %s" % (`i`, `a`))
+check(16 not in a, "16 not in %s" % `a`)
+check(a not in a, "%s not in %s" % (`a`, `a`))
+
+a = tuple(a)
+for i in a:
+    check(i in a, "%s not in %s" % (`i`, `a`))
+check(16 not in a, "16 not in %s" % `a`)
+check(a not in a, "%s not in %s" % (`a`, `a`))
+
+class Deviant1:
+    """Behaves strangely when compared
+
+    This class is designed to make sure that the contains code
+    works when the list is modified during the check.
+    """
+
+    aList = range(15)
+
+    def __cmp__(self, other):
+        if other == 12:
+            self.aList.remove(12)
+            self.aList.remove(13)
+            self.aList.remove(14)
+        return 1
+
+check(Deviant1() not in Deviant1.aList, "Deviant1 failed")
+
+class Deviant2:
+    """Behaves strangely when compared
+
+    This class raises an exception during comparison.  That in
+    turn causes the comparison to fail with a TypeError.
+    """
+
+    def __cmp__(self, other):
+        if other == 4:
+            raise RuntimeError, "gotcha"
+
+try:
+    check(Deviant2() not in a, "oops")
+except TypeError:
+    pass

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

@@ -0,0 +1,47 @@
+# Simple test suite for Cookie.py
+
+from test_support import verify, verbose, run_doctest
+import Cookie
+
+# Currently this only tests SimpleCookie
+
+cases = [
+    ('chips=ahoy; vienna=finger', {'chips':'ahoy', 'vienna':'finger'}),
+    ('keebler="E=mc2; L=\\"Loves\\"; fudge=\\012;";',
+     {'keebler' : 'E=mc2; L="Loves"; fudge=\012;'}),
+
+    # Check illegal cookies that have an '=' char in an unquoted value
+    ('keebler=E=mc2;', {'keebler' : 'E=mc2'})
+    ]
+
+for data, dict in cases:
+    C = Cookie.SimpleCookie() ; C.load(data)
+    print repr(C)
+    print str(C)
+    items = dict.items()
+    items.sort()
+    for k, v in items:
+        print ' ', k, repr( C[k].value ), repr(v)
+        verify(C[k].value == v)
+        print C[k]
+
+C = Cookie.SimpleCookie()
+C.load('Customer="WILE_E_COYOTE"; Version=1; Path=/acme')
+
+verify(C['Customer'].value == 'WILE_E_COYOTE')
+verify(C['Customer']['version'] == '1')
+verify(C['Customer']['path'] == '/acme')
+
+print C.output(['path'])
+print C.js_output()
+print C.js_output(['path'])
+
+# Try cookie with quoted meta-data
+C = Cookie.SimpleCookie()
+C.load('Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"')
+verify(C['Customer'].value == 'WILE_E_COYOTE')
+verify(C['Customer']['version'] == '1')
+verify(C['Customer']['path'] == '/acme')
+
+print "If anything blows up after this line, it's from Cookie's doctest."
+run_doctest(Cookie)

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

@@ -0,0 +1,30 @@
+import copy_reg
+import test_support
+import unittest
+
+
+class C:
+    pass
+
+
+class CopyRegTestCase(unittest.TestCase):
+
+    def test_class(self):
+        self.assertRaises(TypeError, copy_reg.pickle,
+                          C, None, None)
+
+    def test_noncallable_reduce(self):
+        self.assertRaises(TypeError, copy_reg.pickle,
+                          type(1), "not a callable")
+
+    def test_noncallable_constructor(self):
+        self.assertRaises(TypeError, copy_reg.pickle,
+                          type(1), int, "not a callable")
+
+
+def test_main():
+    test_support.run_unittest(CopyRegTestCase)
+
+
+if __name__ == "__main__":
+    test_main()