Test vector observation in the other directionmaven_publishing

In this test we modify a std::vector and check that the Java API reflects the same values. The Java Vector isn't modified, like in the vector observation test, which modifies the Java Vector but not the std::vector. Change-Id: Ic1ded945b9e80dbeccfbfbd1035e66771dfeb97a Reviewed-by: Ville Voutilainen <ville.voutilainen@qt.io>
author: Ville Voutilainen <ville.voutilainen@qt.io> 2025-11-02 19:04:52 +0200
committer: Ville Voutilainen <ville.voutilainen@qt.io> 2025-11-02 19:06:46 +0200
commit: 665f63d36b003027424a7fc1ad748c2041f13ed5 (patch)
tree: 0cd082c382c1402b73c22791d65246f74669104e
parent: 67233231b1d337b49b4cf6b1ba752e22e6708f32 (diff)
4 files changed, 388 insertions, 0 deletions
diff --git a/tests/auto/observer/CMakeLists.txt b/tests/auto/observer/CMakeLists.txt
index 0973e4f..347e8f8 100644
--- a/tests/auto/observer/CMakeLists.txt
+++ b/tests/auto/observer/CMakeLists.txt
@@ -21,6 +21,7 @@ qt_internal_add_test(tst_observer
       src/volumeobserver.h src/volumeobserver.cpp
       src/contentobserver.h src/contentobserver.cpp
       src/vectorobserver.h src/vectorobserver.cpp
+      src/vectorobserverreverse.h src/vectorobserverreverse.cpp
 
     NO_BATCH # QTBUG-121815
     DEFINES
diff --git a/tests/auto/observer/src/vectorobserverreverse.cpp b/tests/auto/observer/src/vectorobserverreverse.cpp
new file mode 100644
index 0000000..63d74f4
--- /dev/null
+++ b/tests/auto/observer/src/vectorobserverreverse.cpp
@@ -0,0 +1,315 @@
+#include "vectorobserverreverse.h"
+
+#include <jenny_proxy/jenny/proxy/java_lang_IntegerProxy.h>
+#include <QTest>
+
+static int getInt(QJniObject object)
+{
+    java::lang::IntegerProxy res = object;
+    return res.intValue();
+}
+
+void VectorObserverReverse::test()
+{
+    QCOMPARE(mVector.size(), mJavaVector.size());
+    QCOMPARE(mVector.size(), 0);
+    mVector.resize(2);
+    QCOMPARE(mVector.size(), mJavaVector.size());
+    QCOMPARE(mJavaVector.size(), 2);
+    mVector[0] = 42;
+    mVector[1] = 666;
+    QCOMPARE(getInt(mJavaVector.get(0)), 42);
+    QCOMPARE(getInt(mJavaVector.get(1)), 666);
+    mVector.clear();
+    QCOMPARE(mVector.size(), mJavaVector.size());
+    QCOMPARE(mJavaVector.size(), 0);
+    mVector.push_back(666);
+    mVector.push_back(42);
+    QCOMPARE(getInt(mJavaVector.get(0)), 666);
+    QCOMPARE(getInt(mJavaVector.get(1)), 42);
+}
+
+VectorObserverReverse::VectorObserverReverse()
+{
+    jlong nativeHandle = reinterpret_cast<jlong>(static_cast<NativeInterface*>(this));
+    QJniObject handler("org/qtproject/example/NativeInvocationHandler", nativeHandle);
+    mJavaVector = QJniObject("org/qtproject/example/VectorProxy",
+                             "(Lorg/qtproject/example/NativeInvocationHandler;)V",
+                             handler.object<jobject>());
+}
+
+void VectorObserverReverse::copyInto(jobjectArray /*anArray*/)
+{
+
+}
+
+void VectorObserverReverse::trimToSize()
+{
+
+}
+
+void VectorObserverReverse::ensureCapacity(jint /*minCapacity*/)
+{
+
+}
+
+void VectorObserverReverse::setSize(jint newSize)
+{
+}
+
+jobject VectorObserverReverse::capacity()
+{
+    return nullptr;
+}
+
+jobject VectorObserverReverse::size()
+{
+    java::lang::IntegerProxy res = java::lang::IntegerProxy::newInstance(mVector.size());
+    QJniEnvironment env;
+    return env->NewGlobalRef(res->object<jobject>());
+}
+
+jobject VectorObserverReverse::isEmpty()
+{
+    return nullptr;
+
+}
+
+jobject VectorObserverReverse::elements()
+{
+    return nullptr;
+
+}
+
+jobject VectorObserverReverse::contains(jobject /*o*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::indexOf(jobject /*o*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::indexOf(jobject /*o*/, jint /*index*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::lastIndexOf(jobject /*o*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::lastIndexOf(jobject /*o*/, jint /*index*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::elementAt(jint /*index*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::firstElement()
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::lastElement()
+{
+
+    return nullptr;
+}
+
+void VectorObserverReverse::setElementAt(jobject /*obj*/, jint /*index*/)
+{
+
+}
+
+void VectorObserverReverse::removeElementAt(jint /*index*/)
+{
+
+}
+
+void VectorObserverReverse::insertElementAt(jobject /*obj*/, jint /*index*/)
+{
+
+}
+
+void VectorObserverReverse::addElement(jobject /*obj*/)
+{
+
+}
+
+jobject VectorObserverReverse::removeElement(jobject /*obj*/)
+{
+
+    return nullptr;
+}
+
+void VectorObserverReverse::removeAllElements()
+{
+
+}
+
+jobject VectorObserverReverse::clone()
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::toArray()
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::toArray(jobjectArray /*a*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::get(jint index)
+{
+    java::lang::IntegerProxy res = java::lang::IntegerProxy::newInstance(mVector[index]);
+    QJniEnvironment env;
+    return env->NewGlobalRef(res->object<jobject>());
+}
+
+jobject VectorObserverReverse::set(jint index, jobject element)
+{
+    return nullptr;
+}
+
+jobject VectorObserverReverse::add(jobject e)
+{
+    return nullptr;
+}
+
+void VectorObserverReverse::add(jint /*index*/, jobject /*element*/)
+{
+
+}
+
+jobject VectorObserverReverse::remove(jobject /*o*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::remove(jint /*index*/)
+{
+
+    return nullptr;
+}
+
+void VectorObserverReverse::clear()
+{
+}
+
+jobject VectorObserverReverse::containsAll(jobject /*c*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::addAll(jobject /*c*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::addAll(jint /*index*/, jobject /*c*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::removeAll(jobject /*c*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::retainAll(jobject /*c*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::removeIf(jobject /*filter*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::equals(jobject /*o*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::hashCode()
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::toString()
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::subList(jint /*fromIndex*/, jint /*toIndex*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::listIterator(jint /*index*/)
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::listIterator()
+{
+
+    return nullptr;
+}
+
+jobject VectorObserverReverse::iterator()
+{
+
+    return nullptr;
+}
+
+void VectorObserverReverse::forEach(jobject /*action*/)
+{
+
+}
+
+void VectorObserverReverse::replaceAll(jobject /*qt_operator*/)
+{
+}
+
+void VectorObserverReverse::sort(jobject /*c*/)
+{
+
+}
+
+jobject VectorObserverReverse::spliterator()
+{
+
+    return nullptr;
+}
diff --git a/tests/auto/observer/src/vectorobserverreverse.h b/tests/auto/observer/src/vectorobserverreverse.h
new file mode 100644
index 0000000..8c9dfa1
--- /dev/null
+++ b/tests/auto/observer/src/vectorobserverreverse.h
@@ -0,0 +1,69 @@
+#ifndef VECTOROBSERVERREVERSE_H
+#define VECTOROBSERVERREVERSE_H
+
+#include <jenny_proxy/jenny/proxy/java_util_VectorProxy.h>
+#include <jenny_callback/jenny/proxy/java_util_VectorProxy.h>
+
+#include <vector>
+
+class VectorObserverReverse : public java::util::VectorInterface
+{
+public:
+    void test();
+
+    VectorObserverReverse();
+    void copyInto(jobjectArray anArray) override;
+    void trimToSize() override;
+    void ensureCapacity(jint minCapacity) override;
+    void setSize(jint newSize) override;
+    jobject capacity() override;
+    jobject size() override;
+    jobject isEmpty() override;
+    jobject elements() override;
+    jobject contains(jobject o) override;
+    jobject indexOf(jobject o) override;
+    jobject indexOf(jobject o, jint index) override;
+    jobject lastIndexOf(jobject o) override;
+    jobject lastIndexOf(jobject o, jint index) override;
+    jobject elementAt(jint index) override;
+    jobject firstElement() override;
+    jobject lastElement() override;
+    void setElementAt(jobject obj, jint index) override;
+    void removeElementAt(jint index) override;
+    void insertElementAt(jobject obj, jint index) override;
+    void addElement(jobject obj) override;
+    jobject removeElement(jobject obj) override;
+    void removeAllElements() override;
+    jobject clone() override;
+    jobject toArray() override;
+    jobject toArray(jobjectArray a) override;
+    jobject get(jint index) override;
+    jobject set(jint index, jobject element) override;
+    jobject add(jobject e) override;
+    void add(jint index, jobject element) override;
+    jobject remove(jobject o) override;
+    jobject remove(jint index) override;
+    void clear() override;
+    jobject containsAll(jobject c) override;
+    jobject addAll(jobject c) override;
+    jobject addAll(jint index, jobject c) override;
+    jobject removeAll(jobject c) override;
+    jobject retainAll(jobject c) override;
+    jobject removeIf(jobject filter) override;
+    jobject equals(jobject o) override;
+    jobject hashCode() override;
+    jobject toString() override;
+    jobject subList(jint fromIndex, jint toIndex) override;
+    jobject listIterator(jint index) override;
+    jobject listIterator() override;
+    jobject iterator() override;
+    void forEach(jobject action) override;
+    void replaceAll(jobject qt_operator) override;
+    void sort(jobject c) override;
+    jobject spliterator() override;
+private:
+    java::util::VectorProxy mJavaVector;
+    std::vector<int> mVector;
+};
+
+#endif // VECTOROBSERVERREVERSE_H
diff --git a/tests/auto/observer/tst_observer.cpp b/tests/auto/observer/tst_observer.cpp
index fba6bd0..8c5eb95 100644
--- a/tests/auto/observer/tst_observer.cpp
+++ b/tests/auto/observer/tst_observer.cpp
@@ -10,6 +10,7 @@
 
 #include "volumeobserver.h"
 #include "vectorobserver.h"
+#include "vectorobserverreverse.h"
 #ifndef QTEST_THROW_ON_FAIL
 # error This test requires QTEST_THROW_ON_FAIL being active.
 #endif
@@ -51,6 +52,8 @@ void tst_observer::vectorObservation() const
 {
     VectorObserver vobs;
     vobs.test();
+    VectorObserverReverse vobsReverse;
+    vobsReverse.test();
 }
 
 QTEST_APPLESS_MAIN(tst_observer);
author	Ville Voutilainen <ville.voutilainen@qt.io>	2025-11-02 19:04:52 +0200
committer	Ville Voutilainen <ville.voutilainen@qt.io>	2025-11-02 19:06:46 +0200
commit	665f63d36b003027424a7fc1ad748c2041f13ed5 (patch)
tree	0cd082c382c1402b73c22791d65246f74669104e
parent	67233231b1d337b49b4cf6b1ba752e22e6708f32 (diff)