def testBadRetryFromJava(self):
"""Should not retry from Java to Python.
Similar use case as testBadRetry, but from Java: Java calls a long
Python operation.
If there is a bug, Java will call Python, then read will fail, then it
will call Python again.
If there is no bug, Java will call Python, read will fail, then Java
will raise an Exception that will be received as a Py4JError on the
Python side.
"""
self.p = start_short_timeout_app_process()
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
try:
operator = WaitOperator(0.5)
opExample = gateway.jvm.py4j.examples.OperatorExample()
opExample.randomBinaryOperator(operator)
self.fail(
"Should never retry once the first command went through."
" number of calls made: {0}".format(operator.callCount))
except Py4JJavaError:
self.assertTrue(True)
finally:
gateway.shutdown()
self.p.join()
class TypeConversionTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testLongInt(self):
ex = self.gateway.getNewExample()
self.assertEqual(1, ex.method7(1234))
self.assertEqual(4, ex.method7(2147483648))
self.assertEqual(4, ex.method7(long(2147483648)))
self.assertEqual(long(4), ex.method8(3))
self.assertEqual(4, ex.method8(3))
self.assertEqual(long(4), ex.method8(long(3)))
self.assertEqual(long(4), ex.method9(long(3)))
def testBigDecimal(self):
ex = self.gateway.getNewExample()
self.assertEqual(Decimal("2147483.647"), ex.method10(2147483647, 3))
self.assertEqual(Decimal("-13.456"), ex.method10(Decimal("-14.456")))
def testFloatConversion(self):
java_inf = self.gateway.jvm.java.lang.Double.parseDouble("Infinity")
self.assertEqual(float("inf"), java_inf)
java_inf = self.gateway.jvm.java.lang.Double.parseDouble("+Infinity")
self.assertEqual(float("inf"), java_inf)
java_neg_inf = self.gateway.jvm.java.lang.Double.parseDouble(
"-Infinity")
self.assertEqual(float("-inf"), java_neg_inf)
java_nan = self.gateway.jvm.java.lang.Double.parseDouble("NaN")
self.assertTrue(math.isnan(java_nan))
def testCallbackServer(self):
# A close is required to stop the thread.
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
gateway.close()
self.assertTrue(True)
sleep(2)
def _initialize_gateway(gateway_address):
(host, port) = gateway_address
callback_params = CallbackServerParameters(address=host, port=0)
gateway = JavaGateway(GatewayClient(address=host, port=port),
start_callback_server=True,
auto_convert=True,
callback_server_parameters=callback_params)
try:
java_import(gateway.jvm, "org.apache.spark.SparkEnv")
java_import(gateway.jvm, "org.apache.spark.SparkConf")
java_import(gateway.jvm, "org.apache.spark.api.java.*")
java_import(gateway.jvm, "org.apache.spark.api.python.*")
java_import(gateway.jvm, "org.apache.spark.mllib.api.python.*")
java_import(gateway.jvm, "org.apache.spark.sql.*")
java_import(gateway.jvm, "org.apache.spark.sql.hive.*")
java_import(gateway.jvm, "scala.Tuple2")
java_import(gateway.jvm, "scala.collection.immutable.List")
except Py4JError as e:
log_error('Error while initializing java gateway: {}'.format(e))
gateway.close()
return None
return gateway
class HelpTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testHelpObject(self):
ex = self.gateway.getNewExample()
help_page = self.gateway.help(ex, short_name=True, display=False)
self.assertGreater(len(help_page), 1)
def testHelpObjectWithPattern(self):
ex = self.gateway.getNewExample()
help_page = self.gateway.help(
ex, pattern="m*", short_name=True, display=False)
self.assertGreater(len(help_page), 1)
def testHelpClass(self):
String = self.gateway.jvm.java.lang.String
help_page = self.gateway.help(String, short_name=False, display=False)
self.assertGreater(len(help_page), 1)
self.assertIn("String", help_page)
class StreamTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testBinarySuccess(self):
e = self.gateway.getNewExample()
# not binary - just get the Java object
v1 = e.getStream()
self.assertTrue(
is_instance_of(
self.gateway, v1, "java.nio.channels.ReadableByteChannel"))
# pull it as a binary stream
with e.getStream.stream() as conn:
self.assertTrue(isinstance(conn, GatewayConnectionGuard))
expected =\
"Lorem ipsum dolor sit amet, consectetur adipiscing elit."
self.assertEqual(expected, smart_decode(conn.read(len(expected))))
def testBinaryFailure(self):
e = self.gateway.getNewExample()
self.assertRaises(Py4JJavaError, lambda: e.getBrokenStream())
self.assertRaises(Py4JJavaError, lambda: e.getBrokenStream.stream())
def testNotAStream(self):
e = self.gateway.getNewExample()
self.assertEqual(1, e.method1())
self.assertRaises(Py4JError, lambda: e.method1.stream())
class HelpTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testHelpObject(self):
ex = self.gateway.getNewExample()
help_page = self.gateway.help(ex, short_name=True, display=False)
print(help_page)
self.assertEqual(939, len(help_page))
def testHelpObjectWithPattern(self):
ex = self.gateway.getNewExample()
help_page = self.gateway.help(ex, pattern='m*', short_name=True,
display=False)
print(help_page)
self.assertEqual(644, len(help_page))
def testHelpClass(self):
String = self.gateway.jvm.java.lang.String
help_page = self.gateway.help(String, short_name=False, display=False)
print(help_page)
self.assertEqual(3439, len(help_page))
class ThreadTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
gateway_client = GatewayClient()
self.gateway = JavaGateway()
self.gateway.set_gateway_client(gateway_client)
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testStress(self):
# Real stress test!
# runner1 = Runner(xrange(1,10000,2),self.gateway)
# runner2 = Runner(xrange(1000,1000000,10000), self.gateway)
# runner3 = Runner(xrange(1000,1000000,10000), self.gateway)
# Small stress test
runner1 = Runner(range(1, 10000, 1000), self.gateway)
runner2 = Runner(range(1000, 1000000, 100000), self.gateway)
runner3 = Runner(range(1000, 1000000, 100000), self.gateway)
runner1.start()
runner2.start()
runner3.start()
runner1.join()
runner2.join()
runner3.join()
self.assertTrue(runner1.ok)
self.assertTrue(runner2.ok)
self.assertTrue(runner3.ok)
class Test(unittest.TestCase):
def setUp(self):
# logger = logging.getLogger("py4j")
# logger.setLevel(logging.DEBUG)
# logger.addHandler(logging.StreamHandler())
self.p = start_example_app_process()
time.sleep(0.5)
self.gateway = JavaGateway()
def tearDown(self):
self.p.terminate()
self.gateway.shutdown()
time.sleep(0.5)
def equal_maps(self, m1, m2):
if len(m1) == len(m2):
equal = True
for k in m1:
equal = m1[k] == m2[k]
if not equal:
break
return equal
else:
return False
def testMap(self):
dp0 = {}
dp = get_map()
dj = self.gateway.jvm.java.util.HashMap()
self.equal_maps(dj, dp0)
dj["a"] = 1
dj["b"] = 2.0
dj["c"] = "z"
self.equal_maps(dj, dp)
del(dj["a"])
del(dp["a"])
dj2 = self.gateway.jvm.java.util.HashMap()
dj2["b"] = 2.0
dj2["c"] = "z"
dj3 = self.gateway.jvm.java.util.HashMap()
dj3["a"] = 1
dj3["b"] = 2.0
dj3["c"] = "z"
self.equal_maps(dj, dp)
self.assertTrue(dj == dj)
self.assertTrue(dj == dj2)
# Does not always work for some reason...
# Probably not worth supporting for now...
# self.assertTrue(dj < dj3)
self.assertTrue(dj != dp)
dps = {1: 1, 2: 2}
djs = self.gateway.jvm.java.util.HashMap()
djs[1] = 1
djs[2] = 2
self.assertEqual(str(djs), str(dps))
def testGC(self):
with gateway_example_app_process("nomem"):
# This will only work with some JVM.
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters())
sleep()
example = gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl))
self.assertEqual(
"This is Hello;\n10MyMy!\n;",
example.callHello2(impl))
self.assertEqual(2, len(gateway.gateway_property.pool))
# Make sure that finalizers do not block
impl2 = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl2))
self.assertEqual(3, len(gateway.gateway_property.pool))
gateway.jvm.java.lang.System.gc()
# Leave time for sotimeout
sleep(3)
# Make sure the three objects have not been removed from the pool
# because the Java side should not send gc request.
self.assertEqual(len(gateway.gateway_property.pool), 3)
gateway.shutdown()
def testGoodRetryFromJava(self):
"""Should retry from Java to Python.
Similar use case as testGoodRetry, but from Java: Python calls Java,
which calls Python back two times in a row. Then python waits for a
while. Python then calls Java, which calls Python.
Because Python Callback server has been waiting for too much time, the
receiving socket has closed so the call from Java to Python will fail
on send, and Java must retry by creating a new connection
(CallbackConnection).
"""
self.p = start_example_app_process()
gateway = JavaGateway(callback_server_parameters=CallbackServerParameters(read_timeout=0.250))
try:
operator = WaitOperator(0)
opExample = gateway.jvm.py4j.examples.OperatorExample()
opExample.randomBinaryOperator(operator)
str_connection = str(list(gateway._callback_server.connections)[0])
opExample.randomBinaryOperator(operator)
str_connection2 = str(list(gateway._callback_server.connections)[0])
sleep(0.5)
opExample.randomBinaryOperator(operator)
str_connection3 = str(list(gateway._callback_server.connections)[0])
self.assertEqual(str_connection, str_connection2)
self.assertNotEqual(str_connection, str_connection3)
except Py4JJavaError:
self.fail("Java callbackclient did not retry.")
finally:
gateway.shutdown()
self.p.join()
def singlethread(java_classpath):
print "Thread starting"
jvm = JVM(java_classpath, dir_path)
socket_no = self.jvm.socket_no
gatewayclient = GatewayClient('localhost', socket_no)
gateway = JavaGateway(gatewayclient, auto_convert=True, auto_field=True)
sys.stderr.write("Initialized global Java gateway with pid {} in socket {}\n".format(self.jvm.pid, socket_no))
gatewayclient = GatewayClient('localhost', socket_no)
print "Gclient started"
gateway = JavaGateway(gatewayclient, auto_convert=True, auto_field=True)
print "Java Gateway started"
#create a new view for the jvm
meteor_view = gateway.new_jvm_view()
#import required packages
java_import(meteor_view, 'edu.cmu.meteor.scorer.*')
#initialize the java object
java_import(meteor_view, 'edu.cmu.meteor.util.*')
print "Modules imported"
#pass the language setting into the meteor configuration object
config = meteor_view.MeteorConfiguration();
config.setLanguage("en");
scorer = meteor_view.MeteorScorer(config)
print "object initialized"
#run object function
stats = scorer.getMeteorStats("Test sentence", "Test sentence !");
print stats.score
return 1
class TypeConversionTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testLongInt(self):
ex = self.gateway.getNewExample()
self.assertEqual(1, ex.method7(1234))
self.assertEqual(4, ex.method7(2147483648))
self.assertEqual(4, ex.method7(long(2147483648)))
self.assertEqual(long(4), ex.method8(3))
self.assertEqual(4, ex.method8(3))
self.assertEqual(long(4), ex.method8(long(3)))
self.assertEqual(long(4), ex.method9(long(3)))
def testBigDecimal(self):
ex = self.gateway.getNewExample()
self.assertEqual(Decimal("2147483.647"), ex.method10(2147483647, 3))
self.assertEqual(Decimal("-13.456"), ex.method10(Decimal("-14.456")))
def shutdown_gateway(event, gateway: JavaGateway, resource_name: str, shutdown_jvm: bool):
if shutdown_jvm:
gateway.shutdown()
else:
gateway.close()
logger.info('Py4J gateway (%s) shut down', resource_name)
def testProtocolSend(self):
testConnection = TestConnection()
gateway = JavaGateway(testConnection, False)
e = gateway.getExample()
self.assertEqual('c\nt\ngetExample\ne\n', testConnection.last_message)
e.method1(1, True, 'Hello\nWorld', e, None, 1.5)
self.assertEqual('c\no0\nmethod1\ni1\nbTrue\nsHello\\nWorld\nro0\nn\nd1.5\ne\n', testConnection.last_message)
del(e)
class ProtocolTest(unittest.TestCase):
def tearDown(self):
# Safety check in case there was an exception...
safe_shutdown(self)
def testEscape(self):
self.assertEqual("Hello\t\rWorld\n\\", unescape_new_line(
escape_new_line("Hello\t\rWorld\n\\")))
self.assertEqual("Hello\t\rWorld\n\\", unescape_new_line(
escape_new_line("Hello\t\rWorld\n\\")))
def testProtocolSend(self):
testConnection = TestConnection()
self.gateway = JavaGateway(testConnection, False)
e = self.gateway.getExample()
self.assertEqual('c\nt\ngetExample\ne\n', testConnection.last_message)
e.method1(1, True, 'Hello\nWorld', e, None, 1.5)
self.assertEqual(
'c\no0\nmethod1\ni1\nbTrue\nsHello\\nWorld\nro0\nn\nd1.5\ne\n',
testConnection.last_message)
del(e)
def testProtocolReceive(self):
p = start_echo_server_process()
time.sleep(1)
try:
testSocket = get_socket()
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yro0\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ysHello World\n'.encode('utf-8'))
# No extra echange (method3) because it is already cached.
testSocket.sendall('yi123\n'.encode('utf-8'))
testSocket.sendall('yd1.25\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yn\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ybTrue\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yL123\n'.encode('utf-8'))
testSocket.close()
time.sleep(1)
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
self.assertEqual('Hello World', ex.method3(1, True))
self.assertEqual(123, ex.method3())
self.assertAlmostEqual(1.25, ex.method3())
self.assertTrue(ex.method2() is None)
self.assertTrue(ex.method4())
self.assertEqual(long(123), ex.method8())
self.gateway.shutdown()
except Exception as e:
print('Error has occurred', e)
print_exc()
self.fail('Problem occurred')
p.join()
class TestIntegration(unittest.TestCase):
def setUp(self):
# logger = logging.getLogger("py4j")
# logger.setLevel(logging.DEBUG)
# logger.addHandler(logging.StreamHandler())
self.p = start_example_app_process()
self.gateway = JavaGateway(callback_server_parameters=CallbackServerParameters())
def tearDown(self):
safe_shutdown(self)
self.p.join()
sleep()
# Does not work when combined with other tests... because of TCP_WAIT
def testShutdown(self):
example = self.gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl))
self.assertEqual("This is Hello;\n10MyMy!\n;", example.callHello2(impl))
self.gateway.shutdown()
self.assertEqual(0, len(self.gateway.gateway_property.pool))
def testProxy(self):
# self.gateway.jvm.py4j.GatewayServer.turnLoggingOn()
sleep()
example = self.gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl))
self.assertEqual("This is Hello;\n10MyMy!\n;", example.callHello2(impl))
def testGC(self):
# This will only work with some JVM.
sleep()
example = self.gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl))
self.assertEqual("This is Hello;\n10MyMy!\n;", example.callHello2(impl))
self.assertEqual(2, len(self.gateway.gateway_property.pool))
self.gateway.jvm.java.lang.System.gc()
sleep(1)
self.assertTrue(len(self.gateway.gateway_property.pool) < 2)
def testDoubleCallbackServer(self):
try:
self.gateway2 = JavaGateway(callback_server_parameters=CallbackServerParameters())
self.fail()
except Exception:
self.assertTrue(True)
def testMethodConstructor(self):
sleep()
goodAddition = GoodAddition()
oe1 = self.gateway.jvm.py4j.examples.OperatorExample()
# Test method
oe1.randomBinaryOperator(goodAddition)
# Test constructor
oe2 = self.gateway.jvm.py4j.examples.OperatorExample(goodAddition)
self.assertTrue(oe2 is not None)
def gateway(*args, **kwargs):
g = JavaGateway(gateway_parameters=GatewayParameters(*args, auto_convert=True, **kwargs))
lineSep = g.jvm.System.lineSeparator()
try:
yield g
# Call a dummy method to make sure we haven't corrupted the streams
assert lineSep == g.jvm.System.lineSeparator()
finally:
g.shutdown()
def gateway(*args, **kwargs):
g = JavaGateway(gateway_parameters=GatewayParameters(*args, auto_convert=True, **kwargs))
time = g.jvm.System.currentTimeMillis()
try:
yield g
# Call a dummy method to make sure we haven't corrupted the streams
assert time <= g.jvm.System.currentTimeMillis()
finally:
g.shutdown()
def check_JavaGateway():
try:
global app
app = JavaGateway(python_proxy_port=port).entry_point
if app.test() != "TESTOK":
restart_JavaGateway()
except Exception:
restart_JavaGateway()
def check_connection(gateway_parameters=None):
test_gateway = JavaGateway(gateway_parameters=gateway_parameters)
try:
# Call a dummy method just to make sure we can connect to the JVM
test_gateway.jvm.System.currentTimeMillis()
except Py4JNetworkError:
# We could not connect. Let"s wait a long time.
# If it fails after that, there is a bug with our code!
sleep(2)
finally:
test_gateway.close()
def test_gateway_connection():
test_gateway = JavaGateway()
try:
# Call a dummy method just to make sure we can connect to the JVM
test_gateway.jvm.System.lineSeparator()
except Py4JNetworkError:
# We could not connect. Let"s wait a long time.
# If it fails after that, there is a bug with our code!
sleep(2)
finally:
test_gateway.close()
def stop_eclipse():
gateway = JavaGateway()
try:
gateway.entry_point.closeEclipse()
time.sleep(1)
gateway.shutdown()
except Exception:
pass
try:
gateway.close()
except Exception:
pass
class TestIntegration(unittest.TestCase):
def setUp(self):
# logger = logging.getLogger("py4j")
# logger.setLevel(logging.DEBUG)
# logger.addHandler(logging.StreamHandler())
time.sleep(1)
self.p = start_example_app_process()
time.sleep(1)
self.gateway = JavaGateway(start_callback_server=True)
def tearDown(self):
safe_shutdown(self)
self.p.join()
time.sleep(1)
# Does not work when combined with other tests... because of TCP_WAIT
def testShutdown(self):
example = self.gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual('This is Hello!', example.callHello(impl))
self.assertEqual('This is Hello;\n10MyMy!\n;',
example.callHello2(impl))
self.gateway.shutdown()
self.assertEqual(0, len(self.gateway.gateway_property.pool))
def testProxy(self):
# self.gateway.jvm.py4j.GatewayServer.turnLoggingOn()
time.sleep(1)
example = self.gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual('This is Hello!', example.callHello(impl))
self.assertEqual('This is Hello;\n10MyMy!\n;',
example.callHello2(impl))
def testGC(self):
# This will only work with some JVM.
time.sleep(1)
example = self.gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual('This is Hello!', example.callHello(impl))
self.assertEqual('This is Hello;\n10MyMy!\n;',
example.callHello2(impl))
self.assertEqual(2, len(self.gateway.gateway_property.pool))
self.gateway.jvm.java.lang.System.gc()
time.sleep(2)
self.assertTrue(len(self.gateway.gateway_property.pool) < 2)
def testDoubleCallbackServer(self):
try:
self.gateway2 = JavaGateway(start_callback_server=True)
self.fail()
except Exception:
self.assertTrue(True)
def test_on_the_fly_compilation(self):
# http://py4j.sourceforge.net/
# make sure that com.bru.workshop.Application is running
from py4j.java_gateway import JavaGateway
app = JavaGateway().entry_point
value = app.compileAndExecute('Test',''' public class Test {
public static Object execute(){
return "success";
}
}''')
print value
self.assertEqual(value, 'success')
def tearDownClass(cls):
gateway = JavaGateway()
workspace = gateway.jvm.org.eclipse.core.resources.ResourcesPlugin.\
getWorkspace()
root = workspace.getRoot()
pm = gateway.jvm.org.eclipse.core.runtime.NullProgressMonitor()
project1 = root.getProject('project1core3.0')
project1.delete(True, True, pm)
time.sleep(1)
gateway.close()
stop_eclipse()
clean_test_dir()
class JVMMultiProcessTest(unittest.TestCase):
def setUp(self):
# logger = logging.getLogger("py4j")
# logger.setLevel(logging.DEBUG)
# logger.addHandler(logging.StreamHandler())
self.p = start_example_app_process()
time.sleep(0.5)
self.gateway = JavaGateway()
def tearDown(self):
self.p.terminate()
self.gateway.shutdown()
time.sleep(0.5)
def testMultiProcessJVMAccess(self):
workers = [TestJVM1(self.gateway) for _ in range(8)]
for worker in workers:
worker.start()
for worker in workers:
worker.join()
def testMultiProcessSystemReference(self):
System = self.gateway.jvm.java.lang.System
workers = [TestJVM2(System) for _ in range(8)]
for worker in workers:
worker.start()
for worker in workers:
worker.join()
def testMultiProcessJVMReference(self):
jvm = self.gateway.jvm
workers = [TestJVM3(jvm) for _ in range(8)]
for worker in workers:
worker.start()
for worker in workers:
worker.join()
def testMultiProcessJVMError(self):
System = self.gateway.jvm.java.lang.System
workers = [TestJVM4(System) for _ in range(8)]
for worker in workers:
worker.start()
for worker in workers:
worker.join()
def cleanup(): """ General cleanup, if running a java gateway shut it down. This is called after server shutdown, unittest, or test_driver completion. If drivers setup static instances or gateways that stay around their cleanup should go here. """ try: from py4j.java_gateway import JavaGateway try: gateway = JavaGateway() gateway.shutdown() except socket.error: pass except ImportError: pass
def test_all_regular_signals_auto_start(self):
listener = MockListener(self)
with gateway_example_app_process(None):
server_started.connect(listener.started)
gateway = JavaGateway(
gateway_parameters=GatewayParameters(),
callback_server_parameters=CallbackServerParameters())
server_stopped.connect(
listener.stopped, sender=gateway.get_callback_server())
server_connection_started.connect(
listener.connection_started,
sender=gateway.get_callback_server())
server_connection_stopped.connect(
listener.connection_stopped,
sender=gateway.get_callback_server())
pre_server_shutdown.connect(
listener.pre_shutdown, sender=gateway.get_callback_server())
post_server_shutdown.connect(
listener.post_shutdown, sender=gateway.get_callback_server())
example = gateway.entry_point.getNewExample()
impl = IHelloImpl()
self.assertEqual("This is Hello!", example.callHello(impl))
gateway.shutdown()
self.assertEqual(1, listener.received["started"])
self.assertEqual(1, listener.received["stopped"])
self.assertEqual(1, listener.received["pre_shutdown"])
self.assertEqual(1, listener.received["post_shutdown"])
self.assertEqual(1, listener.received["connection_started"])
self.assertEqual(1, listener.received["connection_stopped"])
class TypeConversionTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testLongInt(self):
ex = self.gateway.getNewExample()
self.assertEqual(1, ex.method7(1234))
self.assertEqual(4, ex.method7(2147483648))
self.assertEqual(4, ex.method7(-2147483649))
self.assertEqual(4, ex.method7(long(2147483648)))
self.assertEqual(long(4), ex.method8(3))
self.assertEqual(4, ex.method8(3))
self.assertEqual(long(4), ex.method8(long(3)))
self.assertEqual(long(4), ex.method9(long(3)))
try:
ex.method8(3000000000000000000000000000000000000)
self.fail("Should not be able to convert overflowing long")
except Py4JError:
self.assertTrue(True)
# Check that the connection is not broken (refs #265)
self.assertEqual(4, ex.method8(3))
def testBigDecimal(self):
ex = self.gateway.getNewExample()
self.assertEqual(Decimal("2147483.647"), ex.method10(2147483647, 3))
self.assertEqual(Decimal("-13.456"), ex.method10(Decimal("-14.456")))
def testFloatConversion(self):
java_inf = self.gateway.jvm.java.lang.Double.parseDouble("Infinity")
self.assertEqual(float("inf"), java_inf)
java_inf = self.gateway.jvm.java.lang.Double.parseDouble("+Infinity")
self.assertEqual(float("inf"), java_inf)
java_neg_inf = self.gateway.jvm.java.lang.Double.parseDouble(
"-Infinity")
self.assertEqual(float("-inf"), java_neg_inf)
java_nan = self.gateway.jvm.java.lang.Double.parseDouble("NaN")
self.assertTrue(math.isnan(java_nan))
python_double = 17.133574204226083
java_float = self.gateway.jvm.java.lang.Double(python_double)
self.assertAlmostEqual(python_double, java_float, 15)
def testUnboxingInt(self):
ex = self.gateway.getNewExample()
self.assertEqual(4, ex.getInteger(4))
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from py4j.java_gateway import java_import, JavaGateway, GatewayClient
from pyspark.conf import SparkConf
from pyspark.context import SparkContext
# for back compatibility
from pyspark.sql import SQLContext
# start JVM gateway
client = GatewayClient(port=${JVM_GATEWAY_PORT})
gateway = JavaGateway(client, auto_convert=True)
java_import(gateway.jvm, "org.apache.spark.SparkEnv")
java_import(gateway.jvm, "org.apache.spark.SparkConf")
java_import(gateway.jvm, "org.apache.spark.api.java.*")
java_import(gateway.jvm, "org.apache.spark.api.python.*")
java_import(gateway.jvm, "org.apache.spark.mllib.api.python.*")
intp = gateway.entry_point
jsc = intp.getJavaSparkContext()
java_import(gateway.jvm, "org.apache.spark.sql.*")
java_import(gateway.jvm, "org.apache.spark.sql.hive.*")
java_import(gateway.jvm, "scala.Tuple2")
jconf = jsc.getConf()
def testDefaults(self):
self.gateway = JavaGateway.launch_gateway()
self.assertTrue(self.gateway.jvm)
def testAccessSubprocess(self):
self.gateway = JavaGateway.launch_gateway()
self.assertTrue(self.gateway.java_process)
def testRedirectToNullOtherProcessGroup(self):
self.gateway = JavaGateway.launch_gateway(
create_new_process_group=True)
for i in range(4097): # Hangs if not properly redirected
self.gateway.jvm.System.out.println("Test")
def testCwd(self):
parent_directory = os.path.dirname(os.getcwd())
self.gateway = JavaGateway.launch_gateway(cwd=parent_directory)
java_cwd = self.gateway.jvm.System.getProperty("user.dir")
self.assertEqual(parent_directory, java_cwd)
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway()
class MemoryManagementTest(unittest.TestCase):
def setUp(self):
ThreadSafeFinalizer.clear_finalizers(True)
self.p = start_example_app_process()
def tearDown(self):
safe_shutdown(self)
self.p.join()
gc.collect()
def testNoAttach(self):
self.gateway = JavaGateway()
gateway2 = JavaGateway()
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append("Hello World")
self.gateway.shutdown()
self.assertRaises(Exception, lambda: sb.append("Python"))
self.assertRaises(
Exception, lambda: gateway2.jvm.java.lang.StringBuffer())
def testDetach(self):
self.gateway = JavaGateway()
gc.collect()
finalizers_size_start = len(ThreadSafeFinalizer.finalizers)
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append("Hello World")
self.gateway.detach(sb)
sb2 = self.gateway.jvm.java.lang.StringBuffer()
sb2.append("Hello World")
sb2._detach()
gc.collect()
self.assertEqual(
len(ThreadSafeFinalizer.finalizers) - finalizers_size_start, 0)
self.gateway.shutdown()
def testGCCollect(self):
self.gateway = JavaGateway()
gc.collect()
finalizers_size_start = len(ThreadSafeFinalizer.finalizers)
def internal():
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append("Hello World")
sb2 = self.gateway.jvm.java.lang.StringBuffer()
sb2.append("Hello World")
finalizers_size_middle = len(ThreadSafeFinalizer.finalizers)
return finalizers_size_middle
finalizers_size_middle = internal()
gc.collect()
# Before collection: two objects created + two returned objects (append
# returns a stringbuffer reference for easy chaining).
self.assertEqual(finalizers_size_middle, 4)
# Assert after collection
self.assertEqual(
len(ThreadSafeFinalizer.finalizers) - finalizers_size_start, 0)
self.gateway.shutdown()
def testGCCollectNoMemoryManagement(self):
self.gateway = JavaGateway(
gateway_parameters=GatewayParameters(
enable_memory_management=False))
gc.collect()
# Should have nothing in the finalizers
self.assertEqual(len(ThreadSafeFinalizer.finalizers), 0)
def internal():
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append("Hello World")
sb2 = self.gateway.jvm.java.lang.StringBuffer()
sb2.append("Hello World")
finalizers_size_middle = len(ThreadSafeFinalizer.finalizers)
return finalizers_size_middle
finalizers_size_middle = internal()
gc.collect()
# Before collection: two objects created + two returned objects (append
# returns a stringbuffer reference for easy chaining).
self.assertEqual(finalizers_size_middle, 0)
# Assert after collection
self.assertEqual(len(ThreadSafeFinalizer.finalizers), 0)
self.gateway.shutdown()
def testNoField(self):
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=True))
ex = self.gateway.getNewExample()
member = ex.field50
self.assertTrue(isinstance(member, JavaMember))
def testGetMethod(self):
# This is necessary if a field hides a method...
self.gateway = JavaGateway()
ex = self.gateway.getNewExample()
self.assertEqual(1, get_method(ex, 'method1')())
def testAutoFieldDeprecated(self):
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
self.assertEqual(ex.field10, 10)
class FieldTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testAutoField(self):
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=True))
ex = self.gateway.getNewExample()
self.assertEqual(ex.field10, 10)
self.assertEqual(ex.field11, long(11))
sb = ex.field20
sb.append('Hello')
self.assertEqual('Hello', sb.toString())
self.assertTrue(ex.field21 == None)
def testAutoFieldDeprecated(self):
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
self.assertEqual(ex.field10, 10)
def testNoField(self):
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=True))
ex = self.gateway.getNewExample()
member = ex.field50
self.assertTrue(isinstance(member, JavaMember))
def testNoAutoField(self):
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=False))
ex = self.gateway.getNewExample()
self.assertTrue(isinstance(ex.field10, JavaMember))
self.assertTrue(isinstance(ex.field50, JavaMember))
self.assertEqual(10, get_field(ex, 'field10'))
# This field does not exist
self.assertRaises(Exception, get_field, ex, 'field50')
# With auto field = True
ex._auto_field = True
sb = ex.field20
sb.append('Hello')
self.assertEqual('Hello', sb.toString())
def testSetField(self):
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=False))
ex = self.gateway.getNewExample()
set_field(ex, 'field10', 2334)
self.assertEquals(get_field(ex, 'field10'), 2334)
sb = self.gateway.jvm.java.lang.StringBuffer('Hello World!')
set_field(ex, 'field21', sb)
self.assertEquals(get_field(ex, 'field21').toString(), 'Hello World!')
self.assertRaises(Exception, set_field, ex, 'field1', 123)
def testGetMethod(self):
# This is necessary if a field hides a method...
self.gateway = JavaGateway()
ex = self.gateway.getNewExample()
self.assertEqual(1, get_method(ex, 'method1')())
def setUp(self):
self.p = start_example_app_process()
# This is to ensure that the server is started before connecting to it!
self.gateway = JavaGateway()
class OpenNLPTokenizer:
def __init__(self):
print "calling constructor"
# launches java gateway server.
self.gateway_server = GateWayServer()
self.gateway = JavaGateway()
# limit how long to wait for connection to gateway to be available.
kill_time = 20
init_time = time.time()
while True:
if time.time() - init_time > kill_time:
exit("\ncould not establish connection to gateway...")
try:
self.tokenizer = self.gateway.entry_point.getOpenNlpTokenizer()
break
except:
continue
def __del__(self):
self.gateway.detach(self.tokenizer)
self.gateway.close()
self.tokenizer = None
self.gateway = None
def preProcess(self, text):
""" sentenizes and then tokenizes text """
ret_val = []
for tokenized_sent in self.tokenizer.preProcess(text):
tmp = []
for token in tokenized_sent:
tmp.append(token)
ret_val.append(tmp)
return ret_val
def sentenize(self, text):
sentences = []
for sent in self.tokenizer.sentenize(text):
sentences.append(sent)
return sentences
def tokenize(self, string):
tokens = []
for tok in self.tokenizer.tokenize(string):
tokens.append(tok)
return tokens
from py4j.java_gateway import JavaGateway, CallbackServerParameters
class PythonComputer(object):
def sayHello(self, name: str):
return f'Hello {name}'
class Java:
implements = ["com.dartiguenave.experiments.py4j.PythonComputer"]
if __name__ == '__main__':
computer = PythonComputer()
gateway = JavaGateway(
callback_server_parameters=CallbackServerParameters(),
python_server_entry_point=computer)
class JVMTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testConstructors(self):
jvm = self.gateway.jvm
sb = jvm.java.lang.StringBuffer("hello")
sb.append("hello world")
sb.append(1)
self.assertEqual(sb.toString(), "hellohello world1")
l1 = jvm.java.util.ArrayList()
l1.append("hello world")
l1.append(1)
self.assertEqual(2, len(l1))
self.assertEqual("hello world", l1[0])
l2 = ["hello world", 1]
self.assertEqual(str(l2), str(l1))
def testStaticMethods(self):
System = self.gateway.jvm.java.lang.System
self.assertGreater(System.currentTimeMillis(), 0)
self.assertEqual("123", self.gateway.jvm.java.lang.String.valueOf(123))
def testStaticFields(self):
Short = self.gateway.jvm.java.lang.Short
self.assertEqual(-32768, Short.MIN_VALUE)
System = self.gateway.jvm.java.lang.System
self.assertFalse(System.out.checkError())
def testDefaultImports(self):
self.assertGreater(self.gateway.jvm.System.currentTimeMillis(), 0)
self.assertEqual("123", self.gateway.jvm.String.valueOf(123))
def testNone(self):
ex = self.gateway.entry_point.getNewExample()
ex.method4(None)
def testJavaGatewayServer(self):
server = self.gateway.java_gateway_server
self.assertEqual(
server.getListeningPort(), DEFAULT_PORT)
def testJVMView(self):
newView = self.gateway.new_jvm_view("myjvm")
time = newView.System.currentTimeMillis()
self.assertGreater(time, 0)
time = newView.java.lang.System.currentTimeMillis()
self.assertGreater(time, 0)
def testImport(self):
newView = self.gateway.new_jvm_view("myjvm")
java_import(self.gateway.jvm, "java.util.*")
java_import(self.gateway.jvm, "java.io.File")
self.assertIsNotNone(self.gateway.jvm.ArrayList())
self.assertIsNotNone(self.gateway.jvm.File("hello.txt"))
self.assertRaises(Exception, lambda: newView.File("test.txt"))
java_import(newView, "java.util.HashSet")
self.assertIsNotNone(newView.HashSet())
def testEnum(self):
self.assertEqual("FOO", str(self.gateway.jvm.py4j.examples.Enum2.FOO))
def testInnerClass(self):
self.assertEqual(
"FOO",
str(self.gateway.jvm.py4j.examples.EnumExample.MyEnum.FOO))
self.assertEqual(
"HELLO2",
self.gateway.jvm.py4j.examples.EnumExample.InnerClass.MY_CONSTANT2)
def start(self,
cmd,
num_containers=1,
virtual_cores=1,
memory=128,
files=None,
envvars=None,
app_name="knit",
queue="default",
checks=True):
"""
Method to start a yarn app with a distributed shell
Parameters
----------
cmd: str
command to run in each yarn container
num_containers: int
Number of containers YARN should request (default: 1)
* A container should be requested with the number of cores it can
saturate, i.e.
* the average number of threads it expects to have runnable at a
time.
virtual_cores: int
Number of virtual cores per container (default: 1)
* A node's capacity should be configured with virtual cores equal to
* its number of physical cores.
memory: int
Memory per container (default: 128)
* The unit for memory is megabytes.
files: list
list of files to be include in each container. If starting with
`hdfs://`, assume these already exist in HDFS and don't need
uploading. Otherwise, if hdfs3 is installed, existence of the
file on HDFS will be checked to see if upload is needed.
Files ending with `.zip` will be decompressed in the
container before launch as a directory with the same name as the
file: if myarc.zip contains files inside a directory stuff/, to
the container they will appear at ./myarc.zip/stuff/* .
envvars: dict
Environment variables to pass to AM *and* workers. Both keys
and values must be strings only.
app_name: String
Application name shown in YARN (default: "knit")
queue: String
RM Queue to use while scheduling (default: "default")
checks: bool=True
Whether to run pre-flight checks before submitting app to YARN
Returns
-------
applicationId: str
A yarn application ID string
"""
files = files or []
envvars = envvars or {'KNIT_LANG': self.lang}
for k, v in envvars.items():
if not isinstance(k, str) or not isinstance(v, str):
raise ValueError('Environment must contain only strings (%s)' %
((k, v), ))
if self.app_id:
raise ValueError('Already started')
if not isinstance(memory, int):
raise KnitException("Memory argument must be an integer")
if files:
if not isinstance(files, list):
raise KnitException("File argument must be a list of strings")
if checks:
self._pre_flight_checks(num_containers, virtual_cores, memory,
files, queue)
# From https://github.com/apache/spark/blob/d83c2f9f0b08d6d5d369d9fae04cdb15448e7f0d/python/pyspark/java_gateway.py
# thank you spark
## Socket for PythonGatewayServer to communicate its port to us
callback_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
callback_socket.bind(('127.0.0.1', 0))
callback_socket.listen(1)
callback_host, callback_port = callback_socket.getsockname()
if not os.path.exists(self.JAR_FILE_PATH):
raise KnitException('JAR file %s does not exists - please build'
' with maven' % self.JAR_FILE_PATH)
args = [
"hadoop", "jar", self.JAR_FILE_PATH, self.JAVA_APP,
"--callbackHost",
str(callback_host), "--callbackPort",
str(callback_port)
]
## Launch the Java gateway.
# We open a pipe to stdin so that the Java gateway can die when the pipe is broken
if not on_windows:
# Don't send ctrl-c / SIGINT to the Java gateway:
def preexec_func():
signal.signal(signal.SIGINT, signal.SIG_IGN)
proc = Popen(args, stdin=PIPE, preexec_fn=preexec_func)
else:
# preexec_fn not supported on Windows
proc = Popen(args, stdin=PIPE)
self.proc = proc
gateway_port = None
# We use select() here in order to avoid blocking indefinitely if the
# subprocess dies before connecting
long_timeout = 60
while gateway_port is None and proc.poll(
) is None and long_timeout > 0:
timeout = 1 # (seconds)
readable, _, _ = select.select([callback_socket], [], [], timeout)
if callback_socket in readable:
gateway_connection = callback_socket.accept()[0]
# Determine which ephemeral port the server started on:
gateway_port = read_int(gateway_connection.makefile(mode="rb"))
gateway_connection.close()
callback_socket.close()
long_timeout -= 1
if gateway_port is None:
raise Exception(
"The JVM Knit client failed to launch successfully."
" Check that java is installed and the Knit JAR"
" file exists.")
gateway = JavaGateway(GatewayClient(port=gateway_port),
auto_convert=True)
self.client = gateway.entry_point
self.client_gateway = gateway
logger.debug("Files submitted: %s" % files)
upfiles = [
f for f in files
if (not f.startswith('hdfs://') and self.check_needs_upload(f))
]
logger.debug("Files to upload: %s" % upfiles)
jfiles = ListConverter().convert(upfiles, gateway._gateway_client)
jenv = MapConverter().convert(envvars, gateway._gateway_client)
self.app_id = self.client.start(jfiles, jenv, app_name, queue)
## Wait for AM to appear
long_timeout = 100
master_rpcport = -1
while master_rpcport == -1:
master_rpcport = self.client.masterRPCPort()
time.sleep(0.2)
long_timeout -= 0.2
if long_timeout < 0:
break
if master_rpcport in [-1, 'N/A']:
raise Exception(
"""The application master JVM process failed to report back. This can mean:
- that the YARN cluster cannot scheduler adequate resources - check
k.yarn_api.cluster_metrics() and other diagnostic methods;
- that the ApplicationMaster crashed - check the application logs, k.logs();
- that the cluster is otherwise unhealthy - check the RM and NN logs
(use k.yarn_api.system_logs() to find these on a one-node system
""")
master_rpchost = self.client.masterRPCHost()
gateway = JavaGateway(GatewayClient(address=master_rpchost,
port=master_rpcport),
auto_convert=True)
self.master = gateway.entry_point
rfiles = [
triple_slash(f) if f.startswith('hdfs://') else '/'.join(
[self.hdfs_home, '.knitDeps',
os.path.basename(f)]) for f in files
]
logger.debug("Resource files: %s" % rfiles)
jfiles = ListConverter().convert(rfiles, gateway._gateway_client)
jenv = MapConverter().convert(envvars, gateway._gateway_client)
self.master.init(jfiles, jenv, cmd, num_containers, virtual_cores,
memory)
return self.app_id
def test_gateway_client(self):
gateway_client = GatewayClient(port=DEFAULT_PORT)
self.gateway = JavaGateway(gateway_client=gateway_client)
i = self.gateway.jvm.System.currentTimeMillis()
self.assertGreater(i, 0)
(b, g, r) = cv2.split(img)
img = cv2.merge([r, g, b])
img = cv2.resize(img, (50, 50))
images.append(img)
return images, file_names
# load the trained model.
model = load_model('my_model.h5')
# load the best weights for the model.
model.load_weights('weights.best.hdf5')
model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
# connect to the JVM
gateway = JavaGateway(gateway_parameters=GatewayParameters(port=25335))
# get the patient path.
patient = gateway.entry_point
# define the path of the folders where images are contained.
path = patient.getPathInput()
img_list, file_names = load_data(path)
# images to multi dimensional arrays
img_list = np.array(img_list)
img_list = img_list.astype("float32")
img_list /= 255
img_list = img_list.reshape(img_list.shape[0], 50, 50, 3)
def testRedirectToNull(self):
self.gateway = JavaGateway.launch_gateway()
for i in range(4097): # Hangs if not properly redirected
self.gateway.jvm.System.out.println("Test")
def _start_gateway(self):
self._gateway = JavaGateway()
return self._gateway.entry_point.getGenericObject()
def testJavaopts(self):
self.gateway = JavaGateway.launch_gateway(javaopts=["-Xmx64m"])
self.assertTrue(self.gateway.jvm)
#!/usr/bin/python
import sys
import time
# import json
from py4j.java_gateway import GatewayParameters, JavaGateway, java_import
J = JavaGateway(gateway_parameters = GatewayParameters(address="app.vietthuan.com",port=33333))
JJ = J.entry_point
java_import(J.jvm,'java.json.*')
java_import(J.jvm,'java.lang.*')
java_import(J.jvm,'java.util.*')
java_import(J.jvm,'java.io.*')
# java_import(J.jvm,'java.sql.*')
java_import(J.jvm,'java.Math.*')
print("E",J.jvm.Math.E)
print("PI",J.jvm.java.lang.Math.PI)
print("ATEN",J.jvm.Math.atan(J.jvm.Math.PI))
# ====================================
print("max",J.jvm.Math.max(543.234,34242.764))
print("min",J.jvm.java.lang.Math.min(543.234,34242.764)) #完整路徑
# ====================================
# print(type(J.jvm.System.getProperties())) #用key/value方法取值
# print(J.jvm.java.util.ArrayList()) #完整路徑
# jList2 = J.jvm.ArrayList()
# jMap = J.jvm.HashMap()
# jArr = J.jvm.ArrayList()
# jArr.add(1234)
def testCreateNewProcessGroup(self):
self.gateway = JavaGateway.launch_gateway(
create_new_process_group=True)
self.assertTrue(self.gateway.jvm)
def launch_gateway(user_classpath = []): return JavaGateway.launch_gateway(classpath = os.pathsep.join(_classpath(user_classpath)))
def testJavaPath(self):
self.gateway = JavaGateway.launch_gateway(java_path=None)
self.assertTrue(self.gateway.jvm)
from py4j.java_gateway import JavaGateway
class FalseAddition(object):
def doOperation(self, i, j, k=None):
if k == None:
# Integer overflow!
return 3722507311
else:
return 3722507311
class Java:
implements = ['py4j.examples.Operator']
if __name__ == "__main__":
java_gateway = JavaGateway(start_callback_server=True)
operator = FalseAddition()
print('Before the call')
try:
java_gateway.entry_point.randomTernaryOperator(operator)
except Exception:
pass
print('After the call')
java_gateway.shutdown()
print('After shutdown')
class SimpleHello(object):
def sayHello(self, int_value=None, string_value=None):
print(int_value, string_value)
return "Said hello to {0}".format(string_value)
class Java:
implements = ["other.python.py4j.j2p.IHello"]
# Make sure that the python code is started first.
# Then execute: java -cp py4j.jar py4j.examples.SingleThreadClientApplication
from py4j.java_gateway import JavaGateway, CallbackServerParameters
simple_hello = SimpleHello()
gateway = JavaGateway(callback_server_parameters=CallbackServerParameters(),
python_server_entry_point=simple_hello)
def setUp(self):
self.p = start_example_app_process()
gateway_client = GatewayClient()
self.gateway = JavaGateway()
self.gateway.set_gateway_client(gateway_client)
def testNoCallbackServer(self):
# Test that the program can continue to move on and that no close
# is required.
JavaGateway()
self.assertTrue(True)
class ProtocolTest(unittest.TestCase):
def tearDown(self):
# Safety check in case there was an exception...
safe_shutdown(self)
def testEscape(self):
self.assertEqual(
"Hello\t\rWorld\n\\",
unescape_new_line(escape_new_line("Hello\t\rWorld\n\\")))
self.assertEqual(
"Hello\t\rWorld\n\\",
unescape_new_line(escape_new_line("Hello\t\rWorld\n\\")))
def testProtocolSend(self):
testConnection = TestConnection()
self.gateway = JavaGateway()
# Replace gateway client by test connection
self.gateway.set_gateway_client(testConnection)
e = self.gateway.getExample()
self.assertEqual('c\nt\ngetExample\ne\n', testConnection.last_message)
e.method1(1, True, 'Hello\nWorld', e, None, 1.5)
self.assertEqual(
'c\no0\nmethod1\ni1\nbTrue\nsHello\\nWorld\nro0\nn\nd1.5\ne\n',
testConnection.last_message)
del (e)
def testProtocolReceive(self):
p = start_echo_server_process()
try:
testSocket = get_socket()
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yro0\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ysHello World\n'.encode('utf-8'))
# No extra echange (method3) because it is already cached.
testSocket.sendall('yi123\n'.encode('utf-8'))
testSocket.sendall('yd1.25\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yn\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ybTrue\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yL123\n'.encode('utf-8'))
testSocket.sendall('ydinf\n'.encode('utf-8'))
testSocket.close()
sleep()
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=True))
ex = self.gateway.getNewExample()
self.assertEqual('Hello World', ex.method3(1, True))
self.assertEqual(123, ex.method3())
self.assertAlmostEqual(1.25, ex.method3())
self.assertTrue(ex.method2() is None)
self.assertTrue(ex.method4())
self.assertEqual(long(123), ex.method8())
self.assertEqual(float("inf"), ex.method8())
self.gateway.shutdown()
except Exception:
print_exc()
self.fail('Problem occurred')
p.join()
