rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,95 @@
+# Test some Unicode file name semantics
+# We dont test many operations on files other than
+# that their names can be used with Unicode characters.
+import os
+
+from test_support import verify, TestSkipped, TESTFN_UNICODE
+try:
+    from test_support import TESTFN_ENCODING
+    oldlocale = None
+except ImportError:
+    import locale
+    # try to run the test in an UTF-8 locale. If this locale is not
+    # available, avoid running the test since the locale's encoding
+    # might not support TESTFN_UNICODE. Likewise, if the system does
+    # not support locale.CODESET, Unicode file semantics is not
+    # available, either.
+    oldlocale = locale.setlocale(locale.LC_CTYPE)
+    try:
+        locale.setlocale(locale.LC_CTYPE,"en_US.UTF-8")
+        TESTFN_ENCODING = locale.nl_langinfo(locale.CODESET)
+    except (locale.Error, AttributeError):
+        raise TestSkipped("No Unicode filesystem semantics on this platform.")
+
+TESTFN_ENCODED = TESTFN_UNICODE.encode(TESTFN_ENCODING)
+
+# Check with creation as Unicode string.
+f = open(TESTFN_UNICODE, 'wb')
+if not os.path.isfile(TESTFN_UNICODE):
+    print "File doesn't exist after creating it"
+
+if not os.path.isfile(TESTFN_ENCODED):
+    print "File doesn't exist (encoded string) after creating it"
+
+f.close()
+
+# Test stat and chmod
+if os.stat(TESTFN_ENCODED) != os.stat(TESTFN_UNICODE):
+    print "os.stat() did not agree on the 2 filenames"
+os.chmod(TESTFN_ENCODED, 0777)
+os.chmod(TESTFN_UNICODE, 0777)
+
+# Test rename
+os.rename(TESTFN_ENCODED, TESTFN_ENCODED + ".new")
+os.rename(TESTFN_UNICODE+".new", TESTFN_ENCODED)
+
+os.unlink(TESTFN_ENCODED)
+if os.path.isfile(TESTFN_ENCODED) or \
+   os.path.isfile(TESTFN_UNICODE):
+    print "File exists after deleting it"
+
+# Check with creation as encoded string.
+f = open(TESTFN_ENCODED, 'wb')
+if not os.path.isfile(TESTFN_UNICODE) or \
+   not os.path.isfile(TESTFN_ENCODED):
+    print "File doesn't exist after creating it"
+
+path, base = os.path.split(os.path.abspath(TESTFN_ENCODED))
+if base not in os.listdir(path):
+    print "Filename did not appear in os.listdir()"
+
+f.close()
+os.unlink(TESTFN_UNICODE)
+if os.path.isfile(TESTFN_ENCODED) or \
+   os.path.isfile(TESTFN_UNICODE):
+    print "File exists after deleting it"
+
+# test os.open
+f = os.open(TESTFN_ENCODED, os.O_CREAT)
+if not os.path.isfile(TESTFN_UNICODE) or \
+   not os.path.isfile(TESTFN_ENCODED):
+    print "File doesn't exist after creating it"
+os.close(f)
+os.unlink(TESTFN_UNICODE)
+
+# Test directories etc
+cwd = os.getcwd()
+abs_encoded = os.path.abspath(TESTFN_ENCODED) + ".dir"
+abs_unicode = os.path.abspath(TESTFN_UNICODE) + ".dir"
+os.mkdir(abs_encoded)
+try:
+    os.chdir(abs_encoded)
+    os.chdir(abs_unicode)
+finally:
+    os.chdir(cwd)
+    os.rmdir(abs_unicode)
+os.mkdir(abs_unicode)
+try:
+    os.chdir(abs_encoded)
+    os.chdir(abs_unicode)
+finally:
+    os.chdir(cwd)
+    os.rmdir(abs_encoded)
+print "All the Unicode tests appeared to work"
+if oldlocale:
+    locale.setlocale(locale.LC_CTYPE, oldlocale)

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

