Example usage for org.apache.lucene.index DirectoryReader open

List of usage examples for org.apache.lucene.index DirectoryReader open

  1. HOME
  2. Java
  3. org.apache.lucene
  4. org.apache.lucene.index.*
  5. DirectoryReader
  6. open

Introduction

In this page you can find the example usage for org.apache.lucene.index DirectoryReader open.

Prototype

public static DirectoryReader open(final IndexCommit commit) throws IOException

Source Link

Document

Expert: returns an IndexReader reading the index in the given IndexCommit .

Usage

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test the plain builder.//ww w  . ja v a 2s .c o m
 *
 * @throws Exception
 */
@Test
public void testBuilder_plain() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        new Builder(reader).build();
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test with a single field visible./*  w w  w. j  av a  2 s  . co m*/
 *
 * @throws Exception
 */
@SuppressWarnings({ "ImplicitNumericConversion", "AnonymousInnerClassMayBeStatic" })
@Test
public void testBuilder_singleField() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).fields(Collections.singleton("f2")).build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() {
                Assert.assertEquals("Field count mismatch.", 1L, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertTrue("Single visible field not found.", fReader.getFields().contains("f2"));
            }

            @Override
            void testTotalTermFreq() throws IOException {
                Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", idx.docs,
                        fReader.totalTermFreq(new Term("f2", "field2")));
                Assert.assertEquals("TotalTermFreq mismatch for visible field & missing term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "foo")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden field & term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "field1")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 18L,
                        fReader.getSumTotalTermFreq("f2"));
                for (final String f : idx.flds) {
                    if (!"f2".equals(f)) {
                        Assert.assertEquals("SumTotalTermFreq mismatch for hidden field.", 0L,
                                fReader.getSumTotalTermFreq(f));
                    }
                }
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch for visible field.", idx.docs,
                        fReader.getDocCount("f2"));
                // check visibility of all docs without visible fields
                for (final String f : idx.flds) {
                    if (!"f2".equals(f)) {
                        Assert.assertEquals("Document visible with hidden field.", 0L, fReader.getDocCount(f));
                    }
                }
            }

            @Override
            void testDocFreq() throws Exception {
                Assert.assertEquals("Missing term from all documents.", idx.docs,
                        fReader.docFreq(new Term("f2", "field2")));
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible field.", 18L, fReader.getSumDocFreq("f2"));
                for (final String f : idx.flds) {
                    if (!"f2".equals(f)) {
                        Assert.assertEquals("SumDocFreq has result for hidden field.", 0L,
                                fReader.getSumDocFreq(f));
                    }
                }
            }

            @Override
            void testTermVectors() throws Exception {
                for (int i = 0; i < idx.docs - 1; i++) {
                    final Fields f = fReader.getTermVectors(i);
                    Assert.assertEquals("Too much fields retrieved from TermVector.", 1L, f.size());
                    f.forEach(fld -> Assert.assertTrue("Hidden field found.", "f2".equals(fld)));
                }
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", idx.docs, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", idx.docs, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test with a single field negated.//from w  w  w . java2 s  .c  o  m
 *
 * @throws Exception
 */
@SuppressWarnings({ "ImplicitNumericConversion", "AnonymousInnerClassMayBeStatic" })
@Test
public void testBuilder_singleField_negate() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).fields(Collections.singleton("f2"), true) // f2 is hidden
                .build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", idx.flds.size() - 1, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertFalse("Excluded field found.", fReader.getFields().contains("f2"));
            }

            @Override
            void testTotalTermFreq() throws Exception {
                // visible fields
                Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", idx.docs,
                        fReader.totalTermFreq(new Term("f1", "field1")));
                Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", idx.docs,
                        fReader.totalTermFreq(new Term("f3", "field3")));
                Assert.assertEquals("TotalTermFreq mismatch for visible field & missing term.", 0L,
                        fReader.totalTermFreq(new Term("f3", "foo")));
                // hidden fields
                Assert.assertEquals("TotalTermFreq mismatch for hidden field & term.", 0L,
                        fReader.totalTermFreq(new Term("f2", "field2")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 18L,
                        fReader.getSumTotalTermFreq("f1"));
                Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 18L,
                        fReader.getSumTotalTermFreq("f3"));
                Assert.assertEquals("SumTotalTermFreq mismatch for hidden field.", 0L,
                        fReader.getSumTotalTermFreq("f2"));
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch for visible field.", idx.docs,
                        fReader.getDocCount("f1"));
                Assert.assertEquals("Doc count mismatch for visible field.", idx.docs,
                        fReader.getDocCount("f3"));
                // check visibility of all docs without visible fields
                Assert.assertEquals("Document visible with hidden field.", 0L, fReader.getDocCount("f2"));
            }

            @Override
            void testDocFreq() throws Exception {
                Assert.assertEquals("Missing term from all documents.", idx.docs,
                        fReader.docFreq(new Term("f1", "field1")));
                Assert.assertEquals("Found term from hidden documents.", 0L,
                        fReader.docFreq(new Term("f2", "field2")));
                Assert.assertEquals("Missing term from all documents.", idx.docs,
                        fReader.docFreq(new Term("f3", "field3")));
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible field.", 18L, fReader.getSumDocFreq("f1"));
                Assert.assertEquals("SumDocFreq mismatch for visible field.", 18L, fReader.getSumDocFreq("f3"));
                Assert.assertEquals("SumDocFreq has result for hidden field.", 0L, fReader.getSumDocFreq("f2"));
            }

            @Override
            void testTermVectors() throws Exception {
                for (int i = 0; i < idx.docs - 1; i++) {
                    final Fields f = fReader.getTermVectors(i);
                    Assert.assertEquals("Too much fields retrieved from TermVector.", 2L, f.size());
                    f.forEach(fld -> Assert.assertFalse("Hidden field found.", "f2".equals(fld)));
                }
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", idx.docs, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", idx.docs, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test with all fields negated (-> no field visible).
 *
 * @throws Exception/* w ww  .  ja va 2s.c  om*/
 */
@SuppressWarnings({ "ImplicitNumericConversion", "AnonymousInnerClassMayBeStatic" })
@Test
public void testBuilder_allFields_negate() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).fields(idx.flds, true).build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", 0, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                // NOP, no fields
            }

            @Override
            void testTotalTermFreq() throws Exception {
                // hidden fields
                Assert.assertEquals("TotalTermFreq mismatch for hidden field & term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "field1")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden field & term.", 0L,
                        fReader.totalTermFreq(new Term("f2", "field2")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden field & term.", 0L,
                        fReader.totalTermFreq(new Term("f3", "field3")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for hidden field.", 0L,
                        fReader.getSumTotalTermFreq("f1"));
                Assert.assertEquals("SumTotalTermFreq mismatch for hidden field.", 0L,
                        fReader.getSumTotalTermFreq("f2"));
                Assert.assertEquals("SumTotalTermFreq mismatch for hidden field.", 0L,
                        fReader.getSumTotalTermFreq("f3"));
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch for hidden field.", 0L, fReader.getDocCount("f1"));
                Assert.assertEquals("Doc count mismatch for hidden field.", 0L, fReader.getDocCount("f2"));
                Assert.assertEquals("Doc count mismatch for hidden field.", 0L, fReader.getDocCount("f3"));
            }

            @Override
            void testDocFreq() throws Exception {
                Assert.assertEquals("Found term from hidden documents.", 0L,
                        fReader.docFreq(new Term("f1", "field1")));
                Assert.assertEquals("Found term from hidden documents.", 0L,
                        fReader.docFreq(new Term("f2", "field2")));
                Assert.assertEquals("Found term from hidden documents.", 0L,
                        fReader.docFreq(new Term("f3", "field3")));
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for hidden field.", 0L, fReader.getSumDocFreq("f1"));
                Assert.assertEquals("SumDocFreq mismatch for hidden field.", 0L, fReader.getSumDocFreq("f2"));
                Assert.assertEquals("SumDocFreq mismatch for hidden field.", 0L, fReader.getSumDocFreq("f3"));
            }

            @Override
            void testTermVectors() throws Exception {
                // NOP, no documents
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", 0L, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", 1L, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test with all fields enabled.//from   ww w.  ja  v a  2 s  .  com
 *
 * @throws Exception
 */
@SuppressWarnings({ "ImplicitNumericConversion", "AnonymousInnerClassMayBeStatic" })
@Test
public void testBuilder_allFields() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).fields(idx.flds).build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", idx.flds.size(), fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertTrue("Visible field not found.", fReader.getFields().containsAll(idx.flds));
            }

            @SuppressWarnings("ObjectAllocationInLoop")
            @Override
            void testTotalTermFreq() throws Exception {
                for (final String f : idx.flds) {
                    Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", idx.docs,
                            fReader.totalTermFreq(new Term(f, "value")));
                }
                Assert.assertEquals("TotalTermFreq mismatch for visible field & missing term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "foo")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                for (final String f : idx.flds) {
                    Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 18L,
                            fReader.getSumTotalTermFreq(f));
                }
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("testDocCount: " + "Doc count mismatch for visible field.", idx.docs,
                        fReader.getDocCount("f2"));
            }

            @SuppressWarnings("ObjectAllocationInLoop")
            @Override
            void testDocFreq() throws Exception {
                for (final String f : idx.flds) {
                    Assert.assertEquals("testDocFreq: " + "Missing term from all documents.", idx.docs,
                            fReader.docFreq(new Term(f, "value")));
                }
            }

            @Override
            void testSumDocFreq() throws Exception {
                for (final String f : idx.flds) {
                    Assert.assertEquals("testSumDocFreq: " + "Missing term from all documents.", 18L,
                            fReader.getSumDocFreq(f));
                }
            }

            @Override
            void testTermVectors() throws Exception {
                for (int i = 0; i < idx.docs - 1; i++) {
                    final Fields f = fReader.getTermVectors(i);
                    Assert.assertEquals("testTermVectors: " + "Too much fields retrieved from TermVector.",
                            idx.flds.size(), f.size());
                }
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", idx.docs, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", idx.docs, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test specifying multiple fields to include.
 *
 * @throws Exception//from   w w w.  j av  a 2 s .c  om
 */
@SuppressWarnings({ "ImplicitNumericConversion", "AnonymousInnerClassMayBeStatic" })
@Test
public void testBuilder_multiFields() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);

        final FilteredDirectoryReader fReader = new Builder(reader).fields(Arrays.asList("f1", "f3")).build();

        Assert.assertEquals("Field count mismatch.", 2, fReader.getFields().size());

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", 2L, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertFalse("Hidden field found.", fReader.getFields().contains("f2"));
            }

            @Override
            void testTotalTermFreq() throws Exception {
                Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", idx.docs,
                        fReader.totalTermFreq(new Term("f1", "field1")));
                Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", idx.docs,
                        fReader.totalTermFreq(new Term("f3", "field3")));
                Assert.assertEquals("TotalTermFreq mismatch for visible field & missing term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "foo")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden field & term.", 0L,
                        fReader.totalTermFreq(new Term("f2", "field2")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 18L,
                        fReader.getSumTotalTermFreq("f1"));
                Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 18L,
                        fReader.getSumTotalTermFreq("f3"));

                Assert.assertEquals("SumTotalTermFreq mismatch for hidden field.", 0L,
                        fReader.getSumTotalTermFreq("f2"));
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch for visible field.", idx.docs,
                        fReader.getDocCount("f1"));
                Assert.assertEquals("Doc count mismatch for visible field.", idx.docs,
                        fReader.getDocCount("f3"));

                Assert.assertEquals("Document visible with hidden field.", 0L, fReader.getDocCount("f2"));
            }

            @Override
            void testDocFreq() throws Exception {
                Assert.assertEquals("Missing term from all documents.", idx.docs,
                        fReader.docFreq(new Term("f1", "field1")));
                Assert.assertEquals("Missing term from all documents.", idx.docs,
                        fReader.docFreq(new Term("f3", "field3")));

                Assert.assertEquals("Found term from hidden documents.", 0L,
                        fReader.docFreq(new Term("f2", "field2")));
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible field.", 18L, fReader.getSumDocFreq("f1"));
                Assert.assertEquals("SumDocFreq mismatch for visible field.", 18L, fReader.getSumDocFreq("f3"));

                Assert.assertEquals("SumDocFreq has result for hidden field.", 0L, fReader.getSumDocFreq("f2"));
            }

            @Override
            void testTermVectors() throws Exception {
                for (int i = 0; i < idx.docs - 1; i++) {
                    final Fields f = fReader.getTermVectors(i);
                    Assert.assertEquals("Too much fields retrieved from TermVector.", 2L, f.size());
                    f.forEach(fld -> Assert.assertFalse("Hidden field found.", "f2".equals(fld)));
                }
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", idx.docs, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", idx.docs, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test negated field definition with multiple fields.
 *
 * @throws Exception//from  w w w. java  2s . c  o m
 */
@SuppressWarnings({ "ImplicitNumericConversion", "AnonymousInnerClassMayBeStatic" })
@Test
public void testBuilder_multiFields_negate() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.ALL_FIELDS)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);

        final FilteredDirectoryReader fReader = new Builder(reader).fields(Arrays.asList("f1", "f3"), true)
                .build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() {
                Assert.assertEquals("Field count mismatch.", 1L, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertTrue("Single visible field not found.", fReader.getFields().contains("f2"));
                Assert.assertFalse("Excluded field found.", fReader.getFields().contains("f1"));
                Assert.assertFalse("Excluded field found.", fReader.getFields().contains("f3"));
            }

            @Override
            void testTotalTermFreq() throws IOException {
                Assert.assertEquals("TotalTermFreq mismatch for visible field & term.", idx.docs,
                        fReader.totalTermFreq(new Term("f2", "field2")));
                Assert.assertEquals("TotalTermFreq mismatch for visible field & missing term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "foo")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden field & term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "field1")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible field.", 18L,
                        fReader.getSumTotalTermFreq("f2"));
                for (final String f : idx.flds) {
                    if (!"f2".equals(f)) {
                        Assert.assertEquals("SumTotalTermFreq mismatch for hidden field.", 0L,
                                fReader.getSumTotalTermFreq(f));
                    }
                }
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch for visible field.", idx.docs,
                        fReader.getDocCount("f2"));
                // check visibility of all docs without visible fields
                for (final String f : idx.flds) {
                    if (!"f2".equals(f)) {
                        Assert.assertEquals("Document visible with hidden field.", 0L, fReader.getDocCount(f));
                    }
                }
            }

            @Override
            void testDocFreq() throws Exception {
                Assert.assertEquals("Missing term from all documents.", idx.docs,
                        fReader.docFreq(new Term("f2", "field2")));
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible field.", 18L, fReader.getSumDocFreq("f2"));
                for (final String f : idx.flds) {
                    if (!"f2".equals(f)) {
                        Assert.assertEquals("SumDocFreq has result for hidden field.", 0L,
                                fReader.getSumDocFreq(f));
                    }
                }
            }

            @Override
            void testTermVectors() throws Exception {
                for (int i = 0; i < idx.docs - 1; i++) {
                    final Fields f = fReader.getTermVectors(i);
                    Assert.assertEquals("Too much fields retrieved from TermVector.", 1L, f.size());
                    f.forEach(fld -> Assert.assertTrue("Hidden field found.", "f2".equals(fld)));
                }
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", idx.docs, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", idx.docs, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test basic {@link TermFilter} usage./*from  w  ww.j  av a 2s .  c  o m*/
 *
 * @throws Exception
 */
@SuppressWarnings({ "AnonymousInnerClassMayBeStatic", "ImplicitNumericConversion" })
@Test
public void testBuilder_termFilter() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final String skipTerm = "first";
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).termFilter(new TermFilter() {
            @Override
            public boolean isAccepted(@Nullable final TermsEnum termsEnum, @NotNull final BytesRef term) {
                return !skipTerm.equals(term.utf8ToString());
            }
        }).build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", idx.flds.size(), fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertTrue("Visible field not found.", fReader.getFields().containsAll(idx.flds));
            }

            @Override
            void testTotalTermFreq() throws Exception {
                Assert.assertEquals("TotalTermFreq mismatch for visible term.", idx.docs,
                        fReader.totalTermFreq(new Term("f1", "field")));
                Assert.assertEquals("TotalTermFreq mismatch for missing term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "foo")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "first")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible term.", 14L,
                        fReader.getSumTotalTermFreq("f1"));
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch.", idx.docs, fReader.getDocCount("f1"));
            }

            @SuppressWarnings("ObjectAllocationInLoop")
            @Override
            void testDocFreq() throws Exception {
                for (final String f : idx.flds) {
                    Assert.assertEquals("Missing term from all documents.", idx.docs,
                            fReader.docFreq(new Term(f, "value")));
                    Assert.assertEquals("Found hidden term.", 0L, fReader.docFreq(new Term(f, "first")));
                }
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible term.", 14L, fReader.getSumDocFreq("f1"));
            }

            @Override
            void testTermVectors() throws Exception {
                final BytesRef term = new BytesRef("first");
                for (int i = 0; i < idx.docs - 1; i++) {
                    final Fields f = fReader.getTermVectors(i);
                    Assert.assertEquals("Too much fields retrieved from TermVector.", 1L, f.size());
                    final TermsEnum te = f.terms("f1").iterator(null);
                    Assert.assertFalse("Hidden term found.", te.seekExact(term));
                }
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", idx.docs, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", idx.docs, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Filter out all terms.//from w  w w . j av  a  2s  .c  om
 *
 * @throws Exception
 */
@SuppressWarnings({ "AnonymousInnerClassMayBeStatic", "ImplicitNumericConversion" })
@Test
public void testBuilder_termFilter_allTerms() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).termFilter(new TermFilter() {
            @Override
            public boolean isAccepted(@Nullable final TermsEnum termsEnum, @NotNull final BytesRef term) {
                return false; // skip all terms
            }
        }).build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", 0L, fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertTrue("Field found.", fReader.getFields().isEmpty());
            }

            @Override
            void testTotalTermFreq() throws Exception {
                Assert.assertEquals("TotalTermFreq mismatch for hidden term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "field")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for hidden term.", 0L,
                        fReader.getSumTotalTermFreq("f1"));
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch.", 0L, fReader.getDocCount("f1"));
            }

            @SuppressWarnings("ObjectAllocationInLoop")
            @Override
            void testDocFreq() throws Exception {
                for (final String f : idx.flds) {
                    Assert.assertEquals("Missing term from all documents.", 0L,
                            fReader.docFreq(new Term(f, "value")));
                    Assert.assertEquals("Found hidden term.", 0L, fReader.docFreq(new Term(f, "first")));
                }
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible term.", 0L, fReader.getSumDocFreq("f1"));
            }

            @Override
            void testTermVectors() throws Exception {
                for (int i = 0; i < idx.docs - 1; i++) {
                    final Fields f = fReader.getTermVectors(i);
                    if (f != null) {
                        final Terms t = f.terms("f1");
                        if (t != null) {
                            final TermsEnum te = t.iterator(null);
                            Assert.assertNull("Term found. Expected none.", te.next());
                        }
                    }
                }
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", idx.docs, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", idx.docs, fReader.maxDoc());
            }
        };
    }
}

