rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,269 @@
+# Check every path through every method of UserList
+
+#imported from Python 2.3.5
+
+from UserList import UserList
+import unittest, test.test_support
+
+class UserListTest(unittest.TestCase):
+
+    def test_constructors(self):
+        l0 = []
+        l1 = [0]
+        l2 = [0, 1]
+
+        u = UserList()
+        u0 = UserList(l0)
+        u1 = UserList(l1)
+        u2 = UserList(l2)
+
+        uu = UserList(u)
+        uu0 = UserList(u0)
+        uu1 = UserList(u1)
+        uu2 = UserList(u2)
+
+        v = UserList(tuple(u))
+        class OtherList:
+            def __init__(self, initlist):
+                self.__data = initlist
+            def __len__(self):
+                return len(self.__data)
+            def __getitem__(self, i):
+                return self.__data[i]
+        v0 = UserList(OtherList(u0))
+        vv = UserList("this is also a sequence")
+
+    def test_repr(self):
+        l0 = []
+        l2 = [0, 1, 2]
+        u0 = UserList(l0)
+        u2 = UserList(l2)
+
+        self.assertEqual(str(u0), str(l0))
+        self.assertEqual(repr(u0), repr(l0))
+        self.assertEqual(`u2`, `l2`)
+
+    def test_cmplen(self):
+        l0 = []
+        l1 = [0]
+        l2 = [0, 1]
+
+        # Test constructors
+
+        u = UserList()
+        u0 = UserList(l0)
+        u1 = UserList(l1)
+        u2 = UserList(l2)
+
+        uu = UserList(u)
+        uu0 = UserList(u0)
+        uu1 = UserList(u1)
+        uu2 = UserList(u2)
+
+        def mycmp(x, y):
+            r = cmp(x, y)
+            if r < 0: return -1
+            if r > 0: return 1
+            return r
+
+        all = [l0, l1, l2, u, u0, u1, u2, uu, uu0, uu1, uu2]
+        for a in all:
+            for b in all:
+                self.assertEqual(mycmp(a, b), mycmp(len(a), len(b)))
+
+        self.assert_(u0 <= u2)
+        self.assert_(u2 >= u0)
+
+    def test_getitem(self):
+        u = UserList([0, 1, 2])
+        for i in xrange(len(u)):
+            self.assertEqual(u[i], i)
+
+    def test_setitem(self):
+        u = UserList([0, 1])
+        u[0] = 0
+        u[1] = 100
+        self.assertEqual(u, [0, 100])
+        self.assertRaises(IndexError, u.__setitem__, 2, 200)
+
+    def test_delitem(self):
+        u = UserList([0, 1])
+        del u[1]
+        del u[0]
+        self.assertRaises(IndexError, u.__delitem__, 0)
+
+    def test_getslice(self):
+        l = [0, 1]
+        u = UserList(l)
+        for i in xrange(-3, 4):
+            self.assertEqual(u[:i], l[:i])
+            self.assertEqual(u[i:], l[i:])
+            for j in xrange(-3, 4):
+                self.assertEqual(u[i:j], l[i:j])
+
+    def test_setslice(self):
+        l = [0, 1]
+        u = UserList(l)
+
+        # Test __setslice__
+        for i in range(-3, 4):
+            u[:i] = l[:i]
+            self.assertEqual(u, l)
+            u2 = u[:]
+            u2[:i] = u[:i]
+            self.assertEqual(u2, u)
+            u[i:] = l[i:]
+            self.assertEqual(u, l)
+            u2 = u[:]
+            u2[i:] = u[i:]
+            self.assertEqual(u2, u)
+            for j in range(-3, 4):
+                u[i:j] = l[i:j]
+                self.assertEqual(u, l)
+                u2 = u[:]
+                u2[i:j] = u[i:j]
+                self.assertEqual(u2, u)
+
+        uu2 = u2[:]
+        uu2[:0] = [-2, -1]
+        self.assertEqual(uu2, [-2, -1, 0, 1])
+        uu2[0:] = []
+        self.assertEqual(uu2, [])
+
+    def test_contains(self):
+        u = UserList([0, 1, 2])
+        for i in u:
+            self.assert_(i in u)
+        for i in min(u)-1, max(u)+1:
+            self.assert_(i not in u)
+
+    def test_delslice(self):
+        u = UserList([0, 1])
+        del u[1:2]
+        del u[0:1]
+        self.assertEqual(u, [])
+
+        u = UserList([0, 1])
+        del u[1:]
+        del u[:1]
+        self.assertEqual(u, [])
+
+    def test_addmul(self):
+        u1 = UserList([0])
+        u2 = UserList([0, 1])
+        self.assertEqual(u1, u1 + [])
+        self.assertEqual(u1, [] + u1)
+        self.assertEqual(u1 + [1], u2)
+        self.assertEqual([-1] + u1, [-1, 0])
+        self.assertEqual(u2, u2*1)
+        self.assertEqual(u2, 1*u2)
+        self.assertEqual(u2+u2, u2*2)
+        self.assertEqual(u2+u2, 2*u2)
+        self.assertEqual(u2+u2+u2, u2*3)
+        self.assertEqual(u2+u2+u2, 3*u2)
+
+    def test_add_specials(self):
+        u = UserList("spam")
+        u2 = u + "eggs"
+        self.assertEqual(u2, list("spameggs"))
+
+    def test_radd_specials(self):
+        u = UserList("eggs")
+        u2 = "spam" + u
+        self.assertEqual(u2, list("spameggs"))
+        u2 = u.__radd__(UserList("spam"))
+        self.assertEqual(u2, list("spameggs"))
+
+    def test_append(self):
+        u = UserList((0, ))
+        u.append(1)
+        self.assertEqual(u, [0, 1])
+
+    def test_insert(self):
+        u = UserList((0, 1))
+        u.insert(0, -1)
+        self.assertEqual(u, [-1, 0, 1])
+
+    def test_pop(self):
+        u = UserList((-1, 0, 1))
+        u.pop()
+        self.assertEqual(u, [-1, 0])
+        u.pop(0)
+        self.assertEqual(u, [0])
+
+    def test_remove(self):
+        u = UserList((0, 1))
+        u.remove(1)
+        self.assertEqual(u, [0])
+
+    def test_count(self):
+        u = UserList((0, 1))*3
+        self.assertEqual(u.count(0), 3)
+        self.assertEqual(u.count(1), 3)
+        self.assertEqual(u.count(2), 0)
+
+    def test_index(self):
+        u = UserList((0, 1))
+        self.assertEqual(u.index(0), 0)
+        self.assertEqual(u.index(1), 1)
+        self.assertRaises(ValueError, u.index, 2)
+
+        u = UserList([-2,-1,0,0,1,2])
+        self.assertEqual(u.count(0), 2)
+        self.assertEqual(u.index(0), 2)
+        self.assertEqual(u.index(0,2), 2)
+        self.assertEqual(u.index(-2,-10), 0)
+        self.assertEqual(u.index(0,3), 3)
+        self.assertEqual(u.index(0,3,4), 3)
+        self.assertRaises(ValueError, u.index, 2,0,-10)
+
+    def test_reverse(self):
+        u = UserList((0, 1))
+        u2 = u[:]
+        u.reverse()
+        self.assertEqual(u, [1, 0])
+        u.reverse()
+        self.assertEqual(u, u2)
+
+    def test_sort(self):
+        u = UserList([1, 0])
+        u.sort()
+        self.assertEqual(u, [0, 1])
+
+    def test_slice(self):
+        u = UserList("spam")
+        u[:2] = "h"
+        self.assertEqual(u, list("ham"))
+
+    def test_iadd(self):
+        u = UserList((0, 1))
+        u += [0, 1]
+        self.assertEqual(u, [0, 1, 0, 1])
+        u += UserList([0, 1])
+        self.assertEqual(u, [0, 1, 0, 1, 0, 1])
+
+        u = UserList("spam")
+        u += "eggs"
+        self.assertEqual(u, list("spameggs"))
+
+    def test_extend(self):
+        u1 = UserList((0, ))
+        u2 = UserList((0, 1))
+        u = u1[:]
+        u.extend(u2)
+        self.assertEqual(u, u1 + u2)
+
+        u = UserList("spam")
+        u.extend("eggs")
+        self.assertEqual(u, list("spameggs"))
+
+    def test_imul(self):
+        u = UserList((0, 1))
+        u *= 3
+        self.assertEqual(u, [0, 1, 0, 1, 0, 1])
+
+def test_main():
+    test.test_support.run_unittest(UserListTest)
+
+if __name__ == "__main__":
+    test_main()

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

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+import sys
+from test_support import verbose
+import string_tests
+# UserString is a wrapper around the native builtin string type.
+# UserString instances should behave similar to builtin string objects.
+# The test cases were in part derived from 'test_string.py'.
+from UserString import UserString
+
+if __name__ == "__main__":
+    verbose = '-v' in sys.argv
+
+tested_methods = {}
+
+def test(methodname, input, output, *args):
+    global tested_methods
+    tested_methods[methodname] = 1
+    if verbose:
+        print '%r.%s(%s)' % (input, methodname, ", ".join(map(repr, args))),
+    u = UserString(input)
+    objects = [input, u, UserString(u)]
+    res = [""] * 3
+    for i in range(3):
+        object = objects[i]
+        try:
+            f = getattr(object, methodname)
+        except AttributeError:
+            f = None
+            res[i] = AttributeError
+        else:
+            try:
+                res[i] = apply(f, args)
+            except:
+                res[i] = sys.exc_type
+    if res[0] == res[1] == res[2] == output:
+        if verbose:
+            print 'yes'
+    else:
+        if verbose:
+            print 'no'
+        print (methodname, input, output, args, res[0], res[1], res[2])
+
+string_tests.run_method_tests(test)

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

