+ *
* Tests here create an index with a few documents, each having * an indexed "id" field. * The ord values of this field are later used for scoring. - *+ *
* The order tests use Hits to verify that docs are ordered as expected. - *- * The exact score tests use TopDocs top to verify the exact score. + *
+ * The exact score tests use TopDocs top to verify the exact score. */ +@SuppressWarnings({"UseOfSystemOutOrSystemErr"}) public class TestOrdValues extends FunctionTestSetup { - /* @override constructor */ - public TestOrdValues(String name) { - super(name); + /** + * Test OrdFieldSource + */ + @Test + public void testOrdFieldRank() throws CorruptIndexException, Exception { + doTestRank(ID_FIELD, true); } - /** Test OrdFieldSource */ - public void testOrdFieldRank () throws CorruptIndexException, Exception { - doTestRank(ID_FIELD,true); + /** + * Test ReverseOrdFieldSource + */ + @Test + public void testReverseOrdFieldRank() throws CorruptIndexException, Exception { + doTestRank(ID_FIELD, false); } - /** Test ReverseOrdFieldSource */ - public void testReverseOrdFieldRank () throws CorruptIndexException, Exception { - doTestRank(ID_FIELD,false); - } - // Test that queries based on reverse/ordFieldScore scores correctly - private void doTestRank (String field, boolean inOrder) throws CorruptIndexException, Exception { + private void doTestRank(String field, boolean inOrder) throws CorruptIndexException, Exception { IndexSearcher s = new IndexSearcher(dir, true); ValueSource vs; if (inOrder) { @@ -62,42 +62,48 @@ } else { vs = new ReverseOrdFieldSource(field); } - + Query q = new ValueSourceQuery(vs); - log("test: "+q); - QueryUtils.check(q,s); + log("test: " + q); + QueryUtils.check(q, s); ScoreDoc[] h = s.search(q, null, 1000).scoreDocs; - assertEquals("All docs should be matched!",N_DOCS,h.length); + assertEquals("All docs should be matched!", N_DOCS, h.length); String prevID = inOrder - ? "IE" // greater than all ids of docs in this test ("ID0001", etc.) - : "IC"; // smaller than all ids of docs in this test ("ID0001", etc.) - - for (int i=0; i+ *
+ *
+ * If you
+ * override either setUp() or
+ * tearDown() in your unit test, make sure you
+ * call super.setUp() and
+ * super.tearDown()
+ *
+ * This method will be called by tearDown to clean up FieldCache.DEFAULT. + * If a (poorly written) test has some expectation that the FieldCache + * will persist across test methods (ie: a static IndexReader) this + * method can be overridden to do nothing. + *
+ * + * @see FieldCache#purgeAllCaches() + */ + protected void purgeFieldCache(final FieldCache fc) { + fc.purgeAllCaches(); + } + + protected String getTestLabel() { + return getClass().getName() + "." + getName(); + } + + @After + public void tearDown() throws Exception { + try { + // this isn't as useful as calling directly from the scope where the + // index readers are used, because they could be gc'ed just before + // tearDown is called. + // But it's better then nothing. + assertSaneFieldCaches(getTestLabel()); + + if (ConcurrentMergeScheduler.anyUnhandledExceptions()) { + // Clear the failure so that we don't just keep + // failing subsequent test cases + ConcurrentMergeScheduler.clearUnhandledExceptions(); + fail("ConcurrentMergeScheduler hit unhandled exceptions"); + } + } finally { + purgeFieldCache(FieldCache.DEFAULT); + } + } + + /** + * Asserts that FieldCacheSanityChecker does not detect any + * problems with FieldCache.DEFAULT. + *+ * If any problems are found, they are logged to System.err + * (allong with the msg) when the Assertion is thrown. + *
+ *+ * This method is called by tearDown after every test method, + * however IndexReaders scoped inside test methods may be garbage + * collected prior to this method being called, causing errors to + * be overlooked. Tests are encouraged to keep their IndexReaders + * scoped at the class level, or to explicitly call this method + * directly in the same scope as the IndexReader. + *
+ * + * @see FieldCacheSanityChecker + */ + protected void assertSaneFieldCaches(final String msg) { + final CacheEntry[] entries = FieldCache.DEFAULT.getCacheEntries(); + Insanity[] insanity = null; + try { + try { + insanity = FieldCacheSanityChecker.checkSanity(entries); + } catch (RuntimeException e) { + dumpArray(msg + ": FieldCache", entries, System.err); + throw e; + } + + assertEquals(msg + ": Insane FieldCache usage(s) found", + 0, insanity.length); + insanity = null; + } finally { + + // report this in the event of any exception/failure + // if no failure, then insanity will be null anyway + if (null != insanity) { + dumpArray(msg + ": Insane FieldCache usage(s)", insanity, System.err); + } + + } + } + + /** + * Convinience method for logging an iterator. + * + * @param label String logged before/after the items in the iterator + * @param iter Each next() is toString()ed and logged on it's own line. If iter is null this is logged differnetly then an empty iterator. + * @param stream Stream to log messages to. + */ + public static void dumpIterator(String label, Iterator iter, + PrintStream stream) { + stream.println("*** BEGIN " + label + " ***"); + if (null == iter) { + stream.println(" ... NULL ..."); + } else { + while (iter.hasNext()) { + stream.println(iter.next().toString()); + } + } + stream.println("*** END " + label + " ***"); + } + + /** + * Convinience method for logging an array. Wraps the array in an iterator and delegates + * + * @see dumpIterator(String,Iterator,PrintStream) + */ + public static void dumpArray(String label, Object[] objs, + PrintStream stream) { + Iterator iter = (null == objs) ? null : Arrays.asList(objs).iterator(); + dumpIterator(label, iter, stream); + } + + /** + * Returns a {@link Random} instance for generating random numbers during the test. + * The random seed is logged during test execution and printed to System.out on any failure + * for reproducing the test using {@link #newRandom(long)} with the recorded seed + * . + */ + public Random newRandom() { + if (seed != null) { + throw new IllegalStateException("please call LuceneTestCase.newRandom only once per test"); + } + return newRandom(seedRnd.nextLong()); + } + + /** + * Returns a {@link Random} instance for generating random numbers during the test. + * If an error occurs in the test that is not reproducible, you can use this method to + * initialize the number generator with the seed that was printed out during the failing test. + */ + public Random newRandom(long seed) { + if (this.seed != null) { + throw new IllegalStateException("please call LuceneTestCase.newRandom only once per test"); + } + this.seed = Long.valueOf(seed); + return new Random(seed); + } + + public String getName() { + return this.name; + } + + // We get here fro InterceptTestCaseEvents on the 'failed' event.... + public void reportAdditionalFailureInfo() { + if (seed != null) { + System.out.println("NOTE: random seed of testcase '" + getName() + "' was: " + seed); + } + } + + // recorded seed + protected Long seed = null; + + // static members + private static final Random seedRnd = new Random(); + + private String name = ""; + +} Index: src/test/org/apache/lucene/util/LuceneTestCase.java =================================================================== --- src/test/org/apache/lucene/util/LuceneTestCase.java (revision 836280) +++ src/test/org/apache/lucene/util/LuceneTestCase.java (working copy) @@ -47,7 +47,11 @@ *super.tearDown()
*
* @see #assertSaneFieldCaches
+ *
+ * @deprecated Replaced by {@link #LuceneTestCaseJ4}
+ *
*/
+@Deprecated
public abstract class LuceneTestCase extends TestCase {
public LuceneTestCase() {
Index: src/test/org/apache/lucene/util/InterceptTestCaseEvents.java
===================================================================
--- src/test/org/apache/lucene/util/InterceptTestCaseEvents.java (revision 0)
+++ src/test/org/apache/lucene/util/InterceptTestCaseEvents.java (revision 0)
@@ -0,0 +1,60 @@
+package org.apache.lucene.util;
+
+/**
+ * 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 org.junit.rules.TestWatchman;
+import org.junit.runners.model.FrameworkMethod;
+
+import java.lang.reflect.Method;
+
+
+public final class InterceptTestCaseEvents extends TestWatchman {
+ private Object obj;
+
+ public InterceptTestCaseEvents(Object obj) {
+ this.obj = obj;
+ }
+
+ @Override
+ public void failed(Throwable e, FrameworkMethod method) {
+ try {
+ Method reporter = method.getMethod().getDeclaringClass().getMethod("reportAdditionalFailureInfo",(Class[]) null);
+ reporter.invoke(obj, (Object[])null);
+ } catch (Exception e1) {
+ System.err.println("InterceptTestCaseEvents.failed(). Cannot invoke reportAdditionalFailureInfo() method in" +
+ " consuming class, is it declared and public?");
+ }
+ super.failed(e, method);
+ }
+
+ @Override
+ public void finished(FrameworkMethod method) {
+ super.finished(method);
+ }
+
+ @Override
+ public void starting(FrameworkMethod method) {
+ super.starting(method);
+ }
+
+ @Override
+ public void succeeded(FrameworkMethod method) {
+ super.succeeded(method);
+ }
+}