diff options
Diffstat (limited to 'tests/auto/corelib/kernel/qjnienvironment/tst_qjnienvironment.cpp')
-rw-r--r-- | tests/auto/corelib/kernel/qjnienvironment/tst_qjnienvironment.cpp | 325 |
1 files changed, 284 insertions, 41 deletions
diff --git a/tests/auto/corelib/kernel/qjnienvironment/tst_qjnienvironment.cpp b/tests/auto/corelib/kernel/qjnienvironment/tst_qjnienvironment.cpp index d47a9ecd57..95748f46f7 100644 --- a/tests/auto/corelib/kernel/qjnienvironment/tst_qjnienvironment.cpp +++ b/tests/auto/corelib/kernel/qjnienvironment/tst_qjnienvironment.cpp @@ -1,30 +1,7 @@ -/**************************************************************************** -** -** Copyright (C) 2021 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** 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 The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2021 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include <jni.h> #include <QtCore/QJniEnvironment> #include <QtCore/QJniObject> @@ -32,19 +9,36 @@ static const char javaTestClass[] = "org/qtproject/qt/android/testdatapackage/QtJniEnvironmentTestClass"; +static const char javaTestClassNoCtor[] = + "org/qtproject/qt/android/testdatapackage/QtJniEnvironmentTestClassNoCtor"; static QString registerNativesString = QStringLiteral("Qt"); +static int registerNativeInteger = 0; class tst_QJniEnvironment : public QObject { Q_OBJECT private slots: + void init(); void jniEnv(); void javaVM(); void registerNativeMethods(); + void registerNativeMethodsByJclass(); + void findMethod(); + void findStaticMethod(); + void findField(); + void findStaticField(); }; +void tst_QJniEnvironment::init() +{ + // Unless explicitly ignored to test error handling, warning messages + // in this test about a failure to look up a field, method, or class + // make the test fail. + QTest::failOnWarning(QRegularExpression("java.lang.NoSuch.*Error")); +} + void tst_QJniEnvironment::jniEnv() { QJniEnvironment env; @@ -56,7 +50,7 @@ void tst_QJniEnvironment::jniEnv() JNIEnv *jni = 0; QCOMPARE(javaVM->GetEnv((void**)&jni, JNI_VERSION_1_6), JNI_OK); - JNIEnv *e = env; + JNIEnv *e = env.jniEnv(); QVERIFY(e); QCOMPARE(env->GetVersion(), JNI_VERSION_1_6); @@ -71,22 +65,26 @@ void tst_QJniEnvironment::jniEnv() env->ExceptionClear(); QVERIFY(env->FindClass("java/lang/Object")); - QVERIFY(!QJniEnvironment::exceptionCheckAndClear(env)); + QVERIFY(!QJniEnvironment::checkAndClearExceptions(env.jniEnv())); // try to find a nonexistent class + QTest::ignoreMessage(QtWarningMsg, QRegularExpression("java.lang.ClassNotFoundException: .*")); QVERIFY(!env->FindClass("this/doesnt/Exist")); - QVERIFY(QJniEnvironment::exceptionCheckAndClear(env)); + QVERIFY(QJniEnvironment::checkAndClearExceptions(env.jniEnv())); // try to find an existing class with QJniEnvironment QJniEnvironment env; QVERIFY(env.findClass("java/lang/Object")); + QVERIFY(env.findClass<jstring>()); // try to find a nonexistent class + QTest::ignoreMessage(QtWarningMsg, QRegularExpression("java.lang.ClassNotFoundException: .*")); QVERIFY(!env.findClass("this/doesnt/Exist")); // clear exception with member function + QTest::ignoreMessage(QtWarningMsg, QRegularExpression("java.lang.ClassNotFoundException: .*")); QVERIFY(!env->FindClass("this/doesnt/Exist")); - QVERIFY(env.exceptionCheckAndClear()); + QVERIFY(env.checkAndClearExceptions()); } // The env does not detach automatically, even if it goes out of scope. The only way it can @@ -110,25 +108,270 @@ void tst_QJniEnvironment::javaVM() static void callbackFromJava(JNIEnv *env, jobject /*thiz*/, jstring value) { + Q_UNUSED(env) + registerNativesString = QJniObject(value).toString(); +} +Q_DECLARE_JNI_NATIVE_METHOD(callbackFromJava); + +static void tediouslyLongNamed_callbackFromJava(JNIEnv *env, jobject /*thiz*/, jstring value) +{ + Q_UNUSED(env) + registerNativesString = QJniObject(value).toString(); +} +Q_DECLARE_JNI_NATIVE_METHOD(tediouslyLongNamed_callbackFromJava, namedCallbackFromJava) + +static void callbackFromJavaNoCtor(JNIEnv *env, jobject /*thiz*/, jstring value) +{ + Q_UNUSED(env) registerNativesString = QJniObject(value).toString(); } +Q_DECLARE_JNI_NATIVE_METHOD(callbackFromJavaNoCtor); + +class CallbackClass { +public: + static void memberCallbackFromJava(JNIEnv *env, jobject /*thiz*/, jstring value) + { + Q_UNUSED(env) + registerNativesString = QJniObject(value).toString(); + } + Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE(memberCallbackFromJava) + + static void tediouslyLongNamed_memberCallbackFromJava(JNIEnv *env, jobject /*thiz*/, + jstring value) + { + Q_UNUSED(env) + registerNativesString = QJniObject(value).toString(); + } + Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE(tediouslyLongNamed_memberCallbackFromJava, + namedMemberCallbackFromJava) +}; + +namespace CallbackNamespace { + static void namespaceCallbackFromJava(JNIEnv *env, jobject /*thiz*/, jstring value) + { + Q_UNUSED(env) + registerNativesString = QJniObject(value).toString(); + } + Q_DECLARE_JNI_NATIVE_METHOD_IN_CURRENT_SCOPE(namespaceCallbackFromJava) +} void tst_QJniEnvironment::registerNativeMethods() { - JNINativeMethod methods[] { - {"callbackFromJava", "(Ljava/lang/String;)V", reinterpret_cast<void *>(callbackFromJava)} - }; + QJniObject QtString = QJniObject::fromString(registerNativesString); + QJniEnvironment env; + + { + QVERIFY(env.registerNativeMethods(javaTestClass, { + Q_JNI_NATIVE_METHOD(callbackFromJava) + })); + + QJniObject::callStaticMethod<void>(javaTestClass, + "appendJavaToString", + "(Ljava/lang/String;)V", + QtString.object<jstring>()); + QTest::qWait(200); + QVERIFY(registerNativesString == QStringLiteral("From Java: Qt")); + } + + // Named native function + { + QVERIFY(env.registerNativeMethods(javaTestClass, { + Q_JNI_NATIVE_METHOD(tediouslyLongNamed_callbackFromJava) + })); + + QJniObject::callStaticMethod<void>(javaTestClass, + "namedAppendJavaToString", + "(Ljava/lang/String;)V", + QtString.object<jstring>()); + QTest::qWait(200); + QVERIFY(registerNativesString == QStringLiteral("From Java (named): Qt")); + } + + // Static class member as callback + { + QVERIFY(env.registerNativeMethods(javaTestClass, { + Q_JNI_NATIVE_SCOPED_METHOD(memberCallbackFromJava, CallbackClass) + })); + + QJniObject::callStaticMethod<void>(javaTestClass, + "memberAppendJavaToString", + "(Ljava/lang/String;)V", + QtString.object<jstring>()); + QTest::qWait(200); + QVERIFY(registerNativesString == QStringLiteral("From Java (member): Qt")); + } + + // Static named class member as callback + { + QVERIFY(env.registerNativeMethods(javaTestClass, { + Q_JNI_NATIVE_SCOPED_METHOD(tediouslyLongNamed_memberCallbackFromJava, + CallbackClass) + })); + + QJniObject::callStaticMethod<void>(javaTestClass, + "namedMemberAppendJavaToString", + "(Ljava/lang/String;)V", + QtString.object<jstring>()); + QTest::qWait(200); + QVERIFY(registerNativesString == QStringLiteral("From Java (named member): Qt")); + } + + // Function generally just in namespace as callback + { + QVERIFY(env.registerNativeMethods(javaTestClass, { + Q_JNI_NATIVE_SCOPED_METHOD(namespaceCallbackFromJava, CallbackNamespace) + })); + QJniObject::callStaticMethod<void>(javaTestClass, + "namespaceAppendJavaToString", + "(Ljava/lang/String;)V", + QtString.object<jstring>()); + QTest::qWait(200); + QVERIFY(registerNativesString == QStringLiteral("From Java (namespace): Qt")); + } + + // No default constructor in class + { + QVERIFY(env.registerNativeMethods(javaTestClassNoCtor, { + Q_JNI_NATIVE_METHOD(callbackFromJavaNoCtor) + })); + + QJniObject::callStaticMethod<void>(javaTestClassNoCtor, + "appendJavaToString", + "(Ljava/lang/String;)V", + QtString.object<jstring>()); + QTest::qWait(200); + QVERIFY(registerNativesString == QStringLiteral("From Java (no ctor): Qt")); + } +} + +static void intCallbackFromJava(JNIEnv *env, jobject /*thiz*/, jint value) +{ + Q_UNUSED(env) + registerNativeInteger = static_cast<int>(value); +} +Q_DECLARE_JNI_NATIVE_METHOD(intCallbackFromJava); + +void tst_QJniEnvironment::registerNativeMethodsByJclass() +{ QJniEnvironment env; - QVERIFY(env.registerNativeMethods(javaTestClass, methods, 1)); + jclass clazz = env.findClass(javaTestClass); + QVERIFY(clazz != 0); + QVERIFY(env.registerNativeMethods(clazz, { + Q_JNI_NATIVE_METHOD(intCallbackFromJava) + })); - QJniObject QtString = QJniObject::fromString(registerNativesString); - QJniObject::callStaticMethod<void>(javaTestClass, - "appendJavaToString", - "(Ljava/lang/String;)V", - QtString.object<jstring>()); + QCOMPARE(registerNativeInteger, 0); + + QJniObject parameter = QJniObject::fromString(QString("123")); + QJniObject::callStaticMethod<void>(clazz, "convertToInt", "(Ljava/lang/String;)V", + parameter.object<jstring>()); QTest::qWait(200); - QVERIFY(registerNativesString == QStringLiteral("From Java: Qt")); + QCOMPARE(registerNativeInteger, 123); +} + +void tst_QJniEnvironment::findMethod() +{ + QJniEnvironment env; + jclass clazz = env.findClass("java/lang/Integer"); + QVERIFY(clazz != nullptr); + + // existing method + jmethodID methodId = env.findMethod(clazz, "toString", "()Ljava/lang/String;"); + QVERIFY(methodId != nullptr); + + // existing method + methodId = env.findMethod<jstring>(clazz, "toString"); + QVERIFY(methodId != nullptr); + + // invalid signature + QTest::ignoreMessage(QtWarningMsg, QRegularExpression("java.lang.NoSuchMethodError: .*")); + jmethodID invalid = env.findMethod(clazz, "unknown", "()I"); + QVERIFY(invalid == nullptr); + // check that all exceptions are already cleared + QVERIFY(!env.checkAndClearExceptions()); +} + +void tst_QJniEnvironment::findStaticMethod() +{ + QJniEnvironment env; + jclass clazz = env.findClass("java/lang/Integer"); + QVERIFY(clazz != nullptr); + + // existing method + jmethodID staticMethodId = env.findStaticMethod(clazz, "parseInt", "(Ljava/lang/String;)I"); + QVERIFY(staticMethodId != nullptr); + + // existing method + staticMethodId = env.findStaticMethod<jint, jstring>(clazz, "parseInt"); + QVERIFY(staticMethodId != nullptr); + + QJniObject parameter = QJniObject::fromString("123"); + jint result = QJniObject::callStaticMethod<jint>(clazz, staticMethodId, + parameter.object<jstring>()); + QCOMPARE(result, 123); + + // invalid method + QTest::ignoreMessage(QtWarningMsg, QRegularExpression("java.lang.NoSuchMethodError: .*")); + jmethodID invalid = env.findStaticMethod(clazz, "unknown", "()I"); + QVERIFY(invalid == nullptr); + QTest::ignoreMessage(QtWarningMsg, QRegularExpression("java.lang.NoSuchMethodError: .*")); + invalid = env.findStaticMethod<jint>(clazz, "unknown"); + QVERIFY(invalid == nullptr); + // check that all exceptions are already cleared + QVERIFY(!env.checkAndClearExceptions()); +} + +void tst_QJniEnvironment::findField() +{ + QJniEnvironment env; + jclass clazz = env.findClass(javaTestClass); + QVERIFY(clazz != nullptr); + + // valid field + jfieldID validId = env.findField(clazz, "INT_FIELD", "I"); + QVERIFY(validId != nullptr); + validId = env.findField<jint>(clazz, "INT_FIELD"); + QVERIFY(validId != nullptr); + + jmethodID constructorId = env.findMethod(clazz, "<init>", "()V"); + QVERIFY(constructorId != nullptr); + jobject obj = env->NewObject(clazz, constructorId); + QVERIFY(!env.checkAndClearExceptions()); + int value = env->GetIntField(obj, validId); + QVERIFY(!env.checkAndClearExceptions()); + QVERIFY(value == 123); + + // invalid signature + QTest::ignoreMessage(QtWarningMsg, QRegularExpression("java.lang.NoSuchFieldError: .*")); + jfieldID invalidId = env.findField(clazz, "unknown", "I"); + QVERIFY(invalidId == nullptr); + // check that all exceptions are already cleared + QVERIFY(!env.checkAndClearExceptions()); +} + +void tst_QJniEnvironment::findStaticField() +{ + QJniEnvironment env; + jclass clazz = env.findClass(javaTestClass); + QVERIFY(clazz != nullptr); + + // valid field + jfieldID validId = env.findStaticField(clazz, "S_INT_FIELD", "I"); + QVERIFY(validId != nullptr); + validId = env.findStaticField<jint>(clazz, "S_INT_FIELD"); + QVERIFY(validId != nullptr); + + int size = env->GetStaticIntField(clazz, validId); + QVERIFY(!env.checkAndClearExceptions()); + QVERIFY(size == 321); + + // invalid signature + QTest::ignoreMessage(QtWarningMsg, QRegularExpression("java.lang.NoSuchFieldError: .*")); + jfieldID invalidId = env.findStaticField(clazz, "unknown", "I"); + QVERIFY(invalidId == nullptr); + // check that all exceptions are already cleared + QVERIFY(!env.checkAndClearExceptions()); } QTEST_MAIN(tst_QJniEnvironment) |