Rewrote more test to new framework and joined waits together

Author: DavyLandman

src/test/java/engineering/swat/watch/SingleFileTests.java

@@ -30,13 +30,15 @@
 import static engineering.swat.watch.WatchEvent.Kind.DELETED;
 import static engineering.swat.watch.WatchEvent.Kind.MODIFIED;
 import static engineering.swat.watch.WatchEvent.Kind.OVERFLOW;
-import static org.awaitility.Awaitility.await;
+import static engineering.swat.watch.util.WaitFor.await;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.attribute.FileTime;
 import java.time.Instant;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BooleanSupplier;
 
 import org.awaitility.Awaitility;
 import org.junit.jupiter.api.AfterEach;
@@ -45,6 +47,7 @@
 import org.junit.jupiter.api.Test;
 
 import engineering.swat.watch.impl.EventHandlingWatch;
+import engineering.swat.watch.util.WaitFor;
 
 class SingleFileTests {
     private TestDirectory testDir;
@@ -63,7 +66,7 @@ void cleanup() {
 
     @BeforeAll
     static void setupEverything() {
-        Awaitility.setDefaultTimeout(TestHelper.NORMAL_WAIT);
+        WaitFor.setDefaultTimeout(TestHelper.NORMAL_WAIT);
     }
 
     @Test
@@ -86,12 +89,11 @@ void singleFileShouldNotTriggerOnOtherFilesInSameDir() throws IOException, Inter
                     Files.writeString(f, "Hello");
                 }
             }
-            Thread.sleep(TestHelper.SHORT_WAIT.toMillis());
+            Thread.sleep(TestHelper.SMALL_WAIT.toMillis());
             Files.writeString(target, "Hello world");
             await("Single file does trigger")
-                .pollDelay(TestHelper.NORMAL_WAIT.minusMillis(10))
-                .failFast("No others should be notified", others::get)
-                .untilTrue(seen);
+                .failFast("Other files should not trigger", others::get)
+                .until(seen);
         }
     }
 
@@ -115,41 +117,50 @@ void singleFileThatMonitorsOnlyADirectory() throws IOException, InterruptedExcep
                     Files.writeString(f, "Hello");
                 }
             }
-            Thread.sleep(TestHelper.SHORT_WAIT.toMillis());
+            Thread.sleep(TestHelper.SMALL_WAIT.toMillis());
             Files.setLastModifiedTime(target, FileTime.from(Instant.now()));
             await("Single directory does trigger")
-                .pollDelay(TestHelper.NORMAL_WAIT.minusMillis(10))
                 .failFast("No others should be notified", others::get)
-                .untilTrue(seen);
+                .until(seen);
         }
     }
 
     @Test
     void noRescanOnOverflow() throws IOException, InterruptedException {
         var bookkeeper = new TestHelper.Bookkeeper();
         try (var watch = startWatchAndTriggerOverflow(Approximation.NONE, bookkeeper)) {
-            Thread.sleep(TestHelper.SHORT_WAIT.toMillis());
+            //Thread.sleep(TestHelper.SMALL_WAIT.toMillis());
 
-            await("Overflow shouldn't trigger created, modified, or deleted events: " + bookkeeper)
-                .until(() -> bookkeeper.events().kind(CREATED, MODIFIED, DELETED).none());
             await("Overflow should be visible to user-defined event handler")
                 .until(() -> bookkeeper.events().kind(OVERFLOW).any());
+            await("Overflow shouldn't trigger created, modified, or deleted events: " + bookkeeper)
+                .time(TestHelper.SMALL_WAIT)
+                .holds(() -> bookkeeper.events().kind(CREATED, MODIFIED, DELETED).none());
         }
     }
 
     @Test
     void memorylessRescanOnOverflow() throws IOException, InterruptedException {
         var bookkeeper = new TestHelper.Bookkeeper();
         try (var watch = startWatchAndTriggerOverflow(Approximation.ALL, bookkeeper)) {
-            Thread.sleep(TestHelper.SHORT_WAIT.toMillis());
+            //Thread.sleep(TestHelper.SMALL_WAIT.toMillis());
 
             var path = watch.getPath();
             await("Overflow should trigger created event for `" + path + "`")
                 .until(() -> bookkeeper.events().kind(CREATED).rootPath(path).any());
-            await("Overflow shouldn't trigger created events for other files")
-                .until(() -> bookkeeper.events().kind(CREATED).rootPathNot(path).none());
-            await("Overflow shouldn't trigger modified or deleted events")
-                .until(() -> bookkeeper.events().kind(MODIFIED, DELETED).none());
+            await("No extra events")
+                .time(TestHelper.SMALL_WAIT)
+                .holds(() -> {
+                    assertTrue(
+                        bookkeeper.events().kind(CREATED).rootPathNot(path).none(),
+                        "Overflow shouldn't trigger created events for other files"
+                    );
+                    assertTrue(
+                        bookkeeper.events().kind(MODIFIED, DELETED).none()
+                        ,"Overflow shouldn't trigger modified or deleted events"
+                    );
+                    return true;
+                });
             await("Overflow should be visible to user-defined event handler")
                 .until(() -> bookkeeper.events().kind(OVERFLOW).any());
         }

src/test/java/engineering/swat/watch/util/WaitFor.java

@@ -30,6 +30,7 @@ public static void setDefaultTimeout(Duration newDefaultTime) {
     private @Nullable BooleanSupplier failFast;
     private @Nullable Duration time;
     private @Nullable Duration poll;
+    private @Nullable Supplier<String> failMessage;
 
 
     private WaitFor(Supplier<String> message) {
@@ -54,26 +55,38 @@ public WaitFor pollInterval(Duration d) {
         return this;
     }
 
-    public WaitFor failFast(BooleanSupplier b) {
+    public WaitFor failFast(String message, BooleanSupplier b) {
+        return failFast(() -> message, b);
+    }
+
+    public WaitFor failFast(Supplier<String> message, BooleanSupplier b) {
         this.failFast = b;
+        this.failMessage = message;
         return this;
     }
 
-    public WaitFor failFast(AtomicBoolean b) {
-        return failFast(b::get);
+    public WaitFor failFast(Supplier<String> message, AtomicBoolean b) {
+        return failFast(message, b::get);
+    }
+    public WaitFor failFast(String message, AtomicBoolean b) {
+        return failFast(message, b::get);
     }
 
 
 
-    private boolean alreadyFailed() {
+    private void checkFailed() {
         if (failFast != null) {
             try {
-                return failFast.getAsBoolean();
+                if (failFast.getAsBoolean()) {
+                    var actualFailMessage = failMessage;
+                    if (actualFailMessage == null) {
+                        actualFailMessage = () -> this.message.get() + " was terminated earlier due to fail fast";
+                    }
+                    fail(actualFailMessage);
+                }
             } catch (RuntimeException ex) {
-                return false;
             }
         }
-        return false;
     }
 
     private Duration calculatePoll(Duration time) {
@@ -112,12 +125,11 @@ private boolean block(BooleanSupplier action) {
         var end = currentTimeMillis() + time.toMillis();
         while (end > currentTimeMillis()) {
             var start = currentTimeMillis();
+            checkFailed();
             if (action.getAsBoolean()) {
                 return true;
             }
-            if (alreadyFailed()) {
-                fail(message.get() + " was terminated by failFast predicate");
-            }
+            checkFailed();
             var stop = currentTimeMillis();
             var remaining = poll.toMillis() - (stop - start);
             if (remaining > 0) {