JNI: Make declared QtJniTypes classes proper QJniObjects

Instead of having a type that doesn't behave like a QJniObject, which
includes not holding a proper reference on the Java object, make the
QtJniTypes::Object type a QJniObject subclass that can be specialized
via CRTP to provide type-specific constructor and static functions.

QJniObject doesn't have a virtual destructor, but we subclass it only to
add a typed interface, without adding any additional data members.
Add versions of the static functions from QJniObjects to the
QtJniTypes::Object so that they can be called without explicitly
specifying the type or class name. This includes a constructor and named
constructors.

Constructing such objects means constructing a Java object of the class
the object type represents, as per the Q_DECLARE_JNI_CLASS declaration.
This is not without ambiguity, as constructing a type with a jobject
parameter can mean that a type wrapping an existing jobject should be
created, or that a Java object should be created with the provided
jobject as the parameter to the constructor (e.g. a copy constructor).
This ambiguity is for now inevitable; we need to be able to implicitly
convert jobject to such types. However, named constructors are provided
so that client code can avoid the ambiguity.

To prevent unnecessary default constructed QJniObjects that are then
replaced immediately with a properly constructed object, add a protected
QJniObject constructor that creates an uninitialized object (e.g. with
the d-pointer being nullptr), which we can then assign the constructed
jobject to using the available assignment operator. Add the special
copy and move constructor and assignment operators as explicit members
for clarity, even though the can all be defaulted.

Such QJniObject subclasses can then be transparently passed as arguments
into JNI call functions that expect a jobject representation, with the
QtJniTypes::Traits specialization from the type declaration providing the
correct signature.

QJniObject's API includes a lot of legacy overloads: with variadic
arguments, a explicit signature string, and jclass/jmethodID parameters
that are completely unused within Qt itself. In addition the explicit
"Object" member functions to explicitly call the version that returns a
jobject (and then a QJniObject). All this call-side complexity is taken
care of by the compile-time signature generation, implicit class type,
and template argument deduction. Overloads taking a jclass or jmethod
are not used anywhere in Qt, which is perhaps an indicator that they,
while nice to have, are too hard to use even for ourselves.

For the modern QtJniTypes class instantiations, remove all the overhead
and reduce the API to the small set of functions that are used all over
the place, and that don't require an explicit signature, or class/method
lookup.

This is a source incompatible change, as now QJniTypes::Object is no
longer a primitive type, and no longer binary equivalent to jobject.
However, this is acceptable as the API has so far been undocumented,
and is only used internally in Qt (and changes to adapt are largely
already merged).

Change-Id: I6d14c09c8165652095f30511f04dc17217245bf5
Reviewed-by: Juha Vuolle <juha.vuolle@qt.io>

5 files changed, 291 insertions, 21 deletions

diff --git a/src/corelib/kernel/qjniobject.cpp b/src/corelib/kernel/qjniobject.cpp
index 14a5f3ef7d..6bfd4ac596 100644
--- a/src/corelib/kernel/qjniobject.cpp
+++ b/src/corelib/kernel/qjniobject.cpp
@@ -1386,7 +1386,7 @@ bool QJniObject::isSameObject(const QJniObject &other) const
 
 void QJniObject::assign(jobject obj)
 {
-    if (isSameObject(obj))
+    if (d && isSameObject(obj))
         return;
 
     jobject jobj = static_cast<jobject>(obj);
diff --git a/src/corelib/kernel/qjniobject.h b/src/corelib/kernel/qjniobject.h
index 4b34370923..6fe646d50f 100644
--- a/src/corelib/kernel/qjniobject.h
+++ b/src/corelib/kernel/qjniobject.h
@@ -42,6 +42,8 @@ class Q_CORE_EXPORT QJniObject
             using Type = q20::remove_cvref_t<T>;
             if constexpr (std::is_same_v<Type, QString>) {
                 return newLocalRef<jstring>(QJniObject::fromString(value));
+            } else if constexpr (std::is_base_of_v<QJniObject, Type>) {
+                return value.object();
             } else {
                 return static_cast<T &&>(value);
             }
@@ -52,8 +54,11 @@ class Q_CORE_EXPORT QJniObject
             using Type = q20::remove_cvref_t<T>;
             if constexpr (std::is_same_v<Type, QString>) {
                 return object.toString();
+            } else if constexpr (std::is_base_of_v<QJniObject, Type>
+                              && !std::is_same_v<QJniObject, Type>) {
+                return T{std::move(object)};
             } else {
-                return object;
+                return std::move(object);
             }
         }
     };
