def verify_bytes(self, jbyte_values, b):
arrayB_from_list = jarray(jbyte)(jbyte_values)
self.assertEqual(jbyte_values, arrayB_from_list)
array_bytes = bytes(arrayB_from_list)
self.assertEqual(b, array_bytes)
array_bytearray = bytearray(arrayB_from_list)
self.assertEqual(b, array_bytearray)
arrayB_from_bytes = jarray(jbyte)(b)
self.assertEqual(jbyte_values, arrayB_from_bytes)
arrayB_from_bytearray = jarray(jbyte)(bytearray(b))
self.assertEqual(jbyte_values, arrayB_from_bytearray)
def test_array(self):
Object = jclass("java.lang.Object")
Number = jclass("java.lang.Number")
self.verify_value(self.obj, "ObjectArray", jarray(Number)([11, 22]))
with self.conv_error: # Can't use `context`: exception is raised by `jarray` constructor.
self.verify_value(self.obj, "NumberArray",
jarray(Object)([False, True]))
# Arrays of primitives are not assignable to arrays of Object.
self.verify_value(self.obj,
"ObjectArray",
jarray(jboolean)([False, True]),
context=self.conv_error)
def test_conversion(self):
Object = jclass("java.lang.Object")
Integer = jclass("java.lang.Integer")
# All object arrays, primitive arrays, and Python iterables are assignable to Object,
# Cloneable and Serializable
for array in [jarray(Object)(["hello", 42]), jarray(Integer)([11, 22]),
jarray(jboolean)([False, True]), [False, True]]:
with self.subTest(array=array):
for field in ["object", "cloneable", "serializable"]:
with self.subTest(field=field):
setattr(TA, field, array)
self.assertEqual(array, getattr(TA, field))
with self.assertRaisesRegex(TypeError, "Cannot convert"):
setattr(TA, "closeable", array)
def test_set_slice(self):
for key, replaced in SLICE_TESTS:
with self.subTest(key=key, replaced=replaced):
a = jarray(jint)(SLICE_DATA)
expected = [99 if x in replaced else x
for x in a]
a[key] = [99] * len(replaced)
self.assertEqual(expected, a)
# Length mismatch
a = jarray(jint)(SLICE_DATA)
for value in [[], [99, 99]]:
with self.subTest(value=value), \
self.assertRaisesRegex(ValueError, f"can't set slice of length 1 from value "
f"of length {len(value)}"):
a[0:1] = value
# Arrays of different types.
a = jarray(jint)(SLICE_DATA)
with self.assertRaisesRegex(TypeError, "Cannot convert float object to int"):
a[:2] = jarray(jfloat)([99, 99])
a = jarray(jfloat)(SLICE_DATA)
a[:2] = jarray(jint)([99, 99])
self.assertEqual([99, 99, 5, 7, 11], a)
# Without optimization, this takes over 200 seconds. The test_get_slice equivalent is
# probably faster because Cython compiles the __getitem__ loop into native code, so
# leave the array size unchanged in case a future Cython version extends this to more
# situations.
a = jarray(jint)(500000)
b = jarray(jint)(500000)
with self.assertTimeLimit(0.5):
a[:] = b
def test_add(self):
tf = jarray(jboolean)([True, False])
self.assertEqual(tf, tf + [])
self.assertEqual(tf, [] + tf)
self.assertEqual(tf, tf + jarray(jboolean)([]))
self.assertEqual([True, False, True], tf + [True])
with self.assertRaises(TypeError):
tf + True
with self.assertRaises(TypeError):
tf + None
String = jclass("java.lang.String")
hw = jarray(String)(["hello", "world"])
self.assertEqual([True, False, "hello", "world"], tf + hw)
def test_index(self):
a = jarray(jint)([1, 4, 1, 2])
self.assertEqual(0, a.index(1))
self.assertEqual(3, a.index(2))
self.assertEqual(1, a.index(4))
for value in [0, 3, 5]:
with self.subTest(value=value):
with self.assertRaises(ValueError):
a.index(value)
empty = jarray(jint)([])
for value in [0, 1]:
with self.subTest(value=value):
with self.assertRaises(ValueError):
empty.index(value)
class Return(static_proxy()):
@method(jvoid, [])
def void_good(self):
pass
@method(jvoid, [])
def void_bad(self):
return "hello"
@method(jint, [])
def primitive_good(self):
return 42
@method(jint, [])
def primitive_bad_value(self):
return "hello"
@method(jint, [])
def primitive_bad_null(self):
pass
@method(String, [])
def object_good_value(self):
return "hello"
@method(String, [])
def object_good_null(self):
return None
@method(String, [])
def object_bad(self):
return 42
@method(jarray(String), [])
def array_good_value(self):
return ["hello", "world"]
@method(jarray(String), [])
def array_good_null(self):
return None
@method(jarray(String), [])
def array_bad_content(self):
return [1, 2]
@method(jarray(String), [])
def array_bad_value(self):
return "hello"
def test(path):
# x_t = jarray(jdouble)([22.0, 1.0, 0.0, 172.7, 76.7, 2.0, 2.0, 2.0, 2.0, 0.0, 0.0, 2.0, 4.0, 0.0, 0.989, 0.0])
y_t = 3
xx = jarray(jdouble)([5.1,3.5,1.4,0.2])
# 模型加载
clf = joblib.load("storage/data/train_model.m")
# 模型预测
# y_prob = clf.predict(x_t, num_iteration=clf.best_iteration)
# y_pred = [list(x).index(max(x)) for x in y_prob]
# print("预测结果：", y_pred)
# score = metrics.accuracy_score(y_pred=y_pred, y_true=y_t)
# precision = metrics.precision_score(y_true=y_t, y_pred=y_pred, average=None)
# recall = metrics.recall_score(y_true=y_t, y_pred=y_pred, average=None)
# matrix = metrics.confusion_matrix(y_true=y_t, y_pred=y_pred)
# FAR = [(matrix[1, 0] + matrix[2, 0] + matrix[3, 0]) / (
# matrix[1, 0] + matrix[2, 0] + matrix[3, 0] + matrix[1, 1] + matrix[2, 2] + matrix[3, 3]),
# (matrix[0, 1] + matrix[2, 1] + matrix[3, 1]) / (
# matrix[0, 1] + matrix[2, 1] + matrix[3, 1] + matrix[0, 0] + matrix[2, 2] + matrix[3, 3]),
# (matrix[1, 2] + matrix[0, 2] + matrix[3, 2]) / (
# matrix[1, 2] + matrix[0, 2] + matrix[3, 2] + matrix[1, 1] + matrix[0, 0] + matrix[3, 3]),
# (matrix[1, 3] + matrix[0, 3] + matrix[2, 3]) / (
# matrix[1, 3] + matrix[0, 3] + matrix[2, 3] + matrix[1, 1] + matrix[0, 0] + matrix[2, 2]),
# ] # FP/(FP+TN)
# print(matrix)
# print("AUC score: {:<8.5f}".format(score))
# print('precision' + str(precision))
# print('recall' + str(recall))
# print(" FAR" + str(FAR))
def test_get_int(self):
a = jarray(jint)([2, 3, 5, 7, 11])
self.assertEqual(2, a[0])
self.assertEqual(3, a[1])
self.assertEqual(11, a[4])
with self.index_error:
a[5]
with self.index_error:
jarray(jint)([])[0]
self.assertEqual(11, a[-1])
self.assertEqual(7, a[-2])
self.assertEqual(2, a[-5])
with self.index_error:
a[-6]
def verify(expected, actual):
self.assertEqual(expected, actual)
self.assertIsInstance(
actual,
(
unicode if sys.version_info[0] < 3 # noqa: F821
else jarray("Ljava/lang/Object;")))
def test_bytes(self):
# Java byte arrays (signed) and Python bytes (unsigned) can be converted both ways.
self.verify_bytes([], b"")
self.verify_bytes([-128, -127, -2, -1, 0, 1, 126, 127],
b"\x80\x81\xFE\xFF\x00\x01\x7E\x7F")
# Java primitive arrays (except char[]) can be converted to their raw data bytes.
# Expected values are little-endian.
for element_type, values, expected in \
[(jboolean, [False, True], b"\x00\x01"),
(jbyte, [0, 123], bytes(1) + b"\x7b"),
(jshort, [0, 12345], bytes(2) + b"\x39\x30"),
(jint, [0, 123456789], bytes(4) + b"\x15\xcd\x5b\x07"),
(jlong, [0, 1234567890123456789], bytes(8) + b"\x15\x81\xe9\x7d\xf4\x10\x22\x11"),
(jfloat, [0, 1.99], bytes(4) + b"\x52\xb8\xfe\x3f"),
(jdouble, [0, 1.99], bytes(8) + b"\xd7\xa3\x70\x3d\x0a\xd7\xff\x3f")]:
java_type = jarray(element_type)
for python_type in [bytes, bytearray]:
with self.subTest(element_type=element_type,
python_type=python_type):
self.assertEqual(b"", python_type(java_type([])))
self.assertEqual(expected, python_type(java_type(values)))
# Integer arrays containing values 0 to 255 can be converted element-wise using `list`.
for element_type in [jshort, jint, jlong]:
with self.subTest(element_type=element_type):
self.assertEqual(
b"\x00\x01\x7E\x7F\x80\x81\xFE\xFF",
bytes(
list(
jarray(element_type)(
[0, 1, 126, 127, 128, 129, 254, 255]))))
# Other array types (including multi-dimensional arrays) will be treated as an iterable
# of integers, so converting them to bytes will fail unless the array is empty.
for element_type, values in \
[(jchar, "hello"),
(jarray(jbyte), [b"hello", b"world"]),
(String, ["hello"])]:
java_type = jarray(element_type)
for python_type in [bytes, bytearray]:
with self.subTest(element_type=element_type,
python_type=python_type):
self.assertEqual(b"", python_type(java_type([])))
with self.assertRaisesRegex(
TypeError, "cannot be interpreted as an integer"):
python_type(java_type(values))
def test_invalid_index(self):
a = jarray(jint)([2, 3, 5, 7, 11])
index_type_error = \
self.assertRaisesRegex(TypeError, "array indices must be integers or slices, not str")
with index_type_error:
a["hello"]
with index_type_error:
a["hello"] = 4
def test_set_int(self):
a = jarray(jint)([2, 3, 5, 7, 11])
a[0] = 0
a[1] = 10
a[4] = 40
self.assertEqual([0, 10, 5, 7, 40], a)
with self.index_error:
a[5] = 50
with self.index_error:
jarray(jint)([])[0] = 99
a[-1] = -10
a[-2] = -20
a[-5] = -50
self.assertEqual([-50, 10, 5, -20, -10], a)
with self.index_error:
a[-6] = -60
def test_output_arg(self):
string = String('\u1156\u2278\u3390\u44AB')
for btarray in ([0] * 4, (0, ) * 4, jarray(jbyte)([0] * 4)):
# This version of getBytes returns the 8 low-order of each Unicode character.
string.getBytes(0, 4, btarray, 0)
if not isinstance(btarray, tuple):
self.assertEquals(
btarray,
[ctypes.c_int8(x).value for x in [0x56, 0x78, 0x90, 0xAB]])
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 test_eq(self):
tf = jarray(jboolean)([True, False])
self.verify_equal(tf, tf)
self.verify_equal(tf, jarray(jboolean)([True, False]))
self.verify_equal(tf, [True, False])
self.verify_equal(tf, [1, 0])
self.verify_not_equal(tf, [True, True])
self.verify_not_equal(tf, [True, False, True])
single = jarray(jboolean)([True])
self.verify_not_equal(single, True)
empty = jarray(jboolean)([])
self.verify_equal(empty, empty)
self.verify_equal(empty, [])
self.verify_not_equal(empty, single)
self.verify_not_equal(empty, False)
def test_basic(self):
array_C = jarray(jchar)("hello")
self.assertEqual(5, len(array_C))
self.assertEqual(repr(array_C), "jarray('C')(['h', 'e', 'l', 'l', 'o'])")
self.assertTrue(isinstance(array_C, jclass("java.lang.Object")))
self.assertTrue(isinstance(array_C, jclass("java.lang.Cloneable")))
self.assertTrue(isinstance(array_C, jclass("java.io.Serializable")))
self.assertFalse(isinstance(array_C, jclass("java.io.Closeable")))
self.assertRegex(array_C.toString(), r"^\[C")
def test_array(self):
list_bool = [True, False]
for jarray_Z in [jarray(jboolean)(list_bool), jarray("Z")(list_bool)]:
self.assertEqual("[Z", type(jarray_Z).__name__)
self.assertEqual("jarray('Z')({!r})".format(list_bool),
str(jarray_Z))
list_list_bool = [[True, False], [False, True]]
jarray_jarray_Z = jarray(jarray(jboolean))(list_list_bool)
self.assertEqual("[[Z", type(jarray_jarray_Z).__name__)
self.assertEqual("jarray('[Z')({!r})".format(list_list_bool),
str(jarray_jarray_Z))
list_str = ["one", "two"]
String = jclass("java.lang.String")
jarray_String = jarray(String)(list_str)
self.assertEqual("[Ljava/lang/String;", type(jarray_String).__name__)
self.assertEqual("jarray('Ljava/lang/String;')({!r})".format(list_str),
str(jarray_String))
def test_bytes(self):
self.verify_bytes([], b"")
self.verify_bytes([-128, -127, -2, -1, 0, 1, 2, 126, 127],
b"\x80\x81\xFE\xFF\x00\x01\x02\x7E\x7F")
# These optional arguments are not part of the public API and are subject to change.
array_B = jarray(jbyte)([0, 102, 111, 111, 127, -1, -128])
self.assertEqual(b"\x00foo\x7F\xFF\x80", array_B.__bytes__())
self.assertEqual(b"foo", array_B.__bytes__(1, 3))
self.assertEqual(b"\xFF\x80", array_B.__bytes__(5))
self.assertEqual(b"\x00foo", array_B.__bytes__(length=4))
def test_invalid_index(self):
a = jarray(jint)(SLICE_DATA)
for index in ["", "hello", 0.0, 1.0]:
with self.subTest(index=index):
error = self.assertRaisesRegex(
TypeError, fr"array indices must be integers or slices, not "
fr"{type(index).__name__}")
with error:
a[index]
with error:
a[index] = 99
self.assertEqual(SLICE_DATA, a)
def audio_samples(x):
# get float data from string array
x = x.replace("[", "").replace("]", "")
x = x.split(",")
x = np.array(x)
x = x.astype(np.float)
x = x / 32768.0 #Convert to [-1.0, +1.0]
# Calculate MFCC features
x = waveform_to_examples(x, RATE)
return jarray(jfloat)(x.reshape(-1))
def test_blank(self):
array_Z = jarray(jboolean)(2)
self.assertEqual(2, len(array_Z))
self.assertEqual([False, False], array_Z)
array_C = jarray(jchar)(3)
self.assertEqual(3, len(array_C))
self.assertEqual([u"\u0000", u"\u0000", u"\u0000"], array_C)
array_I = jarray(jint)(2)
self.assertEqual(2, len(array_I))
self.assertEqual([0, 0], array_I)
from java.lang import Object
array_Object = jarray(Object)(3)
self.assertEqual(3, len(array_Object))
self.assertEqual([None, None, None], array_Object)
array_empty = jarray(Object)(0)
self.assertEqual(0, len(array_empty))
self.assertEqual([], array_empty)
def test_jni_sig(self):
Object = jclass("java.lang.Object")
self.assertEquals("V", jni_sig(jvoid))
self.assertEquals("Z", jni_sig(jboolean))
self.assertEquals("B", jni_sig(jbyte))
self.assertEquals("C", jni_sig(jchar))
self.assertEquals("D", jni_sig(jdouble))
self.assertEquals("F", jni_sig(jfloat))
self.assertEquals("I", jni_sig(jint))
self.assertEquals("J", jni_sig(jlong))
self.assertEquals("S", jni_sig(jshort))
self.assertEquals("Ljava/lang/Object;", jni_sig(Object))
self.assertEquals("[Z", jni_sig(jarray(jboolean)))
self.assertEquals("[[Z", jni_sig(jarray(jarray(jboolean))))
self.assertEquals("[Ljava/lang/Object;", jni_sig(jarray(Object)))
self.assertEquals("[[Ljava/lang/Object;",
jni_sig(jarray(jarray(Object))))
with self.assertRaisesRegex(
ValueError, "Invalid JNI signature: 'java.lang.Object'"):
jni_sig("java.lang.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"):
jni_sig(obj)
def reshape(raw_data, window_size, step_width):
'''
input:
[n_input,9]
n_input = n_sec * frequence
9, data from 3 sensors
output:
[n_output, window_size, 9]
n_output =
'''
python_raw_data = java.cast(java.jarray(java.jarray(java.jfloat)), raw_data)
raw_data = np.array(python_raw_data)
new_feat_count = ((raw_data.shape[0] - window_size) // step_width) + 1
reshaped_feat = np.empty((new_feat_count, window_size, 9))
for idx, window in enumerate(
utils_gen_windows(raw_data.shape[0], window_size, step_width)
):
new_row = raw_data[window[0] : window[1]]
if idx < new_feat_count:
reshaped_feat[idx, :] = new_row
return reshaped_feat
def test_bytes(self):
# Java byte arrays work for values -128 to 127.
self.verify_bytes([], b"")
self.verify_bytes([-128, -127, -2, -1, 0, 1, 126, 127],
b"\x80\x81\xFE\xFF\x00\x01\x7E\x7F")
# Other Java array types cannot be directly converted to bytes.
for element_type, value in [(jint, 42), (jfloat, 3.0), (jchar, "x"),
(String, "hello")]:
a = jarray(element_type)([value])
for cls in [bytes, bytearray]:
with self.assertRaisesRegexp(
TypeError, "__getbuffer__ is not implemented"):
cls(a)
# But integer array types can be converted indirectly for values 0 to 255.
for element_type in [jshort, jint, jlong]:
self.assertEqual(
b"\x00\x01\x7E\x7F\x80\x81\xFE\xFF",
bytes(
list(
jarray(element_type)(
[0, 1, 126, 127, 128, 129, 254, 255]))))
def test_type_jni(self):
self.assertIs(jarray(String), jarray("Ljava/lang/String;"))
with self.assertRaisesRegex(jclass("java.lang.NoClassDefFoundError"),
"java.lang.Nonexistent"):
jarray("Ljava/lang/Nonexistent;")
with self.assertRaisesRegex(ValueError, "Invalid JNI signature: 'java.lang.String'"):
jarray("java.lang.String")
def verify_bytes(self, jbyte_values, b):
arrayB_from_list = jarray(jbyte)(jbyte_values)
self.assertEqual(jbyte_values, arrayB_from_list)
to_bytes = (bytes
if sys.version_info[0] >= 3 else lambda x: x.__bytes__())
array_bytes = to_bytes(arrayB_from_list)
self.assertIsInstance(array_bytes, bytes)
self.assertEqual(b, array_bytes)
# TODO #5231: use `bytearray(bytes(...))` instead.
# array_bytearray = bytearray(arrayB_from_list)
# self.assertEqual(b, array_bytearray)
arrayB_from_bytes = jarray(jbyte)(b)
self.assertEqual(jbyte_values, arrayB_from_bytes)
arrayB_from_bytearray = jarray(jbyte)(bytearray(b))
self.assertEqual(jbyte_values, arrayB_from_bytearray)
b_as_ints = b if (sys.version_info[0] >= 3) else map(ord, b)
arrayI_from_bytes = jarray(jint)(b_as_ints)
self.assertEqual(b_as_ints, arrayI_from_bytes)
with self.assertRaisesRegexp(
TypeError, "Cannot call __bytes__ on int[], only on byte[]"):
to_bytes(arrayI_from_bytes)
def test_identity(self):
from java.lang import Object, String
Object_klass, String_klass = Object.getClass(), String.getClass()
self.assertIsNot(Object_klass, String_klass)
self.t.fieldKlass = Object_klass
self.assertIs(Object_klass, self.t.fieldKlass)
self.t.setKlass(String_klass)
self.assertIs(String_klass, self.t.getKlass())
a1, a2 = [jarray(String)(x) for x in [["one", "two"], ["three", "four"]]]
self.assertIsNot(a1, a2)
self.t.fieldStringArray = a1
self.assertIs(a1, self.t.fieldStringArray)
self.t.setStringArray(a2)
self.assertIs(a2, self.t.getStringArray())
def test_output_arg(self):
string = String('\u1156\u2278\u3390\u44AB')
for btarray in ([0] * 4,
(0,) * 4,
jarray(jbyte)([0] * 4)):
# This version of getBytes returns the 8 low-order of each Unicode character.
string.getBytes(0, 4, btarray, 0)
if not isinstance(btarray, tuple):
self.assertEqual(btarray, [ctypes.c_int8(x).value
for x in [0x56, 0x78, 0x90, 0xAB]])
for method in ["arraySort", "arraySortObject"]:
for input in [[], [42], [5, 7, 2, 11, 3]]:
with self.subTest(method=method, input=input):
l = input.copy()
getattr(TA, method)(l)
self.assertEqual(sorted(input), l)
def test_varargs(self):
obj = jclass("com.chaquo.python.TestOverload$Varargs")()
self.assertEqual("", obj.resolve_empty_single_I())
self.assertEqual("int... []", obj.resolve_empty_single_I([]))
self.assertEqual("int... null", obj.resolve_empty_single_I(None))
self.assertEqual("int 1", obj.resolve_empty_single_I(1))
self.assertEqual("int... [1]", obj.resolve_empty_single_I([1]))
self.assertEqual("int... [1, 2]", obj.resolve_empty_single_I(1, 2))
self.assertEqual("int... [1, 2]", obj.resolve_empty_single_I([1, 2]))
self.assertEqual("int... []", obj.resolve_ID()) # int is more specific than double.
with self.ambiguous:
obj.resolve_ID(None) # But int[] is not more specific than double[].
self.assertEqual("int... null", obj.resolve_ID(cast(jarray(jint), None)))
self.assertEqual("double... null", obj.resolve_ID(cast(jarray(jdouble), None)))
with self.inapplicable:
obj.resolve_ID(None, None)
self.assertEqual("int 42", obj.resolve_ID(42))
self.assertEqual("double 42.0", obj.resolve_ID(42.0))
self.assertEqual("double... [1.0, 2.0]", obj.resolve_ID(jarray(jdouble)([1, 2])))
self.assertEqual("double... [1.0, 2.0]", obj.resolve_ID(1.0, 2.0))
self.assertEqual("double... [1.0, 2.0]", obj.resolve_ID(1, 2.0))
self.assertEqual("double... [1.0, 2.0]", obj.resolve_ID(1.0, 2))
Long = jclass("java.lang.Long")
with self.ambiguous:
obj.resolve_I_Long() # Neither int nor Long are more specific.
with self.ambiguous:
obj.resolve_I_Long(None) # Neither int[] nor Long[] are more specific.
self.assertEqual("Long... [null, null]", obj.resolve_I_Long(None, None))
with self.ambiguous:
obj.resolve_I_Long(42)
with self.inapplicable:
obj.resolve_I_Long(42.0)
self.assertEqual("int... [42]", obj.resolve_I_Long(jint(42)))
self.assertEqual("Long... [42]", obj.resolve_I_Long(jlong(42)))
self.assertEqual("Long... [42]", obj.resolve_I_Long(Long(42)))
Number = jclass("java.lang.Number")
# Long[] is more specific than Number[].
self.assertEqual("Long... []", obj.resolve_Number_Long())
self.assertEqual("Long... [42]", obj.resolve_Number_Long(42))
self.assertEqual("Long... null", obj.resolve_Number_Long(None))
self.assertEqual("Long... [null]", obj.resolve_Number_Long([None]))
self.assertEqual("Long... [null, null]", obj.resolve_Number_Long(None, None))
self.assertEqual("Number... [42]", obj.resolve_Number_Long(cast(Number, Long(42))))
self.assertEqual("Number... null", obj.resolve_Number_Long(cast(jarray(Number), None)))
self.assertEqual("Number... [null]", obj.resolve_Number_Long(cast(Number, None)))
self.assertEqual("Number... [42]", obj.resolve_Number_Long(jarray(Number)([42])))
self.assertEqual("Number... [null]", obj.resolve_Number_Long(jarray(Number)([None])))
