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
 ----------------
 

jpyutil.py

@@ -36,7 +36,7 @@
 __author__ = "Norman Fomferra (Brockmann Consult GmbH) and contributors"
 __copyright__ = "Copyright 2015-2018 Brockmann Consult GmbH and contributors"
 __license__ = "Apache 2.0"
-__version__ = "0.15.0"
+__version__ = "0.16.0.dev0"
 
 
 # Setup a dedicated logger for jpyutil.

src/main/c/jpy_module.c

@@ -37,7 +37,9 @@ PyObject* JPy_has_jvm(PyObject* self);
 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_get_type_name(PyObject* self, PyObject* args);
 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);
 
@@ -57,10 +59,19 @@ static PyMethodDef JPy_Functions[] = {
                     "get_type(name, resolve=True) - Return the Java class with the given name, e.g. 'java.io.File'. "
                     "Loads the Java class from the JVM if not already done. Optionally avoids resolving the class' methods."},
 
+    {"get_type_name",    (PyCFunction) JPy_get_type_name, METH_VARARGS,
+                    "get_type_name(obj) - Return the Java type associated with the 'obj' reference. "
+                    "This is reference's declared type (which may be a supertype), rather than the object's runtime type."},
+
     {"cast",        JPy_cast, METH_VARARGS,
                     "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 +462,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 +524,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 +537,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)
@@ -548,44 +559,63 @@ PyObject* JPy_get_type(PyObject* self, PyObject* args, PyObject* kwds)
     JPy_FRAME(PyObject*, NULL, JPy_get_type_internal(jenv, self, args, kwds), 16)
 }
 
+PyObject* JPy_get_type_name(PyObject* self, PyObject* args)
+{
+    PyObject* obj;
+    if (!PyArg_ParseTuple(args, "O:get_type_name", &obj)) {
+        return NULL;
+    }
+
+    if (obj == Py_None) {
+        return JPy_FROM_JNULL();
+    }
+
+    if (!JObj_Check(obj)) {
+        PyErr_SetString(PyExc_ValueError, "get_type_name: argument 1 (obj) must be a Java object");
+        return NULL;
+    }
+
+    return JPy_FROM_CSTR(obj->ob_type->tp_name);
+}
+
 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 +624,76 @@ 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) {
+        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());