JNI: add QJniArray class for easier working with arrays

Implements an iterator API and other standard member access functions
for sequential containers so that we can use ranged-for over an object
that is a jarray. Provides read-only access to individual elements
(which is mostly relevant for arrays of objects), or the entire data()
as a contiguous memory block (which is useful for arrays of primitive
types).

QJniObject call functions can return QJniArray<T> when the return type
is either explicitly QJniArray<T> or T[], or their Qt equivalent (e.g.
a jbyteArray can be taken or returned as a QByteArray). If the return
type is a jarray type, then a QJniObject is returned as before.

Arrays can be created from a Qt container through a constructor or the
generic fromData named constructor in the QJniArrayBase class, which
implements the generic logic.

Not documented as public API yet.

Added a compile-time test to verify that types are mapped correctly.
The function test coverage is added to the QJniObject auto-test, as
that already provides the Java test class with functions taking and
returning arrays of different types.

Change-Id: I0750fc4f4cce7314df3b10e122eafbcfd68297b6
Reviewed-by: Assam Boudjelthia <assam.boudjelthia@qt.io>

6 files changed, 359 insertions, 2 deletions

diff --git a/tests/auto/corelib/kernel/CMakeLists.txt b/tests/auto/corelib/kernel/CMakeLists.txt
index ce0e82bae2..130fc080b6 100644
--- a/tests/auto/corelib/kernel/CMakeLists.txt
+++ b/tests/auto/corelib/kernel/CMakeLists.txt
@@ -49,4 +49,5 @@ if(ANDROID)
     add_subdirectory(qjnienvironment)
     add_subdirectory(qjniobject)
     add_subdirectory(qjnitypes)
+    add_subdirectory(qjniarray)
 endif()