@@ -67,9 +72,12 @@ public:
 #endif
         >
     explicit QJniObject(const char *className, Args &&...args)
-        : QJniObject(className, QtJniTypes::constructorSignature<Args...>().data(),
-                     std::forward<Args>(args)...)
-    {}
+        : QJniObject(Qt::Uninitialized)
+    {
+        LocalFrame<Args...> localFrame;
+        *this = QJniObject(className, QtJniTypes::constructorSignature<Args...>().data(),
+                           localFrame.convertToJni(std::forward<Args>(args))...);
+    }
     explicit QJniObject(jclass clazz);
     explicit QJniObject(jclass clazz, const char *signature, ...);
     template<typename ...Args
@@ -82,6 +90,12 @@ public:
                      std::forward<Args>(args)...)
     {}
     QJniObject(jobject globalRef);
+
+    QJniObject(const QJniObject &other) noexcept = default;
+    QJniObject(QJniObject &&other) noexcept = default;
+    QJniObject &operator=(const QJniObject &other) noexcept = default;
+    QJniObject &operator=(QJniObject &&other) noexcept = default;
+
     ~QJniObject();
 
     template<typename Class, typename ...Args>
@@ -527,6 +541,9 @@ public:
         return *this;
     }
 
+protected:
+    QJniObject(Qt::Initialization) {}
+
 private:
     static jclass loadClass(const QByteArray &className, JNIEnv *env);
 
