X-Git-Url: https://git.mdrn.pl/pylucene.git/blobdiff_plain/a2e61f0c04805cfcb8706176758d1283c7e3a55c..aaeed5504b982cf3545252ab528713250aa33eed:/lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/index/TestIndexWriterConfig.java?ds=sidebyside diff --git a/lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/index/TestIndexWriterConfig.java b/lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/index/TestIndexWriterConfig.java new file mode 100644 index 0000000..3412b3d --- /dev/null +++ b/lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/index/TestIndexWriterConfig.java @@ -0,0 +1,309 @@ +package org.apache.lucene.index; + +/** + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import java.io.IOException; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.util.HashSet; +import java.util.Set; + +import org.apache.lucene.analysis.MockAnalyzer; +import org.apache.lucene.analysis.WhitespaceAnalyzer; +import org.apache.lucene.index.DocumentsWriter.IndexingChain; +import org.apache.lucene.index.IndexWriter.IndexReaderWarmer; +import org.apache.lucene.index.IndexWriterConfig.OpenMode; +import org.apache.lucene.search.DefaultSimilarity; +import org.apache.lucene.search.Similarity; +import org.apache.lucene.store.Directory; +import org.apache.lucene.util.LuceneTestCase; +import org.junit.Test; + +public class TestIndexWriterConfig extends LuceneTestCase { + + private static final class MySimilarity extends DefaultSimilarity { + // Does not implement anything - used only for type checking on IndexWriterConfig. + } + + private static final class MyIndexingChain extends IndexingChain { + // Does not implement anything - used only for type checking on IndexWriterConfig. + + @Override + DocConsumer getChain(DocumentsWriter documentsWriter) { + return null; + } + + } + + private static final class MyWarmer extends IndexReaderWarmer { + // Does not implement anything - used only for type checking on IndexWriterConfig. + + @Override + public void warm(IndexReader reader) throws IOException { + } + + } + + @Test + public void testDefaults() throws Exception { + IndexWriterConfig conf = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)); + assertEquals(MockAnalyzer.class, conf.getAnalyzer().getClass()); + assertNull(conf.getIndexCommit()); + assertEquals(KeepOnlyLastCommitDeletionPolicy.class, conf.getIndexDeletionPolicy().getClass()); + assertEquals(ConcurrentMergeScheduler.class, conf.getMergeScheduler().getClass()); + assertEquals(OpenMode.CREATE_OR_APPEND, conf.getOpenMode()); + assertTrue(Similarity.getDefault() == conf.getSimilarity()); + assertEquals(IndexWriterConfig.DEFAULT_TERM_INDEX_INTERVAL, conf.getTermIndexInterval()); + assertEquals(IndexWriterConfig.getDefaultWriteLockTimeout(), conf.getWriteLockTimeout()); + assertEquals(IndexWriterConfig.WRITE_LOCK_TIMEOUT, IndexWriterConfig.getDefaultWriteLockTimeout()); + assertEquals(IndexWriterConfig.DEFAULT_MAX_BUFFERED_DELETE_TERMS, conf.getMaxBufferedDeleteTerms()); + assertEquals(IndexWriterConfig.DEFAULT_RAM_BUFFER_SIZE_MB, conf.getRAMBufferSizeMB(), 0.0); + assertEquals(IndexWriterConfig.DEFAULT_MAX_BUFFERED_DOCS, conf.getMaxBufferedDocs()); + assertEquals(IndexWriterConfig.DEFAULT_READER_POOLING, conf.getReaderPooling()); + assertTrue(DocumentsWriter.defaultIndexingChain == conf.getIndexingChain()); + assertNull(conf.getMergedSegmentWarmer()); + assertEquals(IndexWriterConfig.DEFAULT_MAX_THREAD_STATES, conf.getMaxThreadStates()); + assertEquals(IndexWriterConfig.DEFAULT_READER_TERMS_INDEX_DIVISOR, conf.getReaderTermsIndexDivisor()); + assertEquals(TieredMergePolicy.class, conf.getMergePolicy().getClass()); + + // Sanity check - validate that all getters are covered. + Set getters = new HashSet(); + getters.add("getAnalyzer"); + getters.add("getIndexCommit"); + getters.add("getIndexDeletionPolicy"); + getters.add("getMergeScheduler"); + getters.add("getOpenMode"); + getters.add("getSimilarity"); + getters.add("getTermIndexInterval"); + getters.add("getWriteLockTimeout"); + getters.add("getDefaultWriteLockTimeout"); + getters.add("getMaxBufferedDeleteTerms"); + getters.add("getRAMBufferSizeMB"); + getters.add("getMaxBufferedDocs"); + getters.add("getIndexingChain"); + getters.add("getMergedSegmentWarmer"); + getters.add("getMergePolicy"); + getters.add("getMaxThreadStates"); + getters.add("getReaderPooling"); + getters.add("getReaderTermsIndexDivisor"); + for (Method m : IndexWriterConfig.class.getDeclaredMethods()) { + if (m.getDeclaringClass() == IndexWriterConfig.class && m.getName().startsWith("get")) { + assertTrue("method " + m.getName() + " is not tested for defaults", getters.contains(m.getName())); + } + } + } + + @Test + public void testSettersChaining() throws Exception { + // Ensures that every setter returns IndexWriterConfig to enable easy + // chaining. + for (Method m : IndexWriterConfig.class.getDeclaredMethods()) { + if (m.getDeclaringClass() == IndexWriterConfig.class + && m.getName().startsWith("set") + && !Modifier.isStatic(m.getModifiers())) { + assertEquals("method " + m.getName() + " does not return IndexWriterConfig", + IndexWriterConfig.class, m.getReturnType()); + } + } + } + + @Test + public void testConstants() throws Exception { + // Tests that the values of the constants does not change + assertEquals(1000, IndexWriterConfig.WRITE_LOCK_TIMEOUT); + assertEquals(128, IndexWriterConfig.DEFAULT_TERM_INDEX_INTERVAL); + assertEquals(-1, IndexWriterConfig.DISABLE_AUTO_FLUSH); + assertEquals(IndexWriterConfig.DISABLE_AUTO_FLUSH, IndexWriterConfig.DEFAULT_MAX_BUFFERED_DELETE_TERMS); + assertEquals(IndexWriterConfig.DISABLE_AUTO_FLUSH, IndexWriterConfig.DEFAULT_MAX_BUFFERED_DOCS); + assertEquals(16.0, IndexWriterConfig.DEFAULT_RAM_BUFFER_SIZE_MB, 0.0); + assertEquals(false, IndexWriterConfig.DEFAULT_READER_POOLING); + assertEquals(8, IndexWriterConfig.DEFAULT_MAX_THREAD_STATES); + assertEquals(IndexReader.DEFAULT_TERMS_INDEX_DIVISOR, IndexWriterConfig.DEFAULT_READER_TERMS_INDEX_DIVISOR); + } + + @Test + public void testToString() throws Exception { + String str = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)).toString(); + for (Field f : IndexWriterConfig.class.getDeclaredFields()) { + int modifiers = f.getModifiers(); + if (Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers)) { + // Skip static final fields, they are only constants + continue; + } else if ("indexingChain".equals(f.getName())) { + // indexingChain is a package-private setting and thus is not output by + // toString. + continue; + } + assertTrue(f.getName() + " not found in toString", str.indexOf(f.getName()) != -1); + } + } + + @Test + public void testClone() throws Exception { + IndexWriterConfig conf = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)); + IndexWriterConfig clone = (IndexWriterConfig) conf.clone(); + + // Clone is shallow since not all parameters are cloneable. + assertTrue(conf.getIndexDeletionPolicy() == clone.getIndexDeletionPolicy()); + + conf.setMergeScheduler(new SerialMergeScheduler()); + assertEquals(ConcurrentMergeScheduler.class, clone.getMergeScheduler().getClass()); + } + + @Test + public void testInvalidValues() throws Exception { + IndexWriterConfig conf = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random)); + + // Test IndexDeletionPolicy + assertEquals(KeepOnlyLastCommitDeletionPolicy.class, conf.getIndexDeletionPolicy().getClass()); + conf.setIndexDeletionPolicy(new SnapshotDeletionPolicy(null)); + assertEquals(SnapshotDeletionPolicy.class, conf.getIndexDeletionPolicy().getClass()); + conf.setIndexDeletionPolicy(null); + assertEquals(KeepOnlyLastCommitDeletionPolicy.class, conf.getIndexDeletionPolicy().getClass()); + + // Test MergeScheduler + assertEquals(ConcurrentMergeScheduler.class, conf.getMergeScheduler().getClass()); + conf.setMergeScheduler(new SerialMergeScheduler()); + assertEquals(SerialMergeScheduler.class, conf.getMergeScheduler().getClass()); + conf.setMergeScheduler(null); + assertEquals(ConcurrentMergeScheduler.class, conf.getMergeScheduler().getClass()); + + // Test Similarity + assertTrue(Similarity.getDefault() == conf.getSimilarity()); + conf.setSimilarity(new MySimilarity()); + assertEquals(MySimilarity.class, conf.getSimilarity().getClass()); + conf.setSimilarity(null); + assertTrue(Similarity.getDefault() == conf.getSimilarity()); + + // Test IndexingChain + assertTrue(DocumentsWriter.defaultIndexingChain == conf.getIndexingChain()); + conf.setIndexingChain(new MyIndexingChain()); + assertEquals(MyIndexingChain.class, conf.getIndexingChain().getClass()); + conf.setIndexingChain(null); + assertTrue(DocumentsWriter.defaultIndexingChain == conf.getIndexingChain()); + + try { + conf.setMaxBufferedDeleteTerms(0); + fail("should not have succeeded to set maxBufferedDeleteTerms to 0"); + } catch (IllegalArgumentException e) { + // this is expected + } + + try { + conf.setMaxBufferedDocs(1); + fail("should not have succeeded to set maxBufferedDocs to 1"); + } catch (IllegalArgumentException e) { + // this is expected + } + + try { + // Disable both MAX_BUF_DOCS and RAM_SIZE_MB + conf.setMaxBufferedDocs(4); + conf.setRAMBufferSizeMB(IndexWriterConfig.DISABLE_AUTO_FLUSH); + conf.setMaxBufferedDocs(IndexWriterConfig.DISABLE_AUTO_FLUSH); + fail("should not have succeeded to disable maxBufferedDocs when ramBufferSizeMB is disabled as well"); + } catch (IllegalArgumentException e) { + // this is expected + } + + conf.setRAMBufferSizeMB(IndexWriterConfig.DEFAULT_RAM_BUFFER_SIZE_MB); + conf.setMaxBufferedDocs(IndexWriterConfig.DEFAULT_MAX_BUFFERED_DOCS); + try { + conf.setRAMBufferSizeMB(IndexWriterConfig.DISABLE_AUTO_FLUSH); + fail("should not have succeeded to disable ramBufferSizeMB when maxBufferedDocs is disabled as well"); + } catch (IllegalArgumentException e) { + // this is expected + } + + // Test setReaderTermsIndexDivisor + try { + conf.setReaderTermsIndexDivisor(0); + fail("should not have succeeded to set termsIndexDivisor to 0"); + } catch (IllegalArgumentException e) { + // this is expected + } + + // Setting to -1 is ok + conf.setReaderTermsIndexDivisor(-1); + try { + conf.setReaderTermsIndexDivisor(-2); + fail("should not have succeeded to set termsIndexDivisor to < -1"); + } catch (IllegalArgumentException e) { + // this is expected + } + + assertEquals(IndexWriterConfig.DEFAULT_MAX_THREAD_STATES, conf.getMaxThreadStates()); + conf.setMaxThreadStates(5); + assertEquals(5, conf.getMaxThreadStates()); + conf.setMaxThreadStates(0); + assertEquals(IndexWriterConfig.DEFAULT_MAX_THREAD_STATES, conf.getMaxThreadStates()); + + // Test MergePolicy + assertEquals(TieredMergePolicy.class, conf.getMergePolicy().getClass()); + conf.setMergePolicy(new LogDocMergePolicy()); + assertEquals(LogDocMergePolicy.class, conf.getMergePolicy().getClass()); + conf.setMergePolicy(null); + assertEquals(LogByteSizeMergePolicy.class, conf.getMergePolicy().getClass()); + } + + /** + * @deprecated should be removed once all the deprecated setters are removed + * from IndexWriter. + */ + @Test @Deprecated + public void testIndexWriterSetters() throws Exception { + // This test intentionally tests deprecated methods. The purpose is to pass + // whatever the user set on IW to IWC, so that if the user calls + // iw.getConfig().getXYZ(), he'll get the same value he passed to + // iw.setXYZ(). + IndexWriterConfig conf = new IndexWriterConfig(TEST_VERSION_CURRENT, new WhitespaceAnalyzer(TEST_VERSION_CURRENT)); + Directory dir = newDirectory(); + IndexWriter writer = new IndexWriter(dir, conf); + + writer.setSimilarity(new MySimilarity()); + assertEquals(MySimilarity.class, writer.getConfig().getSimilarity().getClass()); + + writer.setMaxBufferedDeleteTerms(4); + assertEquals(4, writer.getConfig().getMaxBufferedDeleteTerms()); + + writer.setMaxBufferedDocs(10); + assertEquals(10, writer.getConfig().getMaxBufferedDocs()); + + writer.setMergeScheduler(new SerialMergeScheduler()); + assertEquals(SerialMergeScheduler.class, writer.getConfig().getMergeScheduler().getClass()); + + writer.setRAMBufferSizeMB(1.5); + assertEquals(1.5, writer.getConfig().getRAMBufferSizeMB(), 0.0); + + writer.setTermIndexInterval(40); + assertEquals(40, writer.getConfig().getTermIndexInterval()); + + writer.setWriteLockTimeout(100); + assertEquals(100, writer.getConfig().getWriteLockTimeout()); + + writer.setMergedSegmentWarmer(new MyWarmer()); + assertEquals(MyWarmer.class, writer.getConfig().getMergedSegmentWarmer().getClass()); + + writer.setMergePolicy(new LogDocMergePolicy()); + assertEquals(LogDocMergePolicy.class, writer.getConfig().getMergePolicy().getClass()); + writer.close(); + dir.close(); + } + +}