diff --git a/tests/auto/corelib/kernel/qjniarray/CMakeLists.txt b/tests/auto/corelib/kernel/qjniarray/CMakeLists.txt
new file mode 100644
index 0000000000..308b2c6427
--- /dev/null
+++ b/tests/auto/corelib/kernel/qjniarray/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright (C) 2023 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
+    cmake_minimum_required(VERSION 3.16)
+    project(tst_qjnitypes LANGUAGES CXX)
+    find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST)
+endif()
+
+qt_internal_add_test(tst_qjniarray
+    SOURCES
+    tst_qjniarray.cpp
+)
diff --git a/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp b/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp
new file mode 100644
index 0000000000..fa0da3ca66
--- /dev/null
+++ b/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp
@@ -0,0 +1,75 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include <QtTest>
+
+#include <QtCore/qjnitypes.h>
+#include <QtCore/qjniarray.h>
+
+using namespace Qt::StringLiterals;
+
+class tst_QJniArray : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QJniArray() = default;
+};
+
+using namespace QtJniTypes;
+
+// fake type so that we can compile-time test and assert correct type mappings
+Q_DECLARE_JNI_CLASS(List, "qt/test/List");
+
+// verify that we get the return type we expect for the specified return type
+#define VERIFY_RETURN_FOR_TYPE(In, Out) \
+static_assert(std::is_same_v<decltype(List::callStaticMethod<In>("toByteArray")), Out>)
+
+VERIFY_RETURN_FOR_TYPE(jobjectArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jobject[], QJniArray<jobject>);
+//VERIFY_RETURN_FOR_TYPE(QList<QJniObject>, QList<QJniObject>);
+VERIFY_RETURN_FOR_TYPE(QList<jobject>, QList<jobject>);
+
+VERIFY_RETURN_FOR_TYPE(jbyteArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jbyte[], QJniArray<jbyte>);
+VERIFY_RETURN_FOR_TYPE(QByteArray, QByteArray);
+
+VERIFY_RETURN_FOR_TYPE(jbooleanArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jboolean[], QJniArray<jboolean>);
+VERIFY_RETURN_FOR_TYPE(QList<jboolean>, QList<jboolean>);
+VERIFY_RETURN_FOR_TYPE(QList<bool>, QList<jboolean>);
+
+VERIFY_RETURN_FOR_TYPE(jcharArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jchar[], QJniArray<jchar>);
+VERIFY_RETURN_FOR_TYPE(QList<jchar>, QList<jchar>);
+
+VERIFY_RETURN_FOR_TYPE(jshortArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jshort[], QJniArray<jshort>);
+VERIFY_RETURN_FOR_TYPE(QList<jshort>, QList<jshort>);
+VERIFY_RETURN_FOR_TYPE(QList<short>, QList<short>);
+
+VERIFY_RETURN_FOR_TYPE(jintArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jint[], QJniArray<jint>);
+VERIFY_RETURN_FOR_TYPE(QList<jint>, QList<jint>);
+VERIFY_RETURN_FOR_TYPE(QList<int>, QList<int>);
+
+VERIFY_RETURN_FOR_TYPE(jlongArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jlong[], QJniArray<jlong>);
+VERIFY_RETURN_FOR_TYPE(QList<jlong>, QList<jlong>);
+// VERIFY_RETURN_FOR_TYPE(QList<long>, QList<long>); // assumes long is 64bit
+
+VERIFY_RETURN_FOR_TYPE(jfloatArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jfloat[], QJniArray<jfloat>);
+VERIFY_RETURN_FOR_TYPE(QList<jfloat>, QList<jfloat>);
+VERIFY_RETURN_FOR_TYPE(QList<float>, QList<float>);
+
+VERIFY_RETURN_FOR_TYPE(jdoubleArray, QJniObject);
+VERIFY_RETURN_FOR_TYPE(jdouble[], QJniArray<jdouble>);
+VERIFY_RETURN_FOR_TYPE(QList<jdouble>, QList<jdouble>);
+VERIFY_RETURN_FOR_TYPE(QList<double>, QList<double>);
+
+VERIFY_RETURN_FOR_TYPE(QString, QString);
+
+QTEST_MAIN(tst_QJniArray)
+
+#include "tst_qjniarray.moc"
diff --git a/tests/auto/corelib/kernel/qjniobject/testdata/src/org/qtproject/qt/android/testdata/QtJniObjectTestClass.java b/tests/auto/corelib/kernel/qjniobject/testdata/src/org/qtproject/qt/android/testdata/QtJniObjectTestClass.java
index d1b4ea480e..b56447198f 100644
--- a/tests/auto/corelib/kernel/qjniobject/testdata/src/org/qtproject/qt/android/testdata/QtJniObjectTestClass.java
+++ b/tests/auto/corelib/kernel/qjniobject/testdata/src/org/qtproject/qt/android/testdata/QtJniObjectTestClass.java
@@ -135,44 +135,143 @@ public class QtJniObjectTestClass
     public static Object[] staticObjectArrayMethod()
     { Object[] array = { new Object(), new Object(), new Object() }; return array; }
     public Object[] objectArrayMethod() { return staticObjectArrayMethod(); }