diff --git a/src/corelib/kernel/qjnitypes.h b/src/corelib/kernel/qjnitypes.h
index 6007dd3297..a3346ec3f4 100644
--- a/src/corelib/kernel/qjnitypes.h
+++ b/src/corelib/kernel/qjnitypes.h
@@ -13,25 +13,176 @@ QT_BEGIN_NAMESPACE
 
 namespace QtJniTypes
 {
-// A generic thin wrapper around jobject, convertible to jobject.
-// We need this as a baseclass so that QJniObject can be implicitly
-// constructed from the various subclasses. We can also pass instances
-// of this type (or of any of the generated subclasses) as if it was
-// a jobject.
-struct Object
+// A generic base class for specialized QJniObject types, to be used by
+// subclasses via CRTP. It's implicitly convertible to and from jobject, which
+// allows the QJniObject implementation to implicitly pass instances of this
+// type through the variadic argument JNI APIs.
+template<typename Type>
+struct Object : QJniObject
 {
-    jobject _object;
-    constexpr operator jobject() const { return _object; }
-    operator QJniObject() const { return QJniObject(_object); }
+    using Class = Type;
+    operator jobject() const noexcept { return object(); }
+
+    Q_IMPLICIT Object(jobject object) : QJniObject(object) {}
+    Q_IMPLICIT Object(const QJniObject &object) : QJniObject(object) {}
+    Q_IMPLICIT Object(QJniObject &&object) : QJniObject(std::move(object)) {}
+
+    // Compiler-generated copy/move semantics based on QJniObject's shared d-pointer are fine!
+    Object(const Object<Type> &other) = default;
+    Object(Object<Type> &&other) = default;
+    Object<Type> &operator=(const Object<Type> &other) = default;
+    Object<Type> &operator=(Object<Type> &&other) = default;
+
+    // avoid ambiguities with deleted const char * constructor
+    Q_IMPLICIT Object(std::nullptr_t) : QJniObject() {}
+
+    // this intentionally includes the default constructor
+    template<typename ...Args
+            , ValidSignatureTypes<Args...> = true
+    >
+    explicit Object(Args &&...args)
+        : QJniObject(Qt::Initialization::Uninitialized)
+    {
+        *this = Object<Type>{QJniObject::construct<Class>(std::forward<Args>(args)...)};
+    }
+
+    // named constructors avoid ambiguities
+    static Object<Type> fromJObject(jobject object) { return Object<Type>(object); }
+    template <typename ...Args>
+    static Object<Type> construct(Args &&...args)
+    {
+        return Object<Type>{QJniObject::construct<Class, Args...>(std::forward<Args>(args)...)};
+    }
+
+    // public API forwarding to QJniObject, with the implicit Class template parameter
+    template <typename Ret, typename ...Args
+#ifndef Q_QDOC
+        , QtJniTypes::ValidSignatureTypes<Ret, Args...> = true
+#endif
+    >
+    static auto callStaticMethod(const char *name, Args &&...args)
+    {
+        return QJniObject::callStaticMethod<Class, Ret, Args...>(name,
+                                                                 std::forward<Args>(args)...);
+    }
+    template <typename T
+#ifndef Q_QDOC
+        , QtJniTypes::ValidFieldType<T> = true
+#endif
+    >
+    static auto getStaticField(const char *field)
+    {
+        return QJniObject::getStaticField<Class, T>(field);
+    }
+    template <typename T
+#ifndef Q_QDOC
+        , QtJniTypes::ValidFieldType<T> = true
+#endif
+    >
+    static void setStaticField(const char *field, T &&value)
+    {
+        QJniObject::setStaticField<Class, T>(field, std::forward<T>(value));
+    }
+
+    // keep only these overloads, the rest is made private
+    template <typename Ret, typename ...Args
+#ifndef Q_QDOC
+        , QtJniTypes::ValidSignatureTypes<Ret, Args...> = true
+#endif
+    >
+    auto callMethod(const char *method, Args &&...args) const
+    {
+        return QJniObject::callMethod<Ret>(method, std::forward<Args>(args)...);
+    }
+    template <typename T
+#ifndef Q_QDOC
+        , QtJniTypes::ValidFieldType<T> = true
+#endif
+    >
+    auto getField(const char *fieldName) const
+    {
+        return QJniObject::getField<T>(fieldName);
+    }
+
+    template <typename T
+#ifndef Q_QDOC
+        , QtJniTypes::ValidFieldType<T> = true
+#endif
+    >
+    void setField(const char *fieldName, T &&value)
+    {
+        QJniObject::setField(fieldName, std::forward<T>(value));
+    }
+
+private:
+    // The following declutters the API of these types compared to the QJniObject API.
+    // 1) 'Object' methods; the functions we have have return type auto and will return
+    //     the type specified by the template parameter.
+    using QJniObject::callObjectMethod;
+    using QJniObject::callStaticObjectMethod;
+    using QJniObject::getObjectField;
+    using QJniObject::getStaticObjectField;
+
+    // 2) Constructors that take a class name, signature string, or class template argument
+    explicit Object(const char *className) = delete;
+    explicit Object(const char *className, const char *signature, ...) = delete;
+    template<typename ...Args>
+    explicit Object(const char *className, Args &&...args) = delete;
+    explicit Object(jclass clazz, const char *signature, ...) = delete;
+    template<typename Class, typename ...Args>
+    static QJniObject construct(Args &&...args) = delete;
+
+    // 3) Overloads that take a class name/jclass, methodID, signature string, or an
+    //    explicit class template argument
+    template <typename Ret, typename ...Args>
+    auto callMethod(const char *methodName, const char *signature, Args &&...args) const = delete;
+    template <typename Ret, typename ...Args>
+
+    static auto callStaticMethod(const char *className, const char *methodName,
+                                 const char *signature, Args &&...args) = delete;
+    template <typename Ret, typename ...Args>
+    static auto callStaticMethod(jclass clazz, const char *methodName,
+                                 const char *signature, Args &&...args) = delete;
+    template <typename Ret, typename ...Args>
+    static auto callStaticMethod(jclass clazz, jmethodID methodId, Args &&...args) = delete;
+    template <typename Ret, typename ...Args>
+    static auto callStaticMethod(const char *className, const char *methodName,
+                                 Args &&...args) = delete;
+    template <typename Ret, typename ...Args>
+    static auto callStaticMethod(jclass clazz, const char *methodName, Args &&...args) = delete;
+    template <typename Klass, typename Ret, typename ...Args>
+    static auto callStaticMethod(const char *methodName, Args &&...args) = delete;
+
+    template <typename T>
+    static auto getStaticField(const char *className, const char *fieldName) = delete;
+    template <typename T>
+    static auto getStaticField(jclass clazz, const char *fieldName) = delete;
+    template <typename Klass, typename T>
+    static auto getStaticField(const char *fieldName) = delete;
+
+    template <typename T>
+    void setField(const char *fieldName, const char *signature, T value) = delete;
+    template <typename T>
+    static void setStaticField(const char *className, const char *fieldName, T value) = delete;
+    template <typename T>
+    static void setStaticField(const char *className, const char *fieldName,
+                               const char *signature, T value) = delete;
+    template <typename T>
+    static void setStaticField(jclass clazz, const char *fieldName,
+                               const char *signature, T value) = delete;
+    template <typename T>
+    static void setStaticField(jclass clazz, const char *fieldName, T value) = delete;
+    template <typename Klass, typename T>
+    static void setStaticField(const char *fieldName, T value) = delete;
 };
 
 } // namespace QtJniTypes
 
 #define Q_DECLARE_JNI_TYPE_HELPER(Type)                         \
 namespace QtJniTypes {                                          \
-struct Type : Object                                            \
+struct Type : Object<Type>                                      \
 {                                                               \
-    constexpr Type(jobject o) noexcept : Object{o} {}           \
+    using Object::Object;                                       \
 };                                                              \
 }                                                               \
 
