rubyfox-server 2.3.0.pre2

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

@@ -0,0 +1,15 @@
+# test of PR#201
+
+import sys
+from test_support import *
+
+print_test('Java Anonymous Inner Classes (test_janoninner.py)', 1)
+
+print_test('importing', 2)
+import javatests.AnonInner
+
+print_test('instantiating', 2)
+x = javatests.AnonInner()
+
+print_test('invoking', 2)
+assert x.doit() == 2000

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

@@ -0,0 +1,53 @@
+from test_support import *
+from javatests import ListTest
+
+class PyListTest(ListTest):
+       
+   def __init__(self):
+       ListTest.__init__(self)
+       
+   def newInstance(self, coll):
+       if coll is None:
+           return list()
+       else:
+           return list(coll)
+       
+   def isReadOnly(self):
+       return False
+       
+
+class PyTupleTest(ListTest):
+       
+   def __init__(self):
+       ListTest.__init__(self)
+       
+   def newInstance(self, coll):
+       if coll is None:
+           return tuple()
+       else:
+           return tuple(coll)
+       
+   def isReadOnly(self):
+       return True       
+
+
+# these first two tests just verify that we have a good unit test
+print_test("ListTest.java driver (test_javalist.py)", 1)
+print_test("running test on ArrayList", 2)
+alt = ListTest.getArrayListTest(False)
+alt.testAll()
+
+print_test("running test on ArrayList (read-only)", 2)
+alt = ListTest.getArrayListTest(True)
+alt.testAll()
+
+
+# Now run the critical tests
+
+print_test("running test on PyListTest", 2)       
+plt = PyListTest()
+plt.testAll()       
+
+print_test("running test on PyTupleTest", 2)       
+ptt = PyTupleTest()
+ptt.testAll()  

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

