rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,187 @@
+# As a test suite for the os module, this is woefully inadequate, but this
+# does add tests for a few functions which have been determined to be more
+# more portable than they had been thought to be.
+
+import os
+import unittest
+import warnings
+
+warnings.filterwarnings("ignore", "tempnam", RuntimeWarning, __name__)
+warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning, __name__)
+
+from test_support import TESTFN, run_unittest
+
+class TemporaryFileTests(unittest.TestCase):
+    def setUp(self):
+        self.files = []
+        os.mkdir(TESTFN)
+
+    def tearDown(self):
+        for name in self.files:
+            os.unlink(name)
+        os.rmdir(TESTFN)
+
+    def check_tempfile(self, name):
+        # make sure it doesn't already exist:
+        self.failIf(os.path.exists(name),
+                    "file already exists for temporary file")
+        # make sure we can create the file
+        open(name, "w")
+        self.files.append(name)
+
+    def test_tempnam(self):
+        if not hasattr(os, "tempnam"):
+            return
+        warnings.filterwarnings("ignore", "tempnam", RuntimeWarning,
+                                "test_os")
+        self.check_tempfile(os.tempnam())
+
+        name = os.tempnam(TESTFN)
+        self.check_tempfile(name)
+
+        name = os.tempnam(TESTFN, "pfx")
+        self.assert_(os.path.basename(name)[:3] == "pfx")
+        self.check_tempfile(name)
+
+    def test_tmpfile(self):
+        if not hasattr(os, "tmpfile"):
+            return
+        fp = os.tmpfile()
+        fp.write("foobar")
+        fp.seek(0,0)
+        s = fp.read()
+        fp.close()
+        self.assert_(s == "foobar")
+
+    def test_tmpnam(self):
+        if not hasattr(os, "tmpnam"):
+            return
+        warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning,
+                                "test_os")
+        self.check_tempfile(os.tmpnam())
+
+# Test attributes on return values from os.*stat* family.
+class StatAttributeTests(unittest.TestCase):
+    def setUp(self):
+        os.mkdir(TESTFN)
+        self.fname = os.path.join(TESTFN, "f1")
+        f = open(self.fname, 'wb')
+        f.write("ABC")
+        f.close()
+
+    def tearDown(self):
+        os.unlink(self.fname)
+        os.rmdir(TESTFN)
+
+    def test_stat_attributes(self):
+        if not hasattr(os, "stat"):
+            return
+
+        import stat
+        result = os.stat(self.fname)
+
+        # Make sure direct access works
+        self.assertEquals(result[stat.ST_SIZE], 3)
+        self.assertEquals(result.st_size, 3)
+
+        import sys
+
+        # Make sure all the attributes are there
+        members = dir(result)
+        for name in dir(stat):
+            if name[:3] == 'ST_':
+                attr = name.lower()
+                self.assertEquals(getattr(result, attr),
+                                  result[getattr(stat, name)])
+                self.assert_(attr in members)
+
+        try:
+            result[200]
+            self.fail("No exception thrown")
+        except IndexError:
+            pass
+
+        # Make sure that assignment fails
+        try:
+            result.st_mode = 1
+            self.fail("No exception thrown")
+        except TypeError:
+            pass
+
+        try:
+            result.st_rdev = 1
+            self.fail("No exception thrown")
+        except (AttributeError, TypeError):
+            pass
+
+        try:
+            result.parrot = 1
+            self.fail("No exception thrown")
+        except AttributeError:
+            pass
+
+        # Use the stat_result constructor with a too-short tuple.
+        try:
+            result2 = os.stat_result((10,))
+            self.fail("No exception thrown")
+        except TypeError:
+            pass
+
+        # Use the constructr with a too-long tuple.
+        try:
+            result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
+        except TypeError:
+            pass
+
+
+    def test_statvfs_attributes(self):
+        if not hasattr(os, "statvfs"):
+            return
+
+        import statvfs
+        result = os.statvfs(self.fname)
+
+        # Make sure direct access works
+        self.assertEquals(result.f_bfree, result[statvfs.F_BFREE])
+
+        # Make sure all the attributes are there
+        members = dir(result)
+        for name in dir(statvfs):
+            if name[:2] == 'F_':
+                attr = name.lower()
+                self.assertEquals(getattr(result, attr),
+                                  result[getattr(statvfs, name)])
+                self.assert_(attr in members)
+
+        # Make sure that assignment really fails
+        try:
+            result.f_bfree = 1
+            self.fail("No exception thrown")
+        except TypeError:
+            pass
+
+        try:
+            result.parrot = 1
+            self.fail("No exception thrown")
+        except AttributeError:
+            pass
+
+        # Use the constructor with a too-short tuple.
+        try:
+            result2 = os.statvfs_result((10,))
+            self.fail("No exception thrown")
+        except TypeError:
+            pass
+
+        # Use the constructr with a too-long tuple.
+        try:
+            result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
+        except TypeError:
+            pass
+
+def test_main():
+    run_unittest(TemporaryFileTests)
+    run_unittest(StatAttributeTests)
+
+if __name__ == "__main__":
+    test_main()

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

