Lib.test.test_bat_jy.py Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython Show documentation
Show all versions of jython Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
'''Tests jython.bat using the --print option'''
import os
import sys
import unittest
import tempfile
from test import test_support
from java.lang import IllegalThreadStateException
from java.lang import Runtime
from java.lang import System
from java.lang import Thread
from java.io import File
from java.io import BufferedReader;
from java.io import InputStreamReader;
class Monitor(Thread):
def __init__(self, process):
self.process = process
self.output = ''
def run(self):
reader = BufferedReader(InputStreamReader(self.getStream()))
try:
line = reader.readLine()
while line:
self.output += line
line = reader.readLine()
finally:
reader.close()
def getOutput(self):
return self.output
class StdoutMonitor(Monitor):
def __init_(self, process):
Monitor.__init__(self, process)
def getStream(self):
return self.process.getInputStream()
class StderrMonitor(Monitor):
def __init_(self, process):
Monitor.__init__(self, process)
def getStream(self):
return self.process.getErrorStream()
class StarterProcess:
def writeStarter(self, args, javaHome, jythonHome, jythonOpts, internals=False):
(starter, starterPath) = tempfile.mkstemp(suffix='.bat', prefix='starter', text=True)
starter.close()
outfilePath = starterPath[:-4] + '.out'
starter = open(starterPath, 'w') # open starter as simple file
try:
if javaHome:
starter.write('set JAVA_HOME=%s\n' % javaHome)
if jythonHome:
starter.write('set JYTHON_HOME=%s\n' % jythonHome)
if jythonOpts:
starter.write('set JYTHON_OPTS=%s\n' % jythonOpts)
if internals:
starter.write('set _JYTHON_OPTS=leaking_internals\n')
starter.write('set _JYTHON_HOME=c:/leaking/internals\n')
starter.write(self.buildCommand(args, outfilePath))
return (starterPath, outfilePath)
finally:
starter.close()
def buildCommand(self, args, outfilePath):
line = ''
for arg in args:
line += arg
line += ' '
line += '> '
line += outfilePath
line += ' 2>&1'
return line
def getOutput(self, outfilePath):
lines = ''
outfile = open(outfilePath, 'r')
try:
for line in outfile.readlines():
lines += line
finally:
outfile.close()
return lines
def isAlive(self, process):
try:
process.exitValue()
return False
except IllegalThreadStateException:
return True
def run(self, args, javaHome, jythonHome, jythonOpts, internals=False):
''' creates a start script, executes it and captures the output '''
(starterPath, outfilePath) = self.writeStarter(args, javaHome, jythonHome, jythonOpts, internals)
try:
process = Runtime.getRuntime().exec(starterPath)
stdoutMonitor = StdoutMonitor(process)
stderrMonitor = StderrMonitor(process)
stdoutMonitor.start()
stderrMonitor.start()
while self.isAlive(process):
Thread.sleep(300)
return self.getOutput(outfilePath)
finally:
os.remove(starterPath)
os.remove(outfilePath)
class BaseTest(unittest.TestCase):
def quote(self, s):
return '"' + s + '"'
def unquote(self, s):
if len(s) > 0:
if s[:1] == '"':
s = s[1:]
if len(s) > 0:
if s[-1:] == '"':
s = s[:-1]
return s
def getHomeDir(self):
ex = sys.executable
tail = ex[-15:]
if tail == '\\bin\\jython.bat':
home = ex[:-15]
else:
home = ex[:-11] # \jython.bat
return home
def assertOutput(self, flags=None, javaHome=None, jythonHome=None, jythonOpts=None, internals=False):
args = [self.quote(sys.executable), '--print']
memory = None
stack = None
prop = None
jythonArgs = None
boot = False
jdb = False
if flags:
for flag in flags:
if flag[:2] == '-J':
if flag[2:6] == '-Xmx':
memory = flag[6:]
elif flag[2:6] == '-Xss':
stack = flag[6:]
elif flag[2:4] == '-D':
prop = flag[2:]
elif flag[:2] == '--':
if flag[2:6] == 'boot':
boot = True
elif flag[2:5] == 'jdb':
jdb = True
else:
if jythonArgs:
jythonArgs += ' '
jythonArgs += flag
else:
jythonArgs = flag
jythonArgs = jythonArgs.replace('%%', '%') # workaround two .bat files
args.append(flag)
process = StarterProcess()
out = process.run(args, javaHome, jythonHome, jythonOpts, internals)
self.assertNotEquals('', out)
homeIdx = out.find('-Dpython.home=')
java = 'java'
if javaHome:
java = self.quote(self.unquote(javaHome) + '\\bin\\java')
elif jdb:
java = 'jdb'
if not memory:
memory = '512m'
if not stack:
stack = '1152k'
beginning = java + ' '
if prop:
beginning += ' ' + prop
beginning += ' -Xmx' + memory + ' -Xss' + stack + ' '
self.assertEquals(beginning, out[:homeIdx])
executableIdx = out.find('-Dpython.executable=')
homeDir = self.getHomeDir()
if jythonHome:
homeDir = self.unquote(jythonHome)
home = '-Dpython.home=' + self.quote(homeDir) + ' '
self.assertEquals(home, out[homeIdx:executableIdx])
if boot:
classpathFlag = '-Xbootclasspath/a:'
else:
classpathFlag = '-classpath'
classpathIdx = out.find(classpathFlag)
executable = '-Dpython.executable=' + self.quote(sys.executable) + ' '
if not boot:
executable += ' '
self.assertEquals(executable, out[executableIdx:classpathIdx])
# ignore full contents of classpath at the moment
classIdx = out.find('org.python.util.jython')
self.assertTrue(classIdx > classpathIdx)
restIdx = classIdx + len('org.python.util.jython')
rest = out[restIdx:].strip()
if jythonOpts:
self.assertEquals(self.quote(jythonOpts), rest)
else:
if jythonArgs:
self.assertEquals(jythonArgs, rest)
else:
self.assertEquals('', rest)
class VanillaTest(BaseTest):
def test_plain(self):
self.assertOutput()
class JavaHomeTest(BaseTest):
def test_unquoted(self):
# for the build bot, try to specify a real java home
javaHome = System.getProperty('java.home', 'C:\\Program Files\\Java\\someJava')
self.assertOutput(javaHome=javaHome)
def test_quoted(self):
self.assertOutput(javaHome=self.quote('C:\\Program Files\\Java\\someJava'))
# this currently fails, meaning we accept only quoted (x86) homes ...
def __test_x86_unquoted(self):
self.assertOutput(javaHome='C:\\Program Files (x86)\\Java\\someJava')
def test_x86_quoted(self):
self.assertOutput(javaHome=self.quote('C:\\Program Files (x86)\\Java\\someJava'))
class JythonHomeTest(BaseTest):
def createJythonJar(self, parentDir):
jar = File(parentDir, 'jython.jar')
if not jar.exists():
self.assertTrue(jar.createNewFile())
return jar
def cleanup(self, tmpdir, jar=None):
if jar and jar.exists():
self.assertTrue(jar.delete())
os.rmdir(tmpdir)
def test_unquoted(self):
jythonHomeDir = tempfile.mkdtemp()
jar = self.createJythonJar(jythonHomeDir)
self.assertOutput(jythonHome=jythonHomeDir)
self.cleanup(jythonHomeDir, jar)
def test_quoted(self):
jythonHomeDir = tempfile.mkdtemp()
jar = self.createJythonJar(jythonHomeDir)
self.assertOutput(jythonHome=self.quote(jythonHomeDir))
self.cleanup(jythonHomeDir, jar)
class JythonOptsTest(BaseTest):
def test_single(self):
self.assertOutput(jythonOpts='myOpt')
def test_multiple(self):
self.assertOutput(jythonOpts='some arbitrary options')
class InternalsTest(BaseTest):
def test_no_leaks(self):
self.assertOutput(internals=True)
class JavaOptsTest(BaseTest):
def test_memory(self):
self.assertOutput(['-J-Xmx321m'])
def test_stack(self):
self.assertOutput(['-J-Xss321k'])
def test_property(self):
self.assertOutput(['-J-DmyProperty=myValue'])
def test_property_singlequote(self):
self.assertOutput(["-J-DmyProperty='myValue'"])
# a space inside value does not work in jython.bat
def __test_property_singlequote_space(self):
self.assertOutput(["-J-DmyProperty='my Value'"])
def test_property_doublequote(self):
self.assertOutput(['-J-DmyProperty="myValue"'])
# a space inside value does not work in jython.bat
def __test_property_doublequote_space(self):
self.assertOutput(['-J-DmyProperty="my Value"'])
def test_property_underscore(self):
self.assertOutput(['-J-Dmy_Property=my_Value'])
class ArgsTest(BaseTest):
def test_file(self):
self.assertOutput(['test.py'])
def test_dash(self):
self.assertOutput(['-i'])
def test_combined(self):
self.assertOutput(['-W', 'action', 'line'])
def test_singlequoted(self):
self.assertOutput(['-c', "'import sys;'"])
def test_doublequoted(self):
self.assertOutput(['-c', '"print \'something\'"'])
def test_nestedquotes(self):
self.assertOutput(['-c', '"print \'something \"really\" cool\'"'])
def test_nestedquotes2(self):
self.assertOutput(['-c', "'print \"something \'really\' cool\"'"])
def test_underscored(self):
self.assertOutput(['-jar', 'my_stuff.jar'])
def test_property(self):
self.assertOutput(['-DmyProperty=myValue'])
def test_property_underscored(self):
self.assertOutput(['-DmyProperty=my_Value'])
def test_property_singlequoted(self):
self.assertOutput(["-DmyProperty='my_Value'"])
def test_property_doublequoted(self):
self.assertOutput(['-DmyProperty="my_Value"'])
class DoubleDashTest(BaseTest):
def test_boot(self):
self.assertOutput(['--boot'])
def test_jdb(self):
self.assertOutput(['--jdb'])
class GlobPatternTest(BaseTest):
def test_star_nonexisting(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', '*.nonexisting', '*.nonexisting'])
def test_star_nonexisting_doublequoted(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', '"*.nonexisting"', '"*.nonexisting"'])
def test_star_nonexistingfile_singlequoted(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', "'*.nonexisting'", "'*.nonexisting'"])
def test_star_existing(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', '*.bat', '*.bat'])
def test_star_existing_doublequoted(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', '"*.bat"', '"*.bat"'])
def test_star_existing_singlequoted(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', "'*.bat'", "'*.bat'"])
class ArgsSpacesTest(BaseTest):
def test_doublequoted(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', '"part1 part2"', '2nd'])
def test_singlequoted(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', "'part1 part2'", '2nd'])
# this test currently fails
def __test_unbalanced_doublequote(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', 'Scarlet O"Hara', '2nd'])
def test_unbalanced_singlequote(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', "Scarlet O'Hara", '2nd'])
class ArgsSpecialCharsTest(BaseTest):
# exclamation marks are still very special ...
def __test_exclamationmark(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', 'foo!', 'ba!r', '!baz', '!'])
# because we go through a starter.bat file, we have to simulate % with %%
def test_percentsign(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', 'foo%%1', '%%1bar', '%%1', '%%'])
def test_colon(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', 'foo:', ':bar'])
# a semicolon at the beginning of an arg currently fails (e.g. ;bar)
def test_semicolon(self):
self.assertOutput(['-c', 'import sys; print sys.argv[1:]', 'foo;'])
class DummyTest(unittest.TestCase):
def test_nothing(self):
pass
def test_main():
if os._name == 'nt':
test_support.run_unittest(VanillaTest,
JavaHomeTest,
JythonHomeTest,
JythonOptsTest,
InternalsTest,
JavaOptsTest,
ArgsTest,
DoubleDashTest,
GlobPatternTest,
ArgsSpacesTest,
ArgsSpecialCharsTest)
else:
# provide at least one test for the other platforms - happier build bots
test_support.run_unittest(DummyTest)
if __name__ == '__main__':
test_main()