Debug indexingRescanOnOverflow test

Author: sungshik

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

@@ -31,11 +31,18 @@
 
 import java.io.IOException;
 import java.nio.file.Files;
+import java.nio.file.attribute.FileTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Predicate;
 
+import org.apache.logging.log4j.core.util.ExecutorServices;
 import org.awaitility.Awaitility;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
@@ -178,16 +185,30 @@ void indexingRescanOnOverflow() throws IOException, InterruptedException {
         var nModified = new AtomicInteger();
         var nDeleted = new AtomicInteger();
 
+        // var pool = new ForkJoinPool(1);
+        var pool = ForkJoinPool.commonPool();
+        var exec = new Executor() {
+            @Override
+            public void execute(Runnable command) {
+                System.err.println(pool.getPoolSize() + "/" + pool.getParallelism());
+                Thread.dumpStack();
+                pool.execute(command);
+            }
+        };
+
         var watchConfig = Watcher.watch(directory, WatchScope.PATH_AND_CHILDREN)
+            .withExecutor(exec)
             .approximate(OnOverflow.DIRTY)
             .on(e -> {
+                System.out.println(e);
                 var kind = e.getKind();
                 if (kind != OVERFLOW) {
                     // Threads can handle non-`OVERFLOW` events *only after*
                     // everything is "ready" for that (in which case a token is
                     // released to the semaphore, which is initially empty). See
                     // below for an explanation of "readiness".
                     semaphore.acquireUninterruptibly();
+                    System.out.println("Entered");
                     switch (e.getKind()) {
                         case CREATED:
                             nCreated.incrementAndGet();
@@ -201,7 +222,10 @@ void indexingRescanOnOverflow() throws IOException, InterruptedException {
                         default:
                             break;
                     }
+                    System.out.println("Exiting");
                     semaphore.release();
+                } else {
+                    System.out.println("Overflow");
                 }
             });
 
@@ -226,7 +250,8 @@ void indexingRescanOnOverflow() throws IOException, InterruptedException {
 
             var overflow = new WatchEvent(WatchEvent.Kind.OVERFLOW, directory);
             ((EventHandlingWatch) watch).handleEvent(overflow);
-            Thread.sleep(TestHelper.LONG_WAIT.toMillis());
+            System.out.println("------------");
+            Thread.sleep(TestHelper.NORMAL_WAIT.toMillis());
             // At this point, the current thread has presumably slept long
             // enough for the `OVERFLOW` event to have been handled by the
             // rescanner. This means that synthetic events must have been issued