@@ -0,0 +1,182 @@
+import unittest
+import test_support
+
+from org.python.core import PyFile
+import re
+
+import os
+import javashell
+from javashell import LazyDict
+
+# testCmds is a list of (command, expectedOutput)
+# each command is executed twice, once in unitialized environment and
+# once with initialized environment
+
+# smaller set of commands for simple test
+testCmds = [
+    ("echo hello world", "hello world"),
+    ]
+
+# turn off output from javashell.__warn
+javashell.__warn = lambda *args: None
+
+def dprint( *args ):
+    #print args
+    pass
+
+
+# can instead set testCmds = fullTestCmds
+
+# Note that the validation is incomplete for several of these
+# - they should validate depending on platform and pre-post, but
+# they don't.
+
+# can assign testCmds = fullTestCmds for more extensive tests
+key, value = "testKey", "testValue"
+fullTestCmds = [
+            # no quotes, should output both words
+            ("echo hello world", "hello world"),
+            # should print PATH (on NT)
+            ("echo PATH=%PATH%", "(PATH=.*;.*)|(PATH=%PATH%)"),
+            # should print 'testKey=%testKey%' on NT before initialization,
+            # should print 'testKey=' on 95 before initialization,
+            # and 'testKey=testValue' after
+            ("echo %s=%%%s%%" % (key,key),
+                    "(%s=)" % (key,)),     
+            # should print PATH (on Unix)
+            ( "echo PATH=$PATH", "PATH=.*" ),
+            # should print 'testKey=testValue' on Unix after initialization
+            ( "echo %s=$%s" % (key,key),
+                    "(%s=$%s)|(%s=)|(%s=%s)" % (key, key, key, key, value ) ), 
+            # should output quotes on NT but not on Unix
+            ( 'echo "hello there"', '"?hello there"?' ),
+            # should print 'why' to stdout.
+            ( r'''jython -c "import sys;sys.stdout.write( 'why\n' )"''', "why" ),
+            # should print 'why' to stderr.
+            # doesn't work on NT because of quoting issues.
+            # Have to add the print to give some output to stdout...
+            # empty string matches everything...
+            ( r'''jython -c "import sys;sys.stderr.write('why\n');print " ''',
+              '' )
+            ]
+
+class JavaShellTest(unittest.TestCase):
+    """This test validates the subshell functionality (javashell, os.environ, popen*).
+    Does some white box as well as black box testing.
+    """
+    def testGetOsType( self ):
+        """Test expected values for various Java os names"""
+        testVals = {
+            "Windows NT": "nt",
+            "Windows 95": "dos",
+            "MacOS": "mac",
+            "Solaris": "posix",
+            "Linux": "posix",
+            "None": "None"
+            }
+
+        msgFmt = "javashell._getOsType( '%s' ) should return '%s', not '%s'"
+        # test basic mappings
+        for key, val in testVals.items():
+            got = javashell._getOsType( key )
+            assert got == val, msgFmt % ( key, val, got )
+
+    def _testCmds( self, _shellEnv, testCmds, whichEnv ):
+        """test commands (key) and compare output to expected output (value).
+        this actually executes all the commands twice, testing the return
+        code by calling system(), and testing some of the output by calling
+        execute()
+        """
+        for cmd, pattern in testCmds:
+            dprint( "\nExecuting '%s' with %s environment" % (cmd, whichEnv))
+            p = javashell.shellexecute(cmd)
+            line = PyFile( p.getInputStream() ).readlines()[0]
+            assert re.match( pattern, line ), \
+                    "expected match for %s, got %s" % ( pattern, line )
+            dprint( "waiting for", cmd, "to complete")
+            assert not p.waitFor(), \
+                    "%s failed with %s environment" % (cmd, whichEnv)
+
+    def testSystem( self ):
+        """test system and environment functionality"""
+        # this doesn't quite test 'system', because system 
+        os.environ = LazyDict( populate=os._getEnvironment )
+        assert not os.environ._populated, \
+                "before population, os.environ._populated should be false"
+        
+        org = os.environ
+        self._testCmds( javashell._shellEnv, testCmds, "default" )
+
+        # trigger initialization of environment
+        os.environ[ key ] = value
+
+        assert os.environ._populated, \
+                "after population, os.environ._populated should be true"
+        assert org.get( key, None ) == value, \
+                "expected stub to have %s set" % key
+        assert os.environ.get( key, None ) == value, \
+                "expected real os.environment to have %s set" % key
+
+        # if environment is initialized and jython gets ARGS=-i, it thinks
+        # it is running in interactive mode, and fails to exit until
+        # process.getOutputStream().close()
+        try:
+            del os.environ[ "ARGS" ]
+        except KeyError:
+            pass
+
+        # test system using the non-default environment
+        self._testCmds( javashell._shellEnv, testCmds, "initialized" )
+
+        assert os.environ.has_key( "PATH" ), \
+                "expected environment to have PATH attribute " \
+                "(this may not apply to all platforms!)"
+
+    def testBadShell( self ):
+        "Attempting to get an environment with a shell that is not startable"
+        dprint( "testBadShell: ignore warnings about failing to get environment")
+        se2 = javashell._ShellEnv( ["badshell", "-c"], "set" )
+        str(se2.environment) # trigger initialization
+        assert not se2.environment.items(), "environment should be empty"
+        dprint( "end testBadShell")
+
+    def testBadGetEnv( self ):
+        "Attempting to get an environment with a command that does not print an environment"
+        dprint( "testBadGetEnv: ignore warnings about command not printing environment")
+        envCmd="echo This command does not print environment"    
+        se2 = javashell._ShellEnv( javashell._shellEnv.cmd, envCmd, None )
+        str(se2.environment) # trigger initialization
+        assert not se2.environment.items(), "environment should be empty"
+        dprint( "end testBadGetEnv")
+
+    def testPutEnv( self ):
+        "Put an environment variable and ensure that spawned processes see the change"
+        value = "Value we set"
+        os.putenv( "NEWVARIABLE", value )
+        newValue = os.popen( "echo $NEWVARIABLE" ).read().strip()
+        if newValue == "$NEWVARIABLE":
+            newValue = os.popen( "echo %NEWVARIABLE%" ).read().strip()
+        if newValue == "%NEWVARIABLE%":
+            raise test_support.TestSkipped( "Unable to find a subshell to execute echo" )
+        assert newValue == value, (
+            "Expected (%s) to equal value we set (%s)" % (
+            newValue, value
+            ))
+
+    def testFormatUnicodeCommand(self):
+        shell = javashell._ShellEnv(cmd=['runner'])
+        self.assertEqual(shell._formatCmd('echo hello'), ['runner', 'echo hello'])
+        self.assertEqual(shell._formatCmd(u'echo world'), ['runner', u'echo world'])
+
+    def testExecuteUnicodeCommandWithRedirection(self):
+        process = javashell.shellexecute(u'nonexcmd 2>&1')
+        stdout = process.getOutputStream().toString()
+        process.waitFor()
+        self.assertNotEqual(stdout, "", "Redirecting 2>&1 failed with unicode cmd")
+
+def test_main():
+    test_support.run_unittest(JavaShellTest)
+
+if __name__ == "__main__":
+    test_main()
+

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

