Complete test of all QAndroidJniObjects JNI types.

Makes sure that all template specializations are available and
that they pass a minimal call test.
This is a follow-up to 211e92a604bb617ed08ef6324adb191fc7221ef6
and d57cef7332c8b0669b469202b9f5e5e2dab5387f.

Change-Id: I8fa37f1a2ec12441343d2e4d257f2e5c12ad426b
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>

3 files changed, 517 insertions, 0 deletions

diff --git a/tests/auto/qandroidjniobject/qandroidjniobject.pro b/tests/auto/qandroidjniobject/qandroidjniobject.pro
index 83e658a..d3ef5a0 100644
--- a/tests/auto/qandroidjniobject/qandroidjniobject.pro
+++ b/tests/auto/qandroidjniobject/qandroidjniobject.pro
@@ -2,3 +2,7 @@ CONFIG += testcase
 TARGET = tst_qandroidjniobject
 QT += testlib androidextras
 SOURCES += tst_qandroidjniobject.cpp
+
+ANDROID_PACKAGE_SOURCE_DIR = $$PWD/testdata
+OTHER_FILES += \
+              testdata/src/org/qtproject/qt5/android/testdata/QtAndroidJniObjectTestClass.java
diff --git a/tests/auto/qandroidjniobject/testdata/src/org/qtproject/qt5/android/testdata/QtAndroidJniObjectTestClass.java b/tests/auto/qandroidjniobject/testdata/src/org/qtproject/qt5/android/testdata/QtAndroidJniObjectTestClass.java
new file mode 100644
index 0000000..7869db1
--- /dev/null
+++ b/tests/auto/qandroidjniobject/testdata/src/org/qtproject/qt5/android/testdata/QtAndroidJniObjectTestClass.java
@@ -0,0 +1,182 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia. For licensing terms and
+** conditions see http://qt.digia.com/licensing. For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights. These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+package org.qtproject.qt5.android.testdatapackage;
+
+public class QtAndroidJniObjectTestClass
+{
+    static final byte A_BYTE_VALUE = 127;
+    static final short A_SHORT_VALUE = 32767;
+    static final int A_INT_VALUE = 060701;
+    static final long A_LONG_VALUE = 060701;
+    static final float A_FLOAT_VALUE = 1.0f;
+    static final double A_DOUBLE_VALUE = 1.0;
+    static final boolean A_BOOLEAN_VALUE = true;
+    static final char A_CHAR_VALUE = 'Q';
+    static final String A_STRING_OBJECT = "TEST_DATA_STRING";
+    static final Class A_CLASS_OBJECT = QtAndroidJniObjectTestClass.class;
+    static final Object A_OBJECT_OBJECT = new QtAndroidJniObjectTestClass();
+    static final Throwable A_THROWABLE_OBJECT = new Throwable(A_STRING_OBJECT);
+
+    // --------------------------------------------------------------------------------------------
+    public static void staticVoidMethod() { return; }
+    public static void staticVoidMethodWithArgs(int a, boolean b, char c) { return; }
+
+    public void voidMethod() { return; }
+    public void voidMethodWithArgs(int a, boolean b, char c) { return; }
+
+    // --------------------------------------------------------------------------------------------
+    public static boolean staticBooleanMethod() { return A_BOOLEAN_VALUE; }
+    public static boolean staticBooleanMethodWithArgs(boolean a, boolean b, boolean c)
+    { return staticBooleanMethod(); }
+
+    public boolean booleanMethod() { return staticBooleanMethod(); }
+    public boolean booleanMethodWithArgs(boolean a, boolean b, boolean c)
+    { return staticBooleanMethodWithArgs(a, b, c); }
+
+    // --------------------------------------------------------------------------------------------
+    public static byte staticByteMethod() { return A_BYTE_VALUE; }
+    public static byte staticByteMethodWithArgs(byte a, byte b, byte c) { return staticByteMethod(); }
+
+    public byte byteMethod() { return staticByteMethod(); }
+    public byte byteMethodWithArgs(byte a, byte b, byte c)
+    { return staticByteMethodWithArgs(a, b, c); }
+
+    // --------------------------------------------------------------------------------------------
+    public static char staticCharMethod() { return A_CHAR_VALUE; }
+    public static char staticCharMethodWithArgs(char a, char b, char c) { return staticCharMethod(); }
+
+    public char charMethod() { return staticCharMethod(); }
+    public char charMethodWithArgs(char a, char b, char c)
+    { return staticCharMethodWithArgs(a, b, c); }
+
+    // --------------------------------------------------------------------------------------------
+    public static short staticShortMethod() { return A_SHORT_VALUE; }
+    public static short staticShortMethodWithArgs(short a, short b, short c) { return staticShortMethod(); }
+
+    public short shortMethod() { return staticShortMethod(); }
+    public short shortMethodWithArgs(short a, short b, short c)
+    { return staticShortMethodWithArgs(a, b, c); }
+
+    // --------------------------------------------------------------------------------------------
+    public static int staticIntMethod() { return A_INT_VALUE; }
+    public static int staticIntMethodWithArgs(int a, int b, int c) { return staticIntMethod(); }
+
+    public int intMethod() { return staticIntMethod(); }
+    public int intMethodWithArgs(int a, int b, int c) { return staticIntMethodWithArgs(a, b, c); }
+
+    // --------------------------------------------------------------------------------------------
+    public static long staticLongMethod() { return A_LONG_VALUE; }
+    public static long staticLongMethodWithArgs(long a, long b, long c) { return staticLongMethod(); }
+
+    public long longMethod() { return staticLongMethod(); }
+    public long longMethodWithArgs(long a, long b, long c)
+    { return staticLongMethodWithArgs(a, b, c); }
+
+    // --------------------------------------------------------------------------------------------
+    public static float staticFloatMethod() { return A_FLOAT_VALUE; }
+    public static float staticFloatMethodWithArgs(float a, float b, float c) { return staticFloatMethod(); }
+
+    public float floatMethod() { return staticFloatMethod(); }
+    public float floatMethodWithArgs(float a, float b, float c)
+    { return staticFloatMethodWithArgs(a, b, c); }
+
+    // --------------------------------------------------------------------------------------------
+    public static double staticDoubleMethod() { return A_DOUBLE_VALUE; }
+    public static double staticDoubleMethodWithArgs(double a, double b, double c)
+    { return staticDoubleMethod(); }
+
+    public double doubleMethod() { return staticDoubleMethod(); }
+    public double doubleMethodWithArgs(double a, double b, double c)
+    { return staticDoubleMethodWithArgs(a, b, c); }
+
+    // --------------------------------------------------------------------------------------------
+    public static Object staticObjectMethod() { return A_OBJECT_OBJECT; }
+    public Object objectMethod() { return staticObjectMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static Class staticClassMethod() { return A_CLASS_OBJECT; }
+    public Class classMethod() { return staticClassMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static String staticStringMethod() { return A_STRING_OBJECT; }
+    public String stringMethod() { return staticStringMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static Throwable staticThrowableMethod() { return A_THROWABLE_OBJECT; }
+    public Throwable throwableMethod() { return staticThrowableMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static Object[] staticObjectArrayMethod()
+    { Object[] array = { new Object(), new Object(), new Object() }; return array; }
+    public Object[] objectArrayMethod() { return staticObjectArrayMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static boolean[] staticBooleanArrayMethod()
+    { boolean[] array = { true, true, true }; return array; }
+    public boolean[] booleanArrayMethod() { return staticBooleanArrayMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static byte[] staticByteArrayMethod()
+    { byte[] array = { 'a', 'b', 'c' }; return array; }
+    public byte[] byteArrayMethod() { return staticByteArrayMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static char[] staticCharArrayMethod()
+    { char[] array = { 'a', 'b', 'c' }; return array; }
+    public char[] charArrayMethod() { return staticCharArrayMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static short[] staticShortArrayMethod() { short[] array = { 3, 2, 1 }; return array; }
+    public short[] shortArrayMethod() { return staticShortArrayMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static int[] staticIntArrayMethod() { int[] array = { 3, 2, 1 }; return array; }
+    public int[] intArrayMethod() { return staticIntArrayMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static long[] staticLongArrayMethod()
+    { long[] array = { 3, 2, 1 }; return array; }
+    public long[] longArrayMethod() { return staticLongArrayMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static float[] staticFloatArrayMethod()
+    { float[] array = { 1.0f, 2.0f, 3.0f }; return array; }
+    public float[] floatArrayMethod() { return staticFloatArrayMethod(); }
+
+    // --------------------------------------------------------------------------------------------
+    public static double[] staticDoubleArrayMethod()
+    { double[] array = { 3.0, 2.0, 1.0 }; return array; }
+    public double[] doubleArrayMethod() { return staticDoubleArrayMethod(); }
+}
+
diff --git a/tests/auto/qandroidjniobject/tst_qandroidjniobject.cpp b/tests/auto/qandroidjniobject/tst_qandroidjniobject.cpp
index 05ee78c..c865b23 100644
--- a/tests/auto/qandroidjniobject/tst_qandroidjniobject.cpp
+++ b/tests/auto/qandroidjniobject/tst_qandroidjniobject.cpp
@@ -36,6 +36,22 @@
 #include <QtAndroidExtras/QAndroidJniObject>
 #include <QtAndroidExtras/QAndroidJniEnvironment>
 
+static const char testClassName[] = "org/qtproject/qt5/android/testdatapackage/QtAndroidJniObjectTestClass";
+
+static const jbyte A_BYTE_VALUE = 127;
+static const jshort A_SHORT_VALUE = 32767;
+static const jint A_INT_VALUE = 060701;
+static const jlong A_LONG_VALUE = 060701;
+static const jfloat A_FLOAT_VALUE = 1.0;
+static const jdouble A_DOUBLE_VALUE = 1.0;
+static const jboolean A_BOOLEAN_VALUE = true;
+static const jchar A_CHAR_VALUE = 'Q';
+
+static QString A_STRING_OBJECT()
+{
+    return QStringLiteral("TEST_DATA_STRING");
+}
+
 class tst_QAndroidJniObject : public QObject
 {
     Q_OBJECT
@@ -87,6 +103,7 @@ private slots:
     void getStaticCharField();
     void getBooleanField();
     void getIntField();
+    void templateApiCheck();
     void isClassAvailable();
 
     void cleanupTestCase();
@@ -708,6 +725,320 @@ void tst_QAndroidJniObject::getIntField()
     QCOMPARE(res, -1);
 }
 
+void tst_QAndroidJniObject::templateApiCheck()
+{
+    QAndroidJniObject testClass(testClassName);
+    QVERIFY(testClass.isValid());
+
+    // void ---------------------------------------------------------------------------------------
+    QAndroidJniObject::callStaticMethod<void>(testClassName, "staticVoidMethod");
+    QAndroidJniObject::callStaticMethod<void>(testClassName,
+                                              "staticVoidMethodWithArgs",
+                                              "(IZC)V",
+                                              1,
+                                              true,
+                                              'c');
+
+    testClass.callMethod<void>("voidMethod");
+    testClass.callMethod<void>("voidMethodWithArgs", "(IZC)V", 1, true, 'c');
+
+    // jboolean -----------------------------------------------------------------------------------
+    QVERIFY(QAndroidJniObject::callStaticMethod<jboolean>(testClassName, "staticBooleanMethod"));
+    QVERIFY(QAndroidJniObject::callStaticMethod<jboolean>(testClassName,
+                                                          "staticBooleanMethodWithArgs",
+                                                          "(ZZZ)Z",
+                                                          true,
+                                                          true,
+                                                          true));
+
+    QVERIFY(testClass.callMethod<jboolean>("booleanMethod"));
+    QVERIFY(testClass.callMethod<jboolean>("booleanMethodWithArgs",
+                                           "(ZZZ)Z",
+                                           true,
+                                           true,
+                                           true));
+
+    // jbyte --------------------------------------------------------------------------------------
+    QVERIFY(QAndroidJniObject::callStaticMethod<jbyte>(testClassName,
+                                                       "staticByteMethod") == A_BYTE_VALUE);
+    QVERIFY(QAndroidJniObject::callStaticMethod<jbyte>(testClassName,
+                                                       "staticByteMethodWithArgs",
+                                                       "(BBB)B",
+                                                       1,
+                                                       1,
+                                                       1) == A_BYTE_VALUE);
+
+    QVERIFY(testClass.callMethod<jbyte>("byteMethod") == A_BYTE_VALUE);
+    QVERIFY(testClass.callMethod<jbyte>("byteMethodWithArgs", "(BBB)B", 1, 1, 1) == A_BYTE_VALUE);
+
+    // jchar --------------------------------------------------------------------------------------
+    QVERIFY(QAndroidJniObject::callStaticMethod<jchar>(testClassName,
+                                                       "staticCharMethod") == A_CHAR_VALUE);
+    QVERIFY(QAndroidJniObject::callStaticMethod<jchar>(testClassName,
+                                                       "staticCharMethodWithArgs",
+                                                       "(CCC)C",
+                                                       jchar(1),
+                                                       jchar(1),
+                                                       jchar(1)) == A_CHAR_VALUE);
+
+    QVERIFY(testClass.callMethod<jchar>("charMethod") == A_CHAR_VALUE);
+    QVERIFY(testClass.callMethod<jchar>("charMethodWithArgs",
+                                        "(CCC)C",
+                                        jchar(1),
+                                        jchar(1),
+                                        jchar(1)) == A_CHAR_VALUE);
+
+    // jshort -------------------------------------------------------------------------------------
+    QVERIFY(QAndroidJniObject::callStaticMethod<jshort>(testClassName,
+                                                        "staticShortMethod") == A_SHORT_VALUE);
+    QVERIFY(QAndroidJniObject::callStaticMethod<jshort>(testClassName,
+                                                        "staticShortMethodWithArgs",
+                                                        "(SSS)S",
+                                                        jshort(1),
+                                                        jshort(1),
+                                                        jshort(1)) == A_SHORT_VALUE);
+
+    QVERIFY(testClass.callMethod<jshort>("shortMethod") == A_SHORT_VALUE);
+    QVERIFY(testClass.callMethod<jshort>("shortMethodWithArgs",
+                                         "(SSS)S",
+                                         jshort(1),
+                                         jshort(1),
+                                         jshort(1)) == A_SHORT_VALUE);
+
+    // jint ---------------------------------------------------------------------------------------
+    QVERIFY(QAndroidJniObject::callStaticMethod<jint>(testClassName,
+                                                      "staticIntMethod") == A_INT_VALUE);
+    QVERIFY(QAndroidJniObject::callStaticMethod<jint>(testClassName,
+                                                      "staticIntMethodWithArgs",
+                                                      "(III)I",
+                                                      jint(1),
+                                                      jint(1),
+                                                      jint(1)) == A_INT_VALUE);
+
+    QVERIFY(testClass.callMethod<jint>("intMethod") == A_INT_VALUE);
+    QVERIFY(testClass.callMethod<jint>("intMethodWithArgs",
+                                       "(III)I",
+                                       jint(1),
+                                       jint(1),
+                                       jint(1)) == A_INT_VALUE);
+
+    // jlong --------------------------------------------------------------------------------------
+    QVERIFY(QAndroidJniObject::callStaticMethod<jlong>(testClassName,
+                                                       "staticLongMethod") == A_LONG_VALUE);
+    QVERIFY(QAndroidJniObject::callStaticMethod<jlong>(testClassName,
+                                                       "staticLongMethodWithArgs",
+                                                       "(JJJ)J",
+                                                       jlong(1),
+                                                       jlong(1),
+                                                       jlong(1)) == A_LONG_VALUE);
+
+    QVERIFY(testClass.callMethod<jlong>("longMethod") == A_LONG_VALUE);
+    QVERIFY(testClass.callMethod<jlong>("longMethodWithArgs",
+                                        "(JJJ)J",
+                                        jlong(1),
+                                        jlong(1),
+                                        jlong(1)) == A_LONG_VALUE);
+
+    // jfloat -------------------------------------------------------------------------------------
+    QVERIFY(QAndroidJniObject::callStaticMethod<jfloat>(testClassName,
+                                                        "staticFloatMethod") == A_FLOAT_VALUE);
+    QVERIFY(QAndroidJniObject::callStaticMethod<jfloat>(testClassName,
+                                                        "staticFloatMethodWithArgs",
+                                                        "(FFF)F",
+                                                        jfloat(1.1),
+                                                        jfloat(1.1),
+                                                        jfloat(1.1)) == A_FLOAT_VALUE);
+
+    QVERIFY(testClass.callMethod<jfloat>("floatMethod") == A_FLOAT_VALUE);
+    QVERIFY(testClass.callMethod<jfloat>("floatMethodWithArgs",
+                                         "(FFF)F",
+                                         jfloat(1.1),
+                                         jfloat(1.1),
+                                         jfloat(1.1)) == A_FLOAT_VALUE);
+
+    // jdouble ------------------------------------------------------------------------------------
+    QVERIFY(QAndroidJniObject::callStaticMethod<jdouble>(testClassName,
+                                                         "staticDoubleMethod") == A_DOUBLE_VALUE);
+    QVERIFY(QAndroidJniObject::callStaticMethod<jdouble>(testClassName,
+                                                         "staticDoubleMethodWithArgs",
+                                                         "(DDD)D",
+                                                         jdouble(1.1),
+                                                         jdouble(1.1),
+                                                         jdouble(1.1)) == A_DOUBLE_VALUE);
+
+    QVERIFY(testClass.callMethod<jdouble>("doubleMethod") == A_DOUBLE_VALUE);
+    QVERIFY(testClass.callMethod<jdouble>("doubleMethodWithArgs",
+                                          "(DDD)D",
+                                          jdouble(1.1),
+                                          jdouble(1.1),
+                                          jdouble(1.1)) == A_DOUBLE_VALUE);
+
+    // jobject ------------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jobject>(testClassName,
+                                                                                   "staticObjectMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jobject>("objectMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jclass -------------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jclass>(testClassName,
+                                                                                  "staticClassMethod");
+        QVERIFY(res.isValid());
+        QAndroidJniEnvironment env;
+        QVERIFY(env->IsInstanceOf(testClass.object(), res.object<jclass>()));
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jclass>("classMethod");
+        QVERIFY(res.isValid());
+        QAndroidJniEnvironment env;
+        QVERIFY(env->IsInstanceOf(testClass.object(), res.object<jclass>()));
+    }
+    // jstring ------------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jstring>(testClassName,
+                                                                                   "staticStringMethod");
+        QVERIFY(res.isValid());
+        QVERIFY(res.toString() == A_STRING_OBJECT());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jstring>("stringMethod");
+        QVERIFY(res.isValid());
+        QVERIFY(res.toString() == A_STRING_OBJECT());
+
+    }
+    // jthrowable ---------------------------------------------------------------------------------
+    {
+        // The Throwable object the same message (see: "getMessage()") as A_STRING_OBJECT
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jthrowable>(testClassName,
+                                                                                      "staticThrowableMethod");
+        QVERIFY(res.isValid());
+        QVERIFY(res.callObjectMethod<jstring>("getMessage").toString() == A_STRING_OBJECT());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jthrowable>("throwableMethod");
+        QVERIFY(res.isValid());
+        QVERIFY(res.callObjectMethod<jstring>("getMessage").toString() == A_STRING_OBJECT());
+    }
+
+    // jobjectArray -------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jobjectArray>(testClassName,
+                                                                                       "staticObjectArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jobjectArray>("objectArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jbooleanArray ------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jbooleanArray>(testClassName,
+                                                                                        "staticBooleanArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jbooleanArray>("booleanArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jbyteArray ---------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jbyteArray>(testClassName,
+                                                                                     "staticByteArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jbyteArray>("byteArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jcharArray ---------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jcharArray>(testClassName,
+                                                                                     "staticCharArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jcharArray>("charArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jshortArray --------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jshortArray>(testClassName,
+                                                                                      "staticShortArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jshortArray>("shortArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jintArray ----------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jintArray>(testClassName,
+                                                                                    "staticIntArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jintArray>("intArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jlongArray ---------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jlongArray>(testClassName,
+                                                                                     "staticLongArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jlongArray>("longArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jfloatArray --------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jfloatArray>(testClassName,
+                                                                                      "staticFloatArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jfloatArray>("floatArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    // jdoubleArray -------------------------------------------------------------------------------
+    {
+        QAndroidJniObject res = QAndroidJniObject::callStaticObjectMethod<jdoubleArray>(testClassName,
+                                                                                        "staticDoubleArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+    {
+        QAndroidJniObject res = testClass.callObjectMethod<jdoubleArray>("doubleArrayMethod");
+        QVERIFY(res.isValid());
+    }
+
+}
+
 void tst_QAndroidJniObject::isClassAvailable()
 {
     QVERIFY(QAndroidJniObject::isClassAvailable("java/lang/String"));