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 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.
# -*- 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()