class MethodTest(unittest.TestCase):
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()
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testNoneArg(self):
ex = self.gateway.getNewExample()
try:
ex.method2(None)
ex2 = ex.method4(None)
self.assertEquals(ex2.getField1(), 3)
self.assertEquals(2, ex.method7(None))
except Exception:
print_exc()
self.fail()
def testMagicMethods(self):
ex = self.gateway.getNewExample()
self.assertRaises(AttributeError, lambda: ex.__add__("asd"))
def testUnicode(self):
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append("\r\n\tHello\r\n\t")
self.assertEqual("\r\n\tHello\r\n\t", sb.toString())
def testEscape(self):
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append("\r\n\tHello\r\n\t")
self.assertEqual("\r\n\tHello\r\n\t", sb.toString())
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 FieldTest(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)
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testAutoField(self):
self.gateway = JavaGateway(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 testNoField(self):
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
member = ex.field50
self.assertTrue(isinstance(member, JavaMember))
def testNoAutoField(self):
self.gateway = JavaGateway(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(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')())
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 =\
u"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 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))
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.assertTrue(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.assertTrue(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.assertTrue(len(help_page) > 1)
self.assertTrue("String" in help_page)
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")))
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(1172, 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(855, 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 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))
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")))
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 IntegrationTest(unittest.TestCase):
def setUp(self):
self.p = start_echo_server_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
def tearDown(self):
# Safety check in case there was an exception...
safe_shutdown(self)
self.p.join()
def testIntegration(self):
try:
testSocket = get_test_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'))
# testSocket.sendall('yo\n'.encode('utf-8')) # No need because getNewExampe is in cache now!
testSocket.sendall('yro1\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ysHello World2\n'.encode('utf-8'))
testSocket.close()
time.sleep(1)
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
response = ex.method3(1, True)
self.assertEqual('Hello World', response)
ex2 = self.gateway.entry_point.getNewExample()
response = ex2.method3(1, True)
self.assertEqual('Hello World2', response)
self.gateway.shutdown()
except Exception as e:
print('Error has occurred', e)
self.fail('Problem occurred')
def testException(self):
try:
testSocket = get_test_socket()
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('yro0\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall(b'x\n')
testSocket.close()
time.sleep(1)
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
try:
ex.method3(1, True)
self.fail('Should have failed!')
except Py4JError:
self.assertTrue(True)
self.gateway.shutdown()
except Exception as e:
print('Error has occurred', e)
self.fail('Problem occurred')
class IntegrationTest(unittest.TestCase):
def setUp(self):
self.p = start_echo_server_process()
# This is to ensure that the server is started before connecting to it!
time.sleep(1)
def tearDown(self):
# Safety check in case there was an exception...
safe_shutdown(self)
self.p.join()
def testIntegration(self):
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'))
testSocket.sendall('yro1\n'.encode('utf-8'))
testSocket.sendall('yo\n'.encode('utf-8'))
testSocket.sendall('ysHello World2\n'.encode('utf-8'))
testSocket.close()
time.sleep(1)
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
response = ex.method3(1, True)
self.assertEqual('Hello World', response)
ex2 = self.gateway.entry_point.getNewExample()
response = ex2.method3(1, True)
self.assertEqual('Hello World2', response)
self.gateway.shutdown()
except Exception as e:
print('Error has occurred', e)
self.fail('Problem occurred')
def testException(self):
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(b'x\n')
testSocket.close()
time.sleep(1)
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
try:
ex.method3(1, True)
self.fail('Should have failed!')
except Py4JError:
self.assertTrue(True)
self.gateway.shutdown()
except Exception as e:
print('Error has occurred', e)
self.fail('Problem occurred')
class IntegrationTest(unittest.TestCase):
def setUp(self):
self.p = start_echo_server_process()
# This is to ensure that the server is started before connecting to it!
def tearDown(self):
# Safety check in case there was an exception...
safe_shutdown(self)
self.p.join()
def testIntegration(self):
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"))
testSocket.sendall("!yro1\n".encode("utf-8"))
testSocket.sendall("!yo\n".encode("utf-8"))
testSocket.sendall("!ysHello World2\n".encode("utf-8"))
testSocket.close()
sleep()
self.gateway = JavaGateway(
gateway_parameters=GatewayParameters(auto_field=True))
ex = self.gateway.getNewExample()
response = ex.method3(1, True)
self.assertEqual("Hello World", response)
ex2 = self.gateway.entry_point.getNewExample()
response = ex2.method3(1, True)
self.assertEqual("Hello World2", response)
self.gateway.shutdown()
except Exception:
self.fail("Problem occurred")
def testException(self):
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(b"!x\n")
testSocket.close()
sleep()
self.gateway = JavaGateway(
gateway_parameters=GatewayParameters(auto_field=True))
ex = self.gateway.getNewExample()
self.assertRaises(Py4JError, lambda: ex.method3(1, True))
self.gateway.shutdown()
except Exception:
self.fail("Problem occurred")
class IntegrationTest(unittest.TestCase):
def setUp(self):
self.p = start_echo_server_process()
# This is to ensure that the server is started before connecting to it!
def tearDown(self):
# Safety check in case there was an exception...
safe_shutdown(self)
self.p.join()
def testIntegration(self):
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"))
testSocket.sendall("!yro1\n".encode("utf-8"))
testSocket.sendall("!yo\n".encode("utf-8"))
testSocket.sendall("!ysHello World2\n".encode("utf-8"))
testSocket.close()
sleep()
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=True))
ex = self.gateway.getNewExample()
response = ex.method3(1, True)
self.assertEqual("Hello World", response)
ex2 = self.gateway.entry_point.getNewExample()
response = ex2.method3(1, True)
self.assertEqual("Hello World2", response)
self.gateway.shutdown()
except Exception:
self.fail("Problem occurred")
def testException(self):
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(b"!x\n")
testSocket.close()
sleep()
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_field=True))
ex = self.gateway.getNewExample()
self.assertRaises(Py4JError, lambda: ex.method3(1, True))
self.gateway.shutdown()
except Exception:
self.fail("Problem occurred")
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))
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))
class MethodTest(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 testNoneArg(self):
ex = self.gateway.getNewExample()
try:
ex.method2(None)
ex2 = ex.method4(None)
self.assertEquals(ex2.getField1(), 3)
self.assertEquals(2, ex.method7(None))
except Exception:
print_exc()
self.fail()
def testUnicode(self):
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append('\r\n\tHello\r\n\t')
self.assertEqual('\r\n\tHello\r\n\t', sb.toString())
def testEscape(self):
sb = self.gateway.jvm.java.lang.StringBuffer()
sb.append('\r\n\tHello\r\n\t')
self.assertEqual('\r\n\tHello\r\n\t', sb.toString())
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.assertIsNone(ex.method2())
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 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 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()
class AutoConvertTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway(
gateway_parameters=GatewayParameters(auto_convert=True))
def tearDown(self):
safe_shutdown(self)
self.p.join()
sleep()
def testAutoConvert(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
self.assertTrue(jList.equals(pList))
class AutoConvertTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_convert=True))
def tearDown(self):
safe_shutdown(self)
self.p.join()
sleep()
def testAutoConvert(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
self.assertTrue(jList.equals(pList))
class AutoConvertTest(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(auto_convert=True)
def tearDown(self):
safe_shutdown(self)
self.p.join()
time.sleep(0.5)
def testAutoConvert(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
self.assertTrue(jList.equals(pList))
class AutoConvertTest(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(auto_convert=True)
def tearDown(self):
self.p.terminate()
self.gateway.shutdown()
time.sleep(0.5)
def testAutoConvert(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
self.assertTrue(jList.equals(pList))
class AutoConvertTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(auto_convert=True))
def tearDown(self):
safe_shutdown(self)
self.p.join()
sleep()
def testAutoConvert(self):
ex = self.gateway.getNewExample()
python_list = get_list(3)
java_list = ex.getList(3)
self.assertTrue(java_list.equals(python_list))
def testAutoConvertConstructor(self):
python_list = get_list(3)
java_list = self.gateway.jvm.java.util.ArrayList(python_list)
self.assertTrue(java_list.equals(python_list))
def testAutoConvertNotByteArray(self):
self.gateway.jvm.java.nio.ByteBuffer.wrap(bytearray(range(255)))
class AutoConvertTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway(gateway_parameters=GatewayParameters(
auto_convert=True))
def tearDown(self):
safe_shutdown(self)
self.p.join()
sleep()
def testAutoConvert(self):
ex = self.gateway.getNewExample()
python_list = get_list(3)
java_list = ex.getList(3)
self.assertTrue(java_list.equals(python_list))
def testAutoConvertConstructor(self):
python_list = get_list(3)
java_list = self.gateway.jvm.java.util.ArrayList(python_list)
self.assertTrue(java_list.equals(python_list))
def testAutoConvertNotByteArray(self):
self.gateway.jvm.java.nio.ByteBuffer.wrap(bytearray(range(255)))
class ListTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
sleep()
def testJavaListProtocol(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList.append("1")
jList.append("1")
pList.sort()
jList.sort()
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.reverse()
jList.reverse()
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.count("1"), jList.count("1"))
self.assertEqual(pList.count("2"), jList.count("2"))
self.assertEqual(pList.count("-1"), jList.count("-1"))
# Hack because this is a list of strings
self.assertEqual(max(pList), max(jList))
self.assertEqual(min(pList), min(jList))
def testJavaListProtocol2(self):
ex = self.gateway.entry_point.getNewExample()
pList = get_list(3)
pList2 = get_list(4)
jList = ex.getList(3)
jList2 = ex.getList(4)
pList3 = pList + pList2
jList3 = jList + jList2
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = pList * 3
jList3 = jList * 3
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = 3 * pList
jList3 = 3 * jList
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = pList * 0
jList3 = jList * 0
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList += pList2
jList += jList2
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList2 *= 3
jList2 *= 3
self.assertEqual(len(pList2), len(jList2))
self.assertEqual(str(pList2), str(jList2))
pList2 *= -1
jList2 *= -1
self.assertEqual(len(pList2), len(jList2))
self.assertEqual(str(pList2), str(jList2))
def testJavaListGetSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(5)
jList = ex.getList(5)
pSlice = pList[1:3]
jSlice = jList[1:3]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
pSlice = pList[0:0]
jSlice = jList[0:0]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
pSlice = pList[0:-2]
jSlice = jList[0:-2]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
def testJavaListDelSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(5)
jList = ex.getList(5)
del pList[1:3]
del jList[1:3]
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
def testJavaListSetSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(6)
jList = ex.getList(6)
tList = ["500", "600"]
pList[0:0] = tList
jList[0:0] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1:2] = tList
jList[1:2] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[3:5] = tList
jList[3:5] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1:5:2] = tList
jList[1:5:2] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[0:4] = tList
jList[0:4] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList = get_list(6)
jList = ex.getList(6)
try:
pList[0:6:2] = tList
self.fail("Should have failed")
except ValueError:
self.assertTrue(True)
try:
jList[0:6:2] = tList
self.fail("Should have failed")
except ValueError:
self.assertTrue(True)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList = get_list(6)
jList = ex.getList(6)
pList[100:100] = tList
jList[100:100] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1000:10000] = tList
jList[1000:10000] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
try:
self.assertTrue(jList.equals(pList))
self.fail("Should have failed")
except Exception:
self.assertTrue(True)
def testJavaList(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList2 = get_list(3)
jList2 = ex.getList(3)
# Lists are not "hashable" in Python. Too bad.
# self.assertEqual(hash(pList),hash(pList2))
self.assertEqual(hash(jList), hash(jList2))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList, pList2)
self.assertEqual(jList, jList2)
pList.append("4")
jList.append("4")
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList[0], jList[0])
self.assertEqual(pList[3], jList[3])
pList.extend(pList2)
jList.extend(jList2)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual("1" in pList, "1" in jList)
self.assertEqual("500" in pList, "500" in jList)
pList[0] = "100"
jList[0] = "100"
pList[3] = "150"
jList[3] = "150"
pList[-1] = "200"
jList[-1] = "200"
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.insert(0, "100")
jList.insert(0, "100")
pList.insert(3, "150")
jList.insert(3, "150")
pList.insert(-1, "200")
jList.insert(-1, "200")
pList.insert(len(pList), "300")
jList.insert(len(pList), "300")
pList.insert(300, "1500")
jList.insert(300, "1500")
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(), jList.pop())
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(-1), jList.pop(-1))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(2), jList.pop(2))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
del pList[0]
del jList[0]
del pList[-1]
del jList[-1]
del pList[1]
del jList[1]
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.append("700")
jList.append("700")
pList.insert(0, "700")
jList.insert(0, "700")
pList.remove("700")
jList.remove("700")
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
try:
jList[15]
self.fail("Should Fail!")
except IndexError:
self.assertTrue(True)
def testRemove(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList.append(10)
jList.append(10)
# If remove(10) was invoked on the Java side, this would not work!
# Instead, 10 has to be converted to an index...
pList.remove(10)
jList.remove(10)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
def testBinaryOp(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
jList2 = ex.getList(4)
self.assertTrue(jList == jList)
self.assertTrue(jList != jList2)
# self.assertTrue(jList < jList2)
self.assertTrue(jList != pList)
# self.assertTrue(jList == pList)
# self.assertTrue(jList2 != pList)
# self.assertTrue(jList2 > pList)
def testException(self):
ex = self.gateway.getNewExample()
jList = ex.getList(1)
try:
jList.get(5)
except Py4JJavaError:
self.assertTrue(True)
except Py4JError:
self.fail()
class FieldTest(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)
def tearDown(self):
safe_shutdown(self)
self.p.join()
def testAutoField(self):
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
self.assertEqual(ex.field10, 10)
sb = ex.field20
sb.append('Hello')
self.assertEqual('Hello', sb.toString())
self.assertTrue(ex.field21 == None)
def testNoField(self):
self.gateway = JavaGateway(auto_field=True)
ex = self.gateway.getNewExample()
member = ex.field50
self.assertTrue(isinstance(member, JavaMember))
def testNoAutoField(self):
self.gateway = JavaGateway(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'))
try:
get_field(ex, 'field50')
self.fail()
except Exception:
self.assertTrue(True)
ex._auto_field = True
sb = ex.field20
sb.append('Hello')
self.assertEqual('Hello', sb.toString())
try:
get_field(ex, 'field20')
self.fail()
except Exception:
self.assertTrue(True)
def testSetField(self):
self.gateway = JavaGateway(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!')
try:
set_field(ex, 'field1', 123)
self.fail()
except Exception:
self.assertTrue(True)
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')())
class ListTest(unittest.TestCase):
def setUp(self):
self.p = start_example_app_process()
self.gateway = JavaGateway()
def tearDown(self):
safe_shutdown(self)
self.p.join()
sleep()
def testJavaListProtocol(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList.append("1")
jList.append("1")
pList.sort()
jList.sort()
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.reverse()
jList.reverse()
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.count("1"), jList.count("1"))
self.assertEqual(pList.count("2"), jList.count("2"))
self.assertEqual(pList.count("-1"), jList.count("-1"))
# Hack because this is a list of strings
self.assertEqual(max(pList), max(jList))
self.assertEqual(min(pList), min(jList))
def testJavaListProtocol2(self):
ex = self.gateway.entry_point.getNewExample()
pList = get_list(3)
pList2 = get_list(4)
jList = ex.getList(3)
jList2 = ex.getList(4)
pList3 = pList + pList2
jList3 = jList + jList2
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = pList * 3
jList3 = jList * 3
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = 3 * pList
jList3 = 3 * jList
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = pList * 0
jList3 = jList * 0
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList += pList2
jList += jList2
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList2 *= 3
jList2 *= 3
self.assertEqual(len(pList2), len(jList2))
self.assertEqual(str(pList2), str(jList2))
pList2 *= -1
jList2 *= -1
self.assertEqual(len(pList2), len(jList2))
self.assertEqual(str(pList2), str(jList2))
def testJavaListGetSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(5)
jList = ex.getList(5)
pSlice = pList[1:3]
jSlice = jList[1:3]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
pSlice = pList[0:0]
jSlice = jList[0:0]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
pSlice = pList[0:-2]
jSlice = jList[0:-2]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
def testJavaListDelSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(5)
jList = ex.getList(5)
del pList[1:3]
del jList[1:3]
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
def testJavaListSetSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(6)
jList = ex.getList(6)
tList = ["500", "600"]
pList[0:0] = tList
jList[0:0] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1:2] = tList
jList[1:2] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[3:5] = tList
jList[3:5] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1:5:2] = tList
jList[1:5:2] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[0:4] = tList
jList[0:4] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList = get_list(6)
jList = ex.getList(6)
try:
pList[0:6:2] = tList
self.fail("Should have failed")
except ValueError:
self.assertTrue(True)
try:
jList[0:6:2] = tList
self.fail("Should have failed")
except ValueError:
self.assertTrue(True)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList = get_list(6)
jList = ex.getList(6)
pList[100:100] = tList
jList[100:100] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1000:10000] = tList
jList[1000:10000] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
try:
self.assertTrue(jList.equals(pList))
self.fail("Should have failed")
except Exception:
self.assertTrue(True)
def testJavaList(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList2 = get_list(3)
jList2 = ex.getList(3)
# Lists are not "hashable" in Python. Too bad.
# self.assertEqual(hash(pList),hash(pList2))
self.assertEqual(hash(jList), hash(jList2))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList, pList2)
self.assertEqual(jList, jList2)
pList.append("4")
jList.append("4")
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList[0], jList[0])
self.assertEqual(pList[3], jList[3])
pList.extend(pList2)
jList.extend(jList2)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual("1" in pList, "1" in jList)
self.assertEqual("500" in pList, "500" in jList)
pList[0] = "100"
jList[0] = "100"
pList[3] = "150"
jList[3] = "150"
pList[-1] = "200"
jList[-1] = "200"
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.insert(0, "100")
jList.insert(0, "100")
pList.insert(3, "150")
jList.insert(3, "150")
pList.insert(-1, "200")
jList.insert(-1, "200")
pList.insert(len(pList), "300")
jList.insert(len(pList), "300")
pList.insert(300, "1500")
jList.insert(300, "1500")
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(), jList.pop())
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(-1), jList.pop(-1))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(2), jList.pop(2))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
del pList[0]
del jList[0]
del pList[-1]
del jList[-1]
del pList[1]
del jList[1]
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.append("700")
jList.append("700")
pList.insert(0, "700")
jList.insert(0, "700")
pList.remove("700")
jList.remove("700")
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
try:
jList[15]
self.fail("Should Fail!")
except IndexError:
self.assertTrue(True)
def testRemove(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList.append(10)
jList.append(10)
# If remove(10) was invoked on the Java side, this would not work!
# Instead, 10 has to be converted to an index...
pList.remove(10)
jList.remove(10)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
def testBinaryOp(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
jList2 = ex.getList(4)
self.assertTrue(jList == jList)
self.assertTrue(jList != jList2)
# self.assertTrue(jList < jList2)
self.assertTrue(jList != pList)
# self.assertTrue(jList == pList)
# self.assertTrue(jList2 != pList)
# self.assertTrue(jList2 > pList)
def testException(self):
ex = self.gateway.getNewExample()
jList = ex.getList(1)
try:
jList.get(5)
except Py4JJavaError:
self.assertTrue(True)
except Py4JError:
self.fail()
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):
safe_shutdown(self)
self.p.join()
time.sleep(0.5)
def testJavaListProtocol(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList.append('1')
jList.append('1')
pList.sort()
jList.sort()
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.reverse()
jList.reverse()
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.count('1'), jList.count('1'))
self.assertEqual(pList.count('2'), jList.count('2'))
self.assertEqual(pList.count('-1'), jList.count('-1'))
# Hack because this is a list of strings
self.assertEqual(max(pList), max(jList))
self.assertEqual(min(pList), min(jList))
def testJavaListProtocol2(self):
ex = self.gateway.entry_point.getNewExample()
pList = get_list(3)
pList2 = get_list(4)
jList = ex.getList(3)
jList2 = ex.getList(4)
pList3 = pList + pList2
jList3 = jList + jList2
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = pList * 3
jList3 = jList * 3
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = 3 * pList
jList3 = 3 * jList
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = pList * 0
jList3 = jList * 0
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList += pList2
jList += jList2
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList2 *= 3
jList2 *= 3
self.assertEqual(len(pList2), len(jList2))
self.assertEqual(str(pList2), str(jList2))
pList2 *= -1
jList2 *= -1
self.assertEqual(len(pList2), len(jList2))
self.assertEqual(str(pList2), str(jList2))
def testJavaListGetSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(5)
jList = ex.getList(5)
pSlice = pList[1:3]
jSlice = jList[1:3]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
pSlice = pList[0:0]
jSlice = jList[0:0]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
pSlice = pList[0:-2]
jSlice = jList[0:-2]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
def testJavaListDelSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(5)
jList = ex.getList(5)
del pList[1:3]
del jList[1:3]
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
def testJavaListSetSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(6)
jList = ex.getList(6)
tList = ['500', '600']
pList[0:0] = tList
jList[0:0] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1:2] = tList
jList[1:2] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[3:5] = tList
jList[3:5] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1:5:2] = tList
jList[1:5:2] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[0:4] = tList
jList[0:4] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList = get_list(6)
jList = ex.getList(6)
try:
pList[0:6:2] = tList
self.fail('Should have failed')
except ValueError:
self.assertTrue(True)
try:
jList[0:6:2] = tList
self.fail('Should have failed')
except ValueError:
self.assertTrue(True)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList = get_list(6)
jList = ex.getList(6)
pList[100:100] = tList
jList[100:100] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1000:10000] = tList
jList[1000:10000] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
try:
self.assertTrue(jList.equals(pList))
self.fail('Should have failed')
except Exception:
self.assertTrue(True)
def testJavaList(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList2 = get_list(3)
jList2 = ex.getList(3)
# Lists are not "hashable" in Python. Too bad.
#self.assertEqual(hash(pList),hash(pList2))
self.assertEqual(hash(jList), hash(jList2))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList, pList2)
self.assertEqual(jList, jList2)
pList.append('4')
jList.append('4')
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList[0], jList[0])
self.assertEqual(pList[3], jList[3])
pList.extend(pList2)
jList.extend(jList2)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual('1' in pList, '1' in jList)
self.assertEqual('500' in pList, '500' in jList)
pList[0] = '100'
jList[0] = '100'
pList[3] = '150'
jList[3] = '150'
pList[-1] = '200'
jList[-1] = '200'
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.insert(0, '100')
jList.insert(0, '100')
pList.insert(3, '150')
jList.insert(3, '150')
pList.insert(-1, '200')
jList.insert(-1, '200')
pList.insert(len(pList), '300')
jList.insert(len(pList), '300')
pList.insert(300, '1500')
jList.insert(300, '1500')
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(), jList.pop())
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(-1), jList.pop(-1))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(2), jList.pop(2))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
del pList[0]
del jList[0]
del pList[-1]
del jList[-1]
del pList[1]
del jList[1]
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.append('700')
jList.append('700')
pList.insert(0, '700')
jList.insert(0, '700')
pList.remove('700')
jList.remove('700')
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
try:
jList[15]
self.fail('Should Fail!')
except IndexError:
self.assertTrue(True)
def testRemove(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList.append(10)
jList.append(10)
# If remove(10) was invoked on the Java side, this would not work!
# Instead, 10 has to be converted to an index...
pList.remove(10)
jList.remove(10)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
def testBinaryOp(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
jList2 = ex.getList(4)
self.assertTrue(jList == jList)
self.assertTrue(jList != jList2)
#self.assertTrue(jList < jList2)
self.assertTrue(jList != pList)
#self.assertTrue(jList == pList)
# self.assertTrue(jList2 != pList)
# self.assertTrue(jList2 > pList)
def testException(self):
ex = self.gateway.getNewExample()
jList = ex.getList(1)
try:
jList.get(5)
except Py4JJavaError:
self.assertTrue(True)
except Py4JError:
self.fail()
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 is 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")())
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 testJavaListProtocol(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList.append('1')
jList.append('1')
pList.sort()
jList.sort()
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.reverse()
jList.reverse()
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.count('1'), jList.count('1'))
self.assertEqual(pList.count('2'), jList.count('2'))
self.assertEqual(pList.count('-1'), jList.count('-1'))
# Hack because this is a list of strings
self.assertEqual(max(pList), max(jList))
self.assertEqual(min(pList), min(jList))
def testJavaListProtocol2(self):
ex = self.gateway.entry_point.getNewExample()
pList = get_list(3)
pList2 = get_list(4)
jList = ex.getList(3)
jList2 = ex.getList(4)
pList3 = pList + pList2
jList3 = jList + jList2
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = pList * 3
jList3 = jList * 3
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = 3 * pList
jList3 = 3 * jList
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList3 = pList * 0
jList3 = jList * 0
self.assertEqual(len(pList3), len(jList3))
self.assertEqual(str(pList3), str(jList3))
pList += pList2
jList += jList2
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList2 *= 3
jList2 *= 3
self.assertEqual(len(pList2), len(jList2))
self.assertEqual(str(pList2), str(jList2))
pList2 *= -1
jList2 *= -1
self.assertEqual(len(pList2), len(jList2))
self.assertEqual(str(pList2), str(jList2))
def testJavaListGetSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(5)
jList = ex.getList(5)
pSlice = pList[1:3]
jSlice = jList[1:3]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
pSlice = pList[0:0]
jSlice = jList[0:0]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
pSlice = pList[0:-2]
jSlice = jList[0:-2]
self.assertEqual(len(pSlice), len(jSlice))
self.assertEqual(str(pSlice), str(jSlice))
def testJavaListDelSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(5)
jList = ex.getList(5)
del pList[1:3]
del jList[1:3]
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
def testJavaListSetSlice(self):
ex = self.gateway.getNewExample()
pList = get_list(6)
jList = ex.getList(6)
tList = ['500', '600']
pList[0:0] = tList
jList[0:0] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1:2] = tList
jList[1:2] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[3:5] = tList
jList[3:5] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1:5:2] = tList
jList[1:5:2] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[0:4] = tList
jList[0:4] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList = get_list(6)
jList = ex.getList(6)
try:
pList[0:6:2] = tList
self.fail('Should have failed')
except ValueError:
self.assertTrue(True)
try:
jList[0:6:2] = tList
self.fail('Should have failed')
except ValueError:
self.assertTrue(True)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList = get_list(6)
jList = ex.getList(6)
pList[100:100] = tList
jList[100:100] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList[1000:10000] = tList
jList[1000:10000] = tList
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
try:
self.assertTrue(jList.equals(pList))
self.fail('Should have failed')
except Exception:
self.assertTrue(True)
def testJavaList(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList2 = get_list(3)
jList2 = ex.getList(3)
# Lists are not "hashable" in Python. Too bad.
#self.assertEqual(hash(pList),hash(pList2))
self.assertEqual(hash(jList), hash(jList2))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList, pList2)
self.assertEqual(jList, jList2)
pList.append('4')
jList.append('4')
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList[0], jList[0])
self.assertEqual(pList[3], jList[3])
pList.extend(pList2)
jList.extend(jList2)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual('1' in pList, '1' in jList)
self.assertEqual('500' in pList, '500' in jList)
pList[0] = '100'
jList[0] = '100'
pList[3] = '150'
jList[3] = '150'
pList[-1] = '200'
jList[-1] = '200'
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.insert(0, '100')
jList.insert(0, '100')
pList.insert(3, '150')
jList.insert(3, '150')
pList.insert(-1, '200')
jList.insert(-1, '200')
pList.insert(len(pList), '300')
jList.insert(len(pList), '300')
pList.insert(300, '1500')
jList.insert(300, '1500')
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(), jList.pop())
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(-1), jList.pop(-1))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
self.assertEqual(pList.pop(2), jList.pop(2))
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
del pList[0]
del jList[0]
del pList[-1]
del jList[-1]
del pList[1]
del jList[1]
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
pList.append('700')
jList.append('700')
pList.insert(0, '700')
jList.insert(0, '700')
pList.remove('700')
jList.remove('700')
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
try:
jList[15]
self.fail('Should Fail!')
except IndexError:
self.assertTrue(True)
def testRemove(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
pList.append(10)
jList.append(10)
# If remove(10) was invoked on the Java side, this would not work!
# Instead, 10 has to be converted to an index...
pList.remove(10)
jList.remove(10)
self.assertEqual(len(pList), len(jList))
self.assertEqual(str(pList), str(jList))
def testBinaryOp(self):
ex = self.gateway.getNewExample()
pList = get_list(3)
jList = ex.getList(3)
jList2 = ex.getList(4)
self.assertTrue(jList == jList)
self.assertTrue(jList != jList2)
#self.assertTrue(jList < jList2)
self.assertTrue(jList != pList)
#self.assertTrue(jList == pList)
# self.assertTrue(jList2 != pList)
# self.assertTrue(jList2 > pList)
def testException(self):
ex = self.gateway.getNewExample()
jList = ex.getList(1)
try:
jList.get(5)
except Py4JJavaError:
self.assertTrue(True)
except Py4JError:
self.fail()
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()
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 is 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")())