@@ -0,0 +1,125 @@
+""" Test script for the unicodedata module.
+
+    Written by Marc-Andre Lemburg (mal@lemburg.com).
+
+    (c) Copyright CNRI, All Rights Reserved. NO WARRANTY.
+
+"""#"
+from test_support import verify, verbose
+import sha
+
+encoding = 'utf-8'
+
+def test_methods():
+
+    h = sha.sha()
+    for i in range(65536):
+        char = unichr(i)
+        data = [
+
+            # Predicates (single char)
+            char.isalnum() and u'1' or u'0',
+            char.isalpha() and u'1' or u'0',
+            char.isdecimal() and u'1' or u'0',
+            char.isdigit() and u'1' or u'0',
+            char.islower() and u'1' or u'0',
+            char.isnumeric() and u'1' or u'0',
+            char.isspace() and u'1' or u'0',
+            char.istitle() and u'1' or u'0',
+            char.isupper() and u'1' or u'0',
+
+            # Predicates (multiple chars)
+            (char + u'abc').isalnum() and u'1' or u'0',
+            (char + u'abc').isalpha() and u'1' or u'0',
+            (char + u'123').isdecimal() and u'1' or u'0',
+            (char + u'123').isdigit() and u'1' or u'0',
+            (char + u'abc').islower() and u'1' or u'0',
+            (char + u'123').isnumeric() and u'1' or u'0',
+            (char + u' \t').isspace() and u'1' or u'0',
+            (char + u'abc').istitle() and u'1' or u'0',
+            (char + u'ABC').isupper() and u'1' or u'0',
+
+            # Mappings (single char)
+            char.lower(),
+            char.upper(),
+            char.title(),
+
+            # Mappings (multiple chars)
+            (char + u'abc').lower(),
+            (char + u'ABC').upper(),
+            (char + u'abc').title(),
+            (char + u'ABC').title(),
+
+            ]
+        h.update(u''.join(data).encode(encoding))
+    return h.hexdigest()
+
+def test_unicodedata():
+
+    h = sha.sha()
+    for i in range(65536):
+        char = unichr(i)
+        data = [
+            # Properties
+            str(unicodedata.digit(char, -1)),
+            str(unicodedata.numeric(char, -1)),
+            str(unicodedata.decimal(char, -1)),
+            unicodedata.category(char),
+            unicodedata.bidirectional(char),
+            unicodedata.decomposition(char),
+            str(unicodedata.mirrored(char)),
+            str(unicodedata.combining(char)),
+            ]
+        h.update(''.join(data))
+    return h.hexdigest()
+
+### Run tests
+
+print 'Testing Unicode Database...'
+print 'Methods:',
+print test_methods()
+
+# In case unicodedata is not available, this will raise an ImportError,
+# but still test the above cases...
+import unicodedata
+print 'Functions:',
+print test_unicodedata()
+
+# Some additional checks of the API:
+print 'API:',
+
+verify(unicodedata.digit(u'A',None) is None)
+verify(unicodedata.digit(u'9') == 9)
+verify(unicodedata.digit(u'\u215b',None) is None)
+verify(unicodedata.digit(u'\u2468') == 9)
+
+verify(unicodedata.numeric(u'A',None) is None)
+verify(unicodedata.numeric(u'9') == 9)
+verify(unicodedata.numeric(u'\u215b') == 0.125)
+verify(unicodedata.numeric(u'\u2468') == 9.0)
+
+verify(unicodedata.decimal(u'A',None) is None)
+verify(unicodedata.decimal(u'9') == 9)
+verify(unicodedata.decimal(u'\u215b',None) is None)
+verify(unicodedata.decimal(u'\u2468',None) is None)
+
+verify(unicodedata.category(u'\uFFFE') == 'Cn')
+verify(unicodedata.category(u'a') == 'Ll')
+verify(unicodedata.category(u'A') == 'Lu')
+
+verify(unicodedata.bidirectional(u'\uFFFE') == '')
+verify(unicodedata.bidirectional(u' ') == 'WS')
+verify(unicodedata.bidirectional(u'A') == 'L')
+
+verify(unicodedata.decomposition(u'\uFFFE') == '')
+verify(unicodedata.decomposition(u'\u00bc') == '<fraction> 0031 2044 0034')
+
+verify(unicodedata.mirrored(u'\uFFFE') == 0)
+verify(unicodedata.mirrored(u'a') == 0)
+verify(unicodedata.mirrored(u'\u2201') == 1)
+
+verify(unicodedata.combining(u'\uFFFE') == 0)
+verify(unicodedata.combining(u'a') == 0)
+verify(unicodedata.combining(u'\u20e1') == 230)
+
+print 'ok'

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