diff --git a/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp b/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
index 36f6f5923e..49a814f122 100644
--- a/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
+++ b/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
@@ -12,6 +12,7 @@ using namespace Qt::StringLiterals;
 
 static const char testClassName[] = "org/qtproject/qt/android/testdatapackage/QtJniObjectTestClass";
 Q_DECLARE_JNI_CLASS(QtJniObjectTestClass, testClassName)
+using TestClass = QtJniTypes::QtJniObjectTestClass;
 
 static const jbyte A_BYTE_VALUE = 127;
 static const jshort A_SHORT_VALUE = 32767;
@@ -153,6 +154,16 @@ void tst_QJniObject::ctor()
     }
 
     {
+        // from Qt 6.7 on we can construct declared classes through the helper type
+        QJniObject object = TestClass::construct();
+        QVERIFY(object.isValid());
+
+        // or even directly
+        TestClass testObject;
+        QVERIFY(testObject.isValid());
+    }
+
+    {
         QJniObject string = QJniObject::fromString(QLatin1String("Hello, Java"));
         QJniObject object("java/lang/String", "(Ljava/lang/String;)V", string.object<jstring>());
         QVERIFY(object.isValid());
@@ -311,10 +322,15 @@ void tst_QJniObject::className()
     }
 
     {
-        QJniObject strObject = QJniObject("java/lang/String", jString.object<jstring>());
+        QJniObject strObject = QJniObject("java/lang/String", str);
         QCOMPARE(strObject.className(), "java/lang/String");
         QCOMPARE(strObject.toString(), str);
     }
+
+    {
+        TestClass test;
+        QCOMPARE(test.className(), testClassName);
+    }
 }
 
 void tst_QJniObject::callStaticObjectMethodClassName()
@@ -1119,8 +1135,8 @@ void setStaticField(const char *fieldName, T testValue)
 
     // use template overload to reset to default
     T defaultValue = {};
-    QJniObject::setStaticField<QtJniTypes::QtJniObjectTestClass, T>(fieldName, defaultValue);
-    res = QJniObject::getStaticField<QtJniTypes::QtJniObjectTestClass, T>(fieldName);
+    TestClass::setStaticField(fieldName, defaultValue);
+    res = TestClass::getStaticField<T>(fieldName);
     QCOMPARE(res, defaultValue);
 }
 
@@ -1185,8 +1201,8 @@ void tst_QJniObject::setStaticObjectField()
 
     // as of Qt 6.7, we can set and get strings directly
     using namespace QtJniTypes;
-    QJniObject::setStaticField<QtJniObjectTestClass>("S_STRING_OBJECT_VAR", qString);
-    QCOMPARE((QJniObject::getStaticField<QtJniObjectTestClass, QString>("S_STRING_OBJECT_VAR")), qString);
+    QtJniObjectTestClass::setStaticField("S_STRING_OBJECT_VAR", qString);
+    QCOMPARE(QtJniObjectTestClass::getStaticField<QString>("S_STRING_OBJECT_VAR"), qString);
 }
 
 void tst_QJniObject::templateApiCheck()
