package com.atlassian.bonnie;
   
   import java.io.IOException;
   import java.io.File;
   
   import junit.framework.TestCase;
   
   import org.apache.lucene.analysis.standard.StandardAnalyzer;
   import org.apache.lucene.document.Document;
  import org.apache.lucene.document.Field;
  import org.apache.lucene.index.IndexReader;
  import org.apache.lucene.index.IndexWriter;
  import org.apache.lucene.index.Term;
  import org.apache.lucene.search.IndexSearcher;
  import org.apache.lucene.search.TermQuery;
  import org.apache.lucene.store.RAMDirectory;
  
  import edu.emory.mathcs.backport.java.util.concurrent.*;
  import edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicBoolean;
  import edu.emory.mathcs.backport.java.util.concurrent.atomic.AtomicReference;
  
  public final class TestConcurrentLuceneConnection extends TestCase
  {
      ConcurrentLuceneConnection lcon;
      RAMDirectory directory = new RAMDirectory();
  
      private static final String FIELD_NAME = "my.field";
  
      private static final String FIELD_VALUE = "myvalue";
      private final TermQuery query = new TermQuery(new Term(FIELD_NAME, FIELD_VALUE));
  
      protected void setUp() throws Exception
      {
          // Init the directory so we can use it
          new IndexWriter(directory, null, true).close();
          lcon = new ConcurrentLuceneConnection(directory, new StandardAnalyzer(), ILuceneConnection.DEFAULT_CONFIGURATION);
      }
  
      public void testIsIndexCreated()
      {
          assertTrue(lcon.isIndexCreated());
          assertFalse(new ConcurrentLuceneConnection(new RAMDirectory(), new StandardAnalyzer(), ILuceneConnection.DEFAULT_CONFIGURATION).isIndexCreated());
      }
  
      public void testSearcherReuse()
      {
          final int numDocs = 5;
          addDocsToIndex(numDocs);
  
          final AtomicReference searcherRef = new AtomicReference(null);
          lcon.withSearch(new LuceneConnection.SearcherAction()
          {
              public void perform(IndexSearcher searcher) throws IOException
              {
                  searcherRef.set(searcher);
                  assertEquals(5, searcher.search(query).length());
              }
          });
  
          lcon.withSearch(new LuceneConnection.SearcherAction()
          {
              public void perform(IndexSearcher searcher) throws IOException
              {
                  assertEquals(5, searcher.search(query).length());
                  // should be the same searcher, no updates have been done
                  assertTrue(searcherRef.get() == searcher);
                  searcherRef.set(searcher);
              }
          });
  
          lcon.withWriter(new LuceneConnection.WriterAction()
          {
              public void perform(IndexWriter writer)
              {
              }
          });
  
          lcon.withSearch(new LuceneConnection.SearcherAction()
          {
              public void perform(IndexSearcher searcher) throws IOException
              {
                  assertEquals(5, searcher.search(query).length());
                  // should not be the same searcher, updates have been done
                  assertFalse(searcherRef.get() == searcher);
                  searcherRef.set(searcher);
              }
          });
          lcon.withSearch(new LuceneConnection.SearcherAction()
          {
              public void perform(IndexSearcher searcher) throws IOException
              {
                  assertEquals(5, searcher.search(query).length());
                  // should be the same searcher, no updates have been done
                  assertTrue(searcherRef.get() == searcher);
                  searcherRef.set(searcher);
              }
          });
          lcon.close();
          lcon.withSearch(new LuceneConnection.SearcherAction()
         {
             public void perform(IndexSearcher searcher) throws IOException
             {
                 assertEquals(5, searcher.search(query).length());
                 // should not be the same searcher, updates have been done
                 assertFalse(searcherRef.get() == searcher);
                 searcherRef.set(searcher);
             }
         });
         lcon.withSearch(new LuceneConnection.SearcherAction()
         {
             public void perform(IndexSearcher searcher) throws IOException
             {
                 assertEquals(5, searcher.search(query).length());
                 // should be the same searcher, no updates have been done
                 assertTrue(searcherRef.get() == searcher);
                 searcherRef.set(searcher);
             }
         });
         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 return null;
             }
         });
         lcon.withSearch(new LuceneConnection.SearcherAction()
         {
             public void perform(IndexSearcher searcher) throws IOException
             {
                 assertEquals(5, searcher.search(query).length());
                 // should not be the same searcher, deletes might have been done
                 assertFalse(searcherRef.get() == searcher);
                 searcherRef.set(searcher);
             }
         });
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 return null;
             }
         });
         lcon.withSearch(new LuceneConnection.SearcherAction()
         {
             public void perform(IndexSearcher searcher) throws IOException
             {
                 assertEquals(5, searcher.search(query).length());
                 // should be the same searcher, only reads have been done
                 assertTrue(searcherRef.get() == searcher);
             }
         });
     }
     
     public void testWriterIsInteractiveModeConfiguration() throws Exception
     {
         lcon.withWriter(new LuceneConnection.WriterAction()
         {
             public void perform(IndexWriter writer)
             {
                 // check that we are using the interactive settings
                 assertEquals("Should be interactive mode maxMergeSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getInteractiveMaxMergeDocs(), writer.getMaxMergeDocs());
                 assertEquals("Should be interactive mode maxBufferedSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getInteractiveMaxBufferedDocs(), writer.getMaxBufferedDocs());
                 assertEquals("Should be interactive mode mergeFactorSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getInteractiveMergeFactor(), writer.getMergeFactor());
                 assertEquals("Should be default maxField", ILuceneConnection.DEFAULT_CONFIGURATION.getMaxFieldLength(), writer.getMaxFieldLength());
             }
         });
     }
 
     public void testReaderReuse()
     {
         final int numDocs = 5;
         addDocsToIndex(numDocs);
 
         final AtomicReference readerRef = new AtomicReference(null);
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 readerRef.set(reader);
                 assertEquals(5, reader.numDocs());
                 return null;
             }
         });
 
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertEquals(5, reader.numDocs());
                 // should be the same searcher, no updates have been done
                 assertTrue(readerRef.get() == reader);
                 readerRef.set(reader);
                 return null;
             }
         });
 
         lcon.withWriter(new LuceneConnection.WriterAction()
         {
             public void perform(IndexWriter writer)
             {
             }
         });
 
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertEquals(5, reader.numDocs());
                 // should not be the same searcher, updates have been done
                 assertFalse(readerRef.get() == reader);
                 readerRef.set(reader);
                 return null;
             }
         });
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertEquals(5, reader.numDocs());
                 // should be the same searcher, no updates have been done
                 assertTrue(readerRef.get() == reader);
                 readerRef.set(reader);
                 return null;
             }
         });
         lcon.close();
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertEquals(5, reader.numDocs());
                 // should not be the same searcher, updates have been done
                 assertFalse(readerRef.get() == reader);
                 readerRef.set(reader);
                 return null;
             }
         });
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertEquals(5, reader.numDocs());
                 // should be the same searcher, no updates have been done
                 assertTrue(readerRef.get() == reader);
                 readerRef.set(reader);
                 return null;
             }
         });
         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 return null;
             }
         });
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertEquals(5, reader.numDocs());
                 // should not be the same searcher, deletes might have been done
                 assertFalse(readerRef.get() == reader);
                 readerRef.set(reader);
                 return null;
             }
         });
         lcon.withSearch(new ILuceneConnection.SearcherAction()
         {
             public void perform(IndexSearcher searcher)
             {
                 assertNotNull(searcher.getIndexReader());
                 assertTrue(readerRef.get() == searcher.getIndexReader());
             }
         });
         lcon.withReader(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertEquals(5, reader.numDocs());
                 // should be the same searcher, only reads have been done
                 assertTrue(readerRef.get() == reader);
                 return null;
             }
         });
     }
 
     public void testRecreateIndexDirectory() throws IOException
     {
         final int numDocs = 5;
         addDocsToIndex(numDocs);
         
         lcon.withSearch(new ILuceneConnection.SearcherAction()
         {
             public void perform(IndexSearcher searcher) throws IOException
             {
                 assertEquals(5, searcher.search(query).length());
             }
         });
         addDocsToIndex(numDocs);
         lcon.withSearch(new ILuceneConnection.SearcherAction()
         {
             public void perform(IndexSearcher searcher) throws IOException
             {
                 assertEquals(10, searcher.search(query).length());
             }
         });
         lcon.recreateIndexDirectory();
         lcon.withSearch(new ILuceneConnection.SearcherAction()
         {
             public void perform(IndexSearcher searcher) throws IOException
             {
                 assertEquals(0, searcher.search(query).length());
             }
         });
     }
 
     public void testFileConstructor() throws IOException
     {
         final File tempDir = File.createTempFile(this.getClass().getName(), ".idx");
         try
         {
             tempDir.delete();
             tempDir.mkdirs();
             lcon = new ConcurrentLuceneConnection(tempDir, new StandardAnalyzer(), ILuceneConnection.DEFAULT_CONFIGURATION);
             assertFalse(IndexReader.indexExists(tempDir));
             lcon.recreateIndexDirectory();
             assertTrue(IndexReader.indexExists(tempDir));
         }
         finally
         {
             tempDir.delete();
         }
     }
 
     public void testOptimizeCallsCorrectly() throws IOException
     {
         final AtomicBoolean optimizeCalled = new AtomicBoolean(false);
         final IndexWriter mockWriter = new IndexWriter(directory, null, false)
         {
             public synchronized void optimize()
             {
                 optimizeCalled.set(true);
             }
         };
 
         lcon = new ConcurrentLuceneConnection(directory, new StandardAnalyzer(), ILuceneConnection.DEFAULT_CONFIGURATION)
         {
             public void withWriter(ILuceneConnection.WriterAction action) throws LuceneException
             {
                 try
                 {
                     action.perform(mockWriter);
                 }
                 catch (IOException e)
                 {
                     throw new LuceneException(e);
                 }
             }
         };
 
         lcon.optimize();
 
         assertTrue(optimizeCalled.get());
     }
 
     public void testLeakedSearcher() throws Exception
     {
         addDocsToIndex(8);
         IndexSearcher searcher = lcon.leakSearcher();
         try
         {
             assertNotNull(searcher);
             assertEquals(8, searcher.search(query).length());
         }
         finally
         {
             if (searcher != null)
             {
                 searcher.close();
             }
         }
 
     }
 
     public void testFlipSearcher() throws IOException
     {
         // Ensure that calling this method on a fresh connection is OK
         lcon.flipCurrentSearcher();
 
         IndexSearcher searcher = null;
         IndexSearcher anotherSearcher = null;
         try
         {
             searcher = lcon.leakSearcher();
             lcon.flipCurrentSearcher();
             anotherSearcher = lcon.leakSearcher();
             assertFalse(searcher == anotherSearcher);
         }
         finally
         {
             if (searcher != null)
             {
                 searcher.close();
             }
             if (anotherSearcher != null)
             {
                 anotherSearcher.close();
             }
         }
     }
 
     public void testWriterBlocksDelete() throws InterruptedException
     {
         addDocsToIndex(5);
 
         final ExecutorService pool = Executors.newSingleThreadExecutor();
         final AtomicBoolean innerThreadStarted = new AtomicBoolean(false);
         final CountDownLatch deleteComplete = new CountDownLatch(1);
         final AtomicReference firstReaderRef = new AtomicReference(null);
 
         // test withWrite, then simultaneously, withReadAndDeletes
         lcon.withWriter(new ILuceneConnection.WriterAction()
         {
             public void perform(final IndexWriter writer) throws IOException
             {
                 final CountDownLatch latch = new CountDownLatch(1);
 
                 // Execute the deleteTask in a different thread
                 Future deleteTask = pool.submit(new Runnable()
                 {
                     public void run()
                     {
                         innerThreadStarted.set(true);
                         // Let the latch know that the deleteTask has began
                         // running
                         latch.countDown();
                         // this should only be run _after_ the WriterAction
                         // completes
                         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
                         {
                             public Object perform(IndexReader reader) throws IOException
                             {
                                 assertEquals("threaded withWriter: Added 2 documents not detected from thread", 7, reader.numDocs());
                                 reader.deleteDocument(0);
                                 firstReaderRef.set(reader);
                                 deleteComplete.countDown();
                                 return null;
                             }
                         });
                     }
                 });
 
                 // Wait for the deleteTask to begin executing
                 try
                 {
                     latch.await();
                 }
                 catch (InterruptedException e)
                 {
                     throw new RuntimeException(e);
                 }
 
                 // Assert that the deleteTask has started executing
                 assertTrue(innerThreadStarted.get());
                 // But blocked before deleteing a document. The task is blocked
                 // as we should hold the lock on the index
                 // until we leave the withWriter() method.
                 assertFalse(deleteTask.isDone());
                 // Therefore we should still have 5 documents in the index
                 assertEquals(5, writer.docCount());
                 // Add another document
                 writer.addDocument(createDocument());
                 writer.addDocument(createDocument());
 
                 assertFalse(deleteTask.isDone());
             }
         });
 
         // wait for the deleteTask to complete and assert it did...
         deleteComplete.await();
 
         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 // 2 docs added, 1 removed - should have 6 docs
                 assertEquals(6, reader.numDocs());
                 return null;
             }
         });
         assertEquals("threaded withReaderAndDeletes: Document not added in thread", 6, lcon.getNumDocs());
     }
 
     public void testDeleteBlocksWriter() throws InterruptedException
     {
         addDocsToIndex(5);
 
         final ExecutorService pool = Executors.newSingleThreadExecutor();
         final AtomicBoolean innerThreadStarted = new AtomicBoolean(false);
         final CountDownLatch writeComplete = new CountDownLatch(1);
         final AtomicReference firstWriterRef = new AtomicReference(null);
 
         // test withWrite, then simultaneously, withReadAndDeletes
         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
         {
             public Object perform(final IndexReader reader) throws IOException
             {
                 final CountDownLatch latch = new CountDownLatch(1);
 
                 // Execute the deleteTask in a different thread
                 Future writeTask = pool.submit(new Runnable()
                 {
                     public void run()
                     {
                         innerThreadStarted.set(true);
                         // Let the latch know that the deleteTask has began
                         // running
                         latch.countDown();
                         // this should only be run _after_ the WriterAction
                         // completes
                         lcon.withWriter(new ILuceneConnection.WriterAction()
                         {
                             public void perform(IndexWriter writer) throws IOException
                             {
                                 assertEquals("threaded withReaderAndDeletes: deleted documents not detected from thread", 3, reader.numDocs());
                                 writer.addDocument(createDocument());
                                 firstWriterRef.set(writer);
                                 writeComplete.countDown();
                             }
                         });
                     }
                 });
 
                 // Wait for the deleteTask to begin executing
                 try
                 {
                     latch.await();
                 }
                 catch (InterruptedException e)
                 {
                     throw new RuntimeException(e);
                 }
 
                 // Assert that the deleteTask has started executing
                 assertTrue(innerThreadStarted.get());
                 // But blocked before deleteing a document. The task is blocked
                 // as we should hold the lock on the index
                 // until we leave the withWriter() method.
                 assertFalse(writeTask.isDone());
                 // delete documents
                 reader.deleteDocument(0);
                 reader.deleteDocument(1);
                 return null;
             }
         });
 
         // wait for the writeTask to complete and assert it did...
         writeComplete.await();
 
         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 // 2 docs added, 1 removed - should have 6 docs
                 assertEquals(4, reader.numDocs());
                 return null;
             }
         });
         assertEquals("threaded withReaderAndDeletes: Document not added in thread", 4, lcon.getNumDocs());
     }
 
     public void testDeleteClosesReader()
     {
         final AtomicReference readerRef = new AtomicReference(null);
         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertNotNull(reader);
                 readerRef.set(reader);
                 return null;
             }
         });
         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
         {
             public Object perform(IndexReader reader)
             {
                 assertNotNull(reader);
                 assertFalse(readerRef.get() == reader);
                 return null;
             }
         });
     }
 
     public void testWriteClosesWriter()
     {
         final AtomicReference writerRef = new AtomicReference(null);
         lcon.withWriter(new ILuceneConnection.WriterAction()
         {
             public void perform(IndexWriter writer)
             {
                 assertNotNull(writer);
                 writerRef.set(writer);
             }
         });
         lcon.withWriter(new ILuceneConnection.WriterAction()
         {
             public void perform(IndexWriter writer)
             {
                 assertNotNull(writer);
                 assertFalse(writerRef.get() == writer);
             }
         });
     }
     
     public void testDeleteAndWriteAtomicity() throws Exception
     {
         final CountDownLatch latch = new CountDownLatch(1);
         final ExecutorService pool = Executors.newSingleThreadExecutor();
         final AtomicReference secondUpdateFuture = new AtomicReference(null);
         final AtomicBoolean complete = new AtomicBoolean(false);
 
         lcon.withDeleteAndWrites(new ILuceneConnection.ReaderAction()
             {
                 public Object perform(IndexReader reader)
                 {
                     secondUpdateFuture.set(
                         pool.submit(
                             new Runnable()
                             {
                                 public void run()
                                 {
                                     latch.countDown();
                                     lcon.withReaderAndDeletes(
                                         new ILuceneConnection.ReaderAction()
                                         {
                                             public Object perform(IndexReader reader)
                                             {
                                                 assertNotNull(reader);
                                                 assertTrue(complete.get());
                                                 return null;
                                             }
                                         }
                                     );
                                 }
                             }
                         )
                     );
                     try
                     {
                         // make sure we are inside the Runnable (before the ReaderAction is called as it should block)
                         latch.await();
                     }
                     catch (InterruptedException e)
                     {
                         throw new RuntimeException(e);
                     }
                     Thread.yield();
                     return null;
                 }
             }, 
             new ILuceneConnection.WriterAction()
             {
                 public void perform(IndexWriter writer)
                 {
                     assertNotNull(writer);
                     assertEquals("Should be interactive mode maxMergeSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getInteractiveMaxMergeDocs(), writer.getMaxMergeDocs());
                     assertEquals("Should be interactive mode maxBufferedSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getInteractiveMaxBufferedDocs(), writer.getMaxBufferedDocs());
                     assertEquals("Should be interactive mode mergeFactorSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getInteractiveMergeFactor(), writer.getMergeFactor());
     
                     Future future = ((Future) secondUpdateFuture.get());
                     assertFalse(future.isDone());
                     assertFalse(future.isCancelled());
                     complete.set(true);
                 }
             }
         );
         assertTrue(complete.get());
         Future future = ((Future) secondUpdateFuture.get());
         assertNull(future.get());
         assertTrue(future.isDone());
         assertFalse(future.isCancelled());
     }
 
     public void testBatchUpdateHoldsLock() throws Exception
     {
         final CountDownLatch latch = new CountDownLatch(1);
         final ExecutorService pool = Executors.newSingleThreadExecutor();
         final AtomicReference secondUpdateFuture = new AtomicReference(null);
 
         lcon.withBatchUpdate(new ILuceneConnection.BatchUpdateAction()
         {
             public void perform() throws Exception
             {
                 secondUpdateFuture.set(
                     pool.submit(
                         new Runnable()
                         {
                             public void run()
                             {
                                 latch.countDown();
                                 lcon.withReaderAndDeletes(
                                     new ILuceneConnection.ReaderAction()
                                     {
                                         public Object perform(IndexReader reader)
                                         {
                                             assertNotNull(reader);
                                             return null;
                                         }
                                     }
                                 );
                             }
                         }
                     )
                 );
                 latch.await();
                 Thread.yield();
                 lcon.withReaderAndDeletes(
                     new ILuceneConnection.ReaderAction()
                     {
                         public Object perform(IndexReader reader)
                         {
                             assertNotNull(reader);
                             return null;
                         }
                     }
                 );
                 lcon.withWriter(
                     new ILuceneConnection.WriterAction()
                     {
                         public void perform(IndexWriter writer)
                         {
                             assertNotNull(writer);
                             assertEquals("Should be batch mode maxMergeSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getBatchMaxMergeDocs(), writer.getMaxMergeDocs());
                             assertEquals("Should be batch mode maxBufferedSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getBatchMaxBufferedDocs(), writer.getMaxBufferedDocs());
                             assertEquals("Should be batch mode mergeFactorSettings", ILuceneConnection.DEFAULT_CONFIGURATION.getBatchMergeFactor(), writer.getMergeFactor());
                             assertEquals("Should be default maxField", ILuceneConnection.DEFAULT_CONFIGURATION.getMaxFieldLength(), writer.getMaxFieldLength());
                         }
                     }
                 );
 
                 Future future = ((Future) secondUpdateFuture.get());
                 assertFalse(future.isDone());
                 assertFalse(future.isCancelled());
             }
         });
         Future future = ((Future) secondUpdateFuture.get());
         assertNull(future.get());
         assertTrue(future.isDone());
         assertFalse(future.isCancelled());
     }
 
     public void testDeleterDoesNotBlockSearches()
     {
         addDocsToIndex(5);
 
         final int noOfSearches = 1000;
         final ExecutorService pool = Executors.newFixedThreadPool(4);
         final CountDownLatch complete = new CountDownLatch(noOfSearches);
         final AtomicReference readerRef = new AtomicReference(null);
 
         lcon.withReader(
             new ILuceneConnection.ReaderAction()
             {
                 public Object perform(IndexReader reader)
                 {
                     readerRef.set(reader);
                     return null;
                 }
             }
         );
 
         // test withWrite, then simultaneously, withReadAndDeletes
         lcon.withReaderAndDeletes(new ILuceneConnection.ReaderAction()
         {
             public Object perform(final IndexReader reader)
             {
                 for (int i = 0; i < noOfSearches; i++)
                 {
 
                     // Execute the deleteTask in a different thread
                     pool.submit(
                         new Runnable()
                         {
                             public void run()
                             {
                                 // these should not be blocked
                                 lcon.withSearch(new ILuceneConnection.SearcherAction()
                                 {
                                     public void perform(IndexSearcher searcher)
                                     {
                                         assertTrue(readerRef.get() == searcher.getIndexReader());
                                     }
                                 });
                                 lcon.withReader(new ILuceneConnection.ReaderAction()
                                 {
                                     public Object perform(IndexReader reader)
                                     {
                                         assertTrue(readerRef.get() == reader);
                                         return null;
                                     }
                                 });
                                 // Let the latch know that the searchTask has completed
                                 complete.countDown();
                             }
                         }
                     );
                 }
 
                 // Wait for the tasks to complete executing,
                 // failure is an infinite wait... but we wait only for 5 seconds.
                 try
                 {
                     assertTrue("We waited too long, should have passed", complete.await(5, TimeUnit.SECONDS));
                 }
                 catch (InterruptedException e)
                 {
                     throw new AssertionError("We should not have to wait here, tasks should be reentrant: " + e);
                 }
                 return null;
             }
         });
 
         // Test that the searcher got refreshed
         lcon.withReader(
             new ILuceneConnection.ReaderAction()
             {
                 public Object perform(IndexReader reader)
                 {
                     assertFalse(readerRef.get() == reader);
                     return null;
                 }
             }
         );
     }
 
     public void testWriterDoesNotBlockSearches()
     {
         addDocsToIndex(5);
 
         final int noOfSearches = 1000;
         final ExecutorService pool = Executors.newFixedThreadPool(4);
         final CountDownLatch complete = new CountDownLatch(noOfSearches);
         final AtomicReference readerRef = new AtomicReference(null);
 
         lcon.withReader(
             new ILuceneConnection.ReaderAction()
             {
                 public Object perform(IndexReader reader)
                 {
                     readerRef.set(reader);
                     return null;
                 }
             }
         );
 
         // test withWrite, then simultaneously, withReadAndDeletes
         lcon.withWriter(new ILuceneConnection.WriterAction()
         {
             public void perform(final IndexWriter writer)
             {
                 for (int i = 0; i < noOfSearches; i++)
                 {
 
                     // Execute the deleteTask in a different thread
                     pool.submit(
                         new Runnable()
                         {
                             public void run()
                             {
                                 // these should not be blocked
                                 lcon.withSearch(new ILuceneConnection.SearcherAction()
                                 {
                                     public void perform(IndexSearcher searcher)
                                     {
                                         assertTrue(readerRef.get() == searcher.getIndexReader());
                                     }
                                 });
                                 lcon.withReader(new ILuceneConnection.ReaderAction()
                                 {
                                     public Object perform(IndexReader reader)
                                     {
                                         assertTrue(readerRef.get() == reader);
                                         return null;
                                     }
                                 });
                                 // Let the latch know that the searchTask has completed
                                 complete.countDown();
                             }
                         }
                     );
                 }
 
                 // Wait for the tasks to complete executing,
                 // failure is an infinite wait...but we wait for 5 seconds
                 try
                 {
                     assertTrue("We waited too long, should have passed", complete.await(5, TimeUnit.SECONDS));
                 }
                 catch (InterruptedException e)
                 {
                     throw new AssertionError("We should not have to wait here, tasks should be reentrant: " + e);
                 }
             }
         });
 
         // Test that the reader was refreshed
         lcon.withReader(
             new ILuceneConnection.ReaderAction()
             {
                 public Object perform(IndexReader reader)
                 {
                     assertFalse(readerRef.get() == reader);
                     return null;
                 }
             }
         );
     }
 
     /**
      * TODO Make this work.
      * Test that our batch update correctly prevents visibility of the whole operation until it is finished
      */
     /*
     public void testBatchUpdateHasAtomicSearcherVisibility()
     {
         addDocsToIndex(5);
         final ExecutorService pool = Executors.newFixedThreadPool(4);
         final Callable countDocs = new Callable()
         {
             public Object call() throws Exception
             {
                 return lcon.withReader(
                     new ILuceneConnection.ReaderAction()
                     {
                         public Object perform(IndexReader reader) throws IOException
                         {
                             return new Integer(reader.numDocs());
                         }
                     }
                 );
             }
         };
 
         // Test that the reader was refreshed and that our countDocs does the business
         assertNumDocs(5, pool.submit(countDocs));
 
         lcon.withBatchUpdate(
             new ILuceneConnection.BatchUpdateAction()
             {
                 public void perform() throws Exception
                 {
                     assertNumDocs(5, pool.submit(countDocs));
                     lcon.withWriter(
                         new ILuceneConnection.WriterAction(){
                             public void perform(IndexWriter writer) throws IOException
                             {
                                 writer.addDocument(createDocument());
                                 assertNumDocs(5, pool.submit(countDocs));
                                 writer.addDocument(createDocument());
                                 assertNumDocs(5, pool.submit(countDocs));
                                 writer.addDocument(createDocument());
                                 assertNumDocs(5, pool.submit(countDocs));
                             }
                         }
                     );
                     assertNumDocs(5, pool.submit(countDocs));
                     lcon.withReaderAndDeletes(
                         new ILuceneConnection.ReaderAction()
                         {
                             public Object perform(IndexReader reader) throws IOException
                             {
                                 assertNumDocs(5, pool.submit(countDocs));
                                 reader.deleteDocument(0);
                                 assertNumDocs(5, pool.submit(countDocs));
                                 reader.deleteDocument(0);
                                 assertNumDocs(5, pool.submit(countDocs));
                                 return null;
                             }
                         }
                     );
                     assertNumDocs(5, pool.submit(countDocs));
                 }
             }
         );
         assertNumDocs(6, pool.submit(countDocs));
     }
     */
 
     private Document createDocument()
     {
         Document d = new Document();
         d.add(new Field(FIELD_NAME, FIELD_VALUE, Field.Store.YES, Field.Index.TOKENIZED));
         return d;
     }
 
     private void addDocsToIndex(final int numDocs)
     {
         lcon.withWriter(new ILuceneConnection.WriterAction()
         {
             public void perform(IndexWriter writer) throws IOException
             {
                 for (int i = 0; i < numDocs; ++i)
                 {
                     writer.addDocument(createDocument());
                 }
             }
         });
     }
 }