From source file:de.unihildesheim.iw.lucene.index.FilteredDirectoryReaderTest.java

License:Open Source License

/**
 * Test basic {@link Filter} usage.//w w w. j  av  a 2 s . c  o m
 *
 * @throws Exception
 */
@SuppressWarnings({ "AnonymousInnerClassMayBeStatic", "ImplicitNumericConversion" })
@Test
public void testBuilder_filter() throws Exception {
    try (TestMemIndex idx = new TestMemIndex(Index.PLAIN)) {
        final Query q = new TermQuery(new Term("f1", "first"));
        final Filter f = new QueryWrapperFilter(q);
        final DirectoryReader reader = DirectoryReader.open(idx.dir);
        final FilteredDirectoryReader fReader = new Builder(reader).queryFilter(f).build();

        new LeafReaderInstanceTest() {

            @Override
            void testHasDeletions() throws Exception {
                Assert.assertFalse("Reader has deletions.", fReader.hasDeletions());
            }

            @Override
            void testFieldCount() throws Exception {
                Assert.assertEquals("Field count mismatch.", idx.flds.size(), fReader.getFields().size());
            }

            @Override
            void testFieldNames() throws Exception {
                Assert.assertTrue("Visible field not found.", fReader.getFields().containsAll(idx.flds));
            }

            @Override
            void testTotalTermFreq() throws Exception {
                Assert.assertEquals("TotalTermFreq mismatch for visible term.", 1L,
                        fReader.totalTermFreq(new Term("f1", "field")));
                Assert.assertEquals("TotalTermFreq mismatch for missing term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "foo")));
                Assert.assertEquals("TotalTermFreq mismatch for query term.", 1L,
                        fReader.totalTermFreq(new Term("f1", "first")));
                Assert.assertEquals("TotalTermFreq mismatch for hidden term.", 0L,
                        fReader.totalTermFreq(new Term("f1", "second")));
            }

            @Override
            void testSumTotalTermFreq() throws Exception {
                Assert.assertEquals("SumTotalTermFreq mismatch for visible terms.", 3L,
                        fReader.getSumTotalTermFreq("f1"));
            }

            @Override
            void testDocCount() throws Exception {
                Assert.assertEquals("Doc count mismatch.", 1L, fReader.getDocCount("f1"));
            }

            @SuppressWarnings("ObjectAllocationInLoop")
            @Override
            void testDocFreq() throws Exception {
                for (final String fld : idx.flds) {
                    Assert.assertEquals("Missing term from all documents.", 1L,
                            fReader.docFreq(new Term(fld, "value")));
                    Assert.assertEquals("Found hidden term.", 0L, fReader.docFreq(new Term(fld, "second")));
                }
            }

            @Override
            void testSumDocFreq() throws Exception {
                Assert.assertEquals("SumDocFreq mismatch for visible term.", 3L, fReader.getSumDocFreq("f1"));
            }

            @Override
            void testTermVectors() throws Exception {
                final Fields fld = fReader.getTermVectors(0);
                Assert.assertEquals("Too much fields retrieved from TermVector.", 1L, fld.size());
            }

            @Override
            void testNumDocs() throws Exception {
                Assert.assertEquals("NumDocs mismatch.", 1L, fReader.numDocs());
            }

            @Override
            void testMaxDoc() throws Exception {
                Assert.assertEquals("MaxDoc mismatch.", 1L, fReader.maxDoc());
            }
        };
    }
}