public TestIndexReader(String name) 
{
        super(name);
}

 public static  void main(String[] args) 
{
        TestRunner.run (new TestSuite(TestIndexReader.class));
//        TestRunner.run (new TestIndexReader("testBasicDelete"));
//        TestRunner.run (new TestIndexReader("testDeleteReaderWriterConflict"));
//        TestRunner.run (new TestIndexReader("testDeleteReaderReaderConflict"));
//        TestRunner.run (new TestIndexReader("testFilesOpenClose"));
}

Main for running test case by itself.

 public  void testBasicDelete() throws IOException 
{
        Directory dir = new RAMDirectory();
        IndexWriter writer = null;
        IndexReader reader = null;
        Term searchTerm = new Term("content", "aaa");
        //  add 100 documents with term : aaa
        writer  = new IndexWriter(dir, new WhitespaceAnalyzer(), true);
        for (int i = 0; i <  100; i++)
        {
            addDoc(writer, searchTerm.text());
        }
        writer.close();
        // OPEN READER AT THIS POINT - this should fix the view of the
        // index at the point of having 100 "aaa" documents and 0 "bbb"
        reader = IndexReader.open(dir);
        assertEquals("first docFreq", 100, reader.docFreq(searchTerm));
        assertTermDocsCount("first reader", reader, searchTerm, 100);
        // DELETE DOCUMENTS CONTAINING TERM: aaa
        int deleted = 0;
        reader = IndexReader.open(dir);
        deleted = reader.delete(searchTerm);
        assertEquals("deleted count", 100, deleted);
        assertEquals("deleted docFreq", 100, reader.docFreq(searchTerm));
        assertTermDocsCount("deleted termDocs", reader, searchTerm, 0);
        reader.close();
        // CREATE A NEW READER and re-test
        reader = IndexReader.open(dir);
        assertEquals("deleted docFreq", 100, reader.docFreq(searchTerm));
        assertTermDocsCount("deleted termDocs", reader, searchTerm, 0);
        reader.close();
}

 public  void testDeleteReaderReaderConflictOptimized() throws IOException 
{
      deleteReaderReaderConflict(true);
}

 public  void testDeleteReaderReaderConflictUnoptimized() throws IOException 
{
      deleteReaderReaderConflict(false);
}

 public  void testDeleteReaderWriterConflictOptimized() throws IOException 
{
        deleteReaderWriterConflict(true);
}

 public  void testDeleteReaderWriterConflictUnoptimized() throws IOException 
{
      deleteReaderWriterConflict(false);
}

 public  void testFilesOpenClose() throws IOException 
{
        // Create initial data set
        Directory dir = getDirectory(true);
        IndexWriter writer  = new IndexWriter(dir, new WhitespaceAnalyzer(), true);
        addDoc(writer, "test");
        writer.close();
        dir.close();
        // Try to erase the data - this ensures that the writer closed all files
        dir = getDirectory(true);
        // Now create the data set again, just as before
        writer  = new IndexWriter(dir, new WhitespaceAnalyzer(), true);
        addDoc(writer, "test");
        writer.close();
        dir.close();
        // Now open existing directory and test that reader closes all files
        dir = getDirectory(false);
        IndexReader reader1 = IndexReader.open(dir);
        reader1.close();
        dir.close();
        // The following will fail if reader did not close all files
        dir = getDirectory(true);
}

 public  void testGetFieldNames() throws Exception 
{
        RAMDirectory d = new RAMDirectory();
        // set up writer
        IndexWriter writer = new IndexWriter(d, new StandardAnalyzer(), true);
        addDocumentWithFields(writer);
        writer.close();
        // set up reader
        IndexReader reader = IndexReader.open(d);
        Collection fieldNames = reader.getFieldNames();
        assertTrue(fieldNames.contains("keyword"));
        assertTrue(fieldNames.contains("text"));
        assertTrue(fieldNames.contains("unindexed"));
        assertTrue(fieldNames.contains("unstored"));
        // add more documents
        writer = new IndexWriter(d, new StandardAnalyzer(), false);
        // want to get some more segments here
        for (int i = 0; i <  5*writer.mergeFactor; i++)
        {
            addDocumentWithFields(writer);
        }
        // new fields are in some different segments (we hope)
        for (int i = 0; i <  5*writer.mergeFactor; i++)
        {
            addDocumentWithDifferentFields(writer);
        }
        writer.close();
        // verify fields again
        reader = IndexReader.open(d);
        fieldNames = reader.getFieldNames();
        assertEquals(9, fieldNames.size());    // the following fields + an empty one (bug?!)
        assertTrue(fieldNames.contains("keyword"));
        assertTrue(fieldNames.contains("text"));
        assertTrue(fieldNames.contains("unindexed"));
        assertTrue(fieldNames.contains("unstored"));
        assertTrue(fieldNames.contains("keyword2"));
        assertTrue(fieldNames.contains("text2"));
        assertTrue(fieldNames.contains("unindexed2"));
        assertTrue(fieldNames.contains("unstored2"));
        // verify that only indexed fields were returned
        Collection indexedFieldNames = reader.getFieldNames(true);
        assertEquals(6, indexedFieldNames.size());
        assertTrue(indexedFieldNames.contains("keyword"));
        assertTrue(indexedFieldNames.contains("text"));
        assertTrue(indexedFieldNames.contains("unstored"));
        assertTrue(indexedFieldNames.contains("keyword2"));
        assertTrue(indexedFieldNames.contains("text2"));
        assertTrue(indexedFieldNames.contains("unstored2"));
        // verify that only unindexed fields were returned
        Collection unindexedFieldNames = reader.getFieldNames(false);
        assertEquals(3, unindexedFieldNames.size());    // the following fields + an empty one
        assertTrue(unindexedFieldNames.contains("unindexed"));
        assertTrue(unindexedFieldNames.contains("unindexed2"));
}

Tests the IndexReader.getFieldNames implementation