Fix TestMultiIndexMergeScheduler test decrementing before 0 and falling into int-range loop. (#15098)

Author: dweiss

lucene/core/src/test/org/apache/lucene/index/TestMultiIndexMergeScheduler.java

@@ -16,10 +16,12 @@
  */
 package org.apache.lucene.index;
 
+import com.carrotsearch.randomizedtesting.annotations.Timeout;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.store.Directory;
@@ -63,6 +65,7 @@ public void sync(Directory directory) {
     assertTrue(directoriesToBeClosed.isEmpty());
   }
 
+  @Timeout(millis = 1000 * 60 * 2)
   public void testCloseMultiple() throws Exception {
     // Write to many indexes and do merges on them.
     // The unit test is randomized but reproducible.
@@ -119,14 +122,21 @@ public void sync(Directory directory) {
 
     // Randomly spread the documents across the indexes.
     // The merge ordering is calculated beforehand to make this unit test be reproducible.
+    // TODO: why is this a concurrent linked queue if all accesses are under synchronized(lock)?!
     ConcurrentLinkedQueue<Integer> nextDirectoryToWrite = new ConcurrentLinkedQueue<>();
     for (int i = 0; i < DOCUMENT_COUNT; ++i) {
       int r = random().nextInt(DIRECTORY_COUNT);
       nextDirectoryToWrite.add(r);
       ++documentCounts[r];
     }
 
+    // Ensure all threads have at least one document to work with.
+    for (int i = 0; i < documentCounts.length; i++) {
+      documentCounts[i] = Math.max(1, documentCounts[i]);
+    }
+
     // Write documents to each index and force some merges.
+    final AtomicBoolean stop = new AtomicBoolean();
     final ArrayList<Thread> threads = new ArrayList<>();
     final Object lock = new Object();
     for (int schedulerIndex = 0; schedulerIndex < schedulers.size(); schedulerIndex++) {
@@ -138,7 +148,7 @@ public void sync(Directory directory) {
             public void run() {
               try {
                 IndexWriter writer = writers.get(threadID);
-                while (true) {
+                while (stop.get() == false) {
                   synchronized (lock) {
                     if (!nextDirectoryToWrite.isEmpty()
                         && nextDirectoryToWrite.peek() != threadID) {
@@ -147,17 +157,19 @@ public void run() {
                           && nextDirectoryToWrite.peek() != threadID) {
                         try {
                           lock.wait();
-                        } catch (
-                            @SuppressWarnings("unused")
-                            InterruptedException e) {
-                          Thread.currentThread().interrupt();
-                          return;
+                        } catch (InterruptedException e) {
+                          stop.set(true);
+                          throw new RuntimeException("subthread interrupted?", e);
                         }
                       }
                       // awaken
                       continue;
                     }
 
+                    if (documentCounts[threadID] == 0) {
+                      break;
+                    }
+
                     // write a doc
                     Document doc = new Document();
                     Field idField = newStringField("id", "", Field.Store.NO);
@@ -176,10 +188,8 @@ public void run() {
 
                     nextDirectoryToWrite.poll();
                     lock.notifyAll();
-                    if (documentCounts[threadID] == 0) break;
                   }
                 }
-
               } catch (Exception e) {
                 throw new RuntimeException(e);
               }