rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,211 @@
+import rfc822
+import sys
+import test_support
+import unittest
+
+try:
+    from cStringIO import StringIO
+except ImportError:
+    from StringIO import StringIO
+
+
+class MessageTestCase(unittest.TestCase):
+    def create_message(self, msg):
+        return rfc822.Message(StringIO(msg))
+
+    def test_get(self):
+        msg = self.create_message(
+            'To: "last, first" <userid@foo.net>\n\ntest\n')
+        self.assert_(msg.get("to") == '"last, first" <userid@foo.net>')
+        self.assert_(msg.get("TO") == '"last, first" <userid@foo.net>')
+        self.assert_(msg.get("No-Such-Header") is None)
+        self.assert_(msg.get("No-Such-Header", "No-Such-Value")
+                     == "No-Such-Value")
+
+    def test_setdefault(self):
+        msg = self.create_message(
+            'To: "last, first" <userid@foo.net>\n\ntest\n')
+        self.assert_(not msg.has_key("New-Header"))
+        self.assert_(msg.setdefault("New-Header", "New-Value") == "New-Value")
+        self.assert_(msg.setdefault("New-Header", "Different-Value")
+                     == "New-Value")
+        self.assert_(msg["new-header"] == "New-Value")
+
+        self.assert_(msg.setdefault("Another-Header") == "")
+        self.assert_(msg["another-header"] == "")
+
+    def check(self, msg, results):
+        """Check addresses and the date."""
+        m = self.create_message(msg)
+        i = 0
+        for n, a in m.getaddrlist('to') + m.getaddrlist('cc'):
+            try:
+                mn, ma = results[i][0], results[i][1]
+            except IndexError:
+                print 'extra parsed address:', repr(n), repr(a)
+                continue
+            i = i + 1
+            if mn == n and ma == a:
+                pass
+            else:
+                print 'not found:', repr(n), repr(a)
+
+        out = m.getdate('date')
+        if out:
+            self.assertEqual(out,
+                             (1999, 1, 13, 23, 57, 35, 0, 0, 0),
+                             "date conversion failed")
+
+
+    # Note: all test cases must have the same date (in various formats),
+    # or no date!
+
+    def test_basic(self):
+        self.check(
+            'Date:    Wed, 13 Jan 1999 23:57:35 -0500\n'
+            'From:    Guido van Rossum <guido@CNRI.Reston.VA.US>\n'
+            'To:      "Guido van\n'
+            '\t : Rossum" <guido@python.org>\n'
+            'Subject: test2\n'
+            '\n'
+            'test2\n',
+            [('Guido van\n\t : Rossum', 'guido@python.org')])
+
+        self.check(
+            'From: Barry <bwarsaw@python.org\n'
+            'To: guido@python.org (Guido: the Barbarian)\n'
+            'Subject: nonsense\n'
+            'Date: Wednesday, January 13 1999 23:57:35 -0500\n'
+            '\n'
+            'test',
+            [('Guido: the Barbarian', 'guido@python.org')])
+
+        self.check(
+            'From: Barry <bwarsaw@python.org\n'
+            'To: guido@python.org (Guido: the Barbarian)\n'
+            'Cc: "Guido: the Madman" <guido@python.org>\n'
+            'Date:  13-Jan-1999 23:57:35 EST\n'
+            '\n'
+            'test',
+            [('Guido: the Barbarian', 'guido@python.org'),
+             ('Guido: the Madman', 'guido@python.org')
+             ])
+
+        self.check(
+            'To: "The monster with\n'
+            '     the very long name: Guido" <guido@python.org>\n'
+            'Date:    Wed, 13 Jan 1999 23:57:35 -0500\n'
+            '\n'
+            'test',
+            [('The monster with\n     the very long name: Guido',
+              'guido@python.org')])
+
+        self.check(
+            'To: "Amit J. Patel" <amitp@Theory.Stanford.EDU>\n'
+            'CC: Mike Fletcher <mfletch@vrtelecom.com>,\n'
+            '        "\'string-sig@python.org\'" <string-sig@python.org>\n'
+            'Cc: fooz@bat.com, bart@toof.com\n'
+            'Cc: goit@lip.com\n'
+            'Date:    Wed, 13 Jan 1999 23:57:35 -0500\n'
+            '\n'
+            'test',
+            [('Amit J. Patel', 'amitp@Theory.Stanford.EDU'),
+             ('Mike Fletcher', 'mfletch@vrtelecom.com'),
+             ("'string-sig@python.org'", 'string-sig@python.org'),
+             ('', 'fooz@bat.com'),
+             ('', 'bart@toof.com'),
+             ('', 'goit@lip.com'),
+             ])
+
+        self.check(
+            'To: Some One <someone@dom.ain>\n'
+            'From: Anudder Persin <subuddy.else@dom.ain>\n'
+            'Date:\n'
+            '\n'
+            'test',
+            [('Some One', 'someone@dom.ain')])
+
+        self.check(
+            'To: person@dom.ain (User J. Person)\n\n',
+            [('User J. Person', 'person@dom.ain')])
+
+    def test_twisted(self):
+        # This one is just twisted.  I don't know what the proper
+        # result should be, but it shouldn't be to infloop, which is
+        # what used to happen!
+        self.check(
+            'To: <[smtp:dd47@mail.xxx.edu]_at_hmhq@hdq-mdm1-imgout.companay.com>\n'
+            'Date:    Wed, 13 Jan 1999 23:57:35 -0500\n'
+            '\n'
+            'test',
+            [('', ''),
+             ('', 'dd47@mail.xxx.edu'),
+             ('', '_at_hmhq@hdq-mdm1-imgout.companay.com'),
+             ])
+
+    def test_commas_in_full_name(self):
+        # This exercises the old commas-in-a-full-name bug, which
+        # should be doing the right thing in recent versions of the
+        # module.
+        self.check(
+            'To: "last, first" <userid@foo.net>\n'
+            '\n'
+            'test',
+            [('last, first', 'userid@foo.net')])
+
+    def test_quoted_name(self):
+        self.check(
+            'To: (Comment stuff) "Quoted name"@somewhere.com\n'
+            '\n'
+            'test',
+            [('Comment stuff', '"Quoted name"@somewhere.com')])
+
+    def test_bogus_to_header(self):
+        self.check(
+            'To: :\n'
+            'Cc: goit@lip.com\n'
+            'Date:    Wed, 13 Jan 1999 23:57:35 -0500\n'
+            '\n'
+            'test',
+            [('', 'goit@lip.com')])
+
+    def test_addr_ipquad(self):
+        self.check(
+            'To: guido@[132.151.1.21]\n'
+            '\n'
+            'foo',
+            [('', 'guido@[132.151.1.21]')])
+
+    def test_rfc2822_phrases(self):
+        # RFC 2822 (the update to RFC 822) specifies that dots in phrases are
+        # obsolete syntax, which conforming programs MUST recognize but NEVER
+        # generate (see $4.1 Miscellaneous obsolete tokens).  This is a
+        # departure from RFC 822 which did not allow dots in non-quoted
+        # phrases.
+        self.check('To: User J. Person <person@dom.ain>\n\n',
+                   [('User J. Person', 'person@dom.ain')])
+
+    # This takes to long to add to the test suite
+##    def test_an_excrutiatingly_long_address_field(self):
+##        OBSCENELY_LONG_HEADER_MULTIPLIER = 10000
+##        oneaddr = ('Person' * 10) + '@' + ('.'.join(['dom']*10)) + '.com'
+##        addr = ', '.join([oneaddr] * OBSCENELY_LONG_HEADER_MULTIPLIER)
+##        lst = rfc822.AddrlistClass(addr).getaddrlist()
+##        self.assertEqual(len(lst), OBSCENELY_LONG_HEADER_MULTIPLIER)
+
+
+    def test_parseaddr(self):
+        eq = self.assertEqual
+        eq(rfc822.parseaddr('<>'), ('', ''))
+        eq(rfc822.parseaddr('aperson@dom.ain'), ('', 'aperson@dom.ain'))
+        eq(rfc822.parseaddr('bperson@dom.ain (Bea A. Person)'),
+           ('Bea A. Person', 'bperson@dom.ain'))
+        eq(rfc822.parseaddr('Cynthia Person <cperson@dom.ain>'),
+           ('Cynthia Person', 'cperson@dom.ain'))
+
+def test_main():
+    test_support.run_unittest(MessageTestCase)
+
+
+if __name__ == "__main__":
+    test_main()

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