+    public static Object[] staticReverseObjectArray(Object[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            Object old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public Object[] reverseObjectArray(Object[] array)
+    { return staticReverseObjectArray(array); }
 
     // --------------------------------------------------------------------------------------------
     public static boolean[] staticBooleanArrayMethod()
     { boolean[] array = { true, true, true }; return array; }
     public boolean[] booleanArrayMethod() { return staticBooleanArrayMethod(); }
+    public static boolean[] staticReverseBooleanArray(boolean[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            boolean old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public boolean[] reverseBooleanArray(boolean[] array)
+    { return staticReverseBooleanArray(array); }
 
     // --------------------------------------------------------------------------------------------
     public static byte[] staticByteArrayMethod()
     { byte[] array = { 'a', 'b', 'c' }; return array; }
     public byte[] byteArrayMethod() { return staticByteArrayMethod(); }
+    public static byte[] staticReverseByteArray(byte[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            byte old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public byte[] reverseByteArray(byte[] array)
+    { return staticReverseByteArray(array); }
 
     // --------------------------------------------------------------------------------------------
     public static char[] staticCharArrayMethod()
     { char[] array = { 'a', 'b', 'c' }; return array; }
     public char[] charArrayMethod() { return staticCharArrayMethod(); }
+    public static char[] staticReverseCharArray(char[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            char old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public char[] reverseCharArray(char[] array)
+    { return staticReverseCharArray(array); }
 
     // --------------------------------------------------------------------------------------------
     public static short[] staticShortArrayMethod() { short[] array = { 3, 2, 1 }; return array; }
     public short[] shortArrayMethod() { return staticShortArrayMethod(); }
+    public static short[] staticReverseShortArray(short[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            short old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public short[] reverseShortArray(short[] array)
+    { return staticReverseShortArray(array); }
 
     // --------------------------------------------------------------------------------------------
     public static int[] staticIntArrayMethod() { int[] array = { 3, 2, 1 }; return array; }
     public int[] intArrayMethod() { return staticIntArrayMethod(); }
+    public static int[] staticReverseIntArray(int[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            int old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public int[] reverseIntArray(int[] array)
+    { return staticReverseIntArray(array); }
 
     // --------------------------------------------------------------------------------------------
     public static long[] staticLongArrayMethod()
     { long[] array = { 3, 2, 1 }; return array; }
     public long[] longArrayMethod() { return staticLongArrayMethod(); }
+    public static long[] staticReverseLongArray(long[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            long old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public long[] reverseLongArray(long[] array)
+    { return staticReverseLongArray(array); }
 
     // --------------------------------------------------------------------------------------------
     public static float[] staticFloatArrayMethod()
     { float[] array = { 1.0f, 2.0f, 3.0f }; return array; }
     public float[] floatArrayMethod() { return staticFloatArrayMethod(); }
+    public static float[] staticReverseFloatArray(float[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            float old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public float[] reverseFloatArray(float[] array)
+    { return staticReverseFloatArray(array); }
 
     // --------------------------------------------------------------------------------------------
     public static double[] staticDoubleArrayMethod()
     { double[] array = { 3.0, 2.0, 1.0 }; return array; }
     public double[] doubleArrayMethod() { return staticDoubleArrayMethod(); }
+    public static double[] staticReverseDoubleArray(double[] array)
+    {
+        for (int i = 0; i < array.length / 2; ++i) {
+            double old = array[array.length - i - 1];
+            array[array.length - i - 1] = array[i];
+            array[i] = old;
+        }
+        return array;
+    }
+    public double[] reverseDoubleArray(double[] array)
+    { return staticReverseDoubleArray(array); }
 
     // --------------------------------------------------------------------------------------------
     native public int callbackWithObject(QtJniObjectTestClass that);
diff --git a/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp b/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
index 47c3a707f0..751e5a84d8 100644
--- a/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
+++ b/tests/auto/corelib/kernel/qjniobject/tst_qjniobject.cpp
@@ -1495,6 +1495,18 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jobject[]>("staticObjectArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+
+        QJniArray<jobject> newArray(QList<QJniObject>{QJniObject::fromString(u"one"_s),
+                                                      QJniObject::fromString(u"two"_s),
+                                                      QJniObject::fromString(u"three"_s)});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jobject[]>("staticReverseObjectArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.size(), 3);
+        QCOMPARE(QJniObject(reverse.at(0)).toString(), u"three"_s);
+        QCOMPARE(QJniObject(reverse.at(1)).toString(), u"two"_s);
+        QCOMPARE(QJniObject(reverse.at(2)).toString(), u"one"_s);
     }
 
     {
@@ -1503,6 +1515,18 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jobject[]>("objectArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+
+        QJniArray<jobject> newArray(QList<QJniObject>{QJniObject::fromString(u"one"_s),
+                                                      QJniObject::fromString(u"two"_s),
+                                                      QJniObject::fromString(u"three"_s)});
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jobject[]>("reverseObjectArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.size(), 3);
+        QCOMPARE(QJniObject(reverse.at(0)).toString(), u"three"_s);
+        QCOMPARE(QJniObject(reverse.at(1)).toString(), u"two"_s);
+        QCOMPARE(QJniObject(reverse.at(2)).toString(), u"one"_s);
     }
 
     // jbooleanArray ------------------------------------------------------------------------------
@@ -1513,6 +1537,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jboolean[]>("staticBooleanArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jboolean>{true, true, true}));
+
+        QJniArray<jboolean> newArray(QList<jboolean>{true, false, false});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jboolean[]>("staticReverseBooleanArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jboolean>{false, false, true}));
     }
 
     {
@@ -1521,6 +1553,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jboolean[]>("booleanArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jboolean>{true, true, true}));
+
+        QJniArray<jboolean> newArray(QList<jboolean>{true, false, false});
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jboolean[]>("reverseBooleanArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jboolean>{false, false, true}));
     }
 
     // jbyteArray ---------------------------------------------------------------------------------
@@ -1531,6 +1571,18 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jbyte[]>("staticByteArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), "abc");
+
+        QJniArray<jbyte> newArray(QByteArray{"cba"});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jbyte[]>("staticReverseByteArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), "abc");
+
+        const QByteArray reverse2 = TestClass::callStaticMethod<QByteArray>("staticReverseByteArray",
+                                                                            QByteArray("abc"));
+        QCOMPARE(reverse2, "cba");
     }
 
     {
@@ -1539,6 +1591,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jbyte[]>("byteArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), "abc");
+
+        QJniArray<jbyte> newArray = QJniArrayBase::fromContainer(QByteArray{"cba"});
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jbyte[]>("reverseByteArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), "abc");
     }
 
     // jcharArray ---------------------------------------------------------------------------------
@@ -1549,6 +1609,18 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jchar[]>("staticCharArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jchar>{u'a', u'b', u'c'}));
+
+        QJniArray<jchar> newArray(QList<jchar>{u'c', u'b', u'a'});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jchar[]>("staticReverseCharArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jchar>{u'a', u'b', u'c'}));
+
+        const QList<jchar> reverse2 = TestClass::callStaticMethod<QList<jchar>>("staticReverseCharArray",
+                                                                        (QList<jchar>{u'c', u'b', u'a'}));
+        QCOMPARE(reverse2, (QList<jchar>{u'a', u'b', u'c'}));
     }
 
     {
@@ -1557,6 +1629,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jchar[]>("charArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jchar>{u'a', u'b', u'c'}));
+
+        QJniArray<jchar> newArray = QJniArrayBase::fromContainer(QList<jchar>{u'c', u'b', u'a'});
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jchar[]>("reverseCharArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jchar>{u'a', u'b', u'c'}));
     }
 
     // jshortArray --------------------------------------------------------------------------------
@@ -1567,6 +1647,18 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jshort[]>("staticShortArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jshort>{3, 2, 1}));
+
+        QJniArray<jshort> newArray(QList<jshort>{3, 2, 1});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jshort[]>("staticReverseShortArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jshort>{1, 2, 3}));
+
+        const QList<jshort> reverse2 = TestClass::callStaticMethod<QList<jshort>>("staticReverseShortArray",
+                                                                                  (QList<jshort>{1, 2, 3}));
+        QCOMPARE(reverse2, (QList<jshort>{3, 2, 1}));
     }
 
     {
@@ -1575,6 +1667,15 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jshort[]>("shortArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jshort>{3, 2, 1}));
+
+        QJniArray<jshort> newArray = QJniArrayBase::fromContainer(QList<jshort>{3, 2, 1});
+        static_assert(std::is_same_v<decltype(newArray)::Type, jshort>);
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jshort[]>("reverseShortArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jshort>{1, 2, 3}));
     }
 
     // jintArray ----------------------------------------------------------------------------------
@@ -1585,6 +1686,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jint[]>("staticIntArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jint>{3, 2, 1}));
+
+        QJniArray<jint> newArray(QList<jint>{3, 2, 1});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jint[]>("staticReverseIntArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jint>{1, 2, 3}));
     }
 
     {
@@ -1593,6 +1702,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jint[]>("intArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jint>{3, 2, 1}));
+
+        QJniArray<jint> newArray = QJniArrayBase::fromContainer(QList<jint>{3, 2, 1});
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jint[]>("reverseIntArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jint>{1, 2, 3}));
     }
 
     // jlongArray ---------------------------------------------------------------------------------
@@ -1603,6 +1720,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jlong[]>("staticLongArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jlong>{3, 2, 1}));
+
+        QJniArray<jlong> newArray(QList<jlong>{3, 2, 1});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jlong[]>("staticReverseLongArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jlong>{1, 2, 3}));
     }
 
     {
@@ -1611,6 +1736,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jlong[]>("longArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jlong>{3, 2, 1}));
+
+        QJniArray<jlong> newArray = QJniArrayBase::fromContainer(QList<jlong>{3, 2, 1});
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jlong[]>("reverseLongArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jlong>{1, 2, 3}));
     }
 
     // jfloatArray --------------------------------------------------------------------------------
@@ -1621,6 +1754,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jfloat[]>("staticFloatArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jfloat>{1.0f, 2.0f, 3.0f}));
+
+        QJniArray<jfloat> newArray(QList<jfloat>{3.0f, 2.0f, 1.0f});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jfloat[]>("staticReverseFloatArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jfloat>{1.0f, 2.0f, 3.0f}));
     }
 
     {
@@ -1629,6 +1770,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jfloat[]>("floatArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jfloat>{1.0f, 2.0f, 3.0f}));
+
+        QJniArray<jfloat> newArray = QJniArrayBase::fromContainer(QList<jfloat>{3.0f, 2.0f, 1.0f});
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jfloat[]>("reverseFloatArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jfloat>{1.0f, 2.0f, 3.0f}));
     }
 
     // jdoubleArray -------------------------------------------------------------------------------
@@ -1639,6 +1788,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = TestClass::callStaticMethod<jdouble[]>("staticDoubleArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jdouble>{3.0, 2.0, 1.0}));
+
+        QJniArray<jdouble> newArray(QList<jdouble>{3.0, 2.0, 1.0});
+        QVERIFY(newArray.isValid());
+        const auto reverse = TestClass::callStaticMethod<jdouble[]>("staticReverseDoubleArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jdouble>{1.0, 2.0, 3.0}));
     }
 
     {
@@ -1647,6 +1804,14 @@ void tst_QJniObject::templateApiCheck()
 
         const auto array = testClass.callMethod<jdouble[]>("doubleArrayMethod");
         QVERIFY(array.isValid());
+        QCOMPARE(array.size(), 3);
+        QCOMPARE(array.asContainer(), (QList<jdouble>{3.0, 2.0, 1.0}));
+
+        QJniArray<jdouble> newArray = QJniArrayBase::fromContainer(QList<jdouble>{3.0, 2.0, 1.0});
+        QVERIFY(newArray.isValid());
+        const auto reverse = testClass.callMethod<jdouble[]>("reverseDoubleArray", newArray);
+        QVERIFY(reverse.isValid());
+        QCOMPARE(reverse.asContainer(), (QList<jdouble>{1.0, 2.0, 3.0}));
     }
 
 }
diff --git a/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp b/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
index a499b6f2d2..f9d9a4c13c 100644
--- a/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
+++ b/tests/auto/corelib/kernel/qjnitypes/tst_qjnitypes.cpp
@@ -4,6 +4,7 @@
 #include <QtTest>
 
 #include <QtCore/qjnitypes.h>
+#include <QtCore/qjniarray.h>
 
 using namespace Qt::StringLiterals;
 
@@ -59,8 +60,7 @@ static_assert(!(QtJniTypes::Traits<QtJavaWrapper>::signature() == "X"));
 
 Q_DECLARE_JNI_CLASS(JavaType, "org/qtproject/qt/JavaType");
 static_assert(QtJniTypes::Traits<QtJniTypes::JavaType>::signature() == "Lorg/qtproject/qt/JavaType;");
-Q_DECLARE_JNI_TYPE(ArrayType, "[Lorg/qtproject/qt/ArrayType;")
-static_assert(QtJniTypes::Traits<QtJniTypes::ArrayType>::signature() == "[Lorg/qtproject/qt/ArrayType;");
+static_assert(QtJniTypes::Traits<QtJniTypes::JavaType[]>::signature() == "[Lorg/qtproject/qt/JavaType;");
 
 Q_DECLARE_JNI_CLASS(String, "java/lang/String");
 static_assert(QtJniTypes::Traits<jstring>::className() == "java/lang/String");
@@ -119,6 +119,10 @@ static_assert(!QtJniTypes::CTString("ABCDE").startsWith("9AB"));
 static_assert(QtJniTypes::CTString("ABCDE").startsWith('A'));
 static_assert(!QtJniTypes::CTString("ABCDE").startsWith('B'));
 
+static_assert(QtJniTypes::Traits<QJniArray<jobject>>::signature() == "[Ljava/lang/Object;");
+static_assert(QtJniTypes::Traits<QJniArray<jbyte>>::signature() == "[B");
+static_assert(QtJniTypes::isObjectType<QJniArray<jbyte>>());
+
 static_assert(QtJniTypes::CTString("ABCDE").endsWith("CDE"));
 static_assert(QtJniTypes::CTString("ABCDE").endsWith("E"));
 static_assert(QtJniTypes::CTString("ABCDE").endsWith("ABCDE"));