rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,259 @@
+# Test packages (dotted-name import)
+
+import sys, os, tempfile, traceback
+from os import mkdir, rmdir, extsep          # Can't test if these fail
+del mkdir, rmdir
+from test_support import verify, verbose, TestFailed
+
+# Helpers to create and destroy hierarchies.
+
+def mkhier(root, descr):
+    mkdir(root)
+    for name, contents in descr:
+        comps = name.split()
+        fullname = root
+        for c in comps:
+            fullname = os.path.join(fullname, c)
+        if contents is None:
+            mkdir(fullname)
+        else:
+            if verbose: print "write", fullname
+            f = open(fullname, "w")
+            f.write(contents)
+            if contents and contents[-1] != '\n':
+                f.write('\n')
+            f.close()
+
+def mkdir(x):
+    if verbose: print "mkdir", x
+    os.mkdir(x)
+
+def cleanout(root):
+    names = os.listdir(root)
+    for name in names:
+        fullname = os.path.join(root, name)
+        if os.path.isdir(fullname) and not os.path.islink(fullname):
+            cleanout(fullname)
+        else:
+            os.remove(fullname)
+    rmdir(root)
+
+def rmdir(x):
+    if verbose: print "rmdir", x
+    os.rmdir(x)
+
+def fixdir(lst):
+    try:
+        lst.remove('__builtins__')
+    except ValueError:
+        pass
+    return lst
+
+# Helper to run a test
+
+def runtest(hier, code):
+    root = tempfile.mktemp()
+    mkhier(root, hier)
+    savepath = sys.path[:]
+    codefile = tempfile.mktemp()
+    f = open(codefile, "w")
+    f.write(code)
+    f.close()
+    try:
+        sys.path.insert(0, root)
+        if verbose: print "sys.path =", sys.path
+        try:
+            execfile(codefile, globals(), {})
+        except:
+            traceback.print_exc(file=sys.stdout)
+    finally:
+        sys.path[:] = savepath
+        try:
+            cleanout(root)
+        except (os.error, IOError):
+            pass
+        os.remove(codefile)
+
+# Test descriptions
+
+tests = [
+    ("t1", [("t1", None), ("t1 __init__"+os.extsep+"py", "")], "import t1"),
+
+    ("t2", [
+    ("t2", None),
+    ("t2 __init__"+os.extsep+"py", "'doc for t2'; print __name__, 'loading'"),
+    ("t2 sub", None),
+    ("t2 sub __init__"+os.extsep+"py", ""),
+    ("t2 sub subsub", None),
+    ("t2 sub subsub __init__"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
+    ],
+"""
+import t2
+print t2.__doc__
+import t2.sub
+import t2.sub.subsub
+print t2.__name__, t2.sub.__name__, t2.sub.subsub.__name__
+import t2
+from t2 import *
+print dir()
+from t2 import sub
+from t2.sub import subsub
+from t2.sub.subsub import spam
+print sub.__name__, subsub.__name__
+print sub.subsub.__name__
+print dir()
+import t2.sub
+import t2.sub.subsub
+print t2.__name__, t2.sub.__name__, t2.sub.subsub.__name__
+from t2 import *
+print dir()
+"""),
+
+    ("t3", [
+    ("t3", None),
+    ("t3 __init__"+os.extsep+"py", "print __name__, 'loading'"),
+    ("t3 sub", None),
+    ("t3 sub __init__"+os.extsep+"py", ""),
+    ("t3 sub subsub", None),
+    ("t3 sub subsub __init__"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
+    ],
+"""
+import t3.sub.subsub
+print t3.__name__, t3.sub.__name__, t3.sub.subsub.__name__
+reload(t3)
+reload(t3.sub)
+reload(t3.sub.subsub)
+"""),
+
+    ("t4", [
+    ("t4"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (t4"+os.extsep+"py)'"),
+    ("t4", None),
+    ("t4 __init__"+os.extsep+"py", "print __name__, 'loading'"),
+    ("t4 sub"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (sub"+os.extsep+"py)'"),
+    ("t4 sub", None),
+    ("t4 sub __init__"+os.extsep+"py", ""),
+    ("t4 sub subsub"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (subsub"+os.extsep+"py)'"),
+    ("t4 sub subsub", None),
+    ("t4 sub subsub __init__"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
+    ],
+"""
+from t4.sub.subsub import *
+print "t4.sub.subsub.spam =", spam
+"""),
+
+    ("t5", [
+    ("t5", None),
+    ("t5 __init__"+os.extsep+"py", "import t5.foo"),
+    ("t5 string"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
+    ("t5 foo"+os.extsep+"py",
+     "print __name__, 'loading'; import string; print string.spam"),
+     ],
+"""
+import t5
+from t5 import *
+print dir()
+import t5
+print fixdir(dir(t5))
+print fixdir(dir(t5.foo))
+print fixdir(dir(t5.string))
+"""),
+
+    ("t6", [
+    ("t6", None),
+    ("t6 __init__"+os.extsep+"py", "__all__ = ['spam', 'ham', 'eggs']"),
+    ("t6 spam"+os.extsep+"py", "print __name__, 'loading'"),
+    ("t6 ham"+os.extsep+"py", "print __name__, 'loading'"),
+    ("t6 eggs"+os.extsep+"py", "print __name__, 'loading'"),
+    ],
+"""
+import t6
+print fixdir(dir(t6))
+from t6 import *
+print fixdir(dir(t6))
+print dir()
+"""),
+
+    ("t7", [
+    ("t7"+os.extsep+"py", "print 'Importing t7"+os.extsep+"py'"),
+    ("t7", None),
+    ("t7 __init__"+os.extsep+"py", "print __name__, 'loading'"),
+    ("t7 sub"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (sub"+os.extsep+"py)'"),
+    ("t7 sub", None),
+    ("t7 sub __init__"+os.extsep+"py", ""),
+    ("t7 sub subsub"+os.extsep+"py", "print 'THIS SHOULD NOT BE PRINTED (subsub"+os.extsep+"py)'"),
+    ("t7 sub subsub", None),
+    ("t7 sub subsub __init__"+os.extsep+"py", "print __name__, 'loading'; spam = 1"),
+    ],
+"""
+t7, sub, subsub = None, None, None
+import t7 as tas
+print fixdir(dir(tas))
+verify(not t7)
+from t7 import sub as subpar
+print fixdir(dir(subpar))
+verify(not t7 and not sub)
+from t7.sub import subsub as subsubsub
+print fixdir(dir(subsubsub))
+verify(not t7 and not sub and not subsub)
+from t7.sub.subsub import spam as ham
+print "t7.sub.subsub.spam =", ham
+verify(not t7 and not sub and not subsub)
+"""),
+
+]
+
+nontests = [
+    ("x5", [], ("import a" + ".a"*400)),
+    ("x6", [], ("import a" + ".a"*499)),
+    ("x7", [], ("import a" + ".a"*500)),
+    ("x8", [], ("import a" + ".a"*1100)),
+    ("x9", [], ("import " + "a"*400)),
+    ("x10", [], ("import " + "a"*500)),
+    ("x11", [], ("import " + "a"*998)),
+    ("x12", [], ("import " + "a"*999)),
+    ("x13", [], ("import " + "a"*999)),
+    ("x14", [], ("import " + "a"*2000)),
+]
+
+"""XXX Things to test
+
+import package without __init__
+import package with __init__
+__init__ importing submodule
+__init__ importing global module
+__init__ defining variables
+submodule importing other submodule
+submodule importing global module
+submodule import submodule via global name
+from package import submodule
+from package import subpackage
+from package import variable (defined in __init__)
+from package import * (defined in __init__)
+"""
+
+# Run the tests
+
+args = []
+if __name__ == '__main__':
+    args = sys.argv[1:]
+    if args and args[0] == '-q':
+        verbose = 0
+        del args[0]
+
+for name, hier, code in tests:
+    if args and name not in args:
+        print "skipping test", name
+        continue
+    print "running test", name
+    runtest(hier, code)
+
+# Test
+import sys
+import imp
+try:
+    import sys.imp
+except ImportError:
+    # This is what we expect
+    pass
+else:
+    raise TestFailed, "No ImportError exception on 'import sys.imp'"

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

@@ -0,0 +1,84 @@
+import os, sys, string, random, tempfile, unittest
+
+from test_support import run_unittest
+
+class TestImport(unittest.TestCase):
+
+    def __init__(self, *args, **kw):
+        self.package_name = 'PACKAGE_'
+        while sys.modules.has_key(self.package_name):
+            self.package_name += random.choose(string.letters)
+        self.module_name = self.package_name + '.foo'
+        unittest.TestCase.__init__(self, *args, **kw)
+
+    def remove_modules(self):
+        for module_name in (self.package_name, self.module_name):
+            if sys.modules.has_key(module_name):
+                del sys.modules[module_name]
+
+    def setUp(self):
+        self.test_dir = tempfile.mktemp()
+        os.mkdir(self.test_dir)
+        sys.path.append(self.test_dir)
+        self.package_dir = os.path.join(self.test_dir,
+                                        self.package_name)
+        os.mkdir(self.package_dir)
+        open(os.path.join(self.package_dir, '__init__'+os.extsep+'py'), 'w')
+        self.module_path = os.path.join(self.package_dir, 'foo'+os.extsep+'py')
+
+    def tearDown(self):
+        for file in os.listdir(self.package_dir):
+            os.remove(os.path.join(self.package_dir, file))
+        os.rmdir(self.package_dir)
+        os.rmdir(self.test_dir)
+        self.assertNotEqual(sys.path.count(self.test_dir), 0)
+        sys.path.remove(self.test_dir)
+        self.remove_modules()
+
+    def rewrite_file(self, contents):
+        for extension in "co":
+            compiled_path = self.module_path + extension
+            if os.path.exists(compiled_path):
+                os.remove(compiled_path)
+        f = open(self.module_path, 'w')
+        f.write(contents)
+        f.close()
+
+    def test_package_import__semantics(self):
+
+        # Generate a couple of broken modules to try importing.
+
+        # ...try loading the module when there's a SyntaxError
+        self.rewrite_file('for')
+        try: __import__(self.module_name)
+        except SyntaxError: pass
+        else: raise RuntimeError, 'Failed to induce SyntaxError'
+        self.assert_(not sys.modules.has_key(self.module_name) and
+                     not hasattr(sys.modules[self.package_name], 'foo'))
+
+        # ...make up a variable name that isn't bound in __builtins__
+        var = 'a'
+        while var in dir(__builtins__):
+            var += random.choose(string.letters)
+
+        # ...make a module that just contains that
+        self.rewrite_file(var)
+
+        try: __import__(self.module_name)
+        except NameError: pass
+        else: raise RuntimeError, 'Failed to induce NameError.'
+        module = __import__(self.module_name).foo
+
+        # ...now  change  the module  so  that  the NameError  doesn't
+        # happen
+        self.rewrite_file('%s = 1' % var)
+        reload(module)
+        self.assertEqual(getattr(module, var), 1)
+
+
+def test_main():
+    run_unittest(TestImport)
+
+
+if __name__ == "__main__":
+    test_main()

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

@@ -0,0 +1,3 @@
+from test_support import TestSkipped
+
+raise TestSkipped, 'test_poll currently not supported in Jython'

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

@@ -0,0 +1,72 @@
+#! /usr/bin/env python
+"""Test script for popen2.py
+   Christian Tismer
+"""
+
+import os
+import sys
+from test_support import TestSkipped
+
+# popen2 contains its own testing routine
+# which is especially useful to see if open files
+# like stdin can be read successfully by a forked
+# subprocess.
+
+def main():
+    print "Test popen2 module:"
+    if sys.platform[:4] == 'beos' and __name__ != '__main__':
+        #  Locks get messed up or something.  Generally we're supposed
+        #  to avoid mixing "posix" fork & exec with native threads, and
+        #  they may be right about that after all.
+        raise TestSkipped, "popen2() doesn't work during import on BeOS"
+    try:
+        from os import popen
+    except ImportError:
+        # if we don't have os.popen, check that
+        # we have os.fork.  if not, skip the test
+        # (by raising an ImportError)
+        from os import fork
+    import popen2
+    popen2._test()
+
+
+def _test():
+    # same test as popen2._test(), but using the os.popen*() API
+    print "Testing os module:"
+    import popen2
+    cmd  = "cat"
+    teststr = "ab cd\n"
+    if os.name == "nt":
+        cmd = "more"
+    # "more" doesn't act the same way across Windows flavors,
+    # sometimes adding an extra newline at the start or the
+    # end.  So we strip whitespace off both ends for comparison.
+    expected = teststr.strip()
+    print "testing popen2..."
+    w, r = os.popen2(cmd)
+    w.write(teststr)
+    w.close()
+    got = r.read()
+    if got.strip() != expected:
+        raise ValueError("wrote %s read %s" % (`teststr`, `got`))
+    print "testing popen3..."
+    try:
+        w, r, e = os.popen3([cmd])
+    except:
+        w, r, e = os.popen3(cmd)
+    w.write(teststr)
+    w.close()
+    got = r.read()
+    if got.strip() != expected:
+        raise ValueError("wrote %s read %s" % (`teststr`, `got`))
+    got = e.read()
+    if got:
+        raise ValueError("unexected %s on stderr" % `got`)
+    for inst in popen2._active[:]:
+        inst.wait()
+    if popen2._active:
+        raise ValueError("_active not empty")
+    print "All OK"
+
+main()
+_test()

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

@@ -0,0 +1,40 @@
+import posixpath
+
+errors = 0
+
+def tester(fn, wantResult):
+    gotResult = eval(fn)
+    if wantResult != gotResult:
+        print "error!"
+        print "evaluated: " + str(fn)
+        print "should be: " + str(wantResult)
+        print " returned: " + str(gotResult)
+        print ""
+        global errors
+        errors = errors + 1
+
+tester('posixpath.splitdrive("/foo/bar")', ('', '/foo/bar'))
+
+tester('posixpath.split("/foo/bar")', ('/foo', 'bar'))
+tester('posixpath.split("/")', ('/', ''))
+tester('posixpath.split("foo")', ('', 'foo'))
+
+tester('posixpath.splitext("foo.ext")', ('foo', '.ext'))
+tester('posixpath.splitext("/foo/foo.ext")', ('/foo/foo', '.ext'))
+
+tester('posixpath.isabs("/")', 1)
+tester('posixpath.isabs("/foo")', 1)
+tester('posixpath.isabs("/foo/bar")', 1)
+tester('posixpath.isabs("foo/bar")', 0)
+
+tester('posixpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"])',
+       "/home/swen")
+tester('posixpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"])',
+       "/home/swen/")
+tester('posixpath.commonprefix(["/home/swen/spam", "/home/swen/spam"])',
+       "/home/swen/spam")
+
+if errors:
+    print str(errors) + " errors."
+else:
+    print "No errors.  Thank your lucky stars."

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

@@ -0,0 +1,107 @@
+import sys
+from test_support import *
+
+print_test("power (test_pow.py)", 2)
+
+def powtest(type):
+    if (type!=float):
+        print_test("simple identities", 4)
+        for i in range(-1000, 1000):
+            assert type(i)**0 == 1
+            assert type(i)**1 == type(i)
+            if i > 0:
+            	assert type(0)**i == type(0)
+            	assert type(1)**i == type(1)
+            
+        print_test("cubes")
+        for i in range(-100, 100):
+            assert type(i)**3 == i*i*i
+    
+        print_test("powers of two")
+        pow2=1
+        for i in range(0,31):
+            assert 2**i == pow2
+            if i!=30: pow2=pow2*2
+    # modPow() has known assertion failures in all Sun 1.1 JDKs after 1.1.5.
+    # Apparently, Sun is not going to fix this for 1.1 since the bug still
+    # exists in 1.1.8 and the bug ID 4098742 is closed.
+    if sys.platform.startswith('java1.1') and type == long:
+        print_test('modpow... skipping due to JVM bugs', 4)
+        return
+    print_test("modpow", 4)
+    il, ih = -20, 20
+    jl, jh = -5,   5
+    kl, kh = -10, 10
+    compare = cmp
+    if (type==float):
+        il=1
+        compare = fcmp
+    elif (type==int):
+        jl=0
+    elif (type==long):
+        jl,jh = 0, 15
+    for i in range(il, ih+1):
+         for j in range(jl,jh+1):
+             for k in range(kl, kh+1):
+                 if (k!=0):
+                     try:
+                         assert compare(pow(type(i),j,k), type(i)**j % type(k)) == 0, '%s, %s, %s' % (i,j,k)
+                     except TypeError:
+                         if type==float:
+                             # Python 2.2 only allows 3rd arg if first 2 are integers
+                             pass
+                         else:
+                             raise
+
+print_test("integers", 3)
+powtest(int)
+print_test("longs", 3)
+powtest(long)
+print_test("floats", 3)
+powtest(float)
+
+print_test("mixed-mode", 3)
+
+assert 3**3%8 == pow(3,3,8) == 3
+assert 3**3%-8 == pow(3,3,-8) == -5
+assert 3**2%-2 == pow(3,2,-2) == -1
+assert -3**3%8 == pow(-3,3,8) == 5
+assert -3**3%-8 == pow(-3,3,-8) == -3
+assert 5**2%-8 == pow(5,2,-8) == -7
+
+assert 3L**3%8 == pow(3L,3,8) == 3L
+assert 3L**3%-8 == pow(3,3L,-8) == -5L
+assert 3L**2%-2 == pow(3,2,-2L) == -1L
+assert -3L**3%8 == pow(-3L,3,8) == 5L
+assert -3L**3%-8 == pow(-3,3L,-8) == -3L
+assert 5L**2%-8 == pow(5,2,-8L) == -7L
+
+# Python 2.2 only allows 3rd arg if first 2 are integers
+assert 3.**3%8 == pow(3.,3) % 8 == 3.
+assert 3.**3%-8 == pow(3,3.) % -8 == -5.
+assert 3.**2%-2 == pow(3,2) %-2. == -1.
+assert -3.**3%8 == pow(-3.,3) % 8 == 5.
+assert -3.**3%-8 == pow(-3,3.) % -8 == -3.
+assert 5.**2%-8 == pow(5,2) % -8. == -7.
+
+print_test( "Validate that TypeError is thrown with 3 args if first two args aren't integers" )
+import unittest
+tc = unittest.TestCase( "fail" ) # get failUnlessRaises method
+tc.failUnlessRaises( TypeError, pow, 3., 3, 8 )
+tc.failUnlessRaises( TypeError, pow, 3, 3., 8 )
+
+if sys.platform.startswith('java1.1'):
+    print_test("miscellaneous... skipping due to JVM bugs", 3)
+else:    
+    print_test("miscellaneous", 3)
+    for i in range(-10, 11):
+        for j in range(0, 6):
+            for k in range(-7, 11):
+                if (j>=0 and k!=0):
+                    o=pow(i,j) % k
+                    n=pow(i,j,k)
+                    assert o == n, 'Integer mismatch: %d, %d, %d' % (i,j,k)
+                if (j>=0 and k<>0):
+                    o=pow(long(i),j) % k
+                    n=pow(long(i),j,k)
+                    assert o == n, 'Long mismatch: %s, %s, %s' % (i,j,k)

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

@@ -0,0 +1,104 @@
+import pprint
+import unittest
+
+import test_support
+
+try:
+    uni = unicode
+except NameError:
+    def uni(x):return x
+
+
+class QueryTestCase(unittest.TestCase):
+
+    def setUp(self):
+        self.a = range(100)
+        self.b = range(200)
+        self.a[-12] = self.b
+
+    def test_basic(self):
+        """Verify .isrecursive() and .isreadable() w/o recursion."""
+        verify = self.assert_
+        for safe in (2, 2.0, 2j, "abc", [3], (2,2), {3: 3}, uni("yaddayadda"),
+                     self.a, self.b):
+            verify(not pprint.isrecursive(safe),
+                   "expected not isrecursive for " + `safe`)
+            verify(pprint.isreadable(safe),
+                   "expected isreadable for " + `safe`)
+
+    def test_knotted(self):
+        """Verify .isrecursive() and .isreadable() w/ recursion."""
+        # Tie a knot.
+        self.b[67] = self.a
+        # Messy dict.
+        self.d = {}
+        self.d[0] = self.d[1] = self.d[2] = self.d
+
+        verify = self.assert_
+
+        for icky in self.a, self.b, self.d, (self.d, self.d):
+            verify(pprint.isrecursive(icky), "expected isrecursive")
+            verify(not pprint.isreadable(icky),  "expected not isreadable")
+
+        # Break the cycles.
+        self.d.clear()
+        del self.a[:]
+        del self.b[:]
+
+        for safe in self.a, self.b, self.d, (self.d, self.d):
+            verify(not pprint.isrecursive(safe),
+                   "expected not isrecursive for " + `safe`)
+            verify(pprint.isreadable(safe),
+                   "expected isreadable for " + `safe`)
+
+    def test_unreadable(self):
+        """Not recursive but not readable anyway."""
+        verify = self.assert_
+        for unreadable in type(3), pprint, pprint.isrecursive:
+            verify(not pprint.isrecursive(unreadable),
+                   "expected not isrecursive for " + `unreadable`)
+            verify(not pprint.isreadable(unreadable),
+                   "expected not isreadable for " + `unreadable`)
+
+    def test_same_as_repr(self):
+        "Simple objects and small containers that should be same as repr()."
+        verify = self.assert_
+        for simple in (0, 0L, 0+0j, 0.0, "", uni(""), (), [], {}, verify, pprint,
+                       -6, -6L, -6-6j, -1.5, "x", uni("x"), (3,), [3], {3: 6},
+                       (1,2), [3,4], {5: 6, 7: 8},
+                       {"xy\tab\n": (3,), 5: [[]], (): {}},
+                       range(10, -11, -1)
+                      ):
+            native = repr(simple)
+            for function in "pformat", "saferepr":
+                f = getattr(pprint, function)
+                got = f(simple)
+                verify(native == got, "expected %s got %s from pprint.%s" %
+                                      (native, got, function))
+
+
+    def test_basic_line_wrap(self):
+        """verify basic line-wrapping operation"""
+        o = {'RPM_cal': 0,
+             'RPM_cal2': 48059,
+             'Speed_cal': 0,
+             'controldesk_runtime_us': 0,
+             'main_code_runtime_us': 0,
+             'read_io_runtime_us': 0,
+             'write_io_runtime_us': 43690}
+        exp = """\
+{'RPM_cal': 0,
+ 'RPM_cal2': 48059,
+ 'Speed_cal': 0,
+ 'controldesk_runtime_us': 0,
+ 'main_code_runtime_us': 0,
+ 'read_io_runtime_us': 0,
+ 'write_io_runtime_us': 43690}"""
+        self.assertEqual(pprint.pformat(o), exp)
+
+def test_main():
+    test_support.run_unittest(QueryTestCase)
+
+
+if __name__ == "__main__":
+    test_main()