rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,438 @@
+# CAU: Adaptation of the cpython 2.2 test_array.py for jython 2.2
+#      Formerly test_jarray.py, now test_array.py so that this 
+#      test completely supercedes the cpthyhon test.  It would
+#      be better to simply complement the cpython test, but that
+#      test bombs out too early due to basic incompatibilities.
+#
+#      The jarray module is being phased out, with all functionality
+#      now available in the array module.
+
+from test_support import *
+from array import array, zeros
+import sys
+from java.lang import String
+from java.lang.reflect import Array
+from java.util import Arrays
+
+print_test('array module (test_array.py)', 1)
+
+def main():
+   
+    test_jarray() # while it's still supported
+   
+    test_java_compat()
+    test_java_object_arrays()
+
+    testtype('c', 'c')
+    for type in (['b', 'h', 'i', 'l', 'f', 'd']):
+        testtype(type, 1)
+      
+    #test a mix of known success and failure cases
+    init_tests()
+    extend_tests()
+    fromlist_tests()
+
+    unlink(TESTFN)
+
+def test_jarray(): # until it is fully formally removed
+
+   # While jarray is still being phased out, just flex the initilaizers.
+   # The rest of the test for array will catch all the big problems.
+   import jarray
+   jarray.array(range(5), 'i')
+   jarray.array([String("a"), String("b"), String("c")], String)
+   jarray.zeros(5, 'i')
+   jarray.zeros(5, String)
+
+
+def test_java_object_arrays():
+   jStringArr = array(String, [String("a"), String("b"), String("c")])
+   verify(Arrays.equals(jStringArr.typecode, str(String)), 
+         "String array typecode of wrong type, expected %s, found %s" % 
+         (jStringArr.typecode, str(String)))
+   verify(zeros(String, 5) == Array.newInstance(String, 5))
+
+   import java # require for eval to work
+   if jStringArr != eval(str(jStringArr)):
+      raise TestFailed, "eval(str(%s)) <> %s" % (jStringArr,)*2
+   
+
+def test_java_compat():
+   print_test('array', 2)
+   from java import awt
+   hsb = awt.Color.RGBtoHSB(0,255,255, None)
+   #print hsb
+   verify(hsb == array('f', [0.5,1,1]), 
+         "output hsb float array does not correspond to input rgb values")
+   
+   rgb = apply(awt.Color.HSBtoRGB, tuple(hsb))
+   #print hex(rgb)
+   verify(rgb == 0xff00ffff, "output rgb bytes don't match input hsb floats")
+   
+   print_test('zeros', 2)
+   hsb1 = zeros('f', 3)
+   awt.Color.RGBtoHSB(0,255,255, hsb1)
+   #print hsb, hsb1
+   verify(hsb == hsb1, "hsb float arrays were not equal")
+
+def testoverflow(type, lowerLimit, upperLimit):
+        # should not overflow assigning lower limit
+    if verbose:
+        print "test overflow: array(%s, [%s])" % (lowerLimit, type)
+    try:
+        a = array(type, [lowerLimit])
+    except:
+        raise TestFailed("array(%s) overflowed assigning %s" %
+                (lowerLimit, type))
+    # should overflow assigning less than lower limit
+    if verbose:
+        print "test overflow: array(%s, [%s])" % (lowerLimit-1, type)
+    try:
+        a = array(type, [lowerLimit-1])
+        raise TestFailed, "array(%s) did not overflow assigning %s" %\
+                (lowerLimit-1, type)
+    except OverflowError:
+        pass
+    # should not overflow assigning upper limit
+    if verbose:
+        print "test verflow: array(%s, [%s])" % (upperLimit, type)
+    try:
+        a = array(type, [upperLimit])
+    except:
+        raise TestFailed, "array(%s) overflowed assigning %s" %\
+                (upperLimit, type)
+    # should overflow assigning more than upper limit
+    if verbose:
+        print "test overflow: array(%s, [%s])" % (upperLimit+1, type)
+    try:
+        a = array(type, [upperLimit+1])
+        raise TestFailed, "array(%s) did not overflow assigning %s" %\
+                (upperLimit+1, type)
+    except OverflowError:
+        pass
+
+
+def testtype(type, example):
+
+    if verbose:
+       print "testing type ", type
+
+    a = array(type)
+    a.append(example)
+    if verbose:
+        print 40*'*'
+        print 'array after append: ', a
+    a.typecode
+    a.itemsize
+    
+    if a <> eval(str(a)):
+       raise TestFailed, "eval(str(%s)) <> %s" % (a,a)
+
+    if a.typecode in ('i', 'b', 'h', 'l'):
+        a.byteswap()
+
+    if a.typecode == 'c':
+        f = open(TESTFN, "w")
+        f.write("The quick brown fox jumps over the lazy dog.\n")
+        f.close()
+        f = open(TESTFN, 'r')
+        a.fromfile(f, 10)
+        f.close()
+        if verbose:
+            print 'char array with 10 bytes of TESTFN appended: ', a
+        a.fromlist(['a', 'b', 'c'])
+        if verbose:
+            print 'char array with list appended: ', a
+
+    a.insert(0, example)
+    if verbose:
+        print 'array of %s after inserting another:' % a.typecode, a
+    f = open(TESTFN, 'w')
+    a.tofile(f)
+    f.close()
+
+    # This block is just to verify that the operations don't blow up.
+    a.tolist()
+    a.tostring()
+    repr(a)
+    str(a)
+
+    if verbose:
+        print 'array of %s converted to a list: ' % a.typecode, a.tolist()
+    if verbose:
+        print 'array of %s converted to a string: ' \
+               % a.typecode, a.tostring()
+
+    if type == 'c':
+        a = array(type, "abcde")
+        a[:-1] = a
+        if a != array(type, "abcdee"):
+            raise TestFailed, "array(%s) self-slice-assign (head)" % type
+        a = array(type, "abcde")
+        a[1:] = a
+        if a != array(type, "aabcde"):
+            raise TestFailed, "array(%s) self-slice-assign (tail)" % type
+        a = array(type, "abcde")
+        a[1:-1] = a
+        if a != array(type, "aabcdee"):
+            raise TestFailed, "array(%s) self-slice-assign (cntr)" % type
+        if a.index("e") != 5:
+            raise TestFailed, "array(%s) index-test" % type
+        if a.count("a") != 2:
+            raise TestFailed, "array(%s) count-test" % type
+        a.remove("e")
+        if a != array(type, "aabcde"):
+            raise TestFailed, "array(%s) remove-test" % type
+        if a.pop(0) != "a":
+            raise TestFailed, "array(%s) pop-test" % type
+        if a.pop(1) != "b":
+            raise TestFailed, "array(%s) pop-test" % type
+        a.extend(array(type, "xyz"))
+        if a != array(type, "acdexyz"):
+            raise TestFailed, "array(%s) extend-test" % type
+        a.pop()
+        a.pop()
+        a.pop()
+        x = a.pop()
+        if x != 'e':
+            raise TestFailed, "array(%s) pop-test" % type
+        if a != array(type, "acd"):
+            raise TestFailed, "array(%s) pop-test" % type
+        a.reverse()
+        if a != array(type, "dca"):
+            raise TestFailed, "array(%s) reverse-test" % type
+    else:
+        a = array(type, [1, 2, 3, 4, 5])
+        a[:-1] = a
+        if a != array(type, [1, 2, 3, 4, 5, 5]):
+            raise TestFailed, "array(%s) self-slice-assign (head)" % type
+        a = array(type, [1, 2, 3, 4, 5])
+        a[1:] = a
+        if a != array(type, [1, 1, 2, 3, 4, 5]):
+            raise TestFailed, "array(%s) self-slice-assign (tail)" % type
+        a = array(type, [1, 2, 3, 4, 5])
+        a[1:-1] = a
+        if a != array(type, [1, 1, 2, 3, 4, 5, 5]):
+            raise TestFailed, "array(%s) self-slice-assign (cntr)" % type
+        if a.index(5) != 5:
+            raise TestFailed, "array(%s) index-test" % type
+        if a.count(1) != 2:
+            raise TestFailed, "array(%s) count-test" % type
+        a.remove(5)
+        if a != array(type, [1, 1, 2, 3, 4, 5]):
+            raise TestFailed, "array(%s) remove-test" % type
+        if a.pop(0) != 1:
+            raise TestFailed, "array(%s) pop-test" % type
+        if a.pop(1) != 2:
+            raise TestFailed, "array(%s) pop-test" % type
+        a.extend(array(type, [7, 8, 9]))
+        if a != array(type, [1, 3, 4, 5, 7, 8, 9]):
+            raise TestFailed, "array(%s) extend-test" % type
+        a.pop()
+        a.pop()
+        a.pop()
+        x = a.pop()
+        if x != 5:
+            raise TestFailed, "array(%s) pop-test" % type
+        if a != array(type, [1, 3, 4]):
+            raise TestFailed, "array(%s) pop-test" % type
+        a.reverse()
+        if a != array(type, [4, 3, 1]):
+            raise TestFailed, "array(%s) reverse-test" % type
+
+    # test that overflow exceptions are raised as expected for assignment
+    # to array of specific integral types
+    from math import pow
+
+    #check using long inputs
+    if type in ('b', 'h', 'i', 'l'):
+        a = array(type)
+        signedLowerLimit = -1 * long(pow(2, a.itemsize * 8 - 1))
+        signedUpperLimit = long(pow(2, a.itemsize * 8 - 1)) - 1L
+        unsignedLowerLimit = 0
+        unsignedUpperLimit = long(pow(2, a.itemsize * 8)) - 1L
+        testoverflow(type, signedLowerLimit, signedUpperLimit)
+
+    #check using integer inputs - int cannot hold MAXINT+1 nor MININT-1
+    # so only valid test types are byte and short for this test
+    if type in ('b', 'h'):
+        a = array(type)
+        signedLowerLimit =   -1 * int(pow(2, a.itemsize * 8 - 1))
+        signedUpperLimit =   int(pow(2, a.itemsize * 8 - 1)) - 1
+        unsignedLowerLimit = 0
+        unsignedUpperLimit = int(pow(2, a.itemsize * 8)) - 1
+        testoverflow(type, signedLowerLimit, signedUpperLimit)
+
+
+def init_tests():
+    test = array('c', ['t','e','s','t'])
+    verify(init_test( "test: String initialisation", "test", 'c') == test, 
+          "string initialisation failed")
+
+    test = array('i', [41,42,43,44])
+    s = test.tostring();
+    verify(init_test( "test: String2 initialisation", s, 'i') == test, 
+          "string 2 initialisation failed")
+
+    init_test( "test: List initialisation", [1,2,3,4], 'i')
+
+    init_test( "test: Tuple initialisation", (1,2,3,4), 'i')
+
+    test = array('i', [1,2,3,4])
+    verify(init_test( "test: array initialisation", test, 'i') == test, 
+          "array init failed")
+
+    try:
+        init_test('test: "broken" list initialisation', [1,2,3,4, 'fred'], 'i')
+        raise TestFailed, '"broken" list initialisation'
+    except TypeError:
+        pass
+
+    test = array('i', [1,2,3,4])
+    try:
+        init_test('test: "broken" PyArray initialisation', test, 'd')
+        raise TestFailed, '"broken" PyArray initialisation'
+    except TypeError:
+        pass
+
+    f = open(TESTFN, "w")
+    #f.write("\x00\x00\x00\x01")
+    f.write("test message\nline2\nline3");
+    f.close();
+
+    f = open(TESTFN, "r")
+    try:
+        init_test( "test: Invalid initialisation object (file)", f, 'i')
+        raise TestFailed, "Invalid initialisation object (file)"
+    except TypeError:
+        pass
+    f.close()
+
+    try:
+        init_test( "test: Invalid initialisation object (module)", sys, 'i')
+        raise TestFailed, "Invalid initialisation object (module)"
+    except TypeError:
+        pass
+        
+def extend_tests():
+    test = array('c', 'testextend')
+    verify(extend_test("test: String extend", "test", "extend", 'c') == test, 
+          "String extend failed")
+
+    test = array('i', [1,2,3,4,51,52,53,54]);
+    verify( extend_test("test: List extend", [1,2,3,4], [51,52,53,54], 'i') == test, 
+          "List extend failed")
+
+    test = array('i', (1,2,3,4,51,52,53,54));
+    verify( extend_test("test: Tuple extend", (1,2,3,4), (51,52,53,54), 'i') == test, 
+          "Tuple extend failed")
+
+    try:
+        extend_test('test: "broken" list extend', [1,2,3,4], [51,52,53,"fred"], 'i')
+        raise TestFailed, 'test: "broken" list extend'
+    except TypeError:
+        pass
+
+    a = array('d', [123.45, 567.89])
+    test = array('i', [1,2,3,4])
+    try:
+        assert extend_test("test: Array type mismatch", [1,2,3,4], a, 'i') == test, \
+              "Array mismatch test failed"
+        raise TestFailed, "test: Array type mismatch"
+    except TypeError:
+        pass
+    del a
+
+    f = open(TESTFN, "r")
+    try:
+        extend_test("test: incorrect type extend (file)", [1,2,3,4], f, 'i')
+        raise TestFailed, "test: incorrect type extend (file)"
+    except TypeError:
+        pass
+    f.close()
+
+    try:
+        extend_test("test: incorrect type extend (module)", (1,2,3,4), sys, 'i')
+        raise TestFailed, "test: incorrect type extend (module)"
+    except TypeError:
+        pass
+
+    try:
+        extend_test("test: incorrect type extend (integer)", [], 456, 'i')
+        raise TestFailed, "test: incorrect type extend (integer)"
+    except TypeError:
+        pass
+
+def fromlist_tests():
+    test = array('c', ['t','e','s','t','h','e','l','l','o'])
+    verify(fromlist_test("test: String fromlist", "test", ['h','e','l','l','o'], 'c') == test, 
+          "String fromlist failed")
+
+    test = array('i', [1,2,3,4,51,52,53,54])
+    verify(fromlist_test("test: integer fromlist", [1,2,3,4], [51,52,53,54], 'i') == test, 
+          "integer fromlist failed")
+
+    try:
+        fromlist_test('test: "broken" fromlist (integer)', [1,2,3,4], [51,52,53,"fred"], 'i')
+        raise TestFailed, 'test: "broken" fromlist (integer)'
+    except TypeError:
+        pass
+
+    try:
+        fromlist_test("test: invalid fromlist (tuple)", [1,2,3,4], (51,52,53,54), 'i')
+        raise TestFailed, "test: invalid fromlist (tuple)"
+    except TypeError:
+        pass
+
+def init_test(name, init, typecode):
+    if verbose:
+        print 40*'*'
+        print name, "- type:", typecode
+        print "initialiser:", init
+    
+    a = array(typecode, init)
+    
+    if verbose:
+        print a
+        
+    return a
+
+def extend_test(name, init, extend, typecode):
+    if verbose:
+        print 40*'*'
+        print name, "- type:", typecode
+
+    a = array(typecode, init)
+        
+    if verbose:
+        print "initial:", a
+        print "extended by:", extend
+
+    a.extend(extend)
+
+    #if no exceptions then
+    if verbose:
+        print "final:", a
+        
+    return a
+
+def fromlist_test(name, init, listdata, typecode):
+    if verbose:
+        print 40*'*'
+        print name   , "- type:", typecode
+
+    a = array(typecode, init)
+    
+    if verbose:
+        print "initial:", a
+        print "fromlist source:", listdata
+
+    a.fromlist(listdata)
+
+    #if no exceptions then
+    if verbose:
+        print "final:", a
+
+    return a
+
+main()

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

