lucene-java-3.4.0/lucene/contrib/instantiated/src/test/org/apache/lucene/store/instantiated/TestIndicesEquals.java

   1 package org.apache.lucene.store.instantiated;
   2 /**
   3  * Copyright 2006 The Apache Software Foundation
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 import java.io.IOException;
  19 import java.util.ArrayList;
  20 import java.util.Arrays;
  21 import java.util.Comparator;
  22 import java.util.Iterator;
  23 import java.util.List;
  24 import java.util.Random;
  25
  26 import org.apache.lucene.analysis.MockAnalyzer;
  27 import org.apache.lucene.analysis.Token;
  28 import org.apache.lucene.analysis.TokenStream;
  29 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
  30 import org.apache.lucene.document.Document;
  31 import org.apache.lucene.document.Field;
  32 import org.apache.lucene.index.IndexReader;
  33 import org.apache.lucene.index.IndexWriter;
  34 import org.apache.lucene.index.Payload;
  35 import org.apache.lucene.index.Term;
  36 import org.apache.lucene.index.TermDocs;
  37 import org.apache.lucene.index.TermEnum;
  38 import org.apache.lucene.index.TermFreqVector;
  39 import org.apache.lucene.index.TermPositionVector;
  40 import org.apache.lucene.index.TermPositions;
  41 import org.apache.lucene.store.Directory;
  42 import org.apache.lucene.util.AttributeImpl;
  43 import org.apache.lucene.util.LuceneTestCase;
  44
  45 /**
  46  * Asserts equality of content and behaviour of two index readers.
  47  */
  48 public class TestIndicesEquals extends LuceneTestCase {
  49
  50 //  public void test2() throws Exception {
  51 //    FSDirectory fsdir = FSDirectory.open(new File("/tmp/fatcorpus"));
  52 //    IndexReader ir = IndexReader.open(fsdir, false);
  53 //    InstantiatedIndex ii = new InstantiatedIndex(ir);
  54 //    ir.close();
  55 //    testEquals(fsdir, ii);
  56 //  }
  57
  58
  59   public void testLoadIndexReader() throws Exception {
  60     Directory dir = newDirectory();
  61
  62     // create dir data
  63     IndexWriter indexWriter = new IndexWriter(dir, newIndexWriterConfig(
  64         TEST_VERSION_CURRENT, new MockAnalyzer(random)).setMergePolicy(newLogMergePolicy()));
  65
  66     for (int i = 0; i < 20; i++) {
  67       Document document = new Document();
  68       assembleDocument(document, i);
  69       indexWriter.addDocument(document);
  70     }
  71     indexWriter.close();
  72
  73     // test load ii from index reader
  74     IndexReader ir = IndexReader.open(dir, false);
  75     InstantiatedIndex ii = new InstantiatedIndex(ir);
  76     ir.close();
  77
  78     testEqualBehaviour(dir, ii);
  79     dir.close();
  80   }
  81
  82
  83   public void testInstantiatedIndexWriter() throws Exception {
  84
  85     Directory dir = newDirectory();
  86     InstantiatedIndex ii = new InstantiatedIndex();
  87
  88     // we need to pass the "same" random to both, so they surely index the same payload data.
  89     long seed = random.nextLong();
  90
  91     // create dir data
  92     IndexWriter indexWriter = new IndexWriter(dir, newIndexWriterConfig(
  93                                                                         TEST_VERSION_CURRENT, new MockAnalyzer(new Random(seed))).setMergePolicy(newLogMergePolicy()));
  94     indexWriter.setInfoStream(VERBOSE ? System.out : null);
  95     if (VERBOSE) {
  96       System.out.println("TEST: make test index");
  97     }
  98     for (int i = 0; i < 500; i++) {
  99       Document document = new Document();
 100       assembleDocument(document, i);
 101       indexWriter.addDocument(document);
 102     }
 103     indexWriter.close();
 104
 105     // test ii writer
 106     InstantiatedIndexWriter instantiatedIndexWriter = ii.indexWriterFactory(new MockAnalyzer(new Random(seed)), true);
 107     for (int i = 0; i < 500; i++) {
 108       Document document = new Document();
 109       assembleDocument(document, i);
 110       instantiatedIndexWriter.addDocument(document);
 111     }
 112     instantiatedIndexWriter.close();
 113
 114
 115     testEqualBehaviour(dir, ii);
 116
 117     dir.close();
 118
 119   }
 120
 121
 122   private void testTermDocsSomeMore(Directory aprioriIndex, InstantiatedIndex testIndex) throws Exception {
 123
 124     IndexReader aprioriReader = IndexReader.open(aprioriIndex, false);
 125     IndexReader testReader = testIndex.indexReaderFactory();
 126
 127     // test seek
 128
 129     Term t = new Term("c", "danny");
 130     TermEnum aprioriTermEnum = aprioriReader.terms(t);
 131     TermEnum testTermEnum = testReader.terms(t);
 132
 133     assertEquals(aprioriTermEnum.term(), testTermEnum.term());
 134
 135     t = aprioriTermEnum.term();
 136
 137     aprioriTermEnum.close();
 138     testTermEnum.close();
 139
 140     TermDocs aprioriTermDocs = aprioriReader.termDocs(t);
 141     TermDocs testTermDocs = testReader.termDocs(t);
 142
 143     assertEquals(aprioriTermDocs.next(), testTermDocs.next());
 144     assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 145     assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 146
 147     if (aprioriTermDocs.skipTo(4)) {
 148       assertTrue(testTermDocs.skipTo(4));
 149       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 150       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 151     } else {
 152       assertFalse(testTermDocs.skipTo(4));
 153     }
 154
 155     if (aprioriTermDocs.next()) {
 156       assertTrue(testTermDocs.next());
 157       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 158       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 159     } else {
 160       assertFalse(testTermDocs.next());
 161     }
 162
 163
 164     // beyond this point all next and skipto will return false
 165
 166     if (aprioriTermDocs.skipTo(100)) {
 167       assertTrue(testTermDocs.skipTo(100));
 168       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 169       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 170     } else {
 171       assertFalse(testTermDocs.skipTo(100));
 172     }
 173
 174
 175     if (aprioriTermDocs.next()) {
 176       assertTrue(testTermDocs.next());
 177       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 178       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 179     } else {
 180       assertFalse(testTermDocs.next());
 181     }
 182
 183     if (aprioriTermDocs.skipTo(110)) {
 184       assertTrue(testTermDocs.skipTo(110));
 185       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 186       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 187     } else {
 188       assertFalse(testTermDocs.skipTo(110));
 189     }
 190
 191     if (aprioriTermDocs.skipTo(10)) {
 192       assertTrue(testTermDocs.skipTo(10));
 193       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 194       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 195     } else {
 196       assertFalse(testTermDocs.skipTo(10));
 197     }
 198
 199
 200     if (aprioriTermDocs.skipTo(210)) {
 201       assertTrue(testTermDocs.skipTo(210));
 202       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 203       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 204     } else {
 205       assertFalse(testTermDocs.skipTo(210));
 206     }
 207
 208     aprioriTermDocs.close();
 209     testTermDocs.close();
 210
 211
 212
 213     // test seek null (AllTermDocs)
 214     aprioriTermDocs = aprioriReader.termDocs(null);
 215     testTermDocs = testReader.termDocs(null);
 216
 217     while (aprioriTermDocs.next()) {
 218       assertTrue(testTermDocs.next());
 219       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 220       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 221     }
 222     assertFalse(testTermDocs.next());
 223
 224
 225     aprioriTermDocs.close();
 226     testTermDocs.close();
 227
 228
 229     // test seek default
 230     aprioriTermDocs = aprioriReader.termDocs();
 231     testTermDocs = testReader.termDocs();
 232
 233     // this is invalid use of the API,
 234     // but if the response differs then it's an indication that something might have changed.
 235     // in 2.9 and 3.0 the two TermDocs-implementations returned different values at this point.
 236 //    assertEquals("Descripency during invalid use of the TermDocs API, see comments in test code for details.",
 237 //        aprioriTermDocs.next(), testTermDocs.next());
 238
 239     // start using the API the way one is supposed to use it
 240
 241     t = new Term("", "");
 242     aprioriTermDocs.seek(t);
 243     testTermDocs.seek(t);
 244
 245     while (aprioriTermDocs.next()) {
 246       assertTrue(testTermDocs.next());
 247       assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 248       assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 249     }
 250     assertFalse(testTermDocs.next());
 251
 252     aprioriTermDocs.close();
 253     testTermDocs.close();
 254
 255
 256     // clean up
 257     aprioriReader.close();
 258     testReader.close();
 259
 260   }
 261
 262
 263   private void assembleDocument(Document document, int i) {
 264     document.add(new Field("a", i + " Do you really want to go and live in that house all winter?", Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS));
 265     if (i > 0) {
 266       document.add(new Field("b0", i + " All work and no play makes Jack a dull boy", Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS));
 267       document.add(new Field("b1", i + " All work and no play makes Jack a dull boy", Field.Store.YES, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO));
 268       document.add(new Field("b2", i + " All work and no play makes Jack a dull boy", Field.Store.NO, Field.Index.NOT_ANALYZED, Field.TermVector.NO));
 269       document.add(new Field("b3", i + " All work and no play makes Jack a dull boy", Field.Store.YES, Field.Index.NO, Field.TermVector.NO));
 270       if (i > 1) {
 271         document.add(new Field("c", i + " Redrum redrum", Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS));
 272         if (i > 2) {
 273           document.add(new Field("d", i + " Hello Danny, come and play with us... forever and ever. and ever.", Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS));
 274           if (i > 3) {
 275             Field f = new Field("e", i + " Heres Johnny!", Field.Store.YES, Field.Index.ANALYZED, Field.TermVector.WITH_POSITIONS_OFFSETS);
 276             f.setOmitNorms(true);
 277             document.add(f);
 278             if (i > 4) {
 279               final List<Token> tokens = new ArrayList<Token>(2);
 280               Token t = createToken("the", 0, 2, "text");
 281               t.setPayload(new Payload(new byte[]{1, 2, 3}));
 282               tokens.add(t);
 283               t = createToken("end", 3, 5, "text");
 284               t.setPayload(new Payload(new byte[]{2}));
 285               tokens.add(t);
 286               tokens.add(createToken("fin", 7, 9));
 287               TokenStream ts = new TokenStream(Token.TOKEN_ATTRIBUTE_FACTORY) {
 288                 final AttributeImpl reusableToken = (AttributeImpl) addAttribute(CharTermAttribute.class);
 289                 Iterator<Token> it = tokens.iterator();
 290
 291                 @Override
 292                 public final boolean incrementToken() throws IOException {
 293                   if (!it.hasNext()) {
 294                     return false;
 295                   }
 296                   clearAttributes();
 297                   it.next().copyTo(reusableToken);
 298                   return true;
 299                 }
 300
 301                 @Override
 302                 public void reset() throws IOException {
 303                   it = tokens.iterator();
 304                 }
 305               };
 306
 307               document.add(new Field("f", ts));
 308             }
 309           }
 310         }
 311       }
 312     }
 313   }
 314
 315
 316   /**
 317    * Asserts that the content of two index readers equal each other.
 318    *
 319    * @param aprioriIndex the index that is known to be correct
 320    * @param testIndex    the index that is supposed to equals the apriori index.
 321    * @throws Exception
 322    */
 323   protected void testEqualBehaviour(Directory aprioriIndex, InstantiatedIndex testIndex) throws Exception {
 324
 325
 326     testEquals(aprioriIndex,  testIndex);
 327
 328     // delete a few documents
 329     IndexReader air = IndexReader.open(aprioriIndex, false);
 330     InstantiatedIndexReader tir = testIndex.indexReaderFactory();
 331
 332     assertEquals(air.isCurrent(), tir.isCurrent());
 333     assertEquals(air.hasDeletions(), tir.hasDeletions());
 334     assertEquals(air.maxDoc(), tir.maxDoc());
 335     assertEquals(air.numDocs(), tir.numDocs());
 336     assertEquals(air.numDeletedDocs(), tir.numDeletedDocs());
 337
 338     air.deleteDocument(3);
 339     tir.deleteDocument(3);
 340
 341     assertEquals(air.isCurrent(), tir.isCurrent());
 342     assertEquals(air.hasDeletions(), tir.hasDeletions());
 343     assertEquals(air.maxDoc(), tir.maxDoc());
 344     assertEquals(air.numDocs(), tir.numDocs());
 345     assertEquals(air.numDeletedDocs(), tir.numDeletedDocs());
 346
 347     air.deleteDocument(8);
 348     tir.deleteDocument(8);
 349
 350     assertEquals(air.isCurrent(), tir.isCurrent());
 351     assertEquals(air.hasDeletions(), tir.hasDeletions());
 352     assertEquals(air.maxDoc(), tir.maxDoc());
 353     assertEquals(air.numDocs(), tir.numDocs());
 354     assertEquals(air.numDeletedDocs(), tir.numDeletedDocs());
 355
 356     // this (in 3.0) commits the deletions
 357     air.close();
 358     tir.close();
 359
 360     air = IndexReader.open(aprioriIndex, false);
 361     tir = testIndex.indexReaderFactory();
 362
 363     assertEquals(air.isCurrent(), tir.isCurrent());
 364     assertEquals(air.hasDeletions(), tir.hasDeletions());
 365     assertEquals(air.maxDoc(), tir.maxDoc());
 366     assertEquals(air.numDocs(), tir.numDocs());
 367     assertEquals(air.numDeletedDocs(), tir.numDeletedDocs());
 368
 369     for (int d =0; d<air.maxDoc(); d++) {
 370       assertEquals(air.isDeleted(d), tir.isDeleted(d));
 371     }
 372
 373     air.close();
 374     tir.close();
 375
 376
 377     // make sure they still equal
 378     testEquals(aprioriIndex,  testIndex);
 379   }
 380
 381   protected void testEquals(Directory aprioriIndex, InstantiatedIndex testIndex) throws Exception {
 382
 383     testTermDocsSomeMore(aprioriIndex, testIndex);
 384
 385     IndexReader aprioriReader = IndexReader.open(aprioriIndex, false);
 386     IndexReader testReader = testIndex.indexReaderFactory();
 387
 388     assertEquals(aprioriReader.numDocs(), testReader.numDocs());
 389
 390     // assert field options
 391     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.INDEXED), testReader.getFieldNames(IndexReader.FieldOption.INDEXED));
 392     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.INDEXED_NO_TERMVECTOR), testReader.getFieldNames(IndexReader.FieldOption.INDEXED_NO_TERMVECTOR));
 393     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.INDEXED_WITH_TERMVECTOR), testReader.getFieldNames(IndexReader.FieldOption.INDEXED_WITH_TERMVECTOR));
 394     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.STORES_PAYLOADS), testReader.getFieldNames(IndexReader.FieldOption.STORES_PAYLOADS));
 395     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.TERMVECTOR), testReader.getFieldNames(IndexReader.FieldOption.TERMVECTOR));
 396     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.TERMVECTOR_WITH_OFFSET), testReader.getFieldNames(IndexReader.FieldOption.TERMVECTOR_WITH_OFFSET));
 397     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.TERMVECTOR_WITH_POSITION), testReader.getFieldNames(IndexReader.FieldOption.TERMVECTOR_WITH_POSITION));
 398     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.TERMVECTOR_WITH_POSITION_OFFSET), testReader.getFieldNames(IndexReader.FieldOption.TERMVECTOR_WITH_POSITION_OFFSET));
 399     assertEquals(aprioriReader.getFieldNames(IndexReader.FieldOption.UNINDEXED), testReader.getFieldNames(IndexReader.FieldOption.UNINDEXED));
 400
 401     for (Object field : aprioriReader.getFieldNames(IndexReader.FieldOption.ALL)) {
 402
 403       // test norms as used by normal use
 404
 405       byte[] aprioriNorms = aprioriReader.norms((String) field);
 406       byte[] testNorms = testReader.norms((String) field);
 407
 408       if (aprioriNorms != null) {
 409         assertEquals(aprioriNorms.length, testNorms.length);
 410
 411         for (int i = 0; i < aprioriNorms.length; i++) {
 412           assertEquals("norms does not equals for field " + field + " in document " + i, aprioriNorms[i], testNorms[i]);
 413         }
 414
 415         // test norms as used by multireader
 416
 417         aprioriNorms = new byte[aprioriReader.maxDoc()];
 418         aprioriReader.norms((String) field, aprioriNorms, 0);
 419
 420         testNorms = new byte[testReader.maxDoc()];
 421         testReader.norms((String) field, testNorms, 0);
 422
 423         assertEquals(aprioriNorms.length, testNorms.length);
 424
 425         for (int i = 0; i < aprioriNorms.length; i++) {
 426           assertEquals("norms does not equals for field " + field + " in document " + i, aprioriNorms[i], testNorms[i]);
 427         }
 428
 429
 430         // test norms as used by multireader
 431
 432         aprioriNorms = new byte[aprioriReader.maxDoc() + 10];
 433         aprioriReader.norms((String) field, aprioriNorms, 10);
 434
 435         testNorms = new byte[testReader.maxDoc() + 10];
 436         testReader.norms((String) field, testNorms, 10);
 437
 438         assertEquals(aprioriNorms.length, testNorms.length);
 439
 440         for (int i = 0; i < aprioriNorms.length; i++) {
 441           assertEquals("norms does not equals for field " + field + " in document " + i, aprioriNorms[i], testNorms[i]);
 442         }
 443       }
 444
 445     }
 446
 447     for (int docIndex = 0; docIndex < aprioriReader.numDocs(); docIndex++) {
 448       assertEquals(aprioriReader.isDeleted(docIndex), testReader.isDeleted(docIndex));
 449     }
 450
 451     // compare term enumeration stepping
 452
 453     TermEnum aprioriTermEnum = aprioriReader.terms();
 454     TermEnum testTermEnum = testReader.terms();
 455
 456
 457     while (true) {
 458
 459       if (!aprioriTermEnum.next()) {
 460         assertFalse(testTermEnum.next());
 461         break;
 462       }
 463       assertTrue(testTermEnum.next());
 464
 465       assertEquals(aprioriTermEnum.term(), testTermEnum.term());
 466       assertTrue(aprioriTermEnum.docFreq() == testTermEnum.docFreq());
 467
 468       // compare termDocs seeking
 469
 470       TermDocs aprioriTermDocsSeeker = aprioriReader.termDocs(aprioriTermEnum.term());
 471       TermDocs testTermDocsSeeker = testReader.termDocs(testTermEnum.term());
 472
 473       while (aprioriTermDocsSeeker.next()) {
 474         assertTrue(testTermDocsSeeker.skipTo(aprioriTermDocsSeeker.doc()));
 475         assertEquals(aprioriTermDocsSeeker.doc(), testTermDocsSeeker.doc());
 476       }
 477
 478       aprioriTermDocsSeeker.close();
 479       testTermDocsSeeker.close();
 480
 481       // compare documents per term
 482
 483       assertEquals(aprioriReader.docFreq(aprioriTermEnum.term()), testReader.docFreq(testTermEnum.term()));
 484
 485       TermDocs aprioriTermDocs = aprioriReader.termDocs(aprioriTermEnum.term());
 486       TermDocs testTermDocs = testReader.termDocs(testTermEnum.term());
 487
 488       while (true) {
 489         if (!aprioriTermDocs.next()) {
 490           assertFalse(testTermDocs.next());
 491           break;
 492         }
 493         assertTrue(testTermDocs.next());
 494
 495         assertEquals(aprioriTermDocs.doc(), testTermDocs.doc());
 496         assertEquals(aprioriTermDocs.freq(), testTermDocs.freq());
 497       }
 498
 499       aprioriTermDocs.close();
 500       testTermDocs.close();
 501
 502       // compare term positions
 503
 504       TermPositions testTermPositions = testReader.termPositions(testTermEnum.term());
 505       TermPositions aprioriTermPositions = aprioriReader.termPositions(aprioriTermEnum.term());
 506
 507       if (aprioriTermPositions != null) {
 508
 509         for (int docIndex = 0; docIndex < aprioriReader.maxDoc(); docIndex++) {
 510           boolean hasNext = aprioriTermPositions.next();
 511           if (hasNext) {
 512             assertTrue(testTermPositions.next());
 513
 514             assertEquals(aprioriTermPositions.freq(), testTermPositions.freq());
 515
 516
 517             for (int termPositionIndex = 0; termPositionIndex < aprioriTermPositions.freq(); termPositionIndex++) {
 518               int aprioriPos = aprioriTermPositions.nextPosition();
 519               int testPos = testTermPositions.nextPosition();
 520
 521               if (aprioriPos != testPos) {
 522                 assertEquals(aprioriPos, testPos);
 523               }
 524
 525
 526               assertEquals(aprioriTermPositions.isPayloadAvailable(), testTermPositions.isPayloadAvailable());
 527               if (aprioriTermPositions.isPayloadAvailable()) {
 528                 assertEquals(aprioriTermPositions.getPayloadLength(), testTermPositions.getPayloadLength());
 529                 byte[] aprioriPayloads = aprioriTermPositions.getPayload(new byte[aprioriTermPositions.getPayloadLength()], 0);
 530                 byte[] testPayloads = testTermPositions.getPayload(new byte[testTermPositions.getPayloadLength()], 0);
 531                 for (int i = 0; i < aprioriPayloads.length; i++) {
 532                   assertEquals(aprioriPayloads[i], testPayloads[i]);
 533                 }
 534               }
 535
 536             }
 537           }
 538         }
 539
 540         aprioriTermPositions.close();
 541         testTermPositions.close();
 542
 543       }
 544     }
 545
 546     // compare term vectors and position vectors
 547
 548     for (int documentNumber = 0; documentNumber < aprioriReader.numDocs(); documentNumber++) {
 549
 550       if (documentNumber > 0) {
 551         assertNotNull(aprioriReader.getTermFreqVector(documentNumber, "b0"));
 552         assertNull(aprioriReader.getTermFreqVector(documentNumber, "b1"));
 553
 554         assertNotNull(testReader.getTermFreqVector(documentNumber, "b0"));
 555         assertNull(testReader.getTermFreqVector(documentNumber, "b1"));
 556
 557       }
 558
 559       TermFreqVector[] aprioriFreqVectors = aprioriReader.getTermFreqVectors(documentNumber);
 560       TermFreqVector[] testFreqVectors = testReader.getTermFreqVectors(documentNumber);
 561
 562       if (aprioriFreqVectors != null && testFreqVectors != null) {
 563
 564         Arrays.sort(aprioriFreqVectors, new Comparator<TermFreqVector>() {
 565           public int compare(TermFreqVector termFreqVector, TermFreqVector termFreqVector1) {
 566             return termFreqVector.getField().compareTo(termFreqVector1.getField());
 567           }
 568         });
 569         Arrays.sort(testFreqVectors, new Comparator<TermFreqVector>() {
 570           public int compare(TermFreqVector termFreqVector, TermFreqVector termFreqVector1) {
 571             return termFreqVector.getField().compareTo(termFreqVector1.getField());
 572           }
 573         });
 574
 575         assertEquals("document " + documentNumber + " vectors does not match", aprioriFreqVectors.length, testFreqVectors.length);
 576
 577         for (int freqVectorIndex = 0; freqVectorIndex < aprioriFreqVectors.length; freqVectorIndex++) {
 578           assertTrue(Arrays.equals(aprioriFreqVectors[freqVectorIndex].getTermFrequencies(), testFreqVectors[freqVectorIndex].getTermFrequencies()));
 579           assertTrue(Arrays.equals(aprioriFreqVectors[freqVectorIndex].getTerms(), testFreqVectors[freqVectorIndex].getTerms()));
 580
 581           if (aprioriFreqVectors[freqVectorIndex] instanceof TermPositionVector) {
 582             TermPositionVector aprioriTermPositionVector = (TermPositionVector) aprioriFreqVectors[freqVectorIndex];
 583             TermPositionVector testTermPositionVector = (TermPositionVector) testFreqVectors[freqVectorIndex];
 584
 585             for (int positionVectorIndex = 0; positionVectorIndex < aprioriFreqVectors[freqVectorIndex].getTerms().length; positionVectorIndex++)
 586             {
 587               if (aprioriTermPositionVector.getOffsets(positionVectorIndex) != null) {
 588                 assertTrue(Arrays.equals(aprioriTermPositionVector.getOffsets(positionVectorIndex), testTermPositionVector.getOffsets(positionVectorIndex)));
 589               }
 590
 591               if (aprioriTermPositionVector.getTermPositions(positionVectorIndex) != null) {
 592                 assertTrue(Arrays.equals(aprioriTermPositionVector.getTermPositions(positionVectorIndex), testTermPositionVector.getTermPositions(positionVectorIndex)));
 593               }
 594             }
 595           }
 596
 597         }
 598       }
 599
 600     }
 601
 602     aprioriTermEnum.close();
 603     testTermEnum.close();
 604
 605     aprioriReader.close();
 606     testReader.close();
 607   }
 608
 609   private static Token createToken(String term, int start, int offset)
 610   {
 611     return new Token(term, start, offset);
 612   }
 613
 614   private static Token createToken(String term, int start, int offset, String type)
 615   {
 616     return new Token(term, start, offset, type);
 617   }
 618
 619
 620 }