@@ -0,0 +1,119 @@
+from test_support import *
+
+print_test('Basic Java Integration (test_jbasic.py)', 1)
+
+print_test('type conversions', 2)
+print_test('numbers', 3)
+
+from java.lang.Math import abs
+assert abs(-2.) == 2., 'Python float to Java double'
+assert abs(-2) == 2l, 'Python int to Java long'
+assert abs(-2l) == 2l, 'Python long to Java long'
+
+try: abs(-123456789123456789123l)
+except TypeError: pass
+
+print_test('strings', 3)
+from java.lang import Integer, String
+
+assert Integer.valueOf('42') == 42, 'Python string to Java string'
+
+print_test('arrays', 3)
+chars = ['a', 'b', 'c']
+assert String.valueOf(chars) == 'abc', 'char array'
+
+print_test('Enumerations', 3)
+from java.util import Vector
+
+vec = Vector()
+items = range(10)
+for i in items:
+	vec.addElement(i)
+
+expected = 0
+for i in vec:
+	assert i == expected, 'testing __iter__ on java.util.Vector'
+	expected = expected+1
+
+expected = 0
+for i in iter(vec):
+    assert i == expected, 'testing iter(java.util.Vector)'
+    expected = expected+1
+
+
+print_test('create java objects', 2)
+
+from java.math import BigInteger
+
+assert BigInteger('1234', 10).intValue() == 1234, 'BigInteger(string)'
+assert BigInteger([0x11, 0x11, 0x11]).intValue() == 0x111111, 'BigInteger(byte[])'
+assert BigInteger(-1, [0x11, 0x11, 0x11]).intValue() == -0x111111, 'BigInteger(int, byte[])'
+
+print_test('call static methods')
+s1 = String.valueOf(['1', '2', '3'])
+s2 = String.valueOf('123')
+s3 = String.valueOf(123)
+s4 = String.valueOf(123l)
+s5 = String.valueOf(['0', '1', '2', '3', 'a', 'b'], 1, 3)
+assert s1 == s2 == s3 == s4 == s5, 'String.valueOf method with different arguments'
+
+print_test('call instance methods')
+s = String('hello')
+assert s.regionMatches(1, 1, 'ell', 0, 3), 'method call with boolean true'
+assert s.regionMatches(0, 1, 'ell', 0, 3), 'method call with boolean false'
+assert s.regionMatches(1, 'ell', 0, 3), 'method call no boolean'
+
+assert s.regionMatches(1, 1, 'eLl', 0, 3), 'method call ignore case'
+assert not s.regionMatches(1, 'eLl', 0, 3), 'should ignore case'
+
+from java.awt import Dimension
+
+print_test('get/set fields')
+d = Dimension(3,9)
+assert d.width == 3 and d.height == 9, 'getting fields'
+d.width = 42
+assert d.width == 42 and d.height == 9, 'setting fields'
+
+#Make sure non-existent fields fail
+try:
+	print d.foo
+except AttributeError:
+	pass
+else:
+	raise AssertionError, 'd.foo should throw type error'
+
+print_test('get/set bean properties')
+
+from javax import swing
+b1 = swing.JButton()
+b1.label = 'foo'
+b2 = swing.JButton(label='foo')
+assert b1.label == b2.label == 'foo', 'Button label bean property'
+
+print_test('bean event properties')
+# Test bean event properties - single and multiple
+flag = 0
+def testAction(event):
+	global flag
+	flag = flag + 1
+
+from java.awt.event import ActionEvent
+
+doit = ActionEvent(b1, ActionEvent.ACTION_PERFORMED, "")
+
+b1.actionPerformed = testAction
+flag = 0
+b1.doClick()
+assert flag == 1, 'expected one action per event but got %s' % flag
+
+b1.actionPerformed.append(testAction)
+flag = 0
+b1.doClick()
+assert flag == 2, 'two actions per event'
+
+b1.actionPerformed = testAction
+flag = 0
+b1.doClick()
+assert flag == 1, 'one actions per event - again'
+
+# TBD: Jython does not properly exit after this code!

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

