clean: Replace all assert keywords with Assert

Because assert is *VERY* confusing - because (without -ea) it gets optimized out.

Author: vorburger

AGENTS.md

@@ -31,4 +31,4 @@ Note: Tests require Java 25 to compile and run due to the use of modern Java fea
 - Do not recommend using `java.util.Objects.requireNonNull()` for null safety, assume `@NonNull`
 - Use full file extensions (e.g., `*.yaml` not `*.yml`, but `*.md` instead of `*.markdown`) - it's 2025!
 - Do not suggest to always use braces `{}` with `if` statements even for single-line blocks
-- Do accept and not comment on the use of `assert` in `*Test.java` files
+- Do not accept and please comment to flag up any use of the Java `assert` keyword in `*Test.java` or any other files

src/ch/vorburger/jvmtools/ClasspathTest.java

@@ -1,6 +1,6 @@
 package ch.vorburger.jvmtools;
 
-import static ch.vorburger.jvmtools.Assert.assertTrue;
+import static ch.vorburger.test.Assert.assertTrue;
 
 public class ClasspathTest {
 

src/ch/vorburger/jvmtools/JavaCompilerTest.java

@@ -1,7 +1,7 @@
 package ch.vorburger.jvmtools;
 
-import static ch.vorburger.jvmtools.Assert.assertExists;
-import static ch.vorburger.jvmtools.Assert.assertTrue;
+import static ch.vorburger.test.Assert.assertExists;
+import static ch.vorburger.test.Assert.assertTrue;
 
 import java.nio.file.Path;
 

src/ch/vorburger/jvmtools/SourcepathTest.java

@@ -1,5 +1,7 @@
 package ch.vorburger.jvmtools;
 
+import static ch.vorburger.test.Assert.assertTrue;
+
 import java.io.IOException;
 
 public class SourcepathTest {
@@ -10,8 +12,8 @@ public static void main(String[] args) throws IOException {
                 SourcepathTest.class.getClassLoader(), "ch/vorburger/jvmtools/Hello.java");
         var iterator = sourcepath.getJavaFileObjects().iterator();
         var jfo = iterator.next();
-        assert jfo.getName().endsWith("/ch/vorburger/jvmtools/Hello.java");
-        assert jfo.getCharContent(false).toString().contains("public class Hello {");
-        assert iterator.hasNext() == false;
+        assertTrue(jfo.getName().endsWith("/ch/vorburger/jvmtools/Hello.java"));
+        assertTrue(jfo.getCharContent(false).toString().contains("public class Hello {"));
+        assertTrue(iterator.hasNext() == false);
     }
 }

src/ch/vorburger/main/test/ExampleTest.java

@@ -1,5 +1,7 @@
 package ch.vorburger.main.test;
 