@@ -0,0 +1,58 @@
+# test asynchat -- requires threading
+
+import thread # If this fails, we can't test this module
+import asyncore, asynchat, socket, threading, time
+
+HOST = "127.0.0.1"
+PORT = 54321
+
+class echo_server(threading.Thread):
+
+    def run(self):
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((HOST, PORT))
+        sock.listen(1)
+        conn, client = sock.accept()
+        buffer = ""
+        while "\n" not in buffer:
+            data = conn.recv(10)
+            if not data:
+                break
+            buffer = buffer + data
+        while buffer:
+            n = conn.send(buffer)
+            buffer = buffer[n:]
+        conn.close()
+        sock.close()
+
+class echo_client(asynchat.async_chat):
+
+    def __init__(self):
+        asynchat.async_chat.__init__(self)
+        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.connect((HOST, PORT))
+        self.set_terminator("\n")
+        self.buffer = ""
+
+    def handle_connect(self):
+        print "Connected"
+
+    def collect_incoming_data(self, data):
+        self.buffer = self.buffer + data
+
+    def found_terminator(self):
+        print "Received:", `self.buffer`
+        self.buffer = ""
+        self.close()
+
+def main():
+    s = echo_server()
+    s.start()
+    time.sleep(1) # Give server time to initialize
+    c = echo_client()
+    c.push("hello ")
+    c.push("world\n")
+    asyncore.loop()
+
+main()

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