@@ -1473,11 +1489,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jobjectArray>(testClassName,
                                                                           "staticObjectArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jobject[]>("staticObjectArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jobjectArray>("objectArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jobject[]>("objectArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jbooleanArray ------------------------------------------------------------------------------
@@ -1485,11 +1507,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jbooleanArray>(testClassName,
                                                                            "staticBooleanArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jboolean[]>("staticBooleanArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jbooleanArray>("booleanArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jboolean[]>("booleanArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jbyteArray ---------------------------------------------------------------------------------
@@ -1497,11 +1525,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jbyteArray>(testClassName,
                                                                         "staticByteArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jbyte[]>("staticByteArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jbyteArray>("byteArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jbyte[]>("byteArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jcharArray ---------------------------------------------------------------------------------
@@ -1509,11 +1543,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jcharArray>(testClassName,
                                                                         "staticCharArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jchar[]>("staticCharArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jcharArray>("charArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jchar[]>("charArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jshortArray --------------------------------------------------------------------------------
@@ -1521,11 +1561,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jshortArray>(testClassName,
                                                                          "staticShortArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jshort[]>("staticShortArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jshortArray>("shortArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jshort[]>("shortArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jintArray ----------------------------------------------------------------------------------
@@ -1533,11 +1579,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jintArray>(testClassName,
                                                                        "staticIntArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jint[]>("staticIntArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jintArray>("intArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jint[]>("intArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jlongArray ---------------------------------------------------------------------------------
@@ -1545,11 +1597,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jlongArray>(testClassName,
                                                                         "staticLongArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jlong[]>("staticLongArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jlongArray>("longArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jlong[]>("longArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jfloatArray --------------------------------------------------------------------------------
@@ -1557,11 +1615,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jfloatArray>(testClassName,
                                                                          "staticFloatArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jfloat[]>("staticFloatArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jfloatArray>("floatArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jfloat[]>("floatArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     // jdoubleArray -------------------------------------------------------------------------------
@@ -1569,11 +1633,17 @@ void tst_QJniObject::templateApiCheck()
         QJniObject res = QJniObject::callStaticObjectMethod<jdoubleArray>(testClassName,
                                                                           "staticDoubleArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = TestClass::callStaticMethod<jdouble[]>("staticDoubleArrayMethod");
+        QVERIFY(array.isValid());
     }
 
     {
         QJniObject res = testClass.callObjectMethod<jdoubleArray>("doubleArrayMethod");
         QVERIFY(res.isValid());
+
+        const auto array = testClass.callMethod<jdouble[]>("doubleArrayMethod");
+        QVERIFY(array.isValid());
     }
 
 }
diff --git a/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp b/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
index 856368355c..0ce2295092 100644
--- a/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
+++ b/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
@@ -5,6 +5,8 @@
 
 #include <QtCore/qjnitypes.h>
 
+using namespace Qt::StringLiterals;
+
 class tst_QJniTypes : public QObject
 {
     Q_OBJECT
@@ -15,6 +17,7 @@ public:
 private slots:
     void initTestCase();
     void nativeMethod();
+    void construct();
 };
 
 struct QtJavaWrapper {};
@@ -159,6 +162,35 @@ void tst_QJniTypes::nativeMethod()
     QCOMPARE(method.signature, "(ILjava/lang/String;J)Z");
 }
 
+void tst_QJniTypes::construct()
+{
+    using namespace QtJniTypes;
+
+    const QString text = u"Java String"_s;
+    String str(text);
+    QVERIFY(str.isValid());
+    QCOMPARE(str.toString(), text);
+
+    jobject jref = nullptr; // must be jobject, not jstring
+    {
+        // if jref would be a jstring, then this would call the
+        // Java String copy constructor!
+        String jstr(jref);
+        QVERIFY(!jstr.isValid());
+    }
+    jref = str.object<jstring>();
+    {
+        String jstr(jref);
+        QVERIFY(jstr.isValid());
+        QCOMPARE(jstr.toString(), text);
+    }
+
+    String str2 = str;
+    QCOMPARE(str.toString(), text);
+    String str3 = std::move(str2);
+    QCOMPARE(str3.toString(), text);
+}
+
 QTEST_MAIN(tst_QJniTypes)
 
 #include "tst_qjnitypes.moc"