+import static ch.vorburger.test.Assert.assertTrue;
+
 import ch.vorburger.main.MainTester;
 
 public class ExampleTest {
@@ -8,7 +10,7 @@ public class ExampleTest {
 
     public static void main(String[] args) throws Exception {
         var result = t.test(new Example(), "world");
-        assert result.exitCode() == 123;
-        assert "hello, world\n".equals(result.stdout());
+        assertTrue(result.exitCode() == 123);
+        assertTrue("hello, world\n".equals(result.stdout()));
     }
 }

src/ch/vorburger/jvmtools/Assert.java src/ch/vorburger/test/Assert.javasrc/ch/vorburger/jvmtools/Assert.java renamed to src/ch/vorburger/test/Assert.java

@@ -1,19 +1,19 @@
-package ch.vorburger.jvmtools;
+package ch.vorburger.test;
 
 import java.io.File;
 
 // TODO Replace with Truth once we can depend on it here
-final class Assert {
+public final class Assert {
 
-    static void assertTrue(boolean check) {
+    public static void assertTrue(boolean check) {
         if (!check) throw new AssertionError();
     }
 
-    static void assertTrue(boolean check, Object message) {
+    public static void assertTrue(boolean check, Object message) {
         if (!check) throw new AssertionError(message);
     }
 
-    static void assertExists(File file) {
+    public static void assertExists(File file) {
         if (!file.exists()) throw new AssertionError(file + " does not exist");
     }
 

src/dev/enola/be/task/StatusTest.java

@@ -1,16 +1,18 @@
 package dev.enola.be.task;
 
+import static ch.vorburger.test.Assert.assertTrue;
+
 public class StatusTest {
 
     public static void main(String[] args) {
         testIsTerminal();
     }
 
     private static void testIsTerminal() {
-        assert !Status.PENDING.isTerminal() : "PENDING should not be terminal";
-        assert !Status.IN_PROGRESS.isTerminal() : "IN_PROGRESS should not be terminal";
-        assert Status.COMPLETED.isTerminal() : "COMPLETED should be terminal";
-        assert Status.FAILED.isTerminal() : "FAILED should be terminal";
-        assert Status.CANCELLED.isTerminal() : "CANCELLED should be terminal";
+        assertTrue(!Status.PENDING.isTerminal(), "PENDING should not be terminal");
+        assertTrue(!Status.IN_PROGRESS.isTerminal(), "IN_PROGRESS should not be terminal");
+        assertTrue(Status.COMPLETED.isTerminal(), "COMPLETED should be terminal");
+        assertTrue(Status.FAILED.isTerminal(), "FAILED should be terminal");
+        assertTrue(Status.CANCELLED.isTerminal(), "CANCELLED should be terminal");
     }
 }

src/dev/enola/be/task/TaskExecutorTest.java

@@ -1,5 +1,7 @@
 package dev.enola.be.task;
 
+import static ch.vorburger.test.Assert.assertTrue;
+
 import dev.enola.be.task.test.FailingTask;
 import dev.enola.be.task.test.ImmediateTask;
 import dev.enola.be.task.test.SlowTask;
@@ -30,15 +32,15 @@ private static void testCompletedTask() throws Exception {
             var task = new ImmediateTask("test");
             var result = executor.await(task);
             var output = task.output().get();
-            assert result == output : "The result and output objects must be the same";
-            assert "Result: test".equals(result) : "Result should match expected output";
+            assertTrue(result == output, "The result and output objects must be the same");
+            assertTrue("Result: test".equals(result), "Result should match expected output");
 
             var toString = task.toString();
-            assert toString.contains("ImmediateTask") : "toString should contain class name";
-            assert toString.contains("id: " + task.id().toString()) : "toString should contain ID";
-            assert toString.contains("input: test") : "toString should contain input";
-            assert toString.contains("output: Result: test") : "toString should contain output";
-            assert toString.contains("status: COMPLETED") : "toString should contain COMPLETED";
+            assertTrue(toString.contains("ImmediateTask"), "toString should contain class name");
+            assertTrue(toString.contains("id: " + task.id().toString()), "toString !contains ID");
+            assertTrue(toString.contains("input: test"), "toString should contain input");
+            assertTrue(toString.contains("output: Result: test"), "toString should contain output");
+            assertTrue(toString.contains("status: COMPLETED"), "toString should contain COMPLETED");
         }
     }
 
@@ -54,18 +56,17 @@ private static void testFailingTask(FailingTask.FailureMode failureMode) throws
 
             try {
                 executor.await(task);
-                assert false : "Should have thrown an exception";
+                assertTrue(false, "Should have thrown an exception");
             } catch (Throwable e) {
                 // Expected
             }
-
-            assert task.status() == Status.FAILED : "Status should be FAILED after exception";
+            assertTrue(task.status() == Status.FAILED, "Status should be FAILED after exception");
 
             var toString = task.toString();
-            assert !toString.contains("output") : "toString should not contain output";
-            assert toString.contains("status: FAILED") : "toString should contain FAILED";
-            assert toString.contains("failure:") : "toString should contain failure:";
-            assert toString.contains("exception") : "toString should contain exception";
+            assertTrue(!toString.contains("output"), "toString should not contain output");
+            assertTrue(toString.contains("status: FAILED"), "toString should contain FAILED");
+            assertTrue(toString.contains("failure:"), "toString should contain failure:");
+            assertTrue(toString.contains("exception"), "toString should contain exception");
         }
     }
 
@@ -74,19 +75,21 @@ private static void testTimingOutTask() throws Exception {
             var task = new SlowTask("test", 1000, Duration.ofMillis(1));
             try {
                 executor.await(task);
-                assert false : "Should have thrown an exception due to timeout";
+                assertTrue(false, "Should have thrown an exception due to timeout");
 
             } catch (UncheckedTaskAwaitException e) {
-                assert e.getCause() instanceof CancellationException
-                        : "Cause should be CancellationException";
+                assertTrue(
+                        e.getCause() instanceof CancellationException,
+                        "Cause should be CancellationException");
                 // Expected
             }
-            assert task.status() == Status.CANCELLED
-                    : "Status should now be CANCELLED, but is " + task.status();
+            assertTrue(
+                    task.status() == Status.CANCELLED,
+                    "Status should now be CANCELLED, but is " + task.status());
 
             var toString = task.toString();
-            assert !toString.contains("output") : "toString should not contain output";
-            assert toString.contains("status: CANCELLED") : "toString should contain CANCELLED";
+            assertTrue(!toString.contains("output"), "toString should not contain output");
+            assertTrue(toString.contains("status: CANCELLED"), "toString should contain CANCELLED");
         }
     }
 
@@ -99,13 +102,14 @@ private static void testCancelTask() throws Exception {
 
             try {
                 task.await();
-                assert false : "Should have thrown CancellationException";
+                assertTrue(false, "Should have thrown CancellationException");
             } catch (UncheckedTaskAwaitException e) {
                 // Expected
             }
 
-            assert task.status() == Status.CANCELLED
-                    : "Status should be CANCELLED after cancel(), but is " + task.status();
+            assertTrue(
+                    task.status() == Status.CANCELLED,
+                    "Status should be CANCELLED after cancel(), but is " + task.status());
         }
     }
 
@@ -116,7 +120,7 @@ private static void testGetTask() throws Exception {
             executor.async(task);
 
             var retrieved = executor.get(taskId);
-            assert retrieved.id().equals(taskId) : "Retrieved task ID should match";
+            assertTrue(retrieved.id().equals(taskId), "Retrieved task ID should match");
         }
     }
 
