test: add regression test for high contention calls

Author: edusperoni

test-app/app/src/main/assets/app/mainpage.js

@@ -72,5 +72,6 @@ require('./tests/testURLImpl.js');
 require('./tests/testURLSearchParamsImpl.js');
 require('./tests/testPerformanceNow');
 require('./tests/testQueueMicrotask');
+require("./tests/testConcurrentAccess");
 
 require("./tests/testESModules.mjs");

test-app/app/src/main/assets/app/tests/testConcurrentAccess.js

@@ -0,0 +1,78 @@
+// WARNING: IF THIS TEST FAILS IT COMPLETELY BREAKS ALL OTHER TESTS!
+
+describe("Tests concurrent access to JNI", function () {
+  // Customizable test parameters
+  const BACKGROUND_THREADS = 5;
+  const SYNC_CALLS = 2;
+  const ITERATIONS_PER_CALL = 100;
+  const TIMEOUT_MS = 3000;
+
+  it("test_high_contention_concurrent_access_with_multiple_objects", (done) => {
+    console.log('STARTING PROBLEMATIC TEST. THIS MIGHT CRASH OR CAUSE ISSUES IN OTHER TESTS IF IT FAILS. If this is close to the end of the log, check test_high_contention_concurrent_access_with_multiple_objects');
+    let callbackInvocations = 0;
+
+    const callback = new com.tns.tests.ConcurrentAccessTest.Callback({
+      invoke: (
+        list1,
+        list2,
+        list3,
+        list4,
+        list5,
+        list6,
+        list7,
+        list8,
+        list9,
+        list10,
+      ) => {
+        callbackInvocations++;
+        // Assert that accessing size() on any of the lists doesn't throw
+        expect(() => list1.size()).not.toThrow();
+        expect(() => list2.size()).not.toThrow();
+        expect(() => list3.size()).not.toThrow();
+        expect(() => list4.size()).not.toThrow();
+        expect(() => list5.size()).not.toThrow();
+        expect(() => list6.size()).not.toThrow();
+        expect(() => list7.size()).not.toThrow();
+        expect(() => list8.size()).not.toThrow();
+        expect(() => list9.size()).not.toThrow();
+        expect(() => list10.size()).not.toThrow();
+
+        // Verify that the lists actually have content
+        expect(list1.size()).toBe(5);
+        expect(list2.size()).toBe(5);
+        expect(list3.size()).toBe(5);
+        expect(list4.size()).toBe(5);
+        expect(list5.size()).toBe(5);
+        expect(list6.size()).toBe(5);
+        expect(list7.size()).toBe(5);
+        expect(list8.size()).toBe(5);
+        expect(list9.size()).toBe(5);
+        expect(list10.size()).toBe(5);
+      },
+    });
+
+    // Start multiple background threads
+    for (let i = 0; i < BACKGROUND_THREADS; i++) {
+      com.tns.tests.ConcurrentAccessTest.callFromBackgroundThread(
+        callback,
+        ITERATIONS_PER_CALL,
+      );
+    }
+
+    // Call synchronously multiple times
+    for (let i = 0; i < SYNC_CALLS; i++) {
+      com.tns.tests.ConcurrentAccessTest.callSynchronously(
+        callback,
+        ITERATIONS_PER_CALL,
+      );
+    }
+
+    // Wait for all threads to complete
+    setTimeout(() => {
+      const expectedInvocations =
+        (BACKGROUND_THREADS + SYNC_CALLS) * ITERATIONS_PER_CALL;
+      expect(callbackInvocations).toBe(expectedInvocations);
+      done();
+    }, TIMEOUT_MS);
+  });
+});

test-app/app/src/main/java/com/tns/tests/ConcurrentAccessTest.java

@@ -0,0 +1,76 @@
+package com.tns.tests;
+
+import java.util.ArrayList;
+
+public class ConcurrentAccessTest {
+    
+    public interface Callback {
+        void invoke(ArrayList list1, ArrayList list2, ArrayList list3, ArrayList list4, ArrayList list5,
+                   ArrayList list6, ArrayList list7, ArrayList list8, ArrayList list9, ArrayList list10);
+    }
+    
+    public interface ErrorCallback {
+        void onError(Throwable error);
+    }
+    
+    /**
+     * Calls the callback from a background thread multiple times.
+     * @param callback The callback to invoke
+     * @param times Number of times to call the callback (default 50)
+     */
+    public static void callFromBackgroundThread(final Callback callback, final int times) {
+        Thread thread = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                for (int i = 0; i < times; i++) {
+                    invokeCallbackWithArrayLists(callback, i);
+                }
+            }
+        });
+        thread.start();
+    }
+    
+    /**
+     * Calls the callback synchronously from the current thread.
+     * @param callback The callback to invoke
+     * @param times Number of times to call the callback (default 50)
+     */
+    public static void callSynchronously(Callback callback, int times) {
+        for (int i = 0; i < times; i++) {
+            invokeCallbackWithArrayLists(callback, i);
+        }
+    }
+    
+    /**
+     * Helper method that creates 10 ArrayLists and invokes the callback with them.
+     * Each ArrayList contains some data based on the iteration number.
+     */
+    private static void invokeCallbackWithArrayLists(Callback callback, int iteration) {
+        ArrayList<Integer> list1 = new ArrayList<>();
+        ArrayList<Integer> list2 = new ArrayList<>();
+        ArrayList<Integer> list3 = new ArrayList<>();
+        ArrayList<Integer> list4 = new ArrayList<>();
+        ArrayList<Integer> list5 = new ArrayList<>();
+        ArrayList<Integer> list6 = new ArrayList<>();
+        ArrayList<Integer> list7 = new ArrayList<>();
+        ArrayList<Integer> list8 = new ArrayList<>();
+        ArrayList<Integer> list9 = new ArrayList<>();
+        ArrayList<Integer> list10 = new ArrayList<>();
+        
+        // Add some data to each list
+        for (int i = 0; i < 5; i++) {
+            list1.add(iteration * 10 + i);
+            list2.add(iteration * 10 + i + 1);
+            list3.add(iteration * 10 + i + 2);
+            list4.add(iteration * 10 + i + 3);
+            list5.add(iteration * 10 + i + 4);
+            list6.add(iteration * 10 + i + 5);
+            list7.add(iteration * 10 + i + 6);
+            list8.add(iteration * 10 + i + 7);
+            list9.add(iteration * 10 + i + 8);
+            list10.add(iteration * 10 + i + 9);
+        }
+        
+        callback.invoke(list1, list2, list3, list4, list5, list6, list7, list8, list9, list10);
+    }
+}