ExceptionTest: add an exception listener without any refs to make sure JNI alone holds on to it (similar to exceptionListener_noLocalRef_works() but better be safe)

Author: greenrobot

tests/objectbox-java-test/src/test/java/io/objectbox/exception/ExceptionTest.java

@@ -22,12 +22,14 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import io.objectbox.AbstractObjectBoxTest;
 
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
@@ -49,18 +51,19 @@ public void exceptionListener_closedStore_works() {
         store.setDbExceptionListener(e -> System.out.println("This is never called"));
     }
 
-    private static boolean weakRefListenerCalled = false;
+    private static AtomicInteger weakRefListenerCalled = new AtomicInteger(0);
 
     @Test
     public void exceptionListener_noLocalRef_works() throws InterruptedException {
+        weakRefListenerCalled.set(0);
         // Note: do not use lambda, it would keep a reference to this class
         // and prevent garbage collection of the listener.
         //noinspection Convert2Lambda
         DbExceptionListener listenerNoRef = new DbExceptionListener() {
             @Override
             public void onDbException(Exception e) {
                 System.out.println("Listener without strong reference is called");
-                weakRefListenerCalled = true;
+                weakRefListenerCalled.incrementAndGet();
             }
         };
         WeakReference<DbExceptionListener> weakReference = new WeakReference<>(listenerNoRef);
@@ -70,24 +73,25 @@ public void onDbException(Exception e) {
         //noinspection UnusedAssignment
         listenerNoRef = null;
 
-        // Try and fail to release weak reference.
+        // Ensure weak reference is kept as JNI is holding on to listener using a "global ref".
         int triesClearWeakRef = 5;
         while (weakReference.get() != null) {
             if (--triesClearWeakRef == 0) break;
             System.out.println("Suggesting GC");
             System.gc();
+            System.runFinalization();
             //noinspection BusyWait
             Thread.sleep(300);
         }
         assertEquals("Failed to keep weak reference to listener", 0, triesClearWeakRef);
+        assertNotNull(weakReference.get());
 
         // Throw, listener should be called.
-        weakRefListenerCalled = false;
         assertThrows(
                 DbException.class,
                 () -> DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), 0)
         );
-        assertTrue(weakRefListenerCalled);
+        assertEquals(1, weakRefListenerCalled.get());
 
         // Remove reference from native side.
         store.setDbExceptionListener(null);
@@ -98,18 +102,45 @@ public void onDbException(Exception e) {
             if (--triesClearWeakRef == 0) break;
             System.out.println("Suggesting GC");
             System.gc();
+            System.runFinalization();
             //noinspection BusyWait
             Thread.sleep(300);
         }
         assertTrue("Failed to release weak reference to listener", triesClearWeakRef > 0);
 
         // Throw, listener should not be called.
-        weakRefListenerCalled = false;
         assertThrows(
                 DbException.class,
                 () -> DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), 0)
         );
-        assertFalse(weakRefListenerCalled);
+        assertEquals(1, weakRefListenerCalled.get());
+    }
+
+    @Test
+    public void exceptionListener_noref() throws InterruptedException {
+        weakRefListenerCalled.set(0);
+
+        //noinspection Convert2Lambda
+        store.setDbExceptionListener(new DbExceptionListener() {
+            @Override
+            public void onDbException(Exception e) {
+                System.out.println("Listener without reference is called");
+                weakRefListenerCalled.incrementAndGet();
+            }
+        });
+
+        for (int i = 0; i < 5; i++) {
+            System.gc();
+            System.runFinalization();
+            Thread.sleep(100);
+        }
+
+        // Throw, listener should be called.
+        assertThrows(
+                DbException.class,
+                () -> DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), 0)
+        );
+        assertEquals(1, weakRefListenerCalled.get());
     }
 
     @Test