@@ -125,10 +129,11 @@ private static void testGetNonExistentTask() throws Exception {
             var randomId = UUID.randomUUID();
             try {
                 executor.get(randomId);
-                assert false : "Should have thrown IllegalArgumentException";
+                assertTrue(false, "Should have thrown IllegalArgumentException");
             } catch (IllegalArgumentException e) {
-                assert e.getMessage().contains("No such task")
-                        : "Error message should mention 'No such task'";
+                assertTrue(
+                        e.getMessage().contains("No such task"),
+                        "Error message should mention 'No such task'");
             }
         }
     }
@@ -142,29 +147,30 @@ private static void testListTasks() throws Exception {
             executor.async(task2);
 
             var taskIds = executor.list();
-            assert taskIds.size() == 2 : "Should have 2 tasks, got " + taskIds.size();
-            assert taskIds.contains(task1.id()) : "Should contain task1 ID";
-            assert taskIds.contains(task2.id()) : "Should contain task2 ID";
+            assertTrue(taskIds.size() == 2, "Should have 2 tasks, got " + taskIds.size());
+            assertTrue(taskIds.contains(task1.id()), "Should contain task1 ID");
+            assertTrue(taskIds.contains(task2.id()), "Should contain task2 ID");
         }
     }
 
     private static void testTaskStatusProgression() throws Exception {
         try (var executor = new TaskExecutor()) {
             var task = new SlowTask("test", 1000);
 
-            assert task.status() == Status.PENDING : "Status should be PENDING: " + task.status();
-            assert task.toString().contains("status: PENDING") : "toString !PENDING";
+            assertTrue(
+                    task.status() == Status.PENDING, "Status should be PENDING: " + task.status());
+            assertTrue(task.toString().contains("status: PENDING"), "toString !PENDING");
 
             executor.async(task);
 
             var status = task.status();
-            assert status == Status.IN_PROGRESS : "Status should be IN_PROGRESS, got " + status;
-            assert task.toString().contains("status: IN_PROGRESS") : "toString !IN_PROGRESS";
+            assertTrue(status == Status.IN_PROGRESS, "Status should be IN_PROGRESS, got " + status);
+            assertTrue(task.toString().contains("status: IN_PROGRESS"), "toString !IN_PROGRESS");
 
             task.await();
 
-            assert task.status() == Status.COMPLETED : "Final status should be COMPLETED";
-            assert task.toString().contains("status: COMPLETED") : "toString !COMPLETED";
+            assertTrue(task.status() == Status.COMPLETED, "Final status should be COMPLETED");
+            assertTrue(task.toString().contains("status: COMPLETED"), "toString !COMPLETED");
         }
     }
 
@@ -175,10 +181,11 @@ private static void testResubmitTaskFailure() throws Exception {
 
             try {
                 executor.async(task);
-                assert false : "Should have thrown IllegalStateException on resubmit";
+                assertTrue(false, "Should have thrown IllegalStateException on resubmit");
             } catch (IllegalStateException e) {
-                assert e.getMessage().contains("already submitted")
-                        : "Error message should mention 'already submitted'";
+                assertTrue(
+                        e.getMessage().contains("already submitted"),
+                        "Error message should mention 'already submitted'");
             }
         }
     }
