Function for converting Python values to an explicit Java type

.gitignore

@@ -21,3 +21,4 @@ Vagrantfile
 *.so
 *.dll
 
+.vscode/

README.md

@@ -102,6 +102,12 @@ documentation.
 4. Update documentation, `cd doc` and run `make html` 
 5. http://peterdowns.com/posts/first-time-with-pypi.html
 
+
+Running Tests
+----------------
+
+Run: `python setup.py build test`
+
 Automated builds
 ----------------
 

doc/reference.rst

@@ -87,7 +87,10 @@ jpy Functions
         tm = rt.totalMemory()
 
     The returned Java types have a `jclass` attribute which returns the actual Java object. This allows for using
-    the Java types where a Java method would expect a parameter of type `java.lang.Class`.
+    the Java types where a Java method would expect a parameter of type `java.lang.Class`. They also have a `jclassname`
+    attribute, which returns the Java type associated with the 'obj' reference. The `jclassname` is the reference's
+    declared type (which may be a supertype), rather than the object's runtime type (as returned by
+    `obj.getClass().getName()`).
 
     To instantiate Java array objects, the :py:func:`jpy.array()` function is used.
 

src/main/c/jpy_jtype.c

@@ -914,19 +914,19 @@ int JType_ConvertPythonToJavaObject(JNIEnv* jenv, JPy_JType* type, PyObject* pyA
         return JType_CreateJavaDoubleObject(jenv, type, pyArg, objectRef);
     } else if (type == JPy_JPyObject) {
         return JType_CreateJavaPyObject(jenv, type, pyArg, objectRef);
-    } else if (JPy_IS_STR(pyArg) && (type == JPy_JString || type == JPy_JObject || ((*jenv)->IsAssignableFrom(jenv, JPy_JString->classRef, type->classRef)))) {
+    } else if (JPy_IS_STR(pyArg) && (type == JPy_JString || type == JPy_JObject || (*jenv)->IsAssignableFrom(jenv, JPy_JString->classRef, type->classRef))) {
         return JPy_AsJString(jenv, pyArg, objectRef);
-    } else if (PyBool_Check(pyArg) && (type == JPy_JObject || ((*jenv)->IsAssignableFrom(jenv, JPy_Boolean_JClass, type->classRef)))) {
+    } else if (PyBool_Check(pyArg) && (type == JPy_JObject || (*jenv)->IsAssignableFrom(jenv, JPy_Boolean_JClass, type->classRef))) {
         return JType_CreateJavaBooleanObject(jenv, type, pyArg, objectRef);
     } else if (JPy_IS_CLONG(pyArg) && (type == JPy_JObject || (*jenv)->IsAssignableFrom(jenv, JPy_Number_JClass, type->classRef))) {
         return JType_CreateJavaNumberFromPythonInt(jenv, type, pyArg, objectRef);
     } else if (JPy_IS_CLONG(pyArg) && ((*jenv)->IsAssignableFrom(jenv, JPy_Integer_JClass, type->classRef))) {
         return JType_CreateJavaIntegerObject(jenv, type, pyArg, objectRef);
-    } else if (JPy_IS_CLONG(pyArg) && (type == JPy_JObject || ((*jenv)->IsAssignableFrom(jenv, JPy_Long_JClass, type->classRef)))) {
+    } else if (JPy_IS_CLONG(pyArg) && (*jenv)->IsAssignableFrom(jenv, JPy_Long_JClass, type->classRef)) {
         return JType_CreateJavaLongObject(jenv, type, pyArg, objectRef);
-    } else if (PyFloat_Check(pyArg) && (type == JPy_JObject || ((*jenv)->IsAssignableFrom(jenv, JPy_Double_JClass, type->classRef)))) {
+    } else if (PyFloat_Check(pyArg) && (type == JPy_JObject || (*jenv)->IsAssignableFrom(jenv, JPy_Double_JClass, type->classRef))) {
         return JType_CreateJavaDoubleObject(jenv, type, pyArg, objectRef);
-    } else if (PyFloat_Check(pyArg) && (type == JPy_JObject || ((*jenv)->IsAssignableFrom(jenv, JPy_Float_JClass, type->classRef)))) {
+    } else if (PyFloat_Check(pyArg) && (*jenv)->IsAssignableFrom(jenv, JPy_Float_JClass, type->classRef)) {
         return JType_CreateJavaFloatObject(jenv, type, pyArg, objectRef);
     } else if (type == JPy_JObject && allowObjectWrapping) {
         return JType_CreateJavaPyObject(jenv, JPy_JPyObject, pyArg, objectRef);
@@ -1298,6 +1298,7 @@ int JType_AddClassAttribute(JNIEnv* jenv, JPy_JType* declaringClass)
             return -1;
         }
         PyDict_SetItem(typeDict, Py_BuildValue("s", "jclass"), (PyObject*) JObj_FromType(jenv, JPy_JClass, declaringClass->classRef));