@@ -0,0 +1,138 @@
+# test overloaded java methods dispatch logic in PyReflectedFunction
+# needs to grow more tests. Uses javatests.JOverload as a bag of overloaded methods.
+# (can be adapted to test alternative re-implemations even while they are developed
+# write a *Envl class and change/add to to_test for that)
+
+import unittest
+
+import java
+import org.python.core
+
+class PyReflFuncEnvl:
+
+    def __init__(self,name,meths):
+        self.reflfunc = org.python.core.PyReflectedFunction(name)
+        for meth in meths:
+            self.reflfunc.addMethod(meth)
+            
+    def __call__(self,inst,args):
+        return self.reflfunc(inst,*args)
+
+def extract_ov_meths(jcl,envl_class):
+    meths = java.lang.Class.getDeclaredMethods(jcl)
+    names = [ m.name for m in meths]
+    meth_dict = {}
+    for name in names:
+      if name.startswith('ov_') and not meth_dict.has_key(name):
+          meth_dict[name] = envl_class(name,[ m for m in meths if m.name == name ])
+    return meth_dict
+
+from javatests import JOverload
+jo = JOverload()
+
+to_test = [extract_ov_meths(JOverload,PyReflFuncEnvl)]
+
+class OverloadedDispatchTests(unittest.TestCase):
+
+    def check(self,lbl,rng,args,expected):
+        expected = expected.split()
+        for meth_dict in to_test:
+            for i,expect in zip(rng,expected):
+                self.assertEqual(meth_dict['ov_%s%s' % (lbl,i)](jo,args),expect)
+
+    def test_posprec(self):
+        self.check('posprec',[1,2],[0,0],
+                   "(int,long) (long,int)")
+
+    def test_scal_int_zero(self):
+        self.check('scal',xrange(1,15),[0],
+                   """
+(long)
+(int)
+(short)
+(byte)
+(byte)
+(double)
+(float)
+(boolean)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.lang.Object)                   
+                   """)
+
+    def test_scal_string(self):
+        self.check('scal',xrange(1,15),['str'],
+                   """
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.lang.Object)
+                   """)
+
+    def test_scal_char(self):
+        self.check('scal',xrange(1,15),['c'],
+                   """
+(char)
+(char)
+(char)
+(char)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.lang.String)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.lang.Object)
+                   """)
+
+    def test_scal_float_one(self):
+        self.check('scal',xrange(1,15),[1.0],
+                   """
+(double)
+(double)
+(double)
+(double)
+(double)
+(double)
+(float)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.io.Serializable)
+(java.lang.Object)     
+                   """)
+
+
+def printout(meth_dict,lbl,rng,args):
+    for i in rng:
+        print meth_dict['ov_%s%s' % (lbl,i)](jo,args)
+
+import sys
+
+if __name__ == '__main__' and not sys.argv[1:] == ['break-out']:
+    try:
+        import test_support
+    except ImportError:
+        unittest.main()
+    else:
+        test_support.run_unittest(OverloadedDispatchTests)
+        
+    

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

@@ -0,0 +1,33 @@
+"""This test validates the fix for 511493 (jreload truncates large class files).
+
+We do this by loading a large class file Blob.class from blob.jar (source inside the jar).  If the load failes with ClassFormatError,
+the bug is present, if the load succeeds, the bug is fixed, if something else occurs, we don't know.
+"""
+
+import unittest
+import test_support
+
+from jreload import makeLoadSet
+from java.lang import System, ClassFormatError
+
+import os
+
+class JreloadTestCase(unittest.TestCase):
+
+    blobjar = test_support.findfile('blob.jar')
+
+    def test( self ):
+        myls = makeLoadSet('myls', [self.blobjar])
+
+        try:
+            from myls import Blob
+        except ClassFormatError:
+            print "Reload Error is present"
+            raise
+        
+def test_main():
+    test_support.run_unittest(JreloadTestCase)
+
+if __name__ == "__main__":
+    test_main()
+

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

