DRY ManualResetEvent in tests (#40)

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: devhawk

…s/transact/conductor/ConductorTests.java …os/transact/conductor/ConductorTest.javasrc/test/java/dev/dbos/transact/conductor/ConductorTests.java renamed to src/test/java/dev/dbos/transact/conductor/ConductorTest.java src/test/java/dev/dbos/transact/conductor/ConductorTests.java renamed to src/test/java/dev/dbos/transact/conductor/ConductorTest.java

@@ -54,9 +54,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-public class ConductorTests {
+public class ConductorTest {
 
-    static Logger logger = LoggerFactory.getLogger(ConductorTests.class);
+    static Logger logger = LoggerFactory.getLogger(ConductorTest.class);
 
     SystemDatabase mockDB;
     DBOSExecutor mockExec;
@@ -236,7 +236,7 @@ public void onMessage(WebSocket conn, String message) {
         }
 
         public void send(BaseMessage message) throws Exception {
-            String json = ConductorTests.mapper.writeValueAsString(message);
+            String json = ConductorTest.mapper.writeValueAsString(message);
             this.webSocket.send(json);
         }
     }

src/test/java/dev/dbos/transact/conductor/TestWebSocketServer.java

@@ -11,6 +11,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import dev.dbos.transact.utils.ManualResetEvent;
+
 class TestWebSocketServer extends WebSocketServer {
     public interface WebSocketTestListener {
         default void onStart() {

src/test/java/dev/dbos/transact/queue/ConcurrencyTestServiceImpl.java

@@ -1,5 +1,6 @@
 package dev.dbos.transact.queue;
 
+import dev.dbos.transact.utils.ManualResetEvent;
 import dev.dbos.transact.workflow.Workflow;
 
 import java.util.List;

src/test/java/dev/dbos/transact/queue/ManualResetEvent.java

@@ -12,6 +12,7 @@
 import dev.dbos.transact.database.SystemDatabase;
 import dev.dbos.transact.execution.DBOSExecutor;
 import dev.dbos.transact.utils.DBUtils;
+import dev.dbos.transact.utils.ManualResetEvent;
 import dev.dbos.transact.workflow.WorkflowHandle;
 import dev.dbos.transact.workflow.WorkflowState;
 import dev.dbos.transact.workflow.WorkflowStatus;

src/test/java/dev/dbos/transact/queue/QueuesTest.java

@@ -1,4 +1,4 @@
-package dev.dbos.transact.conductor;
+package dev.dbos.transact.utils;
 
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
@@ -12,51 +12,60 @@ public ManualResetEvent(boolean initialState) {
         this.signaled = initialState;
     }
 
-    // Wait until signaled
-    public void waitOne() throws InterruptedException {
+    public void set() {
         lock.lock();
         try {
-            while (!signaled) {
-                condition.await();
-            }
+            signaled = true;
+            condition.signalAll();
         } finally {
             lock.unlock();
         }
     }
 
-    // Wait until signaled or timeout
-    public boolean waitOne(long millis) throws InterruptedException {
+    public void reset() {
         lock.lock();
         try {
-            long nanos = millis * 1_000_000L;
-            while (!signaled) {
-                if (nanos <= 0L) {
-                    return false;
-                }
-                nanos = condition.awaitNanos(nanos);
-            }
-            return true;
+            signaled = false;
         } finally {
             lock.unlock();
         }
     }
 
-    // Set the event (unblocks all waiters)
-    public void set() {
+    // Note, it's a little suspect to wrap a checked exception in an unchecked exception in the two waitOne overloads. 
+    // However, this is test code so a thrown exception should just fail the test.
+
+    public void waitOne() {
         lock.lock();
         try {
-            signaled = true;
-            condition.signalAll();
+            while (!signaled) {
+                try {
+                    condition.await();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    throw new RuntimeException(e);
+                }
+            }
         } finally {
             lock.unlock();
         }
     }
 
-    // Reset the event (future waits will block)
-    public void reset() {
+    public boolean waitOne(long millis) {
         lock.lock();
         try {
-            signaled = false;
+            long nanos = millis * 1_000_000L;
+            while (!signaled) {
+                if (nanos <= 0L) {
+                    return false;
+                }
+                try {
+                    nanos = condition.awaitNanos(nanos);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    throw new RuntimeException(e);
+                }
+            }
+            return true;
         } finally {
             lock.unlock();
         }