@@ -0,0 +1,158 @@
+"""
+Tests for uu module.
+Nick Mathewson
+"""
+
+from test_support import verify, TestFailed, verbose, TESTFN
+import sys, os
+import uu
+from StringIO import StringIO
+
+teststr = "The smooth-scaled python crept over the sleeping dog\n"
+expected = """\
+M5&AE('-M;V]T:\"US8V%L960@<'ET:&]N(&-R97!T(&]V97(@=&AE('-L965P
+(:6YG(&1O9PH """
+encoded1 = "begin 666 t1\n"+expected+"\n \nend\n"
+if verbose:
+    print '1. encode file->file'
+inp = StringIO(teststr)
+out = StringIO()
+uu.encode(inp, out, "t1")
+verify(out.getvalue() == encoded1)
+inp = StringIO(teststr)
+out = StringIO()
+uu.encode(inp, out, "t1", 0644)
+verify(out.getvalue() == "begin 644 t1\n"+expected+"\n \nend\n")
+
+if verbose:
+    print '2. decode file->file'
+inp = StringIO(encoded1)
+out = StringIO()
+uu.decode(inp, out)
+verify(out.getvalue() == teststr)
+inp = StringIO("""UUencoded files may contain many lines,
+                  even some that have 'begin' in them.\n"""+encoded1)
+out = StringIO()
+uu.decode(inp, out)
+verify(out.getvalue() == teststr)
+
+stdinsave = sys.stdin
+stdoutsave = sys.stdout
+try:
+    if verbose:
+        print '3. encode stdin->stdout'
+    sys.stdin = StringIO(teststr)
+    sys.stdout = StringIO()
+    uu.encode("-", "-", "t1", 0666)
+    verify(sys.stdout.getvalue() == encoded1)
+    if verbose:
+        print >>stdoutsave, '4. decode stdin->stdout'
+    sys.stdin = StringIO(encoded1)
+    sys.stdout = StringIO()
+    uu.decode("-", "-")
+    verify(sys.stdout.getvalue() == teststr)
+finally:
+    sys.stdin = stdinsave
+    sys.stdout = stdoutsave
+
+if verbose:
+    print '5. encode file->file'
+tmpIn  = TESTFN + "i"
+tmpOut = TESTFN + "o"
+try:
+    fin = open(tmpIn, 'wb')
+    fin.write(teststr)
+    fin.close()
+
+    fin = open(tmpIn, 'rb')
+    fout = open(tmpOut, 'w')
+    uu.encode(fin, fout, tmpIn, mode=0644)
+    fin.close()
+    fout.close()
+
+    fout = open(tmpOut, 'r')
+    s = fout.read()
+    fout.close()
+    verify(s == 'begin 644 ' + tmpIn + '\n' + expected + '\n \nend\n')
+
+    os.unlink(tmpIn)
+    if verbose:
+        print '6. decode file-> file'
+    uu.decode(tmpOut)
+    fin = open(tmpIn, 'rb')
+    s = fin.read()
+    fin.close()
+    verify(s == teststr)
+    # XXX is there an xp way to verify the mode?
+
+finally:
+    try:
+        fin.close()
+    except:
+        pass
+    try:
+        fout.close()
+    except:
+        pass
+    try:
+        os.unlink(tmpIn)
+    except:
+        pass
+    try:
+        os.unlink(tmpOut)
+    except:
+        pass
+
+if verbose:
+    print '7. error: truncated input'
+inp = StringIO("begin 644 t1\n"+expected)
+out = StringIO()
+try:
+    uu.decode(inp, out)
+    raise TestFailed("No exception thrown")
+except uu.Error, e:
+    verify(str(e) == 'Truncated input file')
+
+if verbose:
+    print '8. error: missing begin'
+inp = StringIO("")
+out = StringIO()
+try:
+    uu.decode(inp, out)
+    raise TestFailed("No exception thrown")
+except uu.Error, e:
+    verify(str(e) == 'No valid begin line found in input file')
+
+# Test to verify that decode() will refuse to overwrite an existing file
+import tempfile
+outfile = tempfile.mktemp()
+inp = StringIO('Here is a message to be uuencoded')
+out = StringIO()
+uu.encode(inp, out, outfile)
+out.seek(0)
+try:
+    if verbose:
+        print '9. decode w/file not exists is okay'
+    uu.decode(out)
+    if not os.path.exists(outfile):
+        raise TestFailed('uudecode w/ out_file=None failed')
+    fp = open(outfile)
+    data = fp.read()
+    fp.close()
+    if data <> inp.getvalue():
+        raise TestFailed('uudecode stored something weird')
+    # Try to write it again, which should cause a failure
+    if verbose:
+        print '10. uudecode w/file exists fails'
+    out.seek(0)
+    try:
+        uu.decode(out)
+    except uu.Error:
+        pass
+    else:
+        raise TestFailed('expected to get a "file exists" error')
+finally:
+    try:
+        os.unlink(outfile)
+    except OSError:
+        pass

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

@@ -0,0 +1,34 @@
+from test_support import TestFailed
+import os, tempfile
+import wave
+
+def check(t, msg=None):
+    if not t:
+        raise TestFailed, msg
+
+nchannels = 2
+sampwidth = 2
+framerate = 8000
+nframes = 100
+
+testfile = tempfile.mktemp()
+
+f = wave.open(testfile, 'wb')
+f.setnchannels(nchannels)
+f.setsampwidth(sampwidth)
+f.setframerate(framerate)
+f.setnframes(nframes)
+output = '\0' * nframes * nchannels * sampwidth
+f.writeframes(output)
+f.close()
+
+f = wave.open(testfile, 'rb')
+check(nchannels == f.getnchannels(), "nchannels")
+check(sampwidth == f.getsampwidth(), "sampwidth")
+check(framerate == f.getframerate(), "framerate")
+check(nframes == f.getnframes(), "nframes")
+input = f.readframes(nframes)
+check(input == output, "data")
+f.close()
+
+os.remove(testfile)