@@ -0,0 +1,63 @@
+# Testing rgbimg module
+
+import rgbimg, os, uu
+
+from test_support import verbose, unlink, findfile
+
+class error(Exception):
+    pass
+
+print 'RGBimg test suite:'
+
+def testimg(rgb_file, raw_file):
+    rgb_file = findfile(rgb_file)
+    raw_file = findfile(raw_file)
+    width, height = rgbimg.sizeofimage(rgb_file)
+    rgb = rgbimg.longimagedata(rgb_file)
+    if len(rgb) != width * height * 4:
+        raise error, 'bad image length'
+    raw = open(raw_file, 'rb').read()
+    if rgb != raw:
+        raise error, \
+              'images don\'t match for '+rgb_file+' and '+raw_file
+    for depth in [1, 3, 4]:
+        rgbimg.longstoimage(rgb, width, height, depth, '@.rgb')
+    os.unlink('@.rgb')
+
+table = [
+    ('testrgb'+os.extsep+'uue', 'test'+os.extsep+'rgb'),
+    ('testimg'+os.extsep+'uue', 'test'+os.extsep+'rawimg'),
+    ('testimgr'+os.extsep+'uue', 'test'+os.extsep+'rawimg'+os.extsep+'rev'),
+    ]
+for source, target in table:
+    source = findfile(source)
+    target = findfile(target)
+    if verbose:
+        print "uudecoding", source, "->", target, "..."
+    uu.decode(source, target)
+
+if verbose:
+    print "testing..."
+
+ttob = rgbimg.ttob(0)
+if ttob != 0:
+    raise error, 'ttob should start out as zero'
+
+testimg('test'+os.extsep+'rgb', 'test'+os.extsep+'rawimg')
+
+ttob = rgbimg.ttob(1)
+if ttob != 0:
+    raise error, 'ttob should be zero'
+
+testimg('test'+os.extsep+'rgb', 'test'+os.extsep+'rawimg'+os.extsep+'rev')
+
+ttob = rgbimg.ttob(0)
+if ttob != 1:
+    raise error, 'ttob should be one'
+
+ttob = rgbimg.ttob(0)
+if ttob != 0:
+    raise error, 'ttob should be zero'
+
+for source, target in table:
+    unlink(findfile(target))

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

