Lib.test.test_pythoninterpreter_jy.py Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython-standalone Show documentation
Show all versions of jython-standalone 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.
# -*- coding: utf-8 -*-
import java.io
import os
import sys
import traceback
import types
import unittest
import test.test_support
from org.python.core.util import StringUtil
from org.python.core import PyFile
from _codecs import encode
from sun.awt.image import BufImgVolatileSurfaceManager
def exec_code_in_pi(source, inp=None, out=None, err=None, locals=None):
"""Runs code in a separate context: (thread, PySystemState, PythonInterpreter)"""
def execution_context():
from org.python.core import Py
from org.python.util import PythonInterpreter
from org.python.core import PySystemState
ps = PySystemState()
pi = PythonInterpreter({}, ps)
if locals is not None: pi.setLocals(locals)
if inp is not None: pi.setIn(inp)
if out is not None: pi.setOut(out)
if err is not None: pi.setErr(err)
try:
if isinstance(source, types.FunctionType):
# A function wrapping a compiled code block
pi.exec(source.func_code)
elif isinstance(source, java.io.InputStream):
# A byte-oriented file-like input stream
pi.execfile(source)
elif isinstance(source, java.io.Reader):
# A character-oriented file-like input stream
code = pi.compile(source)
pi.exec(code)
else:
# A str or unicode (see UnicodeSourceTest)
pi.exec(source)
except:
print
print '-'*60
traceback.print_exc(file=sys.stdout)
print '-'*60
import threading
context = threading.Thread(target=execution_context)
context.start()
context.join()
class InterpreterTest(unittest.TestCase):
# in these tests, note the promotion to unicode by java.io.Writer,
# because these are character-oriented streams. caveat emptor!
def test_pi_out_unicode(self):
source_text = [
u'Some text',
'Plain text',
u'\u1000\u2000\u3000\u4000',
# Some language names from wikipedia
u'Català · Česky · Dansk · Deutsch · English · Español · Esperanto · Français · Bahasa Indonesia · Italiano · Magyar · Nederlands · 日本語 · Norsk (bokmål) · Polski · Português · Русский · Română · Slovenčina · Suomi · Svenska · Türkçe · Українська · Volapük · 中文',
]
def f():
global text
for x in text:
print x
out = java.io.StringWriter()
err = java.io.StringWriter()
exec_code_in_pi(f, None, out, err, {'text': source_text})
output_text = out.toString().splitlines()
for output, source in zip(output_text, source_text):
self.assertEquals(output, source)
def test_pi_out(self):
def f():
print 42
out = java.io.StringWriter()
err = java.io.StringWriter()
exec_code_in_pi(f, None, out, err)
self.assertEquals(u"42\n", out.toString())
def test_more_output(self):
def f():
for i in xrange(42):
print "*" * i
out = java.io.StringWriter()
err = java.io.StringWriter()
exec_code_in_pi(f, None, out, err)
output = out.toString().splitlines()
for i, line in enumerate(output):
self.assertEquals(line, u'*' * i)
self.assertEquals(42, len(output))
class UnicodeSourceTest(unittest.TestCase):
# When the core PythonInterpreter is embedded in a Java program
# it may be supplied as Unicode source as a string or via streams.
def do_test(self, source, ref_out=u'', ref_var=None, inp=None):
if ref_var is None:
ref_var = {}
out = java.io.StringWriter()
err = java.io.StringWriter()
var = {}
if inp is not None:
if isinstance(inp, bytes):
inp = java.io.ByteArrayInputStream(StringUtil.toBytes(inp))
elif isinstance(inp, unicode):
inp = java.io.StringReader(inp)
exec_code_in_pi(source, inp, out, err, var)
del var['__builtins__']
self.assertEquals(ref_var, var)
self.assertEquals(ref_out, out.toString())
def test_ascii_str(self):
# Program written in bytes with ascii range only
self.do_test('a = 42\nprint a', u'42\n', {'a':42})
def test_latin_str(self):
# Program written in bytes with codes above 127
self.do_test('a = "caf\xe9"\nprint a', u'caf\xe9\n', {'a':'caf\xe9'})
def test_ascii_unicode(self):
# Program written in Unicode with ascii range only
self.do_test(u'a = "hello"\nprint a', u'hello\n', {'a':'hello'})
def test_latin_unicode(self):
# Program written in Unicode with codes above 127
self.do_test(u'a = "caf\xe9"\nprint a', u'caf\xe9\n', {'a':'caf\xe9'})
@unittest.skip("PythonInterpreter.exec(String) does not distinguish str/unicode")
def test_bmp_unicode(self):
# Program written in Unicode with codes above 255
a = u"畫蛇添足 Λόγος"
prog = u'a = u"{:s}"\nprint repr(a)'.format(a)
# Submit via exec(unicode)
self.do_test(prog,
u'{}\n'.format(repr(a)),
{'a': a})
def test_bmp_utf8stream(self):
# Program written in Unicode with codes above 255
a = u"畫蛇添足 Λόγος"
prog = u'a = u"{:s}"\nprint repr(a)'.format(a)
# Program as bytes with declared encoding for execfile(InputStream)
progbytes = '# coding: utf-8\n' + prog.encode('utf-8')
stream = java.io.ByteArrayInputStream(StringUtil.toBytes(progbytes))
self.do_test(stream,
u'{}\n'.format(repr(a)),
{'a': a})
def test_bmp_reader(self):
# Program written in Unicode with codes above 255
a = u"畫蛇添足 Λόγος"
prog = u'a = u"{:s}"\nprint repr(a)'.format(a)
# Program as character stream for exec(compile(Reader))
self.do_test(java.io.StringReader(prog),
u'{}\n'.format(repr(a)),
{'a': a})
def unicode_lines():
input_lines = [
u'Some text',
u'un café crème',
u"Λόγος",
u"畫蛇添足",
]
input_text = u'\n'.join(input_lines)
return input_lines, input_text
class InterpreterSetInTest(unittest.TestCase):
# When the core PythonInterpreter is embedded in a Java program it
# may be connected through SetIn to a Unicode or byte stream.
# However, the Unicode Reader interface narrows the data to bytes
# in a way that mangles anything beyond Latin-1. These tests
# illustrate that preparatory to a possible solution, in which the
# encoding is specified to the PythonInterpreter and appears as
# sys.stdin.encoding etc. for use by the application (and libraries).
@staticmethod
def do_read():
import sys
buf = bytearray()
while True:
c = sys.stdin.read(1)
if not c: break
buf.append(c)
# A defined encoding ought to be advertised in sys.stdin.encoding
enc = getattr(sys.stdin, 'encoding', None)
# In the test, allow an override via local variables
enc = locals().get('encoding', enc)
if enc:
result = buf.decode(enc) # unicode
else:
result = bytes(buf)
def test_pi_bytes_read(self):
# Test read() with pi.setIn(PyFile(InputStream))
input_lines, input_text = unicode_lines()
input_bytes = input_text.encode('utf-8')
inp = java.io.ByteArrayInputStream(input_bytes)
var = dict()
exec_code_in_pi(InterpreterSetInTest.do_read, inp, locals=var)
result = var['result']
self.assertEquals(result, input_bytes)
self.assertEquals(type(result), type(input_bytes))
@unittest.skip("Jython treats characters from a Reader as bytes.")
# Has no unicode encoding and fails to build PyString for codes > 255
def test_pi_unicode_read(self):
# Test read() with pi.setIn(Reader)
input_lines, input_text = unicode_lines()
inp = java.io.StringReader(input_text)
var = dict()
exec_code_in_pi(InterpreterSetInTest.do_read, inp, locals=var)
result = var['result']
self.assertEquals(result, input_text)
self.assertEquals(type(result), type(input_text))
def test_pi_encoding_read(self):
# Test read() with pi.setIn(PyFile(InputStream)) and defined encoding
input_lines, input_text = unicode_lines()
input_bytes = input_text.encode('utf-8')
inp = java.io.ByteArrayInputStream(input_bytes)
var = {'encoding': 'utf-8'}
exec_code_in_pi(InterpreterSetInTest.do_read, inp, locals=var)
result = var['result']
self.assertEquals(result, input_text)
self.assertEquals(type(result), type(input_text))
@staticmethod
def do_readline():
import sys
# A defined encoding ought to be advertised in sys.stdin.encoding
enc = getattr(sys.stdin, 'encoding', None)
# In the test, allow an override via local variables
enc = locals().get('encoding', enc)
result = list()
while True:
line = sys.stdin.readline()
if not line: break
if enc: line = line.decode(enc) # unicode
result.append(line.rstrip('\n'))
def test_pi_bytes_readline(self):
# Test readline() with pi.setIn(PyFile(InputStream))
input_lines, input_text = unicode_lines()
input_bytes = input_text.encode('utf-8')
inp = java.io.ByteArrayInputStream(input_bytes)
var = dict()
exec_code_in_pi(InterpreterSetInTest.do_readline, inp, locals=var)
for output, source in zip(var['result'], input_lines):
source = source.encode('utf-8')
self.assertEquals(output, source)
self.assertEquals(type(output), type(source))
@unittest.skip("Jython treats characters from a Reader as bytes.")
# Has no unicode encoding and fails to build PyString for codes > 255
def test_pi_unicode_readline(self):
# Test readline() with pi.setIn(Reader)
input_lines, input_text = unicode_lines()
inp = java.io.StringReader(input_text)
var = dict()
exec_code_in_pi(InterpreterSetInTest.do_readline, inp, locals=var)
for output, source in zip(var['result'], input_lines):
self.assertEquals(output, source)
self.assertEquals(type(output), type(source))
def test_pi_encoding_readline(self):
# Test readline() pi.setIn(PyFile(InputStream)) and defined encoding
input_lines, input_text = unicode_lines()
input_bytes = input_text.encode('utf-8')
inp = java.io.ByteArrayInputStream(input_bytes)
var = {'encoding': 'utf-8'}
exec_code_in_pi(InterpreterSetInTest.do_readline, inp, locals=var)
for output, source in zip(var['result'], input_lines):
self.assertEquals(output, source)
self.assertEquals(type(output), type(source))
@staticmethod
def do_readinto():
import sys
buf = bytearray(1024)
n = sys.stdin.readinto(buf)
result = buf[:n]
def test_pi_bytes_readinto(self):
# Test readinto() with pi.setIn(PyFile(InputStream))
input_lines, input_text = unicode_lines()
input_bytes = input_text.encode('utf-8')
inp = java.io.ByteArrayInputStream(input_bytes)
var = dict()
exec_code_in_pi(InterpreterSetInTest.do_readinto, inp, locals=var)
self.assertEquals(var['result'], input_bytes)
# There is no readinto() with pi.setIn(Reader)
class StdoutWrapperTest(unittest.TestCase):
def test_choose_str(self):
def f():
class Example:
def __str__(self):
return "str"
def __repr__(self):
return "repr"
print Example()
out = java.io.StringWriter()
err = java.io.StringWriter()
exec_code_in_pi(f, None, out, err)
self.assertEqual(out.toString(), "str\n")
def test_main():
test.test_support.run_unittest(
InterpreterTest,
UnicodeSourceTest,
InterpreterSetInTest,
StdoutWrapperTest
)
if __name__ == "__main__":
test_main()