1 files changed, 165 insertions, 0 deletions
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..b7b1f95b39
--- /dev/null
+++ b/tests/auto/corelib/kernel/qjniarray/tst_qjniarray.cpp
@@ -0,0 +1,165 @@
+// Copyright (C) 2022 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
+
+#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;
+
+private slots:
+    void construct();
+    void size();
+    void operators();
+};
+
+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);
+
+VERIFY_RETURN_FOR_TYPE(List, List);
+VERIFY_RETURN_FOR_TYPE(List[], QJniArray<List>);
+VERIFY_RETURN_FOR_TYPE(QJniArray<List>, QJniArray<List>);
+
+void tst_QJniArray::construct()
+{
+    {
+        QStringList strings;
+        for (int i = 0; i < 10000; ++i)
+            strings << QString::number(i);
+        QJniArray<QString> list(strings);
+        QCOMPARE(list.size(), 10000);
+    }
+    {
+        QJniArray<jint> list{1, 2, 3};
+        QCOMPARE(list.size(), 3);
+    }
+    {
+        QJniArray<jint> list(QList<int>{1, 2, 3});
+        QCOMPARE(list.size(), 3);
+    }
+    {
+        QJniArray<jint> list{QList<int>{1, 2, 3}};
+        QCOMPARE(list.size(), 3);
+    }
+}
+
+void tst_QJniArray::size()
+{
+    QJniArray<jint> array;
+    QVERIFY(!array.isValid());
+    QCOMPARE(array.size(), 0);
+
+    QList<int> intList;
+    intList.resize(10);
+    auto intArray = QJniArrayBase::fromContainer(intList);
+    QCOMPARE(intArray.size(), 10);
+}
+
+void tst_QJniArray::operators()
+{
+    QByteArray bytes("abcde");
+    QJniArray<jbyte> array(bytes);
+    QVERIFY(array.isValid());
+
+    {
+        auto it = array.begin();
+        QCOMPARE(*it, 'a');
+        QCOMPARE(*++it, 'b');
+        QCOMPARE(*it++, 'b');
+        QCOMPARE(*it, 'c');
+        ++it;
+        it++;
+        QCOMPARE(*it, 'e');
+        QCOMPARE(++it, array.end());
+    }
+    {
+        auto it = array.rbegin();
+        QCOMPARE(*it, 'e');
+        QCOMPARE(*++it, 'd');
+        QCOMPARE(*it++, 'd');
+        QCOMPARE(*it, 'c');
+        ++it;
+        it++;
+        QCOMPARE(*it, 'a');
+        QCOMPARE(++it, array.rend());
+    }
+    {
+        QJniArray<jbyte>::const_iterator it = {};
+        QCOMPARE(it, QJniArray<jbyte>::const_iterator{});
+        QCOMPARE_NE(array.begin(), array.end());
+
+        it = array.begin();
+        QCOMPARE(it, array.begin());
+    }
+
+    QCOMPARE(std::distance(array.begin(), array.end()), array.size());
+
+    qsizetype index = 0;
+    for (const auto &value : array) {
+        QCOMPARE(value, bytes.at(index));
+        ++index;
+    }
+}
+
+QTEST_MAIN(tst_QJniArray)
+
+#include "tst_qjniarray.moc"