Move class initialization tests to Java fixture

Author: dlunch

AGENTS.md

@@ -22,3 +22,8 @@
 - `classfile/` - Class file parser
 - `java_class_proto/` - Java class prototypes
 - `test_utils/` - Shared test utilities
+
+## Testing Boundaries
+- Keep `java_runtime/tests/classes` limited to Java standard library class and API behavior.
+- Test JVM and interpreter semantics, including class initialization, bytecode execution, and monitor behavior, with compiled Java fixtures under `test_data/src` and expected output under `test_data`, executed by `tests/test_class.rs`.
+- Do not place JVM core behavior tests in the `java_runtime` standard library test tree.

java_runtime/tests/classes/java/lang/mod.rs

@@ -2,7 +2,6 @@ mod test_boolean;
 mod test_byte;
 mod test_character;
 mod test_class;
-mod test_class_initialization;
 mod test_cldc11_exceptions;
 mod test_double;
 mod test_float;

java_runtime/tests/classes/java/lang/test_class_initialization.rs

@@ -0,0 +1,6 @@
+42
+42
+1
+java.lang.ExceptionInInitializerError
+java.lang.NoClassDefFoundError
+java.lang.NoClassDefFoundError

test_data/ConcurrentClinit$Failing.class

@@ -0,0 +1,120 @@
+public class ConcurrentClinit {
+    private static volatile boolean successfulOwnerStarted;
+    private static volatile boolean successfulWaiterStarted;
+    private static volatile boolean failingOwnerStarted;
+    private static volatile boolean failingWaiterStarted;
+
+    private static class Successful {
+        static int initializationCount;
+        static int value;
+
+        static {
+            initializationCount++;
+            successfulOwnerStarted = true;
+            while (!successfulWaiterStarted) {
+                Thread.yield();
+            }
+            try {
+                Thread.sleep(10);
+            } catch (InterruptedException exception) {
+                throw new RuntimeException("interrupted");
+            }
+            value = 42;
+        }
+    }
+
+    private static class Failing {
+        static int value;
+
+        static {
+            failingOwnerStarted = true;
+            while (!failingWaiterStarted) {
+                Thread.yield();
+            }
+            try {
+                Thread.sleep(10);
+            } catch (InterruptedException exception) {
+                throw new RuntimeException("interrupted");
+            }
+            if (failingOwnerStarted) {
+                throw new RuntimeException("initialization failed");
+            }
+        }
+    }
+
+    private static class SuccessfulReader implements Runnable {
+        private final boolean waiter;
+        int value;
+
+        SuccessfulReader(boolean waiter) {
+            this.waiter = waiter;
+        }
+
+        public void run() {
+            if (waiter) {
+                successfulWaiterStarted = true;
+            }
+            value = Successful.value;
+        }
+    }
+
+    private static class FailingReader implements Runnable {
+        private final boolean waiter;
+        String errorClass;
+
+        FailingReader(boolean waiter) {
+            this.waiter = waiter;
+        }
+
+        public void run() {
+            if (waiter) {
+                failingWaiterStarted = true;
+            }
+            try {
+                int ignored = Failing.value;
+            } catch (Throwable throwable) {
+                errorClass = throwable.getClass().getName();
+            }
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        SuccessfulReader successfulOwner = new SuccessfulReader(false);
+        Thread successfulOwnerThread = new Thread(successfulOwner);
+        successfulOwnerThread.start();
+        while (!successfulOwnerStarted) {
+            Thread.yield();
+        }
+
+        SuccessfulReader successfulWaiter = new SuccessfulReader(true);
+        Thread successfulWaiterThread = new Thread(successfulWaiter);
+        successfulWaiterThread.start();
+        successfulOwnerThread.join();
+        successfulWaiterThread.join();
+
+        System.out.println(successfulOwner.value);
+        System.out.println(successfulWaiter.value);
+        System.out.println(Successful.initializationCount);
+
+        FailingReader failingOwner = new FailingReader(false);
+        Thread failingOwnerThread = new Thread(failingOwner);
+        failingOwnerThread.start();
+        while (!failingOwnerStarted) {
+            Thread.yield();
+        }
+
+        FailingReader failingWaiter = new FailingReader(true);
+        Thread failingWaiterThread = new Thread(failingWaiter);
+        failingWaiterThread.start();
+        failingOwnerThread.join();
+        failingWaiterThread.join();
+
+        System.out.println(failingOwner.errorClass);
+        System.out.println(failingWaiter.errorClass);
+        try {
+            int ignored = Failing.value;
+        } catch (Throwable throwable) {
+            System.out.println(throwable.getClass().getName());
+        }
+    }
+}