Add tests for NewWeakGlobalRef and DeleteWeakGlobalRef

Author: jfirebaugh

include/jni/functions.hpp

@@ -164,11 +164,11 @@ namespace jni
     template < class T >
     UniqueWeakGlobalRef<T> NewWeakGlobalRef(JNIEnv& env, T* t)
        {
-        T* result = Wrap<T*>(env.NewWeakGlobalRef(Unwrap(t)));
+        jobject* obj = Wrap<jobject*>(env.NewWeakGlobalRef(Unwrap(t)));
         CheckJavaException(env);
-        if (!result)
+        if (t && !obj)
             throw std::bad_alloc();
-        return UniqueWeakGlobalRef<T>(result, WeakGlobalRefDeleter(env));
+        return UniqueWeakGlobalRef<T>(reinterpret_cast<T*>(obj), WeakGlobalRefDeleter(env));
        }
 
     inline void DeleteWeakGlobalRef(JNIEnv& env, UniqueWeakGlobalRef<jobject>&& ref)

test/high_level.cpp

@@ -71,6 +71,7 @@ int main()
     assert(classValue == testClass);
 
     static bool calledNewGlobalRef = false;
+    static bool calledNewWeakGlobalRef = false;
 
     env.functions->NewGlobalRef = [] (JNIEnv*, jobject obj) -> jobject
        {
@@ -82,6 +83,16 @@ int main()
        {
        };
 
+    env.functions->NewWeakGlobalRef = [] (JNIEnv*, jobject obj) -> jobject
+       {
+        calledNewWeakGlobalRef = true;
+        return obj;
+       };
+
+    env.functions->DeleteWeakGlobalRef = [] (JNIEnv*, jobject) -> void
+       {
+       };
+
     testClass.NewGlobalRef(env);
     assert(calledNewGlobalRef);
 
@@ -90,9 +101,11 @@ int main()
 
     jni::Object<Test> object { objectValue.Ptr() };
     object.NewGlobalRef(env);
+    object.NewWeakGlobalRef(env);
 
     jni::String string { stringValue.Ptr() };
     string.NewGlobalRef(env);
+    string.NewWeakGlobalRef(env);
 
 
     /// Constructor

test/low_level.cpp

@@ -77,6 +77,37 @@ static void TestNewAndDeleteGlobalRef()
        [] { jni::DeleteGlobalRef(env, jni::NewGlobalRef(env, failureValue.Ptr())); }));
    }
 
+static void TestNewAndDeleteWeakGlobalRef()
+   {
+    static Testable<jni::jobject> objectValue;
+    static Testable<jni::jclass> classValue;
+    static Testable<jni::jobject> failureValue;
+    static TestEnv env;
+
+    env.functions->NewWeakGlobalRef = [] (JNIEnv*, jobject obj) -> jobject
+       {
+        if (obj == Unwrap(objectValue.Ptr()))
+            return Unwrap(objectValue.Ptr());
+        if (obj == Unwrap(classValue.Ptr()))
+            return Unwrap(classValue.Ptr());
+        env.exception = true;
+        return nullptr;
+       };
+
+    env.functions->DeleteWeakGlobalRef = [] (JNIEnv*, jobject obj) -> void
+       {
+        if (obj == Unwrap(objectValue.Ptr()))
+            return;
+        env.exception = true;
+       };
+
+    assert(objectValue == *jni::NewWeakGlobalRef(env, objectValue.Ptr()));
+    assert(classValue == *jni::NewWeakGlobalRef(env, classValue.Ptr()));
+    assert(Throws<jni::PendingJavaException>([] { jni::NewWeakGlobalRef(env, failureValue.Ptr()); }));
+    assert(Throws<jni::PendingJavaException>(
+       [] { jni::DeleteWeakGlobalRef(env, jni::NewWeakGlobalRef(env, failureValue.Ptr())); }));
+   }
+
 static void TestNewObject()
    {
     static Testable<jni::jclass> classValue;
@@ -227,6 +258,7 @@ int main()
     */
 
     TestNewAndDeleteGlobalRef();
+    TestNewAndDeleteWeakGlobalRef();
 
     /*
         jobject     (*NewLocalRef)(JNIEnv*, jobject);
@@ -303,9 +335,6 @@ int main()
 
         const jchar* (*GetStringCritical)(JNIEnv*, jstring, jboolean*);
         void        (*ReleaseStringCritical)(JNIEnv*, jstring, const jchar*);
-
-        jweak       (*NewWeakGlobalRef)(JNIEnv*, jobject);
-        void        (*DeleteWeakGlobalRef)(JNIEnv*, jweak);
     */
 
     /*