Ugly test for ConcurrentModificationException when running with Java 17 #73

Author: JerryShea

src/test/java/mytest/RuntimeCompileTest.java

@@ -1,11 +1,21 @@
 package mytest;
 
+import net.openhft.compiler.CachedCompiler;
 import net.openhft.compiler.CompilerUtils;
 import org.junit.Test;
 
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.IntSupplier;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
 
 public class RuntimeCompileTest {
@@ -18,17 +28,64 @@ public class RuntimeCompileTest {
             "}\n";
 
     @Test
-    public void outOfBounds() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
+    public void outOfBounds() throws Exception {
         ClassLoader cl = new URLClassLoader(new URL[0]);
-        Class aClass = CompilerUtils.CACHED_COMPILER.
+        Class<?> aClass = CompilerUtils.CACHED_COMPILER.
                 loadFromJava(cl, "mytest.Test", code);
-        IntConsumer consumer = (IntConsumer) aClass.newInstance();
+        IntConsumer consumer = (IntConsumer) aClass.getDeclaredConstructor().newInstance();
         consumer.accept(1); // ok
         try {
             consumer.accept(128); // no ok
             fail();
         } catch (IllegalArgumentException expected) {
         }
     }
+
+    @Test
+    public void testMultiThread() throws Exception {
+        StringBuilder largeClass = new StringBuilder("package mytest;\n" +
+                "public class Test2 implements IntConsumer, java.util.function.IntSupplier {\n" +
+                "    static final java.util.concurrent.atomic.AtomicInteger called = new java.util.concurrent.atomic.AtomicInteger(0);\n" +
+                "    public int getAsInt() { return called.get(); }\n" +
+                "    public void accept(int num) {\n" +
+                "        called.incrementAndGet();\n" +
+                "    }\n");
+        for (int j=0;j<1_000;j++) {
+            largeClass.append("    public void accept"+j+"(int num) {\n" +
+                    "        if ((byte) num != num)\n" +
+                    "            throw new IllegalArgumentException();\n" +
+                    "    }\n");
+        }
+        largeClass.append("}\n");
+        final String code2 = largeClass.toString();
+
+        final ClassLoader cl = new URLClassLoader(new URL[0]);
+        final CachedCompiler cc = new CachedCompiler(null, null);
+        final int nThreads = Runtime.getRuntime().availableProcessors();
+        final AtomicInteger started = new AtomicInteger(0);
+        final ExecutorService executor = Executors.newFixedThreadPool(nThreads);
+        final List<Future<?>> futures = new ArrayList<>();
+        for (int i=0; i<nThreads; i++) {
+            final int value = i;
+            futures.add(executor.submit(() -> {
+                started.incrementAndGet();
+                while (started.get() < nThreads)
+                    ;
+                try {
+                    Class<?> aClass = cc.loadFromJava(cl, "mytest.Test2", code2);
+                    IntConsumer consumer = (IntConsumer) aClass.getDeclaredConstructor().newInstance();
+                    consumer.accept(value);
+                } catch (Exception e) {
+                    throw new RuntimeException(e);
+                }
+            }));
+        }
+        executor.shutdown();
+        for (Future<?> f : futures)
+            f.get(10, TimeUnit.SECONDS);
+        Class<?> aClass = cc.loadFromJava(cl, "mytest.Test2", code2);
+        IntSupplier consumer = (IntSupplier) aClass.getDeclaredConstructor().newInstance();
+        assertEquals(nThreads, consumer.getAsInt());
+    }
 }
 

src/test/java/net/openhft/compiler/CompilerTest.java

@@ -47,7 +47,7 @@ public class CompilerTest extends TestCase {
         }
     }
 
-    public void test_compiler() throws ClassNotFoundException {
+    public void test_compiler() {
         try {
             // CompilerUtils.setDebug(true);
             // added so the test passes in Maven.
@@ -283,26 +283,27 @@ public void test_compilerErrorsDoNotBreakNextCompilations() throws Exception {
                         "import java.util.concurrent.Callable; " +
                                 "public class OtherClass implements Callable<String> {" +
                                 "public String call() { return S.s; }}")
+                        .getDeclaredConstructor()
                         .newInstance();
 
         assertEquals("S", testClass.getName());
         assertEquals("ok", callable.call());
     }
 
     @Test
-    public void testNewCompiler() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
+    public void testNewCompiler() throws Exception {
         for (int i = 1; i <= 3; i++) {
             ClassLoader classLoader = new ClassLoader() {
             };
             CachedCompiler cc = new CachedCompiler(null, null);
             Class a = cc.loadFromJava(classLoader, "A", "public class A { static int i = " + i + "; }");
             Class b = cc.loadFromJava(classLoader, "B", "public class B implements net.openhft.compiler.MyIntSupplier { public int get() { return A.i; } }");
-            MyIntSupplier bi = (MyIntSupplier) b.newInstance();
+            MyIntSupplier bi = (MyIntSupplier) b.getDeclaredConstructor().newInstance();
             assertEquals(i, bi.get());
         }
     }
 
-    public static void main(String[] args) throws ClassNotFoundException {
+    public static void main(String[] args) {
         new CompilerTest().test_compiler();
     }
 }