def setUpClass(cls):
super(TestJdbc, cls).setUpClass()
# <AK> fix/improv: moved from module level
try:
findClass('org.sqlite.JDBC')
except:
raise unittest.SkipTest('JDBC not on classpath')
def test_set_string_array(self):
from java.lang import String
#from jep.test import Test # <AK> changed
import jep # -||-
Test = jep.findClass('jep.test.Test') # -||-
t = Test()
ar = jarray(1, String)
ar[0] = String("String")
result = t.setStringArray(ar)
self.assertEqual(result[0], ar[0])
def createNdarrayFromBuffer(self, buffer):
DirectNDArray = jep.findClass("jep.DirectNDArray")
from java.util import ArrayList
# Start off with a pyjobject which is a DirectNDArray
dndarray = DirectNDArray(buffer)
from java.util import ArrayList
a = ArrayList()
a.add(dndarray)
# Getting the same object from a java method triggers the automatic
# conversion to an ndarray.
return a.get(0)
def createNdarrayFromBuffer(self, buffer):
DirectNDArray = jep.findClass("jep.DirectNDArray")
from java.util import ArrayList
# Start off with a pyjobject which is a DirectNDArray
dndarray = DirectNDArray(buffer)
from java.util import ArrayList
a = ArrayList()
a.add(dndarray)
# Getting the same object from a java method triggers the automatic
# conversion to an ndarray.
return a.get(0)
def testScalarBoxing(self):
import numpy
getClass = self.test.getDefaultConversionClass
TestClass = jep.findClass('jep.test.Test')
test = TestClass()
getConvert = test.testObjectPassThrough
self.assertEquals('java.lang.Float', getClass(numpy.float32(1.5)).java_name)
self.assertEquals(1.5, getConvert(numpy.float32(1.5)))
self.assertEquals('java.lang.Double', getClass(numpy.float64(1.5)).java_name)
self.assertEquals(1.5, getConvert(numpy.float64(1.5)))
self.assertEquals('java.lang.Long', getClass(numpy.int64(7)).java_name)
self.assertEquals(7, getConvert(numpy.int64(7)))
self.assertEquals('java.lang.Integer', getClass(numpy.int32(7)).java_name)
self.assertEquals(7, getConvert(numpy.int32(7)))
self.assertEquals('java.lang.Short', getClass(numpy.int16(7)).java_name)
self.assertEquals(7, getConvert(numpy.int16(7)))
self.assertEquals('java.lang.Byte', getClass(numpy.int8(7)).java_name)
self.assertEquals(7, getConvert(numpy.int8(7)))
import unittest
import jep
Test = jep.findClass('jep.Test')
from java.lang import Integer
class TestFields(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_string(self):
self.assertEqual('a stringField', self.test.stringField)
self.test.stringField = 'asdf'
self.assertEqual('asdf', self.test.stringField)
def test_boolean_field(self):
self.assertEquals(True, self.test.booleanField)
self.assertEquals(True, self.test.isBooleanField())
self.test.booleanField = False
self.assertEquals(False, self.test.booleanField)
self.assertEquals(False, self.test.isBooleanField())
def test_short_field(self):
self.assertEquals(321, self.test.shortField)
self.assertEquals(321, self.test.getShortField())
self.test.shortField = 123
self.assertEquals(123, self.test.shortField)
self.assertEquals(123, self.test.getShortField())
def test_int_field(self):
import unittest
import sys
import jep
from java.util import ArrayList
TestOverload = jep.findClass('jep.test.TestOverload')
class TestTypes(unittest.TestCase):
def test_any_primitive(self):
if sys.version_info.major == 2:
self.assertEqual(TestOverload.any_primitive(0), 'int')
self.assertEqual(TestOverload.any_primitive(1), 'int')
else:
self.assertEqual(TestOverload.any_primitive(0), 'long')
self.assertEqual(TestOverload.any_primitive(1), 'long')
self.assertIn(TestOverload.any_primitive(0.0), 'double')
self.assertEqual(TestOverload.any_primitive(True), 'boolean')
self.assertEqual(TestOverload.any_primitive(()), 'boolean')
def test_boxing(self):
self.assertEqual(TestOverload.int_or_Integer(0), 'int')
self.assertEqual(TestOverload.int_or_Integer(1), 'int')
self.assertEqual(TestOverload.int_or_Integer(None), 'Integer')
self.assertEqual(TestOverload.int_or_Object(0), 'int')
self.assertEqual(TestOverload.int_or_Object(1), 'int')
self.assertEqual(TestOverload.int_or_Object(None), 'Object')
self.assertEqual(TestOverload.int_or_Object('0'), 'Object')
self.assertEqual(TestOverload.Object_or_Integer(0), 'Integer')
self.assertEqual(TestOverload.Object_or_Integer(1), 'Integer')
self.assertEqual(TestOverload.Object_or_Integer('0'), 'Object')
self.assertEqual(TestOverload.float_or_Float(0.0), 'float')
LgCx = namedtuple('LgCx', ['lu_ec', 'lu_ex'])
class CgQo(QObject):
def __init__(self):
super().__init__()
self.cu_yi = gf_yi(self)
#
# Java (Global)
#
import jep
JC_GR = jep.findClass('javax.script.ScriptEngineManager')().getEngineByName(
'groovy')
JC_GR.put('GC_JEP', JC_JEP)
def jy_ge(x_str):
return JC_GR.eval(x_str)
jy_ge(f'''
GC_APP_NM = '{GC_APP_NM}'
GC_EC_NONE = {GC_EC_NONE}
GC_EC_SHUTDOWN = {GC_EC_SHUTDOWN}
GC_EC_SUCCESS = {GC_EC_SUCCESS}
GC_EC_ERROR = {GC_EC_ERROR}
GC_THIS_PID = {GC_THIS_PID}
''')
import unittest
import jep
Test = jep.findClass('jep.test.Test')
from java.util import ArrayList
from java.lang import Integer
COUNT = 17
def makeJavaList():
jlist = ArrayList()
for i in range(COUNT):
jlist.add(Integer(i))
return jlist
def makePythonList():
pylist = []
for i in range(COUNT):
# At present have to make it a java.lang.Integer for
# assertSequenceEqual to work. If in the future a
# java.lang.Integer can compare equality to a python int,
# then this should be updated to use python ints.
pylist.append(Integer(i))
return pylist
class TestLists(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_sequence(self):
from __future__ import print_function
import unittest
from jep import JepJavaImporter, findClass
Jep = findClass('jep.Jep')
Test = findClass('jep.test.Test')
class TestImport(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_java_sql(self):
from java.sql import DriverManager
def test_not_found(self):
importer = JepJavaImporter()
mod = importer.load_module('java.lang')
mod.Integer
self.assertRaises(ImportError, mod.__getattr__, 'asdf')
def test_restricted_classloader(self):
# should use the supplied classloader for hooks
self.test.testRestrictedClassLoader()
def test_without_restricted_classloader(self):
from java.io import File
dir(File)
from __future__ import absolute_import
import unittest
import jep
Test = jep.findClass('jep.test.Test')
from java.util import ArrayList
COUNT = 17
def makeJavaList():
jlist = ArrayList()
for i in range(COUNT):
jlist.add(i)
return jlist
def makePythonList():
pylist = []
for i in range(COUNT):
pylist.append(i)
return pylist
class TestLists(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_sequence(self):
jlist = makeJavaList()
import unittest
import sys
import jep
from java.util import ArrayList
TestOverload = jep.findClass('jep.test.TestOverload')
class TestTypes(unittest.TestCase):
def test_any_primitive(self):
if sys.version_info.major == 2:
self.assertEqual(TestOverload.any_primitive(0), 'int')
self.assertEqual(TestOverload.any_primitive(1), 'int')
else:
self.assertEqual(TestOverload.any_primitive(0), 'long')
self.assertEqual(TestOverload.any_primitive(1), 'long')
self.assertIn(TestOverload.any_primitive(0.0), 'double')
self.assertEqual(TestOverload.any_primitive(True), 'boolean')
self.assertEqual(TestOverload.any_primitive(()), 'boolean')
def test_boxing(self):
self.assertEqual(TestOverload.int_or_Integer(0), 'int')
self.assertEqual(TestOverload.int_or_Integer(1), 'int')
self.assertEqual(TestOverload.int_or_Integer(None), 'Integer')
self.assertEqual(TestOverload.int_or_Object(0), 'int')
self.assertEqual(TestOverload.int_or_Object(1), 'int')
self.assertEqual(TestOverload.int_or_Object(None), 'Object')
self.assertEqual(TestOverload.int_or_Object('0'), 'Object')
self.assertEqual(TestOverload.Object_or_Integer(0), 'Integer')
self.assertEqual(TestOverload.Object_or_Integer(1), 'Integer')
self.assertEqual(TestOverload.Object_or_Integer('0'), 'Object')
def gf_jcls(x_it):
return jep.findClass(x_it)
import unittest
import jep
Test = jep.findClass('jep.test.numpy.TestNumpy')
class TestNumpy(unittest.TestCase):
def setUp(self, test=None):
self.test = Test()
self.printout = False
def testSetGet(self):
"""
Tests using Jep.set(String, Object) for java NDArrays
of the different primitive types. Then uses
Jep.get(String) to get a Java NDArray back and
checks for equality/symmetry.
"""
if jep.JEP_NUMPY_ENABLED:
self.test.testSetAndGet()
def testArgReturn(self):
"""
Tests making a python ndarray, sending it to Java,
Java making a new one and adding 5 to the values,
and then Java returning the new ndarray to python.
"""
if jep.JEP_NUMPY_ENABLED:
import numpy
x = numpy.array(range(10), numpy.int32)
y = self.test.testArgAndReturn(x)
import unittest
import jep
Test = jep.findClass('jep.test.Test')
Boolean = jep.findClass('java.lang.Boolean')
class TestTypes(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_string(self):
self.assertEqual("toString(). Thanks for calling Java(tm).",
self.test.toString())
def test_enum(self):
testEnum = self.test.getEnum()
self.assertEqual(0, testEnum.ordinal())
def test_long(self):
self.assertEqual(9223372036854775807,
self.test.getClassLong().longValue())
def test_double(self):
self.assertEqual(4.9E-324, self.test.getClassDouble().doubleValue())
def test_float(self):
self.assertAlmostEqual(3.4028234663852886e+38,
self.test.getClassFloat().floatValue())
def test_intobj(self):
def setUp(self):
findClass('org.sqlite.JDBC')
import unittest
from math import isnan
import sys
import jep
TestMethodTypes = jep.findClass('jep.test.types.TestMethodTypes')
TestStaticMethodTypes = jep.findClass('jep.test.types.TestStaticMethodTypes')
TestFieldTypes = jep.findClass('jep.test.types.TestFieldTypes')
TestStaticFieldTypes = jep.findClass('jep.test.types.TestStaticFieldTypes')
from java.lang import Object, Integer, Class
class TestTypes(unittest.TestCase):
def setUp(self):
self.methods = TestMethodTypes()
self.staticMethods = TestStaticMethodTypes
self.fields = TestFieldTypes()
self.staticFields = TestStaticFieldTypes
def test_boolean(self):
for b in (True, False):
self.assertEqual(b, self.methods.primitiveBoolean(b))
self.assertIsInstance(self.methods.primitiveBoolean(b), bool)
self.assertEqual(b, self.methods.objectBoolean(b))
self.assertIsInstance(self.methods.objectBoolean(b), bool)
self.assertEqual(b, self.methods.object(b))
self.assertIsInstance(self.methods.object(b), bool)
self.assertEqual(b, self.staticMethods.primitiveBoolean(b))
self.assertIsInstance(self.staticMethods.primitiveBoolean(b), bool)
self.assertEqual(b, self.staticMethods.objectBoolean(b))
self.assertIsInstance(self.staticMethods.objectBoolean(b), bool)
from __future__ import print_function
import unittest
import jep
TestFieldTypes = jep.findClass('jep.test.types.TestFieldTypes')
class TestRegressions(unittest.TestCase):
def test_out(self):
from java.lang import System
System.out.print("")
def test_byte_value(self):
from java.lang import Integer
try:
# call instance from class, should throw but not crash
Integer.byteValue()
except:
pass
def test_static_access_to_nonstatic_field(self):
with self.assertRaises(TypeError):
TestFieldTypes.objectString = ""
def setUp(self):
findClass('org.sqlite.JDBC')
def setUp(self, test=None):
TestClass = jep.findClass('jep.test.numpy.TestNumpy')
self.test = TestClass()
self.printout = False
import unittest
import jep
Test = jep.findClass('jep.Test')
class TestTypes(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_string(self):
self.assertEqual("toString(). Thanks for calling Java(tm).", self.test.toString())
def test_enum(self):
testEnum = self.test.getEnum()
self.assertEquals(0, testEnum.ordinal())
def test_long(self):
self.assertEquals(9223372036854775807, self.test.getClassLong().longValue())
def test_double(self):
self.assertEquals(4.9E-324, self.test.getClassDouble().doubleValue())
def test_float(self):
self.assertAlmostEqual(3.4028234663852886e+38, self.test.getClassFloat().floatValue())
def test_intobj(self):
self.assertEquals(-2147483648, self.test.getInteger().intValue())
def test_getobj(self):
obj = self.test.getObject()
self.assertEquals("list 0", str(obj.get(0)))
def testCharArrayCreation(self):
NDArray = jep.findClass("jep.NDArray")
with self.assertRaises(ValueError):
NDArray(jep.jarray(4, jep.JCHAR_ID))
import unittest
import jep
Test = jep.findClass('jep.test.numpy.TestNumpy')
class TestNumpy(unittest.TestCase):
def setUp(self, test=None):
self.test = Test()
self.printout = False
def testSetGet(self):
"""
Tests using Jep.set(String, Object) for java NDArrays
of the different primitive types. Then uses
Jep.get(String) to get a Java NDArray back and
checks for equality/symmetry.
"""
if jep.USE_NUMPY:
self.test.testSetAndGet()
def testArgReturn(self):
"""
Tests making a python ndarray, sending it to Java,
Java making a new one and adding 5 to the values,
and then Java returning the new ndarray to python.
"""
if jep.USE_NUMPY:
import numpy
x = numpy.array(range(10), numpy.int32)
y = self.test.testArgAndReturn(x)
def setUp(self, test=None):
TestClass = jep.findClass('jep.test.numpy.TestNumpy')
self.test = TestClass()
self.printout = False
# coding: utf-8
import unittest
import os
import sys
from jep import findClass
from jep.jdbc import connect
from jep import jdbc as dbapi
from java.lang import Integer, Long, Double
from java.sql import Date, Timestamp, Time
skip = sys.platform.startswith('win') or sys.platform.startswith('freebsd')
if not skip:
try:
findClass('org.sqlite.JDBC')
except:
skip = True
@unittest.skipIf(skip,
'file access issues on Windows or JDBC not on classpath')
class TestJdbc(unittest.TestCase):
jdbc_url = 'jdbc:sqlite:build/test.db'
def tearDown(self):
if os.path.exists('build/test.db'):
os.remove('build/test.db')
def test_java_sql(self):
"""
regression test
import unittest
import jep
Test = jep.findClass('jep.test.Test')
Boolean = jep.findClass('java.lang.Boolean')
StringBuilder = jep.findClass('java.lang.StringBuilder')
ArrayList = jep.findClass('java.util.ArrayList')
class TestTypes(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_enum(self):
testEnum = self.test.getEnum()
self.assertEqual(0, testEnum.ordinal())
def test_getstring_array(self):
obj = self.test.getStringArray()
self.assertEqual('one', obj[0])
self.assertEqual('two', obj[1])
self.assertEqual('one two', ' '.join(obj))
def test_string_string_array(self):
obj = self.test.getStringStringArray()
self.assertEqual('one', obj[0][0])
def test_int_array(self):
obj = self.test.getIntArray()
self.assertEqual(1, obj[0])
import unittest
import jep
Test = jep.findClass('jep.test.Test')
Boolean = jep.findClass('java.lang.Boolean')
StringBuilder = jep.findClass('java.lang.StringBuilder')
ArrayList = jep.findClass('java.util.ArrayList')
class TestTypes(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_enum(self):
testEnum = self.test.getEnum()
self.assertEqual(0, testEnum.ordinal())
def test_getstring_array(self):
obj = self.test.getStringArray()
self.assertEqual('one', obj[0])
self.assertEqual('two', obj[1])
self.assertEqual('one two', ' '.join(obj))
def test_string_string_array(self):
obj = self.test.getStringStringArray()
self.assertEqual('one', obj[0][0])
def test_int_array(self):
obj = self.test.getIntArray()
self.assertEqual(1, obj[0])
import unittest
import jep
TestAutoCloseable = jep.findClass('jep.test.closeable.TestAutoCloseable')
class TestAutoCloseables(unittest.TestCase):
def test_with(self):
with TestAutoCloseable() as writer:
writer.write("abc")
self.assertFalse(writer.isClosed())
self.assertTrue(writer.isClosed())
def test_io_exception(self):
with TestAutoCloseable() as writer:
writer.write("abc")
with self.assertRaises(IOError):
writer.write("def")
def test_inner_exception(self):
try:
with TestAutoCloseable() as writer:
writer.write("abc")
from java.fake import ArrayList
writer.write("def")
except ImportError as exc:
pass
self.assertTrue(writer.isClosed())
# encoding: utf-8
#---------------------------------------------------------------
# Global
#---------------------------------------------------------------
import sys
sys.dont_write_bytecode = True
import jep
GC_OR = jep.findClass('ORun')
GC_PS = GC_OR.ol_ps
GC_GR = GC_OR.ol_gr
import platform
import traceback
GC_PYTHON_VR = platform.python_version()
def gf_joa_to_yoa(x_joa):
return [bx2_it for bx2_it in x_joa
] # (j)ava (o)bject (a)rray (to) p(y)thon (o)bject (a)rray
def gf_yoa_to_joa(x_yoa):
fu_joa = GC_OR.om_new_joa(len(x_yoa))
for bu2_idx, bu2_it in enumerate(x_yoa):
fu_joa[bu2_idx] = x_yoa[bu2_idx]
from __future__ import print_function
import unittest
import jep
TestFieldTypes = jep.findClass('jep.test.types.TestFieldTypes')
class TestRegressions(unittest.TestCase):
def test_out(self):
from java.lang import System
System.out.print("")
def test_byte_value(self):
from java.lang import Integer
try:
# call instance from class, should throw but not crash
Integer.byteValue()
except:
pass
def test_static_access_to_nonstatic_field(self):
with self.assertRaises(TypeError):
TestFieldTypes.objectString = ""
from __future__ import absolute_import
import unittest
from math import isnan
import sys
import jep
TestMethodTypes = jep.findClass('jep.test.types.TestMethodTypes')
TestStaticMethodTypes = jep.findClass('jep.test.types.TestStaticMethodTypes')
TestFieldTypes = jep.findClass('jep.test.types.TestFieldTypes')
TestStaticFieldTypes = jep.findClass('jep.test.types.TestStaticFieldTypes')
Test = jep.findClass("jep.test.Test")
from java.lang import Integer
class TestTypes(unittest.TestCase):
def setUp(self):
self.methods = TestMethodTypes()
self.staticMethods = TestStaticMethodTypes
self.fields = TestFieldTypes()
self.staticFields = TestStaticFieldTypes
self.test = Test()
def test_boolean_field(self):
self.assertEqual(True, self.test.booleanField)
self.assertEqual(True, self.test.isBooleanField())
self.test.booleanField = False
self.assertEqual(False, self.test.booleanField)
self.assertEqual(False, self.test.isBooleanField())
def test_byte_field(self):
self.assertEqual(43, self.test.byteField)
self.assertEqual(43, self.test.getByteField())
import unittest
import jep
Test = jep.findClass("jep.test.Test")
class TestTypes(unittest.TestCase):
def setUp(self):
self.test = Test()
def test_string(self):
self.assertEqual("toString(). Thanks for calling Java(tm).", self.test.toString())
def test_enum(self):
testEnum = self.test.getEnum()
self.assertEqual(0, testEnum.ordinal())
def test_long(self):
self.assertEqual(9223372036854775807, self.test.getClassLong().longValue())
def test_double(self):
self.assertEqual(4.9e-324, self.test.getClassDouble().doubleValue())
def test_float(self):
self.assertAlmostEqual(3.4028234663852886e38, self.test.getClassFloat().floatValue())
def test_intobj(self):
self.assertEqual(-2147483648, self.test.getInteger().intValue())
def test_getobj(self):
# coding: utf-8
import unittest
import os
import sys
from jep import findClass
from jep.jdbc import connect
from jep import jdbc as dbapi
from java.lang import Integer, Long, Double, Math
from java.sql import Date, Timestamp, Time
skip = False
try:
findClass('org.sqlite.JDBC')
except:
skip = True
@unittest.skipIf(skip, 'JDBC not on classpath')
class TestJdbc(unittest.TestCase):
jdbc_url = 'jdbc:sqlite:build/test.db'
def tearDown(self):
if os.path.exists('build/test.db'):
os.remove('build/test.db')
def test_java_sql(self):
"""
regression test
example and library from: http://www.zentus.com/sqlitejdbc/
from __future__ import print_function
import unittest
from jep import JepImporter, findClass, JavaException
Jep = findClass('jep.Jep')
Test = findClass('jep.Test')
class TestImport(unittest.TestCase):
def test_java_sql(self):
from java.sql import DriverManager
def test_not_found(self):
importer = JepImporter()
mod = importer.load_module('java.lang')
mod.Integer
self.assertRaises(AttributeError, mod.__getattr__, 'asdf')
def test_restricted_classloader(self):
# should use the supplied classloader for hooks
vm = Jep()
try:
vm.setInteractive(True)
vm.setClassLoader(Test.restrictedClassLoader)
with self.assertRaises(JavaException) as e:
vm.eval("from java.io import File")
vm.eval('f = File("failed.txt")')
finally:
vm.close()
def test_without_restricted_classloader(self):
def testCharArrayCreation(self):
NDArray = jep.findClass("jep.NDArray")
with self.assertRaises(ValueError):
NDArray(jep.jarray(4, jep.JCHAR_ID))
def jf_jcls(x_cls_nm):
return jep.findClass(x_cls_nm)
GC_QAPP.setStyle('fusion')
import jep
import os
import platform
import psutil
GC_FOSA = os.sep # (fo)lder (s)ep(a)rator
GC_PASA = os.pathsep # (pa)th (s)ep(a)rator
GC_TOTAL_CPU = psutil.cpu_count()
GC_TOTAL_MEMORY = psutil.virtual_memory().total
GC_HOST_NM = platform.node()
GC_THIS_PID = os.getpid()
GC_AS = jep.findClass('Global').GC_AS()
GC_LOG = jep.findClass('Global').GC_LOG()
from collections import namedtuple
import ctypes
import inspect
import shutil
import time
import tkinter
import traceback
import types
def gf_os_env(x_key):
return os.environ[x_key] # (g)lobal (f)unction