@@ -0,0 +1,105 @@
+from test_support import *
+
+print_test("Sequence Unpacking (test_unpack.py)", 2)
+
+t = (1, 2, 3)
+l = [4, 5, 6]
+
+class Seq:
+    def __getitem__(self, i):
+        if i >= 0 and i < 3: return i
+        raise IndexError
+
+a = -1
+b = -1
+c = -1
+
+# unpack tuple
+print_test("tuple", 3)
+a, b, c = t
+assert a == 1 and b == 2 and c == 3
+
+print_test("list", 3)
+a, b, c = l
+assert a == 4 and b == 5 and c == 6
+
+print_test("inline tuple")
+a, b, c = 7, 8, 9
+assert a == 7 and b == 8 and c == 9
+
+print_test("string")
+a, b, c = 'one'
+assert a == 'o' and b == 'n' and c == 'e'
+
+print_test("generic sequence")
+a, b, c = Seq()
+assert a == 0 and b == 1 and c == 2
+
+# now for some failures
+print_test("failures")
+
+print_test("non-sequence", 4)
+try:
+    a, b, c = 7
+    raise TestFailed
+except TypeError:
+    pass
+
+print_test("wrong size tuple")
+try:
+    a, b = t
+    raise TestFailed
+except ValueError:
+    pass
+    
+print_test("wrong size list")
+try:
+    a, b = l
+    raise TestFailed
+except ValueError:
+    pass
+
+
+print_test("sequence too short")
+try:
+    a, b, c, d = Seq()
+    raise TestFailed
+except ValueError:
+    pass
+
+
+print_test("sequence too long")
+try:
+    a, b = Seq()
+    raise TestFailed
+except ValueError:
+    pass
+
+
+# unpacking a sequence where the test for too long raises a different
+# kind of error
+BozoError = 'BozoError'
+
+class BadSeq:
+    def __getitem__(self, i):
+        if i >= 0 and i < 3:
+            return i
+        elif i == 3:
+            raise BozoError
+        else:
+            raise IndexError
+
+print_test("sequence too long, wrong error")
+try:
+    a, b, c, d, e = BadSeq()
+    raise TestFailed
+except BozoError:
+    pass
+
+
+print_test("sequence too short, wrong error")
+try:
+    a, b, c = BadSeq()
+    raise TestFailed
+except BozoError:
+    pass

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