@@ -0,0 +1,383 @@
+import parser
+import test_support
+import unittest
+
+#
+#  First, we test that we can generate trees from valid source fragments,
+#  and that these valid trees are indeed allowed by the tree-loading side
+#  of the parser module.
+#
+
+class RoundtripLegalSyntaxTestCase(unittest.TestCase):
+    def roundtrip(self, f, s):
+        st1 = f(s)
+        t = st1.totuple()
+        try:
+            st2 = parser.sequence2st(t)
+        except parser.ParserError:
+            self.fail("could not roundtrip %r" % s)
+
+        self.assertEquals(t, st2.totuple(),
+                          "could not re-generate syntax tree")
+
+    def check_expr(self, s):
+        self.roundtrip(parser.expr, s)
+
+    def check_suite(self, s):
+        self.roundtrip(parser.suite, s)
+
+    def test_yield_statement(self):
+        self.check_suite("from __future__ import generators\n"
+                         "def f(): yield 1")
+        self.check_suite("from __future__ import generators\n"
+                         "def f(): return; yield 1")
+        self.check_suite("from __future__ import generators\n"
+                         "def f(): yield 1; return")
+        self.check_suite("from __future__ import generators\n"
+                         "def f():\n"
+                         "    for x in range(30):\n"
+                         "        yield x\n")
+
+    def test_expressions(self):
+        self.check_expr("foo(1)")
+        self.check_expr("[1, 2, 3]")
+        self.check_expr("[x**3 for x in range(20)]")
+        self.check_expr("[x**3 for x in range(20) if x % 3]")
+        self.check_expr("foo(*args)")
+        self.check_expr("foo(*args, **kw)")
+        self.check_expr("foo(**kw)")
+        self.check_expr("foo(key=value)")
+        self.check_expr("foo(key=value, *args)")
+        self.check_expr("foo(key=value, *args, **kw)")
+        self.check_expr("foo(key=value, **kw)")
+        self.check_expr("foo(a, b, c, *args)")
+        self.check_expr("foo(a, b, c, *args, **kw)")
+        self.check_expr("foo(a, b, c, **kw)")
+        self.check_expr("foo + bar")
+        self.check_expr("foo - bar")
+        self.check_expr("foo * bar")
+        self.check_expr("foo / bar")
+        self.check_expr("foo // bar")
+        self.check_expr("lambda: 0")
+        self.check_expr("lambda x: 0")
+        self.check_expr("lambda *y: 0")
+        self.check_expr("lambda *y, **z: 0")
+        self.check_expr("lambda **z: 0")
+        self.check_expr("lambda x, y: 0")
+        self.check_expr("lambda foo=bar: 0")
+        self.check_expr("lambda foo=bar, spaz=nifty+spit: 0")
+        self.check_expr("lambda foo=bar, **z: 0")
+        self.check_expr("lambda foo=bar, blaz=blat+2, **z: 0")
+        self.check_expr("lambda foo=bar, blaz=blat+2, *y, **z: 0")
+        self.check_expr("lambda x, *y, **z: 0")
+
+    def test_print(self):
+        self.check_suite("print")
+        self.check_suite("print 1")
+        self.check_suite("print 1,")
+        self.check_suite("print >>fp")
+        self.check_suite("print >>fp, 1")
+        self.check_suite("print >>fp, 1,")
+
+    def test_simple_expression(self):
+        # expr_stmt
+        self.check_suite("a")
+
+    def test_simple_assignments(self):
+        self.check_suite("a = b")
+        self.check_suite("a = b = c = d = e")
+
+    def test_simple_augmented_assignments(self):
+        self.check_suite("a += b")
+        self.check_suite("a -= b")
+        self.check_suite("a *= b")
+        self.check_suite("a /= b")
+        self.check_suite("a //= b")
+        self.check_suite("a %= b")
+        self.check_suite("a &= b")
+        self.check_suite("a |= b")
+        self.check_suite("a ^= b")
+        self.check_suite("a <<= b")
+        self.check_suite("a >>= b")
+        self.check_suite("a **= b")
+
+    def test_function_defs(self):
+        self.check_suite("def f(): pass")
+        self.check_suite("def f(*args): pass")
+        self.check_suite("def f(*args, **kw): pass")
+        self.check_suite("def f(**kw): pass")
+        self.check_suite("def f(foo=bar): pass")
+        self.check_suite("def f(foo=bar, *args): pass")
+        self.check_suite("def f(foo=bar, *args, **kw): pass")
+        self.check_suite("def f(foo=bar, **kw): pass")
+
+        self.check_suite("def f(a, b): pass")
+        self.check_suite("def f(a, b, *args): pass")
+        self.check_suite("def f(a, b, *args, **kw): pass")
+        self.check_suite("def f(a, b, **kw): pass")
+        self.check_suite("def f(a, b, foo=bar): pass")
+        self.check_suite("def f(a, b, foo=bar, *args): pass")
+        self.check_suite("def f(a, b, foo=bar, *args, **kw): pass")
+        self.check_suite("def f(a, b, foo=bar, **kw): pass")
+
+    def test_import_from_statement(self):
+        self.check_suite("from sys.path import *")
+        self.check_suite("from sys.path import dirname")
+        self.check_suite("from sys.path import dirname as my_dirname")
+        self.check_suite("from sys.path import dirname, basename")
+        self.check_suite(
+            "from sys.path import dirname as my_dirname, basename")
+        self.check_suite(
+            "from sys.path import dirname, basename as my_basename")
+
+    def test_basic_import_statement(self):
+        self.check_suite("import sys")
+        self.check_suite("import sys as system")
+        self.check_suite("import sys, math")
+        self.check_suite("import sys as system, math")
+        self.check_suite("import sys, math as my_math")
+
+    def test_assert(self):
+        self.check_suite("assert alo < ahi and blo < bhi\n")
+
+#
+#  Second, we take *invalid* trees and make sure we get ParserError
+#  rejections for them.
+#
+
+class IllegalSyntaxTestCase(unittest.TestCase):
+    def check_bad_tree(self, tree, label):
+        try:
+            parser.sequence2st(tree)
+        except parser.ParserError:
+            pass
+        else:
+            self.fail("did not detect invalid tree for %r" % label)
+
+    def test_junk(self):
+        # not even remotely valid:
+        self.check_bad_tree((1, 2, 3), "<junk>")
+
+    def test_illegal_yield_1(self):
+        """Illegal yield statement: def f(): return 1; yield 1"""
+        tree = \
+        (257,
+         (264,
+          (285,
+           (259,
+            (1, 'def'),
+            (1, 'f'),
+            (260, (7, '('), (8, ')')),
+            (11, ':'),
+            (291,
+             (4, ''),
+             (5, ''),
+             (264,
+              (265,
+               (266,
+                (272,
+                 (275,
+                  (1, 'return'),
+                  (313,
+                   (292,
+                    (293,
+                     (294,
+                      (295,
+                       (297,
+                        (298,
+                         (299,
+                          (300,
+                           (301,
+                            (302, (303, (304, (305, (2, '1')))))))))))))))))),
+               (264,
+                (265,
+                 (266,
+                  (272,
+                   (276,
+                    (1, 'yield'),
+                    (313,
+                     (292,
+                      (293,
+                       (294,
+                        (295,
+                         (297,
+                          (298,
+                           (299,
+                            (300,
+                             (301,
+                              (302,
+                               (303, (304, (305, (2, '1')))))))))))))))))),
+                 (4, ''))),
+               (6, ''))))),
+           (4, ''),
+           (0, ''))))
+        self.check_bad_tree(tree, "def f():\n  return 1\n  yield 1")
+
+    def test_illegal_yield_2(self):
+        """Illegal return in generator: def f(): return 1; yield 1"""
+        tree = \
+        (257,
+         (264,
+          (265,
+           (266,
+            (278,
+             (1, 'from'),
+             (281, (1, '__future__')),
+             (1, 'import'),
+             (279, (1, 'generators')))),
+           (4, ''))),
+         (264,
+          (285,
+           (259,
+            (1, 'def'),
+            (1, 'f'),
+            (260, (7, '('), (8, ')')),
+            (11, ':'),
+            (291,
+             (4, ''),
+             (5, ''),
+             (264,
+              (265,
+               (266,
+                (272,
+                 (275,
+                  (1, 'return'),
+                  (313,
+                   (292,
+                    (293,
+                     (294,
+                      (295,
+                       (297,
+                        (298,
+                         (299,
+                          (300,
+                           (301,
+                            (302, (303, (304, (305, (2, '1')))))))))))))))))),
+               (264,
+                (265,
+                 (266,
+                  (272,
+                   (276,
+                    (1, 'yield'),
+                    (313,
+                     (292,
+                      (293,
+                       (294,
+                        (295,
+                         (297,
+                          (298,
+                           (299,
+                            (300,
+                             (301,
+                              (302,
+                               (303, (304, (305, (2, '1')))))))))))))))))),
+                 (4, ''))),
+               (6, ''))))),
+           (4, ''),
+           (0, ''))))
+        self.check_bad_tree(tree, "def f():\n  return 1\n  yield 1")
+
+    def test_print_chevron_comma(self):
+        """Illegal input: print >>fp,"""
+        tree = \
+        (257,
+         (264,
+          (265,
+           (266,
+            (268,
+             (1, 'print'),
+             (35, '>>'),
+             (290,
+              (291,
+               (292,
+                (293,
+                 (295,
+                  (296,
+                   (297,
+                    (298, (299, (300, (301, (302, (303, (1, 'fp')))))))))))))),
+             (12, ','))),
+           (4, ''))),
+         (0, ''))
+        self.check_bad_tree(tree, "print >>fp,")
+
+    def test_a_comma_comma_c(self):
+        """Illegal input: a,,c"""
+        tree = \
+        (258,
+         (311,
+          (290,
+           (291,
+            (292,
+             (293,
+              (295,
+               (296,
+                (297,
+                 (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))),
+          (12, ','),
+          (12, ','),
+          (290,
+           (291,
+            (292,
+             (293,
+              (295,
+               (296,
+                (297,
+                 (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))),
+         (4, ''),
+         (0, ''))
+        self.check_bad_tree(tree, "a,,c")
+
+    def test_illegal_operator(self):
+        """Illegal input: a $= b"""
+        tree = \
+        (257,
+         (264,
+          (265,
+           (266,
+            (267,
+             (312,
+              (291,
+               (292,
+                (293,
+                 (294,
+                  (296,
+                   (297,
+                    (298,
+                     (299,
+                      (300, (301, (302, (303, (304, (1, 'a'))))))))))))))),
+             (268, (37, '$=')),
+             (312,
+              (291,
+               (292,
+                (293,
+                 (294,
+                  (296,
+                   (297,
+                    (298,
+                     (299,
+                      (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))),
+           (4, ''))),
+         (0, ''))
+        self.check_bad_tree(tree, "a $= b")
+
+    def test_malformed_global(self):
+        #doesn't have global keyword in ast
+        tree = (257,
+                (264,
+                 (265,
+                  (266,
+                   (282, (1, 'foo'))), (4, ''))),
+                (4, ''),
+                (0, '')) 
+        self.check_bad_tree(tree, "malformed global ast")
+
+def test_main():
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+    suite.addTest(loader.loadTestsFromTestCase(RoundtripLegalSyntaxTestCase))
+    suite.addTest(loader.loadTestsFromTestCase(IllegalSyntaxTestCase))
+    test_support.run_suite(suite)
+
+
+if __name__ == "__main__":
+    test_main()

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

@@ -0,0 +1,50 @@
+#
+# Test suite to check compliance with PEP 247, the standard API for
+# hashing algorithms.
+#
+
+import md5, sha, hmac
+
+def check_hash_module(module, key=None):
+    assert hasattr(module, 'digest_size'), "Must have digest_size"
+    assert (module.digest_size is None or
+            module.digest_size > 0), "digest_size must be None or positive"
+
+    if key is not None:
+        obj1 = module.new(key)
+        obj2 = module.new(key, "string")
+
+        h1 = module.new(key, "string").digest()
+        obj3 = module.new(key) ; obj3.update("string") ; h2 = obj3.digest()
+        assert h1 == h2, "Hashes must match"
+
+    else:
+        obj1 = module.new()
+        obj2 = module.new("string")
+
+        h1 = module.new("string").digest()
+        obj3 = module.new() ; obj3.update("string") ; h2 = obj3.digest()
+        assert h1 == h2, "Hashes must match"
+
+    assert hasattr(obj1, 'digest_size'), "Objects must have digest_size attr"
+    if module.digest_size is not None:
+        assert obj1.digest_size == module.digest_size, "digest_size must match"
+    assert obj1.digest_size == len(h1), "digest_size must match actual size"
+    obj1.update("string")
+    obj_copy = obj1.copy()
+    assert obj1.digest() == obj_copy.digest(), "Copied objects must match"
+    assert obj1.hexdigest() == obj_copy.hexdigest(), \
+           "Copied objects must match"
+    digest, hexdigest = obj1.digest(), obj1.hexdigest()
+    hd2 = ""
+    for byte in digest:
+        hd2 += "%02x" % ord(byte)
+    assert hd2 == hexdigest, "hexdigest doesn't appear correct"
+
+    print 'Module', module.__name__, 'seems to comply with PEP 247'
+
+
+if __name__ == '__main__':
+    check_hash_module(md5)
+    check_hash_module(sha)
+    check_hash_module(hmac, key='abc')

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

@@ -0,0 +1,40 @@
+import pickle
+import test_support
+import unittest
+from cStringIO import StringIO
+from pickletester import AbstractPickleTests, AbstractPickleModuleTests
+
+class PickleTests(AbstractPickleTests, AbstractPickleModuleTests):
+
+    def setUp(self):
+        self.dumps = pickle.dumps
+        self.loads = pickle.loads
+
+    module = pickle
+    error = KeyError
+
+class PicklerTests(AbstractPickleTests):
+
+    error = KeyError
+
+    def dumps(self, arg, bin=0):
+        f = StringIO()
+        p = pickle.Pickler(f, bin)
+        p.dump(arg)
+        f.seek(0)
+        return f.read()
+
+    def loads(self, buf):
+        f = StringIO(buf)
+        u = pickle.Unpickler(f)
+        return u.load()
+
+def test_main():
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+    suite.addTest(loader.loadTestsFromTestCase(PickleTests))
+    suite.addTest(loader.loadTestsFromTestCase(PicklerTests))
+    test_support.run_suite(suite)
+
+if __name__ == "__main__":
+    test_main()