@@ -191,10 +198,11 @@ private static void testSubmitTaskToAnotherExecutorFailure() throws Exception {
         try (var executor2 = new TaskExecutor()) {
             try {
                 executor2.async(task);
-                assert false : "Should have thrown IllegalStateException on resubmit";
+                assertTrue(false, "Should have thrown IllegalStateException on resubmit");
             } catch (IllegalStateException e) {
-                assert e.getMessage().contains("not PENDING")
-                        : "Error message should mention 'not PENDING'";
+                assertTrue(
+                        e.getMessage().contains("not PENDING"),
+                        "Error message should mention 'not PENDING'");
             }
         }
     }
@@ -216,7 +224,7 @@ protected String execute() {
                         }
                     };
             var threadName = executor.await(task);
-            assert threadName.equals(task.id().toString());
+            assertTrue(threadName.equals(task.id().toString()));
         }
     }
 }

src/dev/enola/be/task/TaskTest.java

@@ -1,5 +1,7 @@
 package dev.enola.be.task;
 
+import static ch.vorburger.test.Assert.assertTrue;
+
 import dev.enola.be.task.test.ImmediateTask;
 
 public class TaskTest {
@@ -13,23 +15,24 @@ public static void main(String[] args) throws Exception {
 
     private static void testTaskHasNonNullId() {
         var task = new ImmediateTask("test");
-        assert task.id() != null : "Task ID should not be null";
+        assertTrue(task.id() != null, "Task ID should not be null");
     }
 
     private static void testTaskInputIsStored() {
         var task = new ImmediateTask("test input");
-        assert "test input".equals(task.input()) : "Task input should match";
+        assertTrue("test input".equals(task.input()), "Task input should match");
     }
 
     private static void testInitialStatusIsPending() {
         var task = new ImmediateTask("test");
-        assert task.status() == Status.PENDING
-                : "Initial status should be PENDING, got " + task.status();
+        assertTrue(
+                task.status() == Status.PENDING,
+                "Initial status should be PENDING, got " + task.status());
     }
 
     private static void testMultipleTasksHaveDifferentIds() {
         var task1 = new ImmediateTask("test1");
         var task2 = new ImmediateTask("test2");
-        assert !task1.id().equals(task2.id()) : "Different tasks should have different IDs";
+        assertTrue(!task1.id().equals(task2.id()), "Different tasks should have different IDs");
     }
 }

test.sh

@@ -10,16 +10,16 @@ find src -name '*.java' ! -name '*Test.java' ! -name 'Test*.java' -print0 \
 find src \( -name '*Test.java' -o -name 'Test*.java' \) -print0 \
   | xargs -0 javac -cp .build/classes -d .build/test-classes
 
-java -ea -cp .build/classes:.build/test-classes:src ch.vorburger.main.test.ExampleTest
+java -cp .build/classes:.build/test-classes:src ch.vorburger.main.test.ExampleTest
 
-java -ea -cp .build/classes:.build/test-classes:src ch.vorburger.jvmtools.ClasspathTest
-java -ea -cp .build/classes:.build/test-classes:src ch.vorburger.jvmtools.SourcepathTest
-java -ea -cp .build/classes:.build/test-classes:src ch.vorburger.jvmtools.JavaCompilerTest
-java -ea -cp .build/classes:.build/test-classes:src ch.vorburger.jvmtools.Bootstrap
+java -cp .build/classes:.build/test-classes:src ch.vorburger.jvmtools.ClasspathTest
+java -cp .build/classes:.build/test-classes:src ch.vorburger.jvmtools.SourcepathTest
+java -cp .build/classes:.build/test-classes:src ch.vorburger.jvmtools.JavaCompilerTest
+java -cp .build/classes:.build/test-classes:src ch.vorburger.jvmtools.Bootstrap
 
-java -ea -cp .build/classes:.build/test-classes dev.enola.be.task.StatusTest
-java -ea -cp .build/classes:.build/test-classes dev.enola.be.task.TaskTest
-java -ea -cp .build/classes:.build/test-classes dev.enola.be.task.TaskExecutorTest
+java -cp .build/classes:.build/test-classes dev.enola.be.task.StatusTest
+java -cp .build/classes:.build/test-classes dev.enola.be.task.TaskTest
+java -cp .build/classes:.build/test-classes dev.enola.be.task.TaskExecutorTest
 
 if command -v pre-commit &> /dev/null
 then