@@ -0,0 +1,109 @@
+# Minimal test of the quote function
+from test_support import verify, verbose
+import urllib
+
+chars = 'abcdefghijklmnopqrstuvwxyz'\
+        '\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356' \
+        '\357\360\361\362\363\364\365\366\370\371\372\373\374\375\376\377' \
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZ' \
+        '\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317' \
+        '\320\321\322\323\324\325\326\330\331\332\333\334\335\336'
+
+expected = 'abcdefghijklmnopqrstuvwxyz' \
+           '%DF%E0%E1%E2%E3%E4%E5%E6%E7%E8%E9%EA%EB%EC%ED%EE' \
+           '%EF%F0%F1%F2%F3%F4%F5%F6%F8%F9%FA%FB%FC%FD%FE%FF' \
+           'ABCDEFGHIJKLMNOPQRSTUVWXYZ' \
+           '%C0%C1%C2%C3%C4%C5%C6%C7%C8%C9%CA%CB%CC%CD%CE%CF' \
+           '%D0%D1%D2%D3%D4%D5%D6%D8%D9%DA%DB%DC%DD%DE'
+
+test = urllib.quote(chars)
+verify(test == expected, "urllib.quote problem 1")
+test2 = urllib.unquote(expected)
+verify(test2 == chars)
+
+in1 = "abc/def"
+out1_1 = "abc/def"
+out1_2 = "abc%2Fdef"
+
+verify(urllib.quote(in1) == out1_1, "urllib.quote problem 2")
+verify(urllib.quote(in1, '') == out1_2, "urllib.quote problem 3")
+
+in2 = "abc?def"
+out2_1 = "abc%3Fdef"
+out2_2 = "abc?def"
+
+verify(urllib.quote(in2) == out2_1, "urllib.quote problem 4")
+verify(urllib.quote(in2, '?') == out2_2, "urllib.quote problem 5")
+
+
+
+in3 = {"p1":"v1","p2":"v2"}
+in3list = [("p1", "v1"), ("p2","v2")]
+exp3_1 = "p2=v2&p1=v1"
+exp3_2 = "p1=v1&p2=v2"
+# dict input, only string values
+act3 = urllib.urlencode(in3)
+verify(act3==exp3_1 or act3==exp3_2, "urllib.urlencode problem 1 dict")
+# list input, only string values
+act3list = urllib.urlencode(in3list)
+verify(act3list==exp3_2, "urllib.urlencode problem 1 list")
+
+
+in4 = {"p1":["v1","v2"]}
+in4list = [("p1", ["v1","v2"])]
+exp4 = "p1=v1&p1=v2"
+# dict input, list values, doseq==1
+act4 = urllib.urlencode(in4,doseq=1)
+verify(act4==exp4, "urllib.urlencode problem 2 dict")
+# list input, list values, doseq==1
+act4list = urllib.urlencode(in4,doseq=1)
+verify(act4list==exp4, "urllib.urlencode problem 2 list")
+
+
+in5 = in4
+in5list = in4list
+exp5 = "p1=%5B%27v1%27%2C+%27v2%27%5D"
+exp5list = "p1=%5B%27v1%27%2C+%27v2%27%5D"
+# dict input, list variables, doseq=0
+act5 = urllib.urlencode(in5)
+verify(act5==exp5, "urllib.urlencode problem 3 dict")
+# list input, list variables, doseq=0
+act5list = urllib.urlencode(in5list)
+verify(act5list==exp5list, "urllib.urlencode problem 3 list")
+
+
+in6 = {"p1":"v1","p2":"v2"}
+in6list = [("p1", "v1"), ("p2","v2")]
+exp6_1 = "p2=v2&p1=v1"
+exp6_2 = "p1=v1&p2=v2"
+# dict input, only string values, doseq==1
+act6 = urllib.urlencode(in6,doseq=1)
+verify(act6==exp6_1 or act6==exp6_2, "urllib.urlencode problem 4 dict")
+# list input, only string values
+act6list = urllib.urlencode(in6list,doseq=1)
+verify(act6list==exp6_2, "urllib.urlencode problem 4 list")
+
+
+in7 = "p1=v1&p2=v2"
+try:
+    act7 = urllib.urlencode(in7)
+    print "urllib.urlencode problem 5 string"
+except TypeError:
+    pass
+
+
+import UserDict
+in8 = UserDict.UserDict()
+in8["p1"] = "v1"
+in8["p2"] = ["v1", "v2"]
+exp8_1 = "p1=v1&p2=v1&p2=v2"
+exp8_2 = "p2=v1&p2=v2&p1=v1"
+act8 = urllib.urlencode(in8,doseq=1)
+verify(act8==exp8_1 or act8==exp8_2, "urllib.urlencode problem 6 UserDict")
+
+
+import UserString
+in9 = UserString.UserString("")
+exp9 = ""
+act9 = urllib.urlencode(in9,doseq=1)
+verify(act9==exp9, "urllib.urlencode problem 7 UserString")

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