@@ -0,0 +1,66 @@
+# Test the atexit module.
+from test_support import TESTFN, vereq, is_jython
+import atexit
+from os import popen, unlink
+import sys
+
+executable = sys.executable
+if is_jython:
+    executable = "jython"
+
+input = """\
+import atexit
+
+def handler1():
+    print "handler1"
+
+def handler2(*args, **kargs):
+    print "handler2", args, kargs
+
+atexit.register(handler1)
+atexit.register(handler2)
+atexit.register(handler2, 7, kw="abc")
+"""
+
+fname = TESTFN + ".py"
+f = file(fname, "w")
+f.write(input)
+f.close()
+
+p = popen("%s %s" % (executable, fname))
+output = p.read()
+p.close()
+vereq(output, """\
+handler2 (7,) {'kw': 'abc'}
+handler2 () {}
+handler1
+""")
+
+input = """\
+def direct():
+    print "direct exit"
+
+import sys
+sys.exitfunc = direct
+
+# Make sure atexit doesn't drop
+def indirect():
+    print "indirect exit"
+
+import atexit
+atexit.register(indirect)
+"""
+
+f = file(fname, "w")
+f.write(input)
+f.close()
+
+p = popen("%s %s" % (executable, fname))
+output = p.read()
+p.close()
+vereq(output, """\
+indirect exit
+direct exit
+""")
+
+unlink(fname)