Also made the torture test a bit faster to run

Author: DavyLandman

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

@@ -26,7 +26,7 @@
  */
 package engineering.swat.watch;
 
-import static org.awaitility.Awaitility.await;
+import static engineering.swat.watch.util.WaitFor.await;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -45,12 +45,10 @@
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Predicate;
 import java.util.stream.Stream;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.awaitility.Awaitility;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
@@ -60,6 +58,8 @@
 import org.junit.jupiter.params.provider.EnumSource;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import engineering.swat.watch.util.WaitFor;
+
 class TortureTests {
 
     private final Logger logger = LogManager.getLogger();
@@ -68,7 +68,7 @@ class TortureTests {
 
     @BeforeAll
     static void setupEverything() {
-        Awaitility.setDefaultTimeout(TestHelper.LONG_WAIT.getSeconds(), TimeUnit.SECONDS);
+        WaitFor.setDefaultTimeout(TestHelper.LONG_WAIT);
     }
 
     @BeforeEach
@@ -181,13 +181,13 @@ void pressureOnFSShouldNotMissNewFilesAnything(Approximation whichFiles) throws
             logger.info("Starting {} jobs", THREADS);
             io.start();
             // now we generate a whole bunch of events
-            Thread.sleep(TestHelper.NORMAL_WAIT.toMillis());
+            Thread.sleep(Math.min(TestHelper.NORMAL_WAIT.toMillis(), Duration.ofSeconds(30).toMillis()));
             logger.info("Stopping jobs");
             pathsWritten = io.stop();
             logger.info("Generated: {} files",  pathsWritten.size());
 
             await("After a while we should have seen all the create events")
-                .timeout(TestHelper.LONG_WAIT.multipliedBy(50))
+                .time(TestHelper.LONG_WAIT.multipliedBy(50))
                 .pollInterval(Duration.ofMillis(500))
                 .until(() -> seenCreates.containsAll(pathsWritten));
         }
@@ -254,10 +254,10 @@ void manyRegistrationsForSamePath() throws InterruptedException, IOException {
             Files.writeString(target, "Hello World");
             var expected = Collections.singleton(target);
             await("We should see only one event")
-                .failFast(() -> !exceptions.isEmpty())
-                .timeout(TestHelper.LONG_WAIT)
+                .failFast(() -> "There was an exception: "+ exceptions, () -> !exceptions.isEmpty())
+                .time(TestHelper.NORMAL_WAIT)
                 .pollInterval(Duration.ofMillis(10))
-                .until(() -> seen, expected::equals);
+                .untilEquals(() -> seen, expected);
             if (!exceptions.isEmpty()) {
                 fail(exceptions.pop());
             }
@@ -269,7 +269,7 @@ void manyRegistrationsForSamePath() throws InterruptedException, IOException {
 
     static Stream<Approximation> manyRegisterAndUnregisterSameTimeSource() {
         Approximation[] values = { Approximation.ALL, Approximation.DIFF };
-        return TestHelper.streamOf(values, 5);
+        return TestHelper.streamOf(values, 3);
     }
 
     @ParameterizedTest
@@ -328,9 +328,9 @@ void manyRegisterAndUnregisterSameTime(Approximation whichFiles) throws Interrup
             assertTrue(seen.isEmpty(), "No events should have been sent");
             Files.writeString(target, "Hello World");
             await("We should see only exactly the " + amountOfWatchersActive + " events we expect")
-                .failFast(() -> !exceptions.isEmpty())
-                .pollDelay(TestHelper.NORMAL_WAIT.minusMillis(100))
-                .until(seen::size, Predicate.isEqual(amountOfWatchersActive))
+                .time(TestHelper.SHORT_WAIT)
+                .failFast(() -> "There was an exception: "+ exceptions, () -> !exceptions.isEmpty())
+                .delayedHoldsEquals(seen::size, amountOfWatchersActive)
                 ;
             if (!exceptions.isEmpty()) {
                 fail(exceptions.pop());

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

@@ -1,3 +1,29 @@
+/*
+ * BSD 2-Clause License
+ *
+ * Copyright (c) 2023, Swat.engineering
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 package engineering.swat.watch.util;
 
 import static java.lang.System.currentTimeMillis;
@@ -172,6 +198,11 @@ public void until(BooleanSupplier p) {
         assertTrue(block(p), message);
     }
 
+    public <T> void untilEquals(Supplier<T> val, T expected) {
+        assertTrue(block(() -> expected.equals(val.get())), message);
+        assertEquals(expected, val.get(), message);
+    }
+
     private void holdBlock(BooleanSupplier p) {
         // we keep going untill a false result
         block(() -> !p.getAsBoolean());
@@ -199,5 +230,30 @@ public void holdsEmpty(Supplier<Stream<?>> stream) {
         });
     }
 
+    private void delayedHoldsBlock(BooleanSupplier p, Runnable finalCheck) {
+        AtomicBoolean turnedTrue = new AtomicBoolean(false);
+        block(() -> {
+            var result = p.getAsBoolean();
+            if (result) {
+                turnedTrue.set(true);
+                // keep running, all good
+                return false;
+            }
+            // now if false, that could be fine, if we're never turned true yet
+            return turnedTrue.get();
+        });
+        finalCheck.run();
+    }
+
+    public void delayedHolds(BooleanSupplier p) {
+        delayedHoldsBlock(p, () -> assertTrue(p, message));
+    }
+
+    public <T> void delayedHoldsEquals(Supplier<T> sup, T expected) {
+        delayedHoldsBlock(
+            () -> expected.equals(sup.get()),
+            () -> assertEquals(expected, sup.get(), message)
+        );
+    }
 
 }