@@ -0,0 +1,31 @@
+from test_support import verify
+import urllib2
+import os
+
+# A couple trivial tests
+
+try:
+    urllib2.urlopen('bogus url')
+except ValueError:
+    pass
+else:
+    verify(0)
+
+# XXX Name hacking to get this to work on Windows.
+fname = os.path.abspath(urllib2.__file__).replace('\\', '/')
+if fname[1:2] == ":":
+    fname = fname[2:]
+# And more hacking to get it to work on MacOS. This assumes
+# urllib.pathname2url works, unfortunately...
+if os.name == 'mac':
+    fname = '/' + fname.replace(':', '/')
+elif os.name == 'riscos':
+    import string
+    fname = os.expand(fname)
+    fname = fname.translate(string.maketrans("/.", "./"))
+
+file_url = "file://%s" % fname
+f = urllib2.urlopen(file_url)
+
+buf = f.read()
+f.close()

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

@@ -0,0 +1,94 @@
+import urlparse
+
+errors = 0
+
+RFC1808_BASE = "http://a/b/c/d;p?q#f"
+
+for url, expected in [('http://www.python.org',
+                       ('http', 'www.python.org', '', '', '', '')),
+                      ('http://www.python.org#abc',
+                       ('http', 'www.python.org', '', '', '', 'abc')),
+                      ('http://www.python.org/#abc',
+                       ('http', 'www.python.org', '/', '', '', 'abc')),
+                      (RFC1808_BASE,
+                       ('http', 'a', '/b/c/d', 'p', 'q', 'f')),
+                      ('file:///tmp/junk.txt',
+                       ('file', '', '/tmp/junk.txt', '', '', '')),
+                      ]:
+    result = urlparse.urlparse(url)
+    print "%-13s = %r" % (url, result)
+    if result != expected:
+        errors += 1
+        print "urlparse(%r)" % url
+        print ("expected %r,\n"
+               "     got %r") % (expected, result)
+    # put it back together and it should be the same
+    result2 = urlparse.urlunparse(result)
+    assert(result2 == url)
+print
+
+def checkJoin(relurl, expected):
+    global errors
+    result = urlparse.urljoin(RFC1808_BASE, relurl)
+    print "%-13s = %r" % (relurl, result)
+    if result != expected:
+        errors += 1
+        print "urljoin(%r, %r)" % (RFC1808_BASE, relurl)
+        print ("expected %r,\n"
+               "     got %r") % (expected, result)
+
+print "urlparse.urljoin() tests"
+print
+
+# "normal" cases from RFC 1808:
+checkJoin('g:h', 'g:h')
+checkJoin('g', 'http://a/b/c/g')
+checkJoin('./g', 'http://a/b/c/g')
+checkJoin('g/', 'http://a/b/c/g/')
+checkJoin('/g', 'http://a/g')
+checkJoin('//g', 'http://g')
+checkJoin('?y', 'http://a/b/c/d;p?y')
+checkJoin('g?y', 'http://a/b/c/g?y')
+checkJoin('g?y/./x', 'http://a/b/c/g?y/./x')
+checkJoin('#s', 'http://a/b/c/d;p?q#s')
+checkJoin('g#s', 'http://a/b/c/g#s')
+checkJoin('g#s/./x', 'http://a/b/c/g#s/./x')
+checkJoin('g?y#s', 'http://a/b/c/g?y#s')
+checkJoin(';x', 'http://a/b/c/d;x')
+checkJoin('g;x', 'http://a/b/c/g;x')
+checkJoin('g;x?y#s', 'http://a/b/c/g;x?y#s')
+checkJoin('.', 'http://a/b/c/')
+checkJoin('./', 'http://a/b/c/')
+checkJoin('..', 'http://a/b/')
+checkJoin('../', 'http://a/b/')
+checkJoin('../g', 'http://a/b/g')
+checkJoin('../..', 'http://a/')
+checkJoin('../../', 'http://a/')
+checkJoin('../../g', 'http://a/g')
+
+# "abnormal" cases from RFC 1808:
+checkJoin('', 'http://a/b/c/d;p?q#f')
+checkJoin('../../../g', 'http://a/../g')
+checkJoin('../../../../g', 'http://a/../../g')
+checkJoin('/./g', 'http://a/./g')
+checkJoin('/../g', 'http://a/../g')
+checkJoin('g.', 'http://a/b/c/g.')
+checkJoin('.g', 'http://a/b/c/.g')
+checkJoin('g..', 'http://a/b/c/g..')
+checkJoin('..g', 'http://a/b/c/..g')
+checkJoin('./../g', 'http://a/b/g')
+checkJoin('./g/.', 'http://a/b/c/g/')
+checkJoin('g/./h', 'http://a/b/c/g/h')
+checkJoin('g/../h', 'http://a/b/c/h')
+
+# RFC 1808 and RFC 1630 disagree on these (according to RFC 1808),
+# so we'll not actually run these tests (which expect 1808 behavior).
+#checkJoin('http:g', 'http:g')
+#checkJoin('http:', 'http:')
+
+print errors, "errors"
+
+# One more test backported from 2.3
+for u in ['Python', './Python']:
+    if urlparse.urlunparse(urlparse.urlparse(u)) != u:
+        print "*** urlparse/urlunparse failure for", `u`

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