+        PyDict_SetItem(typeDict, Py_BuildValue("s", "jclassname"), (PyObject*) JPy_FROM_CSTR(declaringClass->typeObj.tp_name));
     }
     return 0;
 }

src/main/c/jpy_module.c

@@ -38,6 +38,7 @@ PyObject* JPy_create_jvm(PyObject* self, PyObject* args, PyObject* kwds);
 PyObject* JPy_destroy_jvm(PyObject* self, PyObject* args);
 PyObject* JPy_get_type(PyObject* self, PyObject* args, PyObject* kwds);
 PyObject* JPy_cast(PyObject* self, PyObject* args);
+PyObject* JPy_as_jobj(PyObject* self, PyObject* args);
 PyObject* JPy_array(PyObject* self, PyObject* args);
 PyObject* JPy_byte_buffer(PyObject* self, PyObject* args);
 
@@ -61,6 +62,11 @@ static PyMethodDef JPy_Functions[] = {
                     "cast(obj, type) - Cast the given Java object to the given Java type (type name or type object). "
                     "Returns None if the cast is not possible."},
 
+    {"as_jobj",     JPy_as_jobj, METH_VARARGS,
+                    "as_jobj(obj, type) - Convert the given Python object to the given Java type (type name or type object). "
+                    "Returns None if the conversion is not possible. If the Java type is a primitive, the returned object "
+                    "will be of the corresponding boxed type."},
+
     {"array",       JPy_array, METH_VARARGS,
                     "array(name, init) - Return a new Java array of given Java type (type name or type object) and initializer (array length or sequence). "
                     "Possible primitive types are 'boolean', 'byte', 'char', 'short', 'int', 'long', 'float', and 'double'."},
@@ -451,7 +457,7 @@ PyObject* JPy_create_jvm(PyObject* self, PyObject* args, PyObject* kwds)
     if (JPy_JVM != NULL) {
         JPy_DIAG_PRINT(JPy_DIAG_F_JVM + JPy_DIAG_F_ERR, "JPy_create_jvm: WARNING: Java VM is already running.\n");
         JPy_DECREF(options);
-        return Py_BuildValue("");
+        return JPy_FROM_JVOID();
     }
 
     if (!PySequence_Check(options)) {
@@ -513,7 +519,7 @@ PyObject* JPy_create_jvm(PyObject* self, PyObject* args, PyObject* kwds)
         return NULL;
     }
 
-    return Py_BuildValue("");
+    return JPy_FROM_JVOID();
 }
 
 PyObject* JPy_destroy_jvm(PyObject* self, PyObject* args)
@@ -526,7 +532,7 @@ PyObject* JPy_destroy_jvm(PyObject* self, PyObject* args)
         JPy_JVM = NULL;
     }
 
-    return Py_BuildValue("");
+    return JPy_FROM_JVOID();
 }
 
 PyObject* JPy_get_type_internal(JNIEnv* jenv, PyObject* self, PyObject* args, PyObject* kwds)
