public void assertFieldInfosEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException { FieldInfos leftInfos = MultiFields.getMergedFieldInfos(leftReader); FieldInfos rightInfos = MultiFields.getMergedFieldInfos(rightReader); // TODO: would be great to verify more than just the names of the fields! TreeSet<String> left = new TreeSet<>(); TreeSet<String> right = new TreeSet<>(); for (FieldInfo fi : leftInfos) { left.add(fi.name); } for (FieldInfo fi : rightInfos) { right.add(fi.name); } assertEquals(info, left, right); }
/** * checks that two stored fields are equivalent */ public void assertStoredFieldEquals(String info, IndexableField leftField, IndexableField rightField) { assertEquals(info, leftField.name(), rightField.name()); assertEquals(info, leftField.binaryValue(), rightField.binaryValue()); assertEquals(info, leftField.stringValue(), rightField.stringValue()); assertEquals(info, leftField.numericValue(), rightField.numericValue()); // TODO: should we check the FT at all? }
/** * checks that reader-level statistics are the same */ public void assertReaderStatisticsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException { // Somewhat redundant: we never delete docs assertEquals(info, leftReader.maxDoc(), rightReader.maxDoc()); assertEquals(info, leftReader.numDocs(), rightReader.numDocs()); assertEquals(info, leftReader.numDeletedDocs(), rightReader.numDeletedDocs()); assertEquals(info, leftReader.hasDeletions(), rightReader.hasDeletions()); }
/** * checks docs + freqs, sequentially */ public void assertDocsEnumEquals(String info, PostingsEnum leftDocs, PostingsEnum rightDocs, boolean hasFreqs) throws IOException { if (leftDocs == null) { assertNull(rightDocs); return; } assertEquals(info, -1, leftDocs.docID()); assertEquals(info, -1, rightDocs.docID()); int docid; while ((docid = leftDocs.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) { assertEquals(info, docid, rightDocs.nextDoc()); if (hasFreqs) { assertEquals(info, leftDocs.freq(), rightDocs.freq()); } } assertEquals(info, DocIdSetIterator.NO_MORE_DOCS, rightDocs.nextDoc()); }
/** * checks docs + freqs + positions + payloads, sequentially */ public void assertDocsAndPositionsEnumEquals(String info, PostingsEnum leftDocs, PostingsEnum rightDocs) throws IOException { assertNotNull(leftDocs); assertNotNull(rightDocs); assertEquals(info, -1, leftDocs.docID()); assertEquals(info, -1, rightDocs.docID()); int docid; while ((docid = leftDocs.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) { assertEquals(info, docid, rightDocs.nextDoc()); int freq = leftDocs.freq(); assertEquals(info, freq, rightDocs.freq()); for (int i = 0; i < freq; i++) { assertEquals(info, leftDocs.nextPosition(), rightDocs.nextPosition()); assertEquals(info, leftDocs.getPayload(), rightDocs.getPayload()); assertEquals(info, leftDocs.startOffset(), rightDocs.startOffset()); assertEquals(info, leftDocs.endOffset(), rightDocs.endOffset()); } } assertEquals(info, DocIdSetIterator.NO_MORE_DOCS, rightDocs.nextDoc()); }
/** * checks term-level statistics */ public void assertTermStatsEquals(String info, TermsEnum leftTermsEnum, TermsEnum rightTermsEnum) throws IOException { assertEquals(info, leftTermsEnum.docFreq(), rightTermsEnum.docFreq()); if (leftTermsEnum.totalTermFreq() != -1 && rightTermsEnum.totalTermFreq() != -1) { assertEquals(info, leftTermsEnum.totalTermFreq(), rightTermsEnum.totalTermFreq()); } }
public void assertDocValuesEquals(String info, int num, NumericDocValues leftDocValues, NumericDocValues rightDocValues) throws IOException { assertNotNull(info, leftDocValues); assertNotNull(info, rightDocValues); while (true) { int leftDocID = leftDocValues.nextDoc(); int rightDocID = rightDocValues.nextDoc(); assertEquals(leftDocID, rightDocID); if (leftDocID == NO_MORE_DOCS) { return; } assertEquals(leftDocValues.longValue(), rightDocValues.longValue()); } }
/** * checks that top-level statistics on Fields are the same */ public void assertFieldStatisticsEquals(String info, Fields leftFields, Fields rightFields) throws IOException { if (leftFields.size() != -1 && rightFields.size() != -1) { assertEquals(info, leftFields.size(), rightFields.size()); } }
assertEquals(info, docid, rightDocs.nextDoc()); } else { assertEquals(info, docid, rightDocs.advance(skip)); assertEquals(info, leftDocs.freq(), rightDocs.freq());
assertEquals(info, docid, rightDocs.nextDoc()); } else { assertEquals(info, docid, rightDocs.advance(skip)); assertEquals(info, freq, rightDocs.freq()); for (int i = 0; i < freq; i++) { assertEquals(info, leftDocs.nextPosition(), rightDocs.nextPosition()); assertEquals(info, leftDocs.getPayload(), rightDocs.getPayload());
/** * Fields api equivalency */ public void assertFieldsEquals(String info, IndexReader leftReader, Fields leftFields, Fields rightFields, boolean deep) throws IOException { // Fields could be null if there are no postings, // but then it must be null for both if (leftFields == null || rightFields == null) { assertNull(info, leftFields); assertNull(info, rightFields); return; } assertFieldStatisticsEquals(info, leftFields, rightFields); Iterator<String> leftEnum = leftFields.iterator(); Iterator<String> rightEnum = rightFields.iterator(); while (leftEnum.hasNext()) { String field = leftEnum.next(); assertEquals(info, field, rightEnum.next()); assertTermsEquals(info, leftReader, leftFields.terms(field), rightFields.terms(field), deep); } assertFalse(rightEnum.hasNext()); }
public void assertPointsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException { FieldInfos fieldInfos1 = MultiFields.getMergedFieldInfos(leftReader); FieldInfos fieldInfos2 = MultiFields.getMergedFieldInfos(rightReader); for(FieldInfo fieldInfo1 : fieldInfos1) { if (fieldInfo1.getPointDimensionCount() != 0) { FieldInfo fieldInfo2 = fieldInfos2.fieldInfo(fieldInfo1.name); // same dimension count? assertEquals(info, fieldInfo2.getPointDimensionCount(), fieldInfo2.getPointDimensionCount()); // same bytes per dimension? assertEquals(info, fieldInfo2.getPointNumBytes(), fieldInfo2.getPointNumBytes()); assertEquals(info + " field=" + fieldInfo1.name, uninvert(fieldInfo1.name, leftReader), uninvert(fieldInfo1.name, rightReader)); } } // make sure FieldInfos2 doesn't have any point fields that FieldInfo1 didn't have for(FieldInfo fieldInfo2 : fieldInfos2) { if (fieldInfo2.getPointDimensionCount() != 0) { FieldInfo fieldInfo1 = fieldInfos1.fieldInfo(fieldInfo2.name); // same dimension count? assertEquals(info, fieldInfo2.getPointDimensionCount(), fieldInfo1.getPointDimensionCount()); // same bytes per dimension? assertEquals(info, fieldInfo2.getPointNumBytes(), fieldInfo1.getPointNumBytes()); // we don't need to uninvert and compare here ... we did that in the first loop above } } }
/** * checks collection-level statistics on Terms */ public void assertTermsStatisticsEquals(String info, Terms leftTerms, Terms rightTerms) throws IOException { if (leftTerms.getDocCount() != -1 && rightTerms.getDocCount() != -1) { assertEquals(info, leftTerms.getDocCount(), rightTerms.getDocCount()); } if (leftTerms.getSumDocFreq() != -1 && rightTerms.getSumDocFreq() != -1) { assertEquals(info, leftTerms.getSumDocFreq(), rightTerms.getSumDocFreq()); } if (leftTerms.getSumTotalTermFreq() != -1 && rightTerms.getSumTotalTermFreq() != -1) { assertEquals(info, leftTerms.getSumTotalTermFreq(), rightTerms.getSumTotalTermFreq()); } if (leftTerms.size() != -1 && rightTerms.size() != -1) { assertEquals(info, leftTerms.size(), rightTerms.size()); } }
assertEquals(info, leftEnum.seekExact(b), rightEnum.seekExact(b)); } else { SeekStatus leftStatus = leftEnum.seekCeil(b); SeekStatus rightStatus = rightEnum.seekCeil(b); assertEquals(info, leftStatus, rightStatus); if (leftStatus != SeekStatus.END) { assertEquals(info, leftEnum.term(), rightEnum.term()); assertTermStatsEquals(info, leftEnum, rightEnum);
public void assertDeletedDocsEquals(String info, IndexReader leftReader, IndexReader rightReader) throws IOException { assert leftReader.numDeletedDocs() == rightReader.numDeletedDocs(); Bits leftBits = MultiFields.getLiveDocs(leftReader); Bits rightBits = MultiFields.getLiveDocs(rightReader); if (leftBits == null || rightBits == null) { assertNull(info, leftBits); assertNull(info, rightBits); return; } assert leftReader.maxDoc() == rightReader.maxDoc(); assertEquals(info, leftBits.length(), rightBits.length()); for (int i = 0; i < leftReader.maxDoc(); i++) { assertEquals(info, leftBits.get(i), rightBits.get(i)); } }
Set<String> leftFields = getDVFields(leftReader); Set<String> rightFields = getDVFields(rightReader); assertEquals(info, leftFields, rightFields); while (true) { int docID = leftValues.nextDoc(); assertEquals(docID, rightValues.nextDoc()); if (docID == NO_MORE_DOCS) { break; assertEquals(leftValues.binaryValue(), rightValues.binaryValue()); assertEquals(info, leftValues.getValueCount(), rightValues.getValueCount()); assertEquals(info, left, right); assertEquals(docID, leftValues.nextDoc()); assertEquals(docID, rightValues.nextDoc()); final BytesRef left = BytesRef.deepCopyOf(leftValues.binaryValue()); final BytesRef right = rightValues.binaryValue(); assertEquals(info, left, right); assertEquals(info, leftValues.getValueCount(), rightValues.getValueCount()); assertEquals(info, left, right); assertEquals(docID, rightValues.nextDoc()); if (docID == NO_MORE_DOCS) { break;
assertEquals("hasOffsets", leftTerms.hasOffsets(), rightTerms.hasOffsets()); assertEquals("hasPositions", leftTerms.hasPositions(), rightTerms.hasPositions()); assertEquals("hasPayloads", leftTerms.hasPayloads(), rightTerms.hasPayloads());
assertEquals(info, term, rightTermsEnum.next()); assertTermStatsEquals(info, leftTermsEnum, rightTermsEnum); if (deep) {