@@ -0,0 +1,120 @@
+# Check every path through every method of UserDict
+
+from test_support import verify, verbose
+from UserDict import UserDict, IterableUserDict
+
+d0 = {}
+d1 = {"one": 1}
+d2 = {"one": 1, "two": 2}
+
+# Test constructors
+
+u = UserDict()
+u0 = UserDict(d0)
+u1 = UserDict(d1)
+u2 = IterableUserDict(d2)
+
+uu = UserDict(u)
+uu0 = UserDict(u0)
+uu1 = UserDict(u1)
+uu2 = UserDict(u2)
+
+# Test __repr__
+
+verify(str(u0) == str(d0))
+verify(repr(u1) == repr(d1))
+verify(`u2` == `d2`)
+
+# Test __cmp__ and __len__
+
+all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
+for a in all:
+    for b in all:
+        verify(cmp(a, b) == cmp(len(a), len(b)))
+
+# Test __getitem__
+
+verify(u2["one"] == 1)
+try:
+    u1["two"]
+except KeyError:
+    pass
+else:
+    verify(0, "u1['two'] shouldn't exist")
+
+# Test __setitem__
+
+u3 = UserDict(u2)
+u3["two"] = 2
+u3["three"] = 3
+
+# Test __delitem__
+
+del u3["three"]
+try:
+    del u3["three"]
+except KeyError:
+    pass
+else:
+    verify(0, "u3['three'] shouldn't exist")
+
+# Test clear
+
+u3.clear()
+verify(u3 == {})
+
+# Test copy()
+
+u2a = u2.copy()
+verify(u2a == u2)
+
+class MyUserDict(UserDict):
+    def display(self): print self
+
+m2 = MyUserDict(u2)
+m2a = m2.copy()
+verify(m2a == m2)
+
+# SF bug #476616 -- copy() of UserDict subclass shared data
+m2['foo'] = 'bar'
+verify(m2a != m2)
+
+# Test keys, items, values
+
+verify(u2.keys() == d2.keys())
+verify(u2.items() == d2.items())
+verify(u2.values() == d2.values())
+
+# Test has_key and "in".
+
+for i in u2.keys():
+    verify(u2.has_key(i) == 1)
+    verify((i in u2) == 1)
+    verify(u1.has_key(i) == d1.has_key(i))
+    verify((i in u1) == (i in d1))
+    verify(u0.has_key(i) == d0.has_key(i))
+    verify((i in u0) == (i in d0))
+
+# Test update
+
+t = UserDict()
+t.update(u2)
+verify(t == u2)
+
+# Test get
+
+for i in u2.keys():
+    verify(u2.get(i) == u2[i])
+    verify(u1.get(i) == d1.get(i))
+    verify(u0.get(i) == d0.get(i))
+
+# Test "in" iteration.
+for i in xrange(20):
+    u2[i] = str(i)
+ikeys = []
+for k in u2:
+    ikeys.append(k)
+ikeys.sort()
+keys = u2.keys()
+keys.sort()
+verify(ikeys == keys)