public TestSegmentReader(String s) 
{
     
    super(s);
}

 protected  void setUp() 
{
    try {
      DocHelper.setupDoc(testDoc);
      DocHelper.writeDoc(dir, testDoc);
      reader = new SegmentReader(new SegmentInfo("test", 1, dir));
    } catch (IOException e) {
    }
}

 protected  void tearDown() 
{

}

 public  void test() 
{
    assertTrue(dir != null);
    assertTrue(reader != null);
    assertTrue(DocHelper.nameValues.size()  > 0);
    assertTrue(DocHelper.numFields(testDoc) == 6);
}

 public  void testDelete() 
{
    Document docToDelete = new Document();
    DocHelper.setupDoc(docToDelete);
    DocHelper.writeDoc(dir, "seg-to-delete", docToDelete);
    try {
      SegmentReader deleteReader = new SegmentReader(new SegmentInfo("seg-to-delete", 1, dir));
      assertTrue(deleteReader != null);
      assertTrue(deleteReader.numDocs() == 1);
      deleteReader.delete(0);
      assertTrue(deleteReader.isDeleted(0) == true);
      assertTrue(deleteReader.hasDeletions() == true);
      assertTrue(deleteReader.numDocs() == 0);
      try {
        Document test = deleteReader.document(0);
        assertTrue(false);
      } catch (IllegalArgumentException e) {
        assertTrue(true);
      }
    } catch (IOException e) {
      e.printStackTrace();
      assertTrue(false);
    }
}

 public  void testDocument() 
{
    try {
      assertTrue(reader.numDocs() == 1);
      assertTrue(reader.maxDoc()  >= 1);
      Document result = reader.document(0);
      assertTrue(result != null);
      //There are 2 unstored fields on the document that are not preserved across writing
      assertTrue(DocHelper.numFields(result) == DocHelper.numFields(testDoc) - 2);
      Enumeration fields = result.fields();
      while (fields.hasMoreElements()) {
        Field field = (Field) fields.nextElement();
        assertTrue(field != null);
        assertTrue(DocHelper.nameValues.containsKey(field.name()));
      }
    } catch (IOException e) {
      e.printStackTrace();
      assertTrue(false);
    }
}

 public  void testGetFieldNameVariations() 
{
    try {
      Collection result = reader.getFieldNames();
      assertTrue(result != null);
      assertTrue(result.size() == 7);
      for (Iterator iter = result.iterator(); iter.hasNext();) {
        String s = (String) iter.next();
        //System.out.println("Name: " + s);
        assertTrue(DocHelper.nameValues.containsKey(s) == true || s.equals(""));
      }                                                                               
      result = reader.getFieldNames(true);
      assertTrue(result != null);
//      System.out.println("Size: " + result.size());
      assertTrue(result.size() == 5);
      for (Iterator iter = result.iterator(); iter.hasNext();) {
        String s = (String) iter.next();
        assertTrue(DocHelper.nameValues.containsKey(s) == true || s.equals(""));
      }
      result = reader.getFieldNames(false);
      assertTrue(result != null);
      assertTrue(result.size() == 2);
      //Get all indexed fields that are storing term vectors
      result = reader.getIndexedFieldNames(true);
      assertTrue(result != null);
      assertTrue(result.size() == 2);
      result = reader.getIndexedFieldNames(false);
      assertTrue(result != null);
      assertTrue(result.size() == 3);
    } catch (IOException e) {
      e.printStackTrace();
      assertTrue(false);
    }
}

 public  void testNorms() 
{
    //TODO: Not sure how these work/should be tested
/*
    try {
      byte [] norms = reader.norms(DocHelper.TEXT_FIELD_1_KEY);
      System.out.println("Norms: " + norms);
      assertTrue(norms != null);
    } catch (IOException e) {
      e.printStackTrace();
      assertTrue(false);
    }
*/
}

 public  void testTermVectors() 
{
    try {
      TermFreqVector result = reader.getTermFreqVector(0, DocHelper.TEXT_FIELD_2_KEY);
      assertTrue(result != null);
      String [] terms = result.getTerms();
      int [] freqs = result.getTermFrequencies();
      assertTrue(terms != null && terms.length == 3 && freqs != null && freqs.length == 3);
      for (int i = 0; i <  terms.length; i++) {
        String term = terms[i];
        int freq = freqs[i];
        assertTrue(DocHelper.FIELD_2_TEXT.indexOf(term) != -1);
        assertTrue(freq  > 0);
      }
      TermFreqVector [] results = reader.getTermFreqVectors(0);
      assertTrue(results != null);
      assertTrue(results.length == 2);      
    } catch (IOException e) {
      e.printStackTrace();
      assertTrue(false);
    }
}

 public  void testTerms() 
{
    try {
      TermEnum terms = reader.terms();
      assertTrue(terms != null);
      while (terms.next() == true)
      {
        Term term = terms.term();
        assertTrue(term != null);
        //System.out.println("Term: " + term);
        String fieldValue = (String)DocHelper.nameValues.get(term.field());
        assertTrue(fieldValue.indexOf(term.text()) != -1);
      }
      TermDocs termDocs = reader.termDocs();
      assertTrue(termDocs != null);
      termDocs.seek(new Term(DocHelper.TEXT_FIELD_1_KEY, "field"));
      assertTrue(termDocs.next() == true);
      TermPositions positions = reader.termPositions();
      positions.seek(new Term(DocHelper.TEXT_FIELD_1_KEY, "field"));
      assertTrue(positions != null);
      assertTrue(positions.doc() == 0);
      assertTrue(positions.nextPosition()  >= 0);
    } catch (IOException e) {
      e.printStackTrace();
      assertTrue(false);
    }
}