@@ -0,0 +1,261 @@
+# Tests for rich comparisons
+
+from test_support import TestFailed, verify, verbose
+
+class Number:
+
+    def __init__(self, x):
+        self.x = x
+
+    def __lt__(self, other):
+        return self.x < other
+
+    def __le__(self, other):
+        return self.x <= other
+
+    def __eq__(self, other):
+        return self.x == other
+
+    def __ne__(self, other):
+        return self.x != other
+
+    def __gt__(self, other):
+        return self.x > other
+
+    def __ge__(self, other):
+        return self.x >= other
+
+    def __cmp__(self, other):
+        raise TestFailed, "Number.__cmp__() should not be called"
+
+    def __repr__(self):
+        return "Number(%s)" % repr(self.x)
+
+class Vector:
+
+    def __init__(self, data):
+        self.data = data
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, i):
+        return self.data[i]
+
+    def __setitem__(self, i, v):
+        self.data[i] = v
+
+    def __hash__(self):
+        raise TypeError, "Vectors cannot be hashed"
+
+    def __nonzero__(self):
+        raise TypeError, "Vectors cannot be used in Boolean contexts"
+
+    def __cmp__(self, other):
+        raise TestFailed, "Vector.__cmp__() should not be called"
+
+    def __repr__(self):
+        return "Vector(%s)" % repr(self.data)
+
+    def __lt__(self, other):
+        return Vector([a < b for a, b in zip(self.data, self.__cast(other))])
+
+    def __le__(self, other):
+        return Vector([a <= b for a, b in zip(self.data, self.__cast(other))])
+
+    def __eq__(self, other):
+        return Vector([a == b for a, b in zip(self.data, self.__cast(other))])
+
+    def __ne__(self, other):
+        return Vector([a != b for a, b in zip(self.data, self.__cast(other))])
+
+    def __gt__(self, other):
+        return Vector([a > b for a, b in zip(self.data, self.__cast(other))])
+
+    def __ge__(self, other):
+        return Vector([a >= b for a, b in zip(self.data, self.__cast(other))])
+
+    def __cast(self, other):
+        if isinstance(other, Vector):
+            other = other.data
+        if len(self.data) != len(other):
+            raise ValueError, "Cannot compare vectors of different length"
+        return other
+
+operators = "<", "<=", "==", "!=", ">", ">="
+opmap = {}
+for op in operators:
+    opmap[op] = eval("lambda a, b: a %s b" % op)
+
+def testvector():
+    a = Vector(range(2))
+    b = Vector(range(3))
+    for op in operators:
+        try:
+            opmap[op](a, b)
+        except ValueError:
+            pass
+        else:
+            raise TestFailed, "a %s b for different length should fail" % op
+    a = Vector(range(5))
+    b = Vector(5 * [2])
+    for op in operators:
+        print "%23s %-2s %-23s -> %s" % (a, op, b, opmap[op](a, b))
+        print "%23s %-2s %-23s -> %s" % (a, op, b.data, opmap[op](a, b.data))
+        print "%23s %-2s %-23s -> %s" % (a.data, op, b, opmap[op](a.data, b))
+        try:
+            if opmap[op](a, b):
+                raise TestFailed, "a %s b shouldn't be true" % op
+            else:
+                raise TestFailed, "a %s b shouldn't be false" % op
+        except TypeError:
+            pass
+
+def testop(a, b, op):
+    try:
+        ax = a.x
+    except AttributeError:
+        ax = a
+    try:
+        bx = b.x
+    except AttributeError:
+        bx = b
+    opfunc = opmap[op]
+    realoutcome = opfunc(ax, bx)
+    testoutcome = opfunc(a, b)
+    if realoutcome != testoutcome:
+        print "Error for", a, op, b, ": expected", realoutcome,
+        print "but got", testoutcome
+##    else:
+##        print a, op, b, "-->", testoutcome # and "true" or "false"
+
+def testit(a, b):
+    testop(a, b, "<")
+    testop(a, b, "<=")
+    testop(a, b, "==")
+    testop(a, b, "!=")
+    testop(a, b, ">")
+    testop(a, b, ">=")
+
+def basic():
+    for a in range(3):
+        for b in range(3):
+            testit(Number(a), Number(b))
+            testit(a, Number(b))
+            testit(Number(a), b)
+
+def tabulate(c1=Number, c2=Number):
+    for op in operators:
+        opfunc = opmap[op]
+        print
+        print "operator:", op
+        print
+        print "%9s" % "",
+        for b in range(3):
+            b = c2(b)
+            print "| %9s" % b,
+        print "|"
+        print '----------+-' * 4
+        for a in range(3):
+            a = c1(a)
+            print "%9s" % a,
+            for b in range(3):
+                b = c2(b)
+                print "| %9s" % opfunc(a, b),
+            print "|"
+        print '----------+-' * 4
+    print
+    print '*' * 50
+
+def misbehavin():
+    class Misb:
+        def __lt__(self, other): return 0
+        def __gt__(self, other): return 0
+        def __eq__(self, other): return 0
+        def __le__(self, other): raise TestFailed, "This shouldn't happen"
+        def __ge__(self, other): raise TestFailed, "This shouldn't happen"
+        def __ne__(self, other): raise TestFailed, "This shouldn't happen"
+        def __cmp__(self, other): raise RuntimeError, "expected"
+    a = Misb()
+    b = Misb()
+    verify((a<b) == 0)
+    verify((a==b) == 0)
+    verify((a>b) == 0)
+    try:
+        print cmp(a, b)
+    except RuntimeError:
+        pass
+    else:
+        raise TestFailed, "cmp(Misb(), Misb()) didn't raise RuntimeError"
+
+def recursion():
+    from UserList import UserList
+    a = UserList(); a.append(a)
+    b = UserList(); b.append(b)
+    def check(s, a=a, b=b):
+        if verbose:
+            print "check", s
+        try:
+            if not eval(s):
+                raise TestFailed, s + " was false but expected to be true"
+        except RuntimeError, msg:
+            raise TestFailed, str(msg)
+    if verbose:
+        print "recursion tests: a=%s, b=%s" % (a, b)
+    check('a==b')
+    check('not a!=b')
+    a.append(1)
+    if verbose:
+        print "recursion tests: a=%s, b=%s" % (a, b)
+    check('a!=b')
+    check('not a==b')
+    b.append(0)
+    if verbose:
+        print "recursion tests: a=%s, b=%s" % (a, b)
+    check('a!=b')
+    check('not a==b')
+    a[1] = -1
+    if verbose:
+        print "recursion tests: a=%s, b=%s" % (a, b)
+    check('a!=b')
+    check('not a==b')
+    if verbose: print "recursion tests ok"
+
+def dicts():
+    # Verify that __eq__ and __ne__ work for dicts even if the keys and
+    # values don't support anything other than __eq__ and __ne__.  Complex
+    # numbers are a fine example of that.
+    import random
+    imag1a = {}
+    for i in range(50):
+        imag1a[random.randrange(100)*1j] = random.randrange(100)*1j
+    items = imag1a.items()
+    random.shuffle(items)
+    imag1b = {}
+    for k, v in items:
+        imag1b[k] = v
+    imag2 = imag1b.copy()
+    imag2[k] = v + 1.0
+    verify(imag1a == imag1a, "imag1a == imag1a should have worked")
+    verify(imag1a == imag1b, "imag1a == imag1b should have worked")
+    verify(imag2 == imag2, "imag2 == imag2 should have worked")
+    verify(imag1a != imag2, "imag1a != imag2 should have worked")
+    for op in "<", "<=", ">", ">=":
+        try:
+            eval("imag1a %s imag2" % op)
+        except TypeError:
+            pass
+        else:
+            raise TestFailed("expected TypeError from imag1a %s imag2" % op)
+
+def main():
+    basic()
+    tabulate()
+    tabulate(c1=int)
+    tabulate(c2=int)
+    testvector()
+    misbehavin()
+    recursion()
+    dicts()
+
+main()

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

@@ -0,0 +1,28 @@
+import rotor
+
+r = rotor.newrotor("you'll never guess this")
+r = rotor.newrotor("you'll never guess this", 12)
+
+A = 'spam and eggs'
+B = 'cheese shop'
+
+a = r.encrypt(A)
+print `a`
+b = r.encryptmore(B)
+print `b`
+
+A1 = r.decrypt(a)
+print A1
+if A1 != A:
+    print 'decrypt failed'
+
+B1 = r.decryptmore(b)
+print B1
+if B1 != B:
+    print 'decryptmore failed'
+
+try:
+    r.setkey()
+except TypeError:
+    pass
+r.setkey('you guessed it!')