@@ -0,0 +1,57 @@
+from test_support import *
+
+print_test('Java Serialization (test_jser.py)', 1)
+
+from java import io, awt
+import os, sys
+
+object1 = 42
+object2 = ['a', 1, 1.0]
+class Foo:
+	def bar(self):
+		return 'bar'
+
+object3 = Foo()
+object3.baz	= 99
+
+object4 = awt.Color(1,2,3)
+
+print_test('writing', 2)
+
+sername = os.path.join(sys.prefix, "test.ser")
+fout = io.ObjectOutputStream(io.FileOutputStream(sername))
+print_test('Python int', 3)
+fout.writeObject(object1)
+print_test('Python list', 3)
+fout.writeObject(object2)
+print_test('Python instance', 3)
+fout.writeObject(object3)
+print_test('Java instance', 3)
+fout.writeObject(object4)
+fout.close()
+
+fin	= io.ObjectInputStream(io.FileInputStream(sername))
+print_test('reading', 2)
+iobject1 = fin.readObject()
+iobject2 = fin.readObject()
+iobject3 = fin.readObject()
+iobject4 = fin.readObject()
+fin.close()
+
+#print iobject1, iobject2, iobject3, iobject3.__class__, iobject4
+
+print_test('Python int', 3)
+assert iobject1	== object1
+
+print_test('Python list', 3)
+assert iobject2	== object2
+
+print_test('Python instance', 3)
+assert iobject3.baz	== 99
+assert iobject3.bar() == 'bar'
+assert iobject3.__class__ == Foo
+
+print_test('Java instance', 3)
+assert iobject4 == object4
+
+os.remove(sername)

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

@@ -0,0 +1,93 @@
+import test_support, unittest
+import java
+from org.python.util import PythonObjectInputStream
+
+def serialize(o, special=0):
+    b = java.io.ByteArrayOutputStream()
+    objs = java.io.ObjectOutputStream(b)
+    objs.writeObject(o)
+    if not special:
+        OIS = java.io.ObjectInputStream
+    else:
+        OIS = PythonObjectInputStream
+    objs = OIS(java.io.ByteArrayInputStream(b.toByteArray()))
+    return objs.readObject()
+
+from jser2_classes import A, AJ, N, NL, NT
+
+class TestJavaSerialisation(unittest.TestCase):
+
+    def test_list(self):
+        l = [1,"a", 3.0]
+        l1 = serialize(l)
+        self.assertEqual(l, l1)
+
+    def test_dict(self):
+        d = {'a': 3.0}
+        d1 = serialize(d)
+        self.assertEqual(d, d1)
+
+    def test_tuple(self):
+        t = (1, 'a')
+        t1 = serialize(t)
+        self.assertEqual(t, t1)
+
+    def test_oldstyle(self):
+        a = A('x')
+        a1 = serialize(a)
+        self.assertEqual(a, a1)
+
+    # wasn't working in 2.1 either
+    #def test_oldstyle_cls(self):
+    #    A1 = serialize(A)
+    #    self.assert_(A is A1)
+
+    def test_jsubcl(self):
+        aj = AJ('x')
+        aj1 = serialize(aj, special=1)
+        self.assertEqual(aj, aj1)
+
+    def test_singletons(self):
+        for v in (None, Ellipsis):
+            v1 = serialize(v)
+            self.assert_(v is v1)
+            v1 = serialize((v,))[0]
+            self.assert_(v is v1)
+
+    def test_NotImplemented(self):
+        # XXX serialize(NotImplemented) is None because of __tojava__
+        v1 = serialize((NotImplemented,))[0]
+        self.assert_(v1 is NotImplemented)
+
+    def test_type(self):
+        list1 = serialize(list)
+        self.assert_(list1 is list)
+        list1 = serialize((list,))[0]
+        self.assert_(list1 is list)
+
+    def test_user_type(self):
+        N1 = serialize(N)
+        self.assert_(N1 is N)
+        N1 = serialize((N,))[0]
+        self.assert_(N1 is N)
+
+    def test_newstyle(self):
+        n = N('x')
+        n1 = serialize(n)
+        self.assertEqual(n, n1)
+
+    def test_newstyle_list(self):
+        nl = NL('x',1,2,3)
+        nl1 = serialize(nl)
+        self.assertEqual(nl, nl1)
+
+    def test_newstyle_tuple(self):
+        nt = NT('x',1,2,3)
+        nt1 = serialize(nt)
+        self.assertEqual(nt, nt1)
+
+def test_main():
+    test_support.run_unittest(TestJavaSerialisation)
+
+if __name__ == "__main__":
+    test_main()