@@ -551,41 +557,41 @@ PyObject* JPy_get_type(PyObject* self, PyObject* args, PyObject* kwds)
 PyObject* JPy_cast_internal(JNIEnv* jenv, PyObject* self, PyObject* args)
 {
     PyObject* obj;
-    PyObject* objType;
-    JPy_JType* type;
+    PyObject* targetTypeArg;        // can be a string PyObject (i.e. JPy_IS_STR) or a JPy_JType
+    JPy_JType* targetTypeParsed;    // the actual type that targetTypeArg is processed as
     jboolean inst;
 
-    if (!PyArg_ParseTuple(args, "OO:cast", &obj, &objType)) {
+    if (!PyArg_ParseTuple(args, "OO:cast", &obj, &targetTypeArg)) {
         return NULL;
     }
 
     if (obj == Py_None) {
-        return Py_BuildValue("");
+        return JPy_FROM_JNULL();
     }
 
     if (!JObj_Check(obj)) {
         PyErr_SetString(PyExc_ValueError, "cast: argument 1 (obj) must be a Java object");
         return NULL;
     }
 
-    if (JPy_IS_STR(objType)) {
-        const char* typeName = JPy_AS_UTF8(objType);
-        type = JType_GetTypeForName(jenv, typeName, JNI_FALSE);
-        if (type == NULL) {
+    if (JPy_IS_STR(targetTypeArg)) {
+        const char* typeName = JPy_AS_UTF8(targetTypeArg);
+        targetTypeParsed = JType_GetTypeForName(jenv, typeName, JNI_FALSE);
+        if (targetTypeParsed == NULL) {
             return NULL;
         }
-    } else if (JType_Check(objType)) {
-        type = (JPy_JType*) objType;
+    } else if (JType_Check(targetTypeArg)) {
+        targetTypeParsed = (JPy_JType*) targetTypeArg;
     } else {
         PyErr_SetString(PyExc_ValueError, "cast: argument 2 (obj_type) must be a Java type name or Java type object");
         return NULL;
     }
 
-    inst = (*jenv)->IsInstanceOf(jenv, ((JPy_JObj*) obj)->objectRef, type->classRef);
+    inst = (*jenv)->IsInstanceOf(jenv, ((JPy_JObj*) obj)->objectRef, targetTypeParsed->classRef);
     if (inst) {
-        return (PyObject*) JObj_FromType(jenv, (JPy_JType*) objType, ((JPy_JObj*) obj)->objectRef);
+        return (PyObject*) JObj_FromType(jenv, (JPy_JType*) targetTypeParsed, ((JPy_JObj*) obj)->objectRef);
     } else {
-        return Py_BuildValue("");
+        return JPy_FROM_JNULL();
     }
 }
 
@@ -594,6 +600,77 @@ PyObject* JPy_cast(PyObject* self, PyObject* args)
     JPy_FRAME(PyObject*, NULL, JPy_cast_internal(jenv, self, args), 16)
 }
 
+PyObject* JPy_as_jobj_internal(JNIEnv* jenv, PyObject* self, PyObject* args)
+{
+    PyObject* obj;
+    PyObject* targetTypeArg;        // can be a string PyObject (i.e. JPy_IS_STR) or a JPy_JType
+    JPy_JType* targetTypeParsed;    // the actual type that targetTypeArg is processed as
+    jboolean inst;
+
+    PyObject* resultObj;
+    jobject objectRef;
+
+    // Parse the 'args' from Python into 'obj'/'objType'.
+    if (!PyArg_ParseTuple(args, "OO:as_jobj", &obj, &targetTypeArg)) {
+        return NULL;
+    }
+
+    if (obj == Py_None) {
+        return JPy_FROM_JNULL();
+    }
+
+    if (JPy_IS_STR(targetTypeArg)) {
+        const char* typeName = JPy_AS_UTF8(targetTypeArg);
+        targetTypeParsed = JType_GetTypeForName(jenv, typeName, JNI_FALSE);
+        if (targetTypeParsed == NULL) {
+            return NULL;
+        }
+    } else if (JType_Check(targetTypeArg)) {
+        targetTypeParsed = (JPy_JType*) targetTypeArg;
+    } else {
+        PyErr_SetString(PyExc_ValueError, "cast: argument 2 (obj_type) must be a Java type name or Java type object");
+        return NULL;
+    }
+
+    // If the input obj is a Java object, and it is already of the specified target type,
+    // then just cast it.
+    if (JObj_Check(obj)) {
+        inst = (*jenv)->IsInstanceOf(jenv, ((JPy_JObj*) obj)->objectRef, targetTypeParsed->classRef);
+        if (inst) {
+            return (PyObject*) JObj_FromType(jenv, (JPy_JType*) targetTypeParsed, ((JPy_JObj*) obj)->objectRef);
+        }
+    }
+
+    // Convert the Python object to the specified Java type
+    if (JPy_AsJObjectWithType(jenv,  obj, &objectRef, targetTypeParsed) < 0) {
+        return NULL;
+    }
+
+    // Create a global reference for the objectRef (so it is valid after we exit this frame)
+    objectRef = (*jenv)->NewGlobalRef(jenv, objectRef);
+    if (objectRef == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    // Create a PyObject (JObj) to hold the result
+    resultObj = (JPy_JObj*) PyObject_New(JPy_JObj, JTYPE_AS_PYTYPE(targetTypeParsed));
+    if (resultObj == NULL) {
+        (*jenv)->DeleteGlobalRef(jenv, objectRef);
+        return NULL;
+    }
+    // Store the reference to the converted object in the result JObj
+    ((JPy_JObj*) resultObj)->objectRef = objectRef;
+
+    return (PyObject*) resultObj;
+}
+
+
+PyObject* JPy_as_jobj(PyObject* self, PyObject* args)
+{
+    JPy_FRAME(PyObject*, NULL, JPy_as_jobj_internal(jenv, self, args), 16)
+}
+
 PyObject* JPy_array_internal(JNIEnv* jenv, PyObject* self, PyObject* args)
 {
     JPy_JType* componentType;

src/test/java/org/jpy/EmbeddableTestJunit.java

@@ -1,12 +1,18 @@
 package org.jpy;
 
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.TestRule;
 
 /**
  * Wraps up {@link EmbeddableTest} with JUnit so {@link EmbeddableTest} doesn't have to have the
  * JUnit dependency.
  */
 public class EmbeddableTestJunit {
+
+    @Rule
+    public TestRule testStatePrinter = new TestStatePrinter();
+
     @Test
     public void testStartingAndStoppingIfAvailable() {
         EmbeddableTest.testStartingAndStoppingIfAvailable();

src/test/java/org/jpy/JavaReflectionTest.java

@@ -19,7 +19,9 @@
 import org.jpy.annotations.Mutable;
 import org.jpy.annotations.Return;
 import org.jpy.fixtures.MethodReturnValueTestFixture;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.TestRule;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
@@ -34,6 +36,9 @@
  */
 public class JavaReflectionTest {
 
+    @Rule
+    public TestRule testStatePrinter = new TestStatePrinter();
+
     @Test
     public void testPrimitiveAndVoidNames() throws Exception {
         assertEquals("boolean", Boolean.TYPE.getName());

src/test/java/org/jpy/LifeCycleTest.java

@@ -1,9 +1,15 @@
 package org.jpy;
 
 import org.junit.Assert;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.TestRule;
 
 public class LifeCycleTest {
+
+    @Rule
+    public TestRule testStatePrinter = new TestStatePrinter();
+
     private static final boolean ON_WINDOWS = System.getProperty("os.name").toLowerCase().contains("windows");
 
     @Test

src/test/java/org/jpy/PyLibTest.java

@@ -27,10 +27,14 @@
 import java.util.Map;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.TestRule;
 
 public class PyLibTest {
 
+    @Rule
+    public TestRule testStatePrinter = new TestStatePrinter();
     @Before
     public void setUp() throws Exception {
         //PyLib.Diag.setFlags(PyLib.Diag.F_ERR);

src/test/java/org/jpy/PyLibWithSysPathTest.java

@@ -17,6 +17,7 @@
 package org.jpy;
 
 import org.junit.*;
+import org.junit.rules.TestRule;
 
 import java.io.File;
 import java.net.URI;
@@ -27,6 +28,9 @@
 
 public class PyLibWithSysPathTest {
 
+    @Rule
+    public TestRule testStatePrinter = new TestStatePrinter();
+
     @Before
     public void setUp() throws Exception {
 

src/test/java/org/jpy/PyModuleTest.java

@@ -17,6 +17,7 @@
 package org.jpy;
 
 import org.junit.*;
+import org.junit.rules.TestRule;
 
 import java.io.File;
 
@@ -29,6 +30,8 @@
  */
 public class PyModuleTest {
 
+    @Rule
+    public TestRule testStatePrinter = new TestStatePrinter();
     @Before
     public void setUp() throws Exception {
         //System.out.println("PyModuleTest: Current thread: " + Thread.currentThread());