def test_cast(self):
from java.lang import Boolean, Object
b = Boolean(True)
b_Object = cast(Object, b)
self.assertIsNot(b, b_Object)
self.assertEqual(b, b_Object)
self.assertIs(Boolean.getClass(), b.getClass())
self.assertIs(Boolean.getClass(), b_Object.getClass())
self.assertIsNot(Object.getClass(), b_Object.getClass())
self.assertIs(b_Object, cast(Object, b))
self.assertIs(b, cast(Boolean, b_Object))
for obj in [Boolean, "Ljava/lang/Boolean;"]:
with self.subTest(obj=obj):
with self.assertRaisesRegex(TypeError, "cannot create java.lang.Boolean "
"proxy from java.lang.Object instance"):
cast(obj, Object())
with self.assertRaisesRegex(jclass("java.lang.NoClassDefFoundError"),
"java.lang.Nonexistent"):
cast("Ljava/lang/Nonexistent;", Object())
with self.assertRaisesRegex(ValueError, "Invalid JNI signature: 'java.lang.Object'"):
cast("java.lang.Object", Object())
for obj in [0, True, None, int, str]:
with self.subTest(obj=obj):
with self.assertRaisesRegex(TypeError, f"{obj!r} is not a Java type"):
cast(obj, Object())
def test_construction(self):
from java.lang import Object
refcount1 = sys.gettotalrefcount()
result = Object()
del result
refcount2 = sys.gettotalrefcount()
self.assertEquals(refcount1, refcount2 - 1)
def test_instance(self):
with self.assertRaisesRegex(AttributeError, "has no attribute"):
self.t.nonexistent
with self.assertRaisesRegex(AttributeError, "has no attribute"):
self.t.nonexistent = True
with self.assertRaisesRegex(AttributeError, "final"):
self.t.fieldFinalZ = True
with self.assertRaisesRegex(AttributeError, "not a field"):
self.t.setZ = True
with self.assertRaisesRegex(TypeError, "not callable"):
self.t.fieldZ()
with self.assertRaisesRegex(TypeError, r"takes 0 arguments \(1 given\)"):
self.t.noArgs(True)
with self.assertRaisesRegex(TypeError, r"takes at least 1 argument \(0 given\)"):
self.t.varargs1()
with self.assertRaisesRegex(TypeError, r"takes at least 1 argument \(0 given\)"):
self.Test.varargs1(self.t)
with self.assertRaisesRegex(TypeError, r"takes 1 argument \(0 given\)"):
self.t.setZ()
Object = jclass("java.lang.Object")
with self.assertRaisesRegex(AttributeError, "static context"):
self.Test.fieldZ
with self.assertRaisesRegex(AttributeError, "static context"):
self.Test.fieldZ = True
with self.assertRaisesRegex(TypeError, "must be called with .*TestBasics instance "
r"as first argument \(got nothing instead\)"):
self.Test.getZ()
with self.assertRaisesRegex(TypeError, "must be called with .*TestBasics instance "
r"as first argument \(got Object instance instead\)"):
self.Test.getZ(Object())
self.assertEqual(False, self.Test.getZ(self.t))
def test_explicit(self):
"Tests explicit method calls, please don't do this in application code"
x = Object()
slock = x.synchronized()
slock.__enter__()
y = 5 + 3
slock.__exit__()
self.assertEqual(y, 8)
def __init__(self, file, name, mode):
self.lockerObject = Object()
type = Type.WRITE
if mode == 'r':
type = Type.READ
self.file = file
locked = FileLocker.lock(self.lockerObject, file, type)
# log if not locked, because that's bad
super(File, self).__init__(file.getAbsolutePath(), mode)
def test_access_no_call(self):
start_memory = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
obj = Object()
for i in xrange(0, iterations, 1):
b = obj.hashCode
end_memory = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
if start_memory * failure_threshold < end_memory:
percent = end_memory * 100 / start_memory - 100
raise Exception(
'Uncalled methods are leaking memory, process size increased %d%% over %d iterations.'
% (percent, iterations))
def test_with_exception_unlocks(self):
"Tests that the end of the with block will unlock even if an exception occurred"
x = Object()
slock = x.synchronized()
try:
with slock:
from java.fake import ArrayList
except ImportError as exc:
pass
with self.assertRaises(RuntimeError):
# you cannot unlock that which has been unlocked
slock.__exit__()
def parse(code):
EOF = Object()
ret = None
thread = Thread.currentThread()
# Evaluate all tokens in code, one by one
while not thread.isInterrupted():
r = LispReader.read(LineNumberingPushbackReader(StringReader(code)),
False, EOF, False)
if EOF == r:
break
ret = Compiler.eval(r)
# Return the result of evaluating the last token
return ret
def test_cast(self):
Object = jclass("java.lang.Object")
Boolean = jclass("java.lang.Boolean")
Boolean_array = jarray(Boolean)([True, False])
Boolean_array_Object_array = cast(jarray(Object), Boolean_array)
self.assertIsNot(Boolean_array, Boolean_array_Object_array)
self.assertEqual(Boolean_array, Boolean_array_Object_array)
self.assertIs(Boolean_array_Object_array,
cast(jarray(Object), Boolean_array))
self.assertIs(Boolean_array,
cast(jarray(Boolean), Boolean_array_Object_array))
Boolean_array_Object = cast(Object, Boolean_array)
self.assertIsNot(Boolean_array, Boolean_array_Object)
self.assertEqual(Boolean_array, Boolean_array_Object)
self.assertIs(Boolean_array_Object, cast(Object, Boolean_array))
self.assertIs(Boolean_array, cast(jarray(Boolean),
Boolean_array_Object))
with self.assertRaisesRegexp(
TypeError, "cannot create boolean\[\] proxy from "
"java.lang.Boolean\[\] instance"):
cast(jarray(jboolean), Boolean_array)
with self.assertRaisesRegexp(
TypeError, "cannot create java.lang.Object\[\] proxy from "
"java.lang.Object instance"):
cast(jarray(Object), Object())
Object_array = jarray(Object)([])
with self.assertRaisesRegexp(
TypeError, "cannot create java.lang.Boolean proxy from "
"java.lang.Object\[\] instance"):
cast(Boolean, Object_array)
with self.assertRaisesRegexp(
TypeError, "cannot create java.lang.Boolean\[\] proxy from "
"java.lang.Object\[\] instance"):
cast(jarray(Boolean), Object_array)
Z_array = jarray(jboolean)([True, False])
with self.assertRaisesRegexp(
TypeError, "cannot create java.lang.Boolean\[\] proxy from "
"boolean\[\] instance"):
cast(jarray(Boolean), Z_array)
with self.assertRaisesRegexp(
TypeError, "cannot create java.lang.Object\[\] proxy from "
"boolean\[\] instance"):
cast(jarray(Object), Z_array)
def test_cast(self):
from java.lang import Boolean, Object
b = Boolean(True)
b_Object = cast(Object, b)
self.assertIsNot(b, b_Object)
self.assertEqual(b, b_Object)
self.assertIs(Boolean.getClass(), b.getClass())
self.assertIs(Boolean.getClass(), b_Object.getClass())
self.assertIsNot(Object.getClass(), b_Object.getClass())
self.assertIs(b_Object, cast(Object, b))
self.assertIs(b, cast(Boolean, b_Object))
with self.assertRaisesRegexp(
TypeError, "cannot create java.lang.Boolean proxy from "
"java.lang.Object instance"):
cast(Boolean, Object())
def test_str_repr(self):
Object = jclass('java.lang.Object')
String = jclass('java.lang.String')
o = Object()
object_str = str(o)
self.assertRegex(object_str, "^java.lang.Object@")
self.assertEqual("<" + object_str + ">", repr(o))
str_u = "abc olé 中文"
repr_u = "<java.lang.String '{}'>".format(str_u)
s = String(str_u)
self.assertEqual(str_u, str(s))
self.assertEqual(repr_u, repr(s))
self.assertEqual("cast('Ljava/lang/Object;', None)", repr(cast(Object, None)))
self.assertEqual("cast('Ljava/lang/String;', None)", repr(cast(String, None)))
def test_modify(self):
Object = jclass("java.lang.Object")
array_Z = jarray(jboolean)([True, False])
with self.assertRaisesRegex(TypeError, "Cannot convert int object to boolean"):
array_Z[0] = 1
with self.assertRaisesRegex(TypeError, "Cannot convert Object object to boolean"):
array_Z[0] = Object()
Boolean = jclass("java.lang.Boolean")
array_Boolean = jarray(Boolean)([True, False])
with self.assertRaisesRegex(TypeError, "Cannot convert int object to java.lang.Boolean"):
array_Boolean[0] = 1
with self.assertRaisesRegex(TypeError, "Cannot convert int object to java.lang.Boolean"):
cast(jarray(Object), array_Boolean)[0] = 1
array_Object = jarray(Object)([True, False])
array_Object[0] = 1
self.assertEqual([1, False], array_Object)
def set_scanner_table_model(self, scanner_issue, issue_name, issue_param,
vuln_param):
key = issue_name + "." + vuln_param
scanner_issue_id = str(
scanner_issue.getRequestResponse()).split("@")[1]
scanner_table_model = self.scanner_table_models[key]
# Using the addRow() method requires that the data type being passed to be of type
# Vector() or Object(). Passing a Python object of type list in addRow causes a type
# conversion error of sorts which presents as an ArrayOutOfBoundsException. Therefore,
# row is an instantiation of Object() to avoid this error.
row = Object()
row = [
False, issue_param,
scanner_issue.getHttpService().getHost(),
scanner_issue.getPath(), scanner_issue_id
]
try:
scanner_table_model.addRow(row)
except Exception as e:
print e
def test_str_repr(self):
Object = jclass('java.lang.Object')
String = jclass('java.lang.String')
o = Object()
object_str = str(o)
self.assertRegexpMatches(object_str, "^java.lang.Object@")
self.assertEqual("<" + object_str + ">", repr(o))
str_u = u"abc olé 中文"
repr_u = u"<java.lang.String '{}'>".format(str_u)
s = String(str_u)
if sys.version_info[0] < 3:
self.assertEqual(str_u.encode("utf-8"), str(s))
self.assertEqual(str_u, unicode(s)) # noqa: F821
self.assertEqual(repr_u.encode("utf-8"), repr(s))
else:
self.assertEqual(str_u, str(s))
self.assertEqual(repr_u, repr(s))
self.assertEqual("cast('Ljava/lang/Object;', None)",
repr(cast(Object, None)))
self.assertEqual("cast('Ljava/lang/String;', None)",
repr(cast(String, None)))
def test_del_throws_exception(self):
o = Object()
with self.assertRaises(TypeError):
del o.equals
def setUp(self):
from java.lang import Object
self.obj = Object()
def test_java_name(self):
self.assertEquals(Object.java_name, "java.lang.Object")
self.assertEquals(Object().java_name, "java.lang.Object")
def test_hash(self):
o = Object()
self.assertTrue(isinstance(hash(o), int))
from shared.tools.snapshot.utils import encode, getDesignerContext
from java.lang import Object
from com.sepasoft.production.common.model.storage import ConvertLog
CONVERTLOG_PLACEHOLDER = ConvertLog(Object())
MES_TYPES = set(['cell', 'cell_group', 'line', 'area', 'site', 'enterprise'])
def trace_equipment_path(item, resolved_model):
parent = resolved_model.get(item['Parent Production Item UUID'], None)
if parent:
return trace_equipment_path(parent, resolved_model) + [item['Name']]
else:
return [item['Name']]
def resolve_model_item(resource_objects):
storage_item = resource_objects[0]
production_item = storage_item.convertToProductionItem(
'some string', CONVERTLOG_PLACEHOLDER)
configuration = {
'Name': production_item.getName(),
'Type': production_item.getProductionType(),
}
if not production_item.getEnabled():
def test_str(self):
o = Object()
self.assertIn('java.lang.Object@', str(o))
def test_with(self):
"Simple test illustrating basic usage"
x = Object()
with x.synchronized():
y = 5 + 3
self.assertEqual(y, 8)
from java.lang import Object, Class, Number
d = {}
o = Object()
d[o] = 'o'
import Foo, SubFoo
class C(Object):
pass
c = C()
d[c] = 'c'
class SubFoo2(Foo):
pass
class N(Number):
pass
foo, subfoo, subfoo2, n = Foo(), SubFoo(), SubFoo2(), N()
for _v, _id in zip([foo, subfoo, subfoo2, n],
['foo', 'subfoo', 'subfoo2', 'n']):
d[_v] = _id
def test_integer_setitem_object_throws_exception(self):
from java.lang import Integer, Object
ar = jarray(1, Integer)
t = Object()
with self.assertRaises(TypeError):
ar[0] = t
def test_object_setitem(self):
from java.lang import Object
ar = jarray(1, Object)
t = Object()
ar[0] = t
self.assertEqual(ar[0], t)
def returnsObject(self):
return Object()
def test_bad_form(self):
"Tests attempting unlock of a non-locked object, please don't do this in application code"
x = Object()
slock = x.synchronized()
with self.assertRaises(RuntimeError):
slock.__exit__()
