You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by bu...@apache.org on 2011/02/22 02:01:11 UTC
svn commit: r1073192 [14/32] - in /lucene/dev/branches/realtime_search: ./
dev-tools/eclipse/ dev-tools/idea/.idea/ dev-tools/idea/lucene/contrib/ant/
dev-tools/idea/lucene/contrib/demo/
dev-tools/idea/lucene/contrib/highlighter/ dev-tools/idea/lucene/...
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mockrandom/MockRandomCodec.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mockrandom/MockRandomCodec.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mockrandom/MockRandomCodec.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mockrandom/MockRandomCodec.java Tue Feb 22 01:00:39 2011
@@ -323,14 +323,14 @@ public class MockRandomCodec extends Cod
@Override
public void files(Directory dir, SegmentInfo segmentInfo, String codecId, Set<String> files) throws IOException {
- final String seedFileName = IndexFileNames.segmentFileName(segmentInfo.name, codecId, SEED_EXT);
+ final String seedFileName = IndexFileNames.segmentFileName(segmentInfo.name, codecId, SEED_EXT);
files.add(seedFileName);
SepPostingsReaderImpl.files(segmentInfo, codecId, files);
StandardPostingsReader.files(dir, segmentInfo, codecId, files);
BlockTermsReader.files(dir, segmentInfo, codecId, files);
FixedGapTermsIndexReader.files(dir, segmentInfo, codecId, files);
VariableGapTermsIndexReader.files(dir, segmentInfo, codecId, files);
-
+
// hackish!
Iterator<String> it = files.iterator();
while(it.hasNext()) {
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSepCodec.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSepCodec.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntFactory.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntFactory.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntIndexInput.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntIndexInput.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntIndexInput.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntIndexInput.java Tue Feb 22 01:00:39 2011
@@ -68,7 +68,7 @@ public class MockSingleIntIndexInput ext
return in.readVInt();
}
}
-
+
class Index extends IntIndexInput.Index {
private long fp;
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntIndexOutput.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntIndexOutput.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntIndexOutput.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/mocksep/MockSingleIntIndexOutput.java Tue Feb 22 01:00:39 2011
@@ -25,7 +25,7 @@ import java.io.IOException;
/** Writes ints directly to the file (not in blocks) as
* vInt.
- *
+ *
* @lucene.experimental
*/
public class MockSingleIntIndexOutput extends IntIndexOutput {
@@ -77,7 +77,7 @@ public class MockSingleIntIndexOutput ex
}
lastFP = fp;
}
-
+
@Override
public String toString() {
return Long.toString(fp);
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/preflexrw/PreFlexFieldsWriter.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/preflexrw/PreFlexFieldsWriter.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/preflexrw/PreFlexRWCodec.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/preflexrw/PreFlexRWCodec.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/preflexrw/TermInfosWriter.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/index/codecs/preflexrw/TermInfosWriter.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/search/CheckHits.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/search/CheckHits.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/search/QueryUtils.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/search/QueryUtils.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/search/QueryUtils.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/search/QueryUtils.java Tue Feb 22 01:00:39 2011
@@ -2,13 +2,14 @@ package org.apache.lucene.search;
import java.io.IOException;
import java.util.Random;
+import java.lang.reflect.Method;
import junit.framework.Assert;
import org.apache.lucene.analysis.MockAnalyzer;
import org.apache.lucene.document.Document;
-import org.apache.lucene.index.IndexReader.AtomicReaderContext;
import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexReader.AtomicReaderContext;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.index.IndexWriterConfig;
import org.apache.lucene.index.MultiReader;
@@ -18,7 +19,6 @@ import org.apache.lucene.store.MockDirec
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.util.LuceneTestCase;
import org.apache.lucene.util.ReaderUtil;
-import org.apache.lucene.util._TestUtil;
import static org.apache.lucene.util.LuceneTestCase.TEST_VERSION_CURRENT;
@@ -172,7 +172,16 @@ public class QueryUtils {
}
w.commit();
w.deleteDocuments( new MatchAllDocsQuery() );
- _TestUtil.keepFullyDeletedSegments(w);
+ try {
+ // Carefully invoke what is a package-private (test
+ // only, internal) method on IndexWriter:
+ Method m = IndexWriter.class.getDeclaredMethod("keepFullyDeletedSegments");
+ m.setAccessible(true);
+ m.invoke(w);
+ } catch (Exception e) {
+ // Should not happen?
+ throw new RuntimeException(e);
+ }
w.commit();
if (0 < numDeletedDocs)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/MockDirectoryWrapper.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/MockDirectoryWrapper.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/MockDirectoryWrapper.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/MockDirectoryWrapper.java Tue Feb 22 01:00:39 2011
@@ -38,18 +38,6 @@ import org.apache.lucene.util._TestUtil;
/**
* This is a Directory Wrapper that adds methods
* intended to be used only by unit tests.
- * It also adds a number of features useful for testing:
- * <ul>
- * <li> Instances created by {@link LuceneTestCase#newDirectory()} are tracked
- * to ensure they are closed by the test.
- * <li> When a MockDirectoryWrapper is closed, it will throw an exception if
- * it has any open files against it (with a stacktrace indicating where
- * they were opened from).
- * <li> When a MockDirectoryWrapper is closed, it runs CheckIndex to test if
- * the index was corrupted.
- * <li> MockDirectoryWrapper simulates some "features" of Windows, such as
- * refusing to write/delete to open files.
- * </ul>
*/
public class MockDirectoryWrapper extends Directory {
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/MockIndexInputWrapper.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/MockIndexInputWrapper.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/MockIndexOutputWrapper.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/MockIndexOutputWrapper.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/_TestHelper.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/store/_TestHelper.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LineFileDocs.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LineFileDocs.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LineFileDocs.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LineFileDocs.java Tue Feb 22 01:00:39 2011
@@ -32,9 +32,9 @@ import java.util.Random;
import org.apache.lucene.document.Document;
import org.apache.lucene.document.Field;
-/** Minimal port of contrib/benchmark's LneDocSource +
- * DocMaker, so tests can enum docs from a line file created
- * by contrib/benchmark's WriteLineDoc task */
+// Minimal port of contrib/benchmark's LneDocSource +
+// DocMaker, so tests can enum docs from a line file created
+// by contrib/benchmark's WriteLineDoc task
public class LineFileDocs implements Closeable {
private BufferedReader reader;
@@ -42,8 +42,8 @@ public class LineFileDocs implements Clo
private final AtomicInteger id = new AtomicInteger();
private final String path;
- /** If forever is true, we rewind the file at EOF (repeat
- * the docs over and over) */
+ // If forever is true, we rewind the file at EOF (repeat
+ // the docs over and over)
public LineFileDocs(Random random, String path) throws IOException {
this.path = path;
open(random);
@@ -138,7 +138,7 @@ public class LineFileDocs implements Clo
private final ThreadLocal<DocState> threadDocs = new ThreadLocal<DocState>();
- /** Note: Document instance is re-used per-thread */
+ // Document instance is re-used per-thread
public Document nextDoc() throws IOException {
String line;
synchronized(this) {
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LuceneJUnitDividingSelector.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LuceneJUnitDividingSelector.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LuceneJUnitResultFormatter.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LuceneJUnitResultFormatter.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
(empty)
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/LuceneTestCase.java Tue Feb 22 01:00:39 2011
@@ -116,7 +116,7 @@ public abstract class LuceneTestCase ext
* If this is set, it is the only method that should run.
*/
static final String TEST_METHOD;
-
+
/** Create indexes in this directory, optimally use a subdir, named after the test */
public static final File TEMP_DIR;
static {
@@ -156,11 +156,11 @@ public abstract class LuceneTestCase ext
* multiply it by the number of iterations
*/
public static final int RANDOM_MULTIPLIER = Integer.parseInt(System.getProperty("tests.multiplier", "1"));
-
+
private int savedBoolMaxClauseCount;
private volatile Thread.UncaughtExceptionHandler savedUncaughtExceptionHandler = null;
-
+
/** Used to track if setUp and tearDown are called correctly from subclasses */
private boolean setup;
@@ -182,28 +182,28 @@ public abstract class LuceneTestCase ext
private static class UncaughtExceptionEntry {
public final Thread thread;
public final Throwable exception;
-
+
public UncaughtExceptionEntry(Thread thread, Throwable exception) {
this.thread = thread;
this.exception = exception;
}
}
private List<UncaughtExceptionEntry> uncaughtExceptions = Collections.synchronizedList(new ArrayList<UncaughtExceptionEntry>());
-
+
// saves default codec: we do this statically as many build indexes in @beforeClass
private static String savedDefaultCodec;
// default codec: not set when we use a per-field provider.
private static Codec codec;
// default codec provider
private static CodecProvider savedCodecProvider;
-
+
private static Locale locale;
private static Locale savedLocale;
private static TimeZone timeZone;
private static TimeZone savedTimeZone;
-
+
private static Map<MockDirectoryWrapper,StackTraceElement[]> stores;
-
+
private static final String[] TEST_CODECS = new String[] {"MockSep", "MockFixedIntBlock", "MockVariableIntBlock", "MockRandom"};
private static void swapCodec(Codec c, CodecProvider cp) {
@@ -281,7 +281,7 @@ public abstract class LuceneTestCase ext
// randomly picks from core and test codecs
static String pickRandomCodec(Random rnd) {
- int idx = rnd.nextInt(CodecProvider.CORE_CODECS.length +
+ int idx = rnd.nextInt(CodecProvider.CORE_CODECS.length +
TEST_CODECS.length);
if (idx < CodecProvider.CORE_CODECS.length) {
return CodecProvider.CORE_CODECS[idx];
@@ -314,7 +314,7 @@ public abstract class LuceneTestCase ext
/** @deprecated (4.0) until we fix no-fork problems in solr tests */
@Deprecated
private static List<String> testClassesRun = new ArrayList<String>();
-
+
@BeforeClass
public static void beforeClassLuceneTestCaseJ4() {
staticSeed = "random".equals(TEST_SEED) ? seedRand.nextLong() : TwoLongs.fromString(TEST_SEED).l1;
@@ -339,7 +339,7 @@ public abstract class LuceneTestCase ext
TimeZone.setDefault(timeZone);
testsFailed = false;
}
-
+
@AfterClass
public static void afterClassLuceneTestCaseJ4() {
int rogueThreads = threadCleanup("test class");
@@ -353,12 +353,12 @@ public abstract class LuceneTestCase ext
if ("randomPerField".equals(TEST_CODEC)) {
if (cp instanceof RandomCodecProvider)
codecDescription = cp.toString();
- else
+ else
codecDescription = "PreFlex";
} else {
codecDescription = codec.toString();
}
-
+
if (CodecProvider.getDefault() == savedCodecProvider)
removeTestCodecs(codec, CodecProvider.getDefault());
CodecProvider.setDefault(savedCodecProvider);
@@ -388,14 +388,14 @@ public abstract class LuceneTestCase ext
stores = null;
// if verbose or tests failed, report some information back
if (VERBOSE || testsFailed)
- System.err.println("NOTE: test params are: codec=" + codecDescription +
- ", locale=" + locale +
+ System.err.println("NOTE: test params are: codec=" + codecDescription +
+ ", locale=" + locale +
", timezone=" + (timeZone == null ? "(null)" : timeZone.getID()));
if (testsFailed) {
System.err.println("NOTE: all tests run in this JVM:");
System.err.println(Arrays.toString(testClassesRun.toArray()));
- System.err.println("NOTE: " + System.getProperty("os.name") + " "
- + System.getProperty("os.version") + " "
+ System.err.println("NOTE: " + System.getProperty("os.name") + " "
+ + System.getProperty("os.version") + " "
+ System.getProperty("os.arch") + "/"
+ System.getProperty("java.vendor") + " "
+ System.getProperty("java.version") + " "
@@ -408,7 +408,7 @@ public abstract class LuceneTestCase ext
}
private static boolean testsFailed; /* true if any tests failed */
-
+
// This is how we get control when errors occur.
// Think of this as start/end/success/failed
// events.
@@ -443,7 +443,7 @@ public abstract class LuceneTestCase ext
LuceneTestCase.this.name = method.getName();
super.starting(method);
}
-
+
};
@Before
@@ -461,7 +461,7 @@ public abstract class LuceneTestCase ext
savedUncaughtExceptionHandler.uncaughtException(t, e);
}
});
-
+
savedBoolMaxClauseCount = BooleanQuery.getMaxClauseCount();
}
@@ -493,7 +493,7 @@ public abstract class LuceneTestCase ext
if (!getClass().getName().startsWith("org.apache.solr")) {
int rogueThreads = threadCleanup("test method: '" + getName() + "'");
if (rogueThreads > 0) {
- System.err.println("RESOURCE LEAK: test method: '" + getName()
+ System.err.println("RESOURCE LEAK: test method: '" + getName()
+ "' left " + rogueThreads + " thread(s) running");
// TODO: fail, but print seed for now.
if (!testsFailed && uncaughtExceptions.isEmpty()) {
@@ -515,18 +515,18 @@ public abstract class LuceneTestCase ext
fail("Some threads threw uncaught exceptions!");
}
- // calling assertSaneFieldCaches here isn't as useful as having test
- // classes call it directly from the scope where the index readers
- // are used, because they could be gc'ed just before this tearDown
+ // calling assertSaneFieldCaches here isn't as useful as having test
+ // classes call it directly from the scope where the index readers
+ // are used, because they could be gc'ed just before this tearDown
// method is called.
//
// But it's better then nothing.
//
- // If you are testing functionality that you know for a fact
- // "violates" FieldCache sanity, then you should either explicitly
+ // If you are testing functionality that you know for a fact
+ // "violates" FieldCache sanity, then you should either explicitly
// call purgeFieldCache at the end of your test method, or refactor
- // your Test class so that the inconsistant FieldCache usages are
- // isolated in distinct test methods
+ // your Test class so that the inconsistant FieldCache usages are
+ // isolated in distinct test methods
assertSaneFieldCaches(getTestLabel());
} finally {
@@ -537,14 +537,14 @@ public abstract class LuceneTestCase ext
private final static int THREAD_STOP_GRACE_MSEC = 1000;
// jvm-wide list of 'rogue threads' we found, so they only get reported once.
private final static IdentityHashMap<Thread,Boolean> rogueThreads = new IdentityHashMap<Thread,Boolean>();
-
+
static {
// just a hack for things like eclipse test-runner threads
for (Thread t : Thread.getAllStackTraces().keySet()) {
rogueThreads.put(t, true);
}
}
-
+
/**
* Looks for leftover running threads, trying to kill them off,
* so they don't fail future tests.
@@ -555,20 +555,20 @@ public abstract class LuceneTestCase ext
Thread[] stillRunning = new Thread[Thread.activeCount()+1];
int threadCount = 0;
int rogueCount = 0;
-
+
if ((threadCount = Thread.enumerate(stillRunning)) > 1) {
while (threadCount == stillRunning.length) {
// truncated response
stillRunning = new Thread[stillRunning.length*2];
threadCount = Thread.enumerate(stillRunning);
}
-
+
for (int i = 0; i < threadCount; i++) {
Thread t = stillRunning[i];
-
- if (t.isAlive() &&
- !rogueThreads.containsKey(t) &&
- t != Thread.currentThread() &&
+
+ if (t.isAlive() &&
+ !rogueThreads.containsKey(t) &&
+ t != Thread.currentThread() &&
/* its ok to keep your searcher across test cases */
(t.getName().startsWith("LuceneTestCase") && context.startsWith("test method")) == false) {
System.err.println("WARNING: " + context + " left thread running: " + t);
@@ -595,7 +595,7 @@ public abstract class LuceneTestCase ext
}
return rogueCount;
}
-
+
/**
* Asserts that FieldCacheSanityChecker does not detect any
* problems with FieldCache.DEFAULT.
@@ -638,13 +638,13 @@ public abstract class LuceneTestCase ext
}
}
-
+
// @deprecated (4.0) These deprecated methods should be removed soon, when all tests using no Epsilon are fixed:
@Deprecated
static public void assertEquals(double expected, double actual) {
assertEquals(null, expected, actual);
}
-
+
@Deprecated
static public void assertEquals(String message, double expected, double actual) {
assertEquals(message, Double.valueOf(expected), Double.valueOf(actual));
@@ -659,18 +659,18 @@ public abstract class LuceneTestCase ext
static public void assertEquals(String message, float expected, float actual) {
assertEquals(message, Float.valueOf(expected), Float.valueOf(actual));
}
-
+
// Replacement for Assume jUnit class, so we can add a message with explanation:
-
+
private static final class TestIgnoredException extends RuntimeException {
TestIgnoredException(String msg) {
super(msg);
}
-
+
TestIgnoredException(String msg, Throwable t) {
super(msg, t);
}
-
+
@Override
public String getMessage() {
StringBuilder sb = new StringBuilder(super.getMessage());
@@ -678,7 +678,7 @@ public abstract class LuceneTestCase ext
sb.append(" - ").append(getCause());
return sb.toString();
}
-
+
// only this one is called by our code, exception is not used outside this class:
@Override
public void printStackTrace(PrintStream s) {
@@ -690,25 +690,25 @@ public abstract class LuceneTestCase ext
}
}
}
-
+
public static void assumeTrue(String msg, boolean b) {
Assume.assumeNoException(b ? null : new TestIgnoredException(msg));
}
-
+
public static void assumeFalse(String msg, boolean b) {
assumeTrue(msg, !b);
}
-
+
public static void assumeNoException(String msg, Exception e) {
Assume.assumeNoException(e == null ? null : new TestIgnoredException(msg, e));
}
-
+
public static <T> Set<T> asSet(T... args) {
return new HashSet<T>(Arrays.asList(args));
}
/**
- * Convenience method for logging an iterator.
+ * 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.
@@ -728,7 +728,7 @@ public abstract class LuceneTestCase ext
}
/**
- * Convenience method for logging an array. Wraps the array in an iterator and delegates
+ * Convinience method for logging an array. Wraps the array in an iterator and delegates
*
* @see #dumpIterator(String,Iterator,PrintStream)
*/
@@ -742,8 +742,7 @@ public abstract class LuceneTestCase ext
public static IndexWriterConfig newIndexWriterConfig(Version v, Analyzer a) {
return newIndexWriterConfig(random, v, a);
}
-
- /** create a new index writer config with random defaults using the specified random */
+
public static IndexWriterConfig newIndexWriterConfig(Random r, Version v, Analyzer a) {
IndexWriterConfig c = new IndexWriterConfig(v, a);
if (r.nextBoolean()) {
@@ -760,7 +759,7 @@ public abstract class LuceneTestCase ext
c.setTermIndexInterval(_TestUtil.nextInt(r, 1, 1000));
}
if (r.nextBoolean()) {
- c.setMaxThreadStates(_TestUtil.nextInt(r, 1, 20));
+ c.setIndexerThreadPool(new ThreadAffinityDocumentsWriterThreadPool(_TestUtil.nextInt(r, 1, 20)));
}
if (r.nextBoolean()) {
@@ -835,18 +834,14 @@ public abstract class LuceneTestCase ext
public static MockDirectoryWrapper newDirectory() throws IOException {
return newDirectory(random);
}
-
- /**
- * Returns a new Directory instance, using the specified random.
- * See {@link #newDirectory()} for more information.
- */
+
public static MockDirectoryWrapper newDirectory(Random r) throws IOException {
Directory impl = newDirectoryImpl(r, TEST_DIRECTORY);
MockDirectoryWrapper dir = new MockDirectoryWrapper(r, impl);
stores.put(dir, Thread.currentThread().getStackTrace());
return dir;
}
-
+
/**
* Returns a new Directory instance, with contents copied from the
* provided directory. See {@link #newDirectory()} for more
@@ -855,23 +850,23 @@ public abstract class LuceneTestCase ext
public static MockDirectoryWrapper newDirectory(Directory d) throws IOException {
return newDirectory(random, d);
}
-
+
/** Returns a new FSDirectory instance over the given file, which must be a folder. */
public static MockDirectoryWrapper newFSDirectory(File f) throws IOException {
return newFSDirectory(f, null);
}
-
+
/** Returns a new FSDirectory instance over the given file, which must be a folder. */
public static MockDirectoryWrapper newFSDirectory(File f, LockFactory lf) throws IOException {
String fsdirClass = TEST_DIRECTORY;
if (fsdirClass.equals("random")) {
fsdirClass = FS_DIRECTORIES[random.nextInt(FS_DIRECTORIES.length)];
}
-
+
if (fsdirClass.indexOf(".") == -1) {// if not fully qualified, assume .store
fsdirClass = "org.apache.lucene.store." + fsdirClass;
}
-
+
Class<? extends FSDirectory> clazz;
try {
try {
@@ -879,11 +874,11 @@ public abstract class LuceneTestCase ext
} catch (ClassCastException e) {
// TEST_DIRECTORY is not a sub-class of FSDirectory, so draw one at random
fsdirClass = FS_DIRECTORIES[random.nextInt(FS_DIRECTORIES.length)];
-
+
if (fsdirClass.indexOf(".") == -1) {// if not fully qualified, assume .store
fsdirClass = "org.apache.lucene.store." + fsdirClass;
}
-
+
clazz = Class.forName(fsdirClass).asSubclass(FSDirectory.class);
}
MockDirectoryWrapper dir = new MockDirectoryWrapper(random, newFSDirectoryImpl(clazz, f, lf));
@@ -893,12 +888,7 @@ public abstract class LuceneTestCase ext
throw new RuntimeException(e);
}
}
-
- /**
- * Returns a new Directory instance, using the specified random
- * with contents copied from the provided directory. See
- * {@link #newDirectory()} for more information.
- */
+
public static MockDirectoryWrapper newDirectory(Random r, Directory d) throws IOException {
Directory impl = newDirectoryImpl(r, TEST_DIRECTORY);
for (String file : d.listAll()) {
@@ -908,87 +898,68 @@ public abstract class LuceneTestCase ext
stores.put(dir, Thread.currentThread().getStackTrace());
return dir;
}
-
- /** Returns a new field instance.
- * See {@link #newField(String, String, Store, Index, TermVector)} for more information */
+
public static Field newField(String name, String value, Index index) {
return newField(random, name, value, index);
}
-
- /** Returns a new field instance.
- * See {@link #newField(String, String, Store, Index, TermVector)} for more information */
+
public static Field newField(String name, String value, Store store, Index index) {
return newField(random, name, value, store, index);
}
-
- /**
- * Returns a new Field instance. Use this when the test does not
- * care about some specific field settings (most tests)
- * <ul>
- * <li>If the store value is set to Store.NO, sometimes the field will be randomly stored.
- * <li>More term vector data than you ask for might be indexed, for example if you choose YES
- * it might index term vectors with offsets too.
- * </ul>
- */
+
public static Field newField(String name, String value, Store store, Index index, TermVector tv) {
return newField(random, name, value, store, index, tv);
}
-
- /** Returns a new field instance, using the specified random.
- * See {@link #newField(String, String, Store, Index, TermVector)} for more information */
+
public static Field newField(Random random, String name, String value, Index index) {
return newField(random, name, value, Store.NO, index);
}
-
- /** Returns a new field instance, using the specified random.
- * See {@link #newField(String, String, Store, Index, TermVector)} for more information */
+
public static Field newField(Random random, String name, String value, Store store, Index index) {
return newField(random, name, value, store, index, TermVector.NO);
}
-
- /** Returns a new field instance, using the specified random.
- * See {@link #newField(String, String, Store, Index, TermVector)} for more information */
+
public static Field newField(Random random, String name, String value, Store store, Index index, TermVector tv) {
if (!index.isIndexed())
return new Field(name, value, store, index);
-
+
if (!store.isStored() && random.nextBoolean())
store = Store.YES; // randomly store it
-
+
tv = randomTVSetting(random, tv);
-
+
return new Field(name, value, store, index, tv);
}
-
- static final TermVector tvSettings[] = {
- TermVector.NO, TermVector.YES, TermVector.WITH_OFFSETS,
- TermVector.WITH_POSITIONS, TermVector.WITH_POSITIONS_OFFSETS
+
+ static final TermVector tvSettings[] = {
+ TermVector.NO, TermVector.YES, TermVector.WITH_OFFSETS,
+ TermVector.WITH_POSITIONS, TermVector.WITH_POSITIONS_OFFSETS
};
-
+
private static TermVector randomTVSetting(Random random, TermVector minimum) {
switch(minimum) {
case NO: return tvSettings[_TestUtil.nextInt(random, 0, tvSettings.length-1)];
case YES: return tvSettings[_TestUtil.nextInt(random, 1, tvSettings.length-1)];
- case WITH_OFFSETS: return random.nextBoolean() ? TermVector.WITH_OFFSETS
+ case WITH_OFFSETS: return random.nextBoolean() ? TermVector.WITH_OFFSETS
: TermVector.WITH_POSITIONS_OFFSETS;
- case WITH_POSITIONS: return random.nextBoolean() ? TermVector.WITH_POSITIONS
+ case WITH_POSITIONS: return random.nextBoolean() ? TermVector.WITH_POSITIONS
: TermVector.WITH_POSITIONS_OFFSETS;
default: return TermVector.WITH_POSITIONS_OFFSETS;
}
}
-
+
/** return a random Locale from the available locales on the system */
public static Locale randomLocale(Random random) {
Locale locales[] = Locale.getAvailableLocales();
return locales[random.nextInt(locales.length)];
}
-
+
/** return a random TimeZone from the available timezones on the system */
public static TimeZone randomTimeZone(Random random) {
String tzIds[] = TimeZone.getAvailableIDs();
return TimeZone.getTimeZone(tzIds[random.nextInt(tzIds.length)]);
}
-
+
/** return a Locale object equivalent to its programmatic name */
public static Locale localeForName(String localeName) {
String elements[] = localeName.split("\\_");
@@ -1010,7 +981,7 @@ public abstract class LuceneTestCase ext
"RAMDirectory",
FS_DIRECTORIES[0], FS_DIRECTORIES[1], FS_DIRECTORIES[2]
};
-
+
public static String randomDirectory(Random random) {
if (random.nextInt(10) == 0) {
return CORE_DIRECTORIES[random.nextInt(CORE_DIRECTORIES.length)];
@@ -1035,7 +1006,7 @@ public abstract class LuceneTestCase ext
return FSDirectory.open(file);
}
}
-
+
static Directory newDirectoryImpl(Random random, String clazzName) {
if (clazzName.equals("random"))
clazzName = randomDirectory(random);
@@ -1055,18 +1026,17 @@ public abstract class LuceneTestCase ext
return clazz.newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
- }
+ }
}
-
- /** create a new searcher over the reader.
- * This searcher might randomly use threads. */
+
+ /** create a new searcher over the reader */
public static IndexSearcher newSearcher(IndexReader r) throws IOException {
if (random.nextBoolean()) {
return new IndexSearcher(r);
} else {
int threads = 0;
- final ExecutorService ex = (random.nextBoolean()) ? null
- : Executors.newFixedThreadPool(threads = _TestUtil.nextInt(random, 1, 8),
+ final ExecutorService ex = (random.nextBoolean()) ? null
+ : Executors.newFixedThreadPool(threads = _TestUtil.nextInt(random, 1, 8),
new NamedThreadFactory("LuceneTestCase"));
if (ex != null && VERBOSE) {
System.out.println("NOTE: newSearcher using ExecutorService with " + threads + " threads");
@@ -1091,12 +1061,12 @@ public abstract class LuceneTestCase ext
public String getName() {
return this.name;
}
-
+
/** Gets a resource from the classpath as {@link File}. This method should only be used,
* if a real file is needed. To get a stream, code should prefer
* {@link Class#getResourceAsStream} using {@code this.getClass()}.
*/
-
+
protected File getDataFile(String name) throws IOException {
try {
return new File(this.getClass().getResource(name).toURI());
@@ -1107,11 +1077,11 @@ public abstract class LuceneTestCase ext
// We get here from InterceptTestCaseEvents on the 'failed' event....
public void reportAdditionalFailureInfo() {
- System.err.println("NOTE: reproduce with: ant test -Dtestcase=" + getClass().getSimpleName()
+ System.err.println("NOTE: reproduce with: ant test -Dtestcase=" + getClass().getSimpleName()
+ " -Dtestmethod=" + getName() + " -Dtests.seed=" + new TwoLongs(staticSeed, seed)
+ reproduceWithExtraParams());
}
-
+
// extra params that were overridden needed to reproduce the command
private String reproduceWithExtraParams() {
StringBuilder sb = new StringBuilder();
@@ -1127,12 +1097,12 @@ public abstract class LuceneTestCase ext
private static long staticSeed;
// seed for individual test methods, changed in @before
private long seed;
-
+
private static final Random seedRand = new Random();
protected static final Random random = new Random(0);
private String name = "<unknown>";
-
+
/**
* Annotation for tests that should only be run during nightly builds.
*/
@@ -1140,7 +1110,7 @@ public abstract class LuceneTestCase ext
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface Nightly {}
-
+
/** optionally filters the tests to be run by TEST_METHOD */
public static class LuceneTestCaseRunner extends BlockJUnit4ClassRunner {
private List<FrameworkMethod> testMethods;
@@ -1170,11 +1140,11 @@ public abstract class LuceneTestCase ext
testMethods.add(new FrameworkMethod(m));
}
}
-
+
if (testMethods.isEmpty()) {
throw new RuntimeException("No runnable methods!");
}
-
+
if (TEST_NIGHTLY == false) {
if (getTestClass().getJavaClass().isAnnotationPresent(Nightly.class)) {
/* the test class is annotated with nightly, remove all methods */
@@ -1224,9 +1194,9 @@ public abstract class LuceneTestCase ext
@Override
public boolean shouldRun(Description d) {
return TEST_METHOD == null || d.getMethodName().equals(TEST_METHOD);
- }
+ }
};
-
+
try {
f.apply(this);
} catch (NoTestsRemainException e) {
@@ -1234,12 +1204,12 @@ public abstract class LuceneTestCase ext
}
}
}
-
+
private static class RandomCodecProvider extends CodecProvider {
private List<Codec> knownCodecs = new ArrayList<Codec>();
private Map<String,Codec> previousMappings = new HashMap<String,Codec>();
private final int perFieldSeed;
-
+
RandomCodecProvider(Random random) {
this.perFieldSeed = random.nextInt();
register(new StandardCodec());
@@ -1271,13 +1241,13 @@ public abstract class LuceneTestCase ext
}
return codec.name;
}
-
+
@Override
- public synchronized String toString() {
+ public String toString() {
return "RandomCodecProvider: " + previousMappings.toString();
}
}
-
+
@Ignore("just a hack")
public final void alwaysIgnoredTestMethod() {}
}
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/_TestUtil.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/_TestUtil.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/_TestUtil.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/_TestUtil.java Tue Feb 22 01:00:39 2011
@@ -72,22 +72,22 @@ public class _TestUtil {
}
}
- /**
- * Convenience method: Unzip zipName + ".zip" under destDir, removing destDir first
+ /**
+ * Convenience method: Unzip zipName + ".zip" under destDir, removing destDir first
*/
public static void unzip(File zipName, File destDir) throws IOException {
-
+
ZipFile zipFile = new ZipFile(zipName);
-
+
Enumeration<? extends ZipEntry> entries = zipFile.entries();
-
+
rmDir(destDir);
-
+
destDir.mkdir();
-
+
while (entries.hasMoreElements()) {
ZipEntry entry = entries.nextElement();
-
+
InputStream in = zipFile.getInputStream(entry);
File targetFile = new File(destDir, entry.getName());
if (entry.isDirectory()) {
@@ -97,24 +97,24 @@ public class _TestUtil {
if (targetFile.getParentFile()!=null) {
// be on the safe side: do not rely on that directories are always extracted
// before their children (although this makes sense, but is it guaranteed?)
- targetFile.getParentFile().mkdirs();
+ targetFile.getParentFile().mkdirs();
}
OutputStream out = new BufferedOutputStream(new FileOutputStream(targetFile));
-
+
byte[] buffer = new byte[8192];
int len;
while((len = in.read(buffer)) >= 0) {
out.write(buffer, 0, len);
}
-
+
in.close();
out.close();
}
}
-
+
zipFile.close();
}
-
+
public static void syncConcurrentMerges(IndexWriter writer) {
syncConcurrentMerges(writer.getConfig().getMergeScheduler());
}
@@ -130,7 +130,7 @@ public class _TestUtil {
public static CheckIndex.Status checkIndex(Directory dir) throws IOException {
return checkIndex(dir, CodecProvider.getDefault());
}
-
+
/** This runs the CheckIndex tool on the index in. If any
* issues are hit, a RuntimeException is thrown; else,
* true is returned. */
@@ -187,62 +187,62 @@ public class _TestUtil {
}
private static final int[] blockStarts = {
- 0x0000, 0x0080, 0x0100, 0x0180, 0x0250, 0x02B0, 0x0300, 0x0370, 0x0400,
- 0x0500, 0x0530, 0x0590, 0x0600, 0x0700, 0x0750, 0x0780, 0x07C0, 0x0800,
- 0x0900, 0x0980, 0x0A00, 0x0A80, 0x0B00, 0x0B80, 0x0C00, 0x0C80, 0x0D00,
- 0x0D80, 0x0E00, 0x0E80, 0x0F00, 0x1000, 0x10A0, 0x1100, 0x1200, 0x1380,
- 0x13A0, 0x1400, 0x1680, 0x16A0, 0x1700, 0x1720, 0x1740, 0x1760, 0x1780,
- 0x1800, 0x18B0, 0x1900, 0x1950, 0x1980, 0x19E0, 0x1A00, 0x1A20, 0x1B00,
- 0x1B80, 0x1C00, 0x1C50, 0x1CD0, 0x1D00, 0x1D80, 0x1DC0, 0x1E00, 0x1F00,
- 0x2000, 0x2070, 0x20A0, 0x20D0, 0x2100, 0x2150, 0x2190, 0x2200, 0x2300,
- 0x2400, 0x2440, 0x2460, 0x2500, 0x2580, 0x25A0, 0x2600, 0x2700, 0x27C0,
- 0x27F0, 0x2800, 0x2900, 0x2980, 0x2A00, 0x2B00, 0x2C00, 0x2C60, 0x2C80,
- 0x2D00, 0x2D30, 0x2D80, 0x2DE0, 0x2E00, 0x2E80, 0x2F00, 0x2FF0, 0x3000,
- 0x3040, 0x30A0, 0x3100, 0x3130, 0x3190, 0x31A0, 0x31C0, 0x31F0, 0x3200,
- 0x3300, 0x3400, 0x4DC0, 0x4E00, 0xA000, 0xA490, 0xA4D0, 0xA500, 0xA640,
- 0xA6A0, 0xA700, 0xA720, 0xA800, 0xA830, 0xA840, 0xA880, 0xA8E0, 0xA900,
- 0xA930, 0xA960, 0xA980, 0xAA00, 0xAA60, 0xAA80, 0xABC0, 0xAC00, 0xD7B0,
- 0xE000, 0xF900, 0xFB00, 0xFB50, 0xFE00, 0xFE10,
- 0xFE20, 0xFE30, 0xFE50, 0xFE70, 0xFF00, 0xFFF0,
- 0x10000, 0x10080, 0x10100, 0x10140, 0x10190, 0x101D0, 0x10280, 0x102A0,
- 0x10300, 0x10330, 0x10380, 0x103A0, 0x10400, 0x10450, 0x10480, 0x10800,
- 0x10840, 0x10900, 0x10920, 0x10A00, 0x10A60, 0x10B00, 0x10B40, 0x10B60,
- 0x10C00, 0x10E60, 0x11080, 0x12000, 0x12400, 0x13000, 0x1D000, 0x1D100,
- 0x1D200, 0x1D300, 0x1D360, 0x1D400, 0x1F000, 0x1F030, 0x1F100, 0x1F200,
+ 0x0000, 0x0080, 0x0100, 0x0180, 0x0250, 0x02B0, 0x0300, 0x0370, 0x0400,
+ 0x0500, 0x0530, 0x0590, 0x0600, 0x0700, 0x0750, 0x0780, 0x07C0, 0x0800,
+ 0x0900, 0x0980, 0x0A00, 0x0A80, 0x0B00, 0x0B80, 0x0C00, 0x0C80, 0x0D00,
+ 0x0D80, 0x0E00, 0x0E80, 0x0F00, 0x1000, 0x10A0, 0x1100, 0x1200, 0x1380,
+ 0x13A0, 0x1400, 0x1680, 0x16A0, 0x1700, 0x1720, 0x1740, 0x1760, 0x1780,
+ 0x1800, 0x18B0, 0x1900, 0x1950, 0x1980, 0x19E0, 0x1A00, 0x1A20, 0x1B00,
+ 0x1B80, 0x1C00, 0x1C50, 0x1CD0, 0x1D00, 0x1D80, 0x1DC0, 0x1E00, 0x1F00,
+ 0x2000, 0x2070, 0x20A0, 0x20D0, 0x2100, 0x2150, 0x2190, 0x2200, 0x2300,
+ 0x2400, 0x2440, 0x2460, 0x2500, 0x2580, 0x25A0, 0x2600, 0x2700, 0x27C0,
+ 0x27F0, 0x2800, 0x2900, 0x2980, 0x2A00, 0x2B00, 0x2C00, 0x2C60, 0x2C80,
+ 0x2D00, 0x2D30, 0x2D80, 0x2DE0, 0x2E00, 0x2E80, 0x2F00, 0x2FF0, 0x3000,
+ 0x3040, 0x30A0, 0x3100, 0x3130, 0x3190, 0x31A0, 0x31C0, 0x31F0, 0x3200,
+ 0x3300, 0x3400, 0x4DC0, 0x4E00, 0xA000, 0xA490, 0xA4D0, 0xA500, 0xA640,
+ 0xA6A0, 0xA700, 0xA720, 0xA800, 0xA830, 0xA840, 0xA880, 0xA8E0, 0xA900,
+ 0xA930, 0xA960, 0xA980, 0xAA00, 0xAA60, 0xAA80, 0xABC0, 0xAC00, 0xD7B0,
+ 0xE000, 0xF900, 0xFB00, 0xFB50, 0xFE00, 0xFE10,
+ 0xFE20, 0xFE30, 0xFE50, 0xFE70, 0xFF00, 0xFFF0,
+ 0x10000, 0x10080, 0x10100, 0x10140, 0x10190, 0x101D0, 0x10280, 0x102A0,
+ 0x10300, 0x10330, 0x10380, 0x103A0, 0x10400, 0x10450, 0x10480, 0x10800,
+ 0x10840, 0x10900, 0x10920, 0x10A00, 0x10A60, 0x10B00, 0x10B40, 0x10B60,
+ 0x10C00, 0x10E60, 0x11080, 0x12000, 0x12400, 0x13000, 0x1D000, 0x1D100,
+ 0x1D200, 0x1D300, 0x1D360, 0x1D400, 0x1F000, 0x1F030, 0x1F100, 0x1F200,
0x20000, 0x2A700, 0x2F800, 0xE0000, 0xE0100, 0xF0000, 0x100000
};
-
+
private static final int[] blockEnds = {
- 0x007F, 0x00FF, 0x017F, 0x024F, 0x02AF, 0x02FF, 0x036F, 0x03FF, 0x04FF,
- 0x052F, 0x058F, 0x05FF, 0x06FF, 0x074F, 0x077F, 0x07BF, 0x07FF, 0x083F,
- 0x097F, 0x09FF, 0x0A7F, 0x0AFF, 0x0B7F, 0x0BFF, 0x0C7F, 0x0CFF, 0x0D7F,
- 0x0DFF, 0x0E7F, 0x0EFF, 0x0FFF, 0x109F, 0x10FF, 0x11FF, 0x137F, 0x139F,
- 0x13FF, 0x167F, 0x169F, 0x16FF, 0x171F, 0x173F, 0x175F, 0x177F, 0x17FF,
- 0x18AF, 0x18FF, 0x194F, 0x197F, 0x19DF, 0x19FF, 0x1A1F, 0x1AAF, 0x1B7F,
- 0x1BBF, 0x1C4F, 0x1C7F, 0x1CFF, 0x1D7F, 0x1DBF, 0x1DFF, 0x1EFF, 0x1FFF,
- 0x206F, 0x209F, 0x20CF, 0x20FF, 0x214F, 0x218F, 0x21FF, 0x22FF, 0x23FF,
- 0x243F, 0x245F, 0x24FF, 0x257F, 0x259F, 0x25FF, 0x26FF, 0x27BF, 0x27EF,
- 0x27FF, 0x28FF, 0x297F, 0x29FF, 0x2AFF, 0x2BFF, 0x2C5F, 0x2C7F, 0x2CFF,
- 0x2D2F, 0x2D7F, 0x2DDF, 0x2DFF, 0x2E7F, 0x2EFF, 0x2FDF, 0x2FFF, 0x303F,
- 0x309F, 0x30FF, 0x312F, 0x318F, 0x319F, 0x31BF, 0x31EF, 0x31FF, 0x32FF,
- 0x33FF, 0x4DBF, 0x4DFF, 0x9FFF, 0xA48F, 0xA4CF, 0xA4FF, 0xA63F, 0xA69F,
- 0xA6FF, 0xA71F, 0xA7FF, 0xA82F, 0xA83F, 0xA87F, 0xA8DF, 0xA8FF, 0xA92F,
- 0xA95F, 0xA97F, 0xA9DF, 0xAA5F, 0xAA7F, 0xAADF, 0xABFF, 0xD7AF, 0xD7FF,
- 0xF8FF, 0xFAFF, 0xFB4F, 0xFDFF, 0xFE0F, 0xFE1F,
- 0xFE2F, 0xFE4F, 0xFE6F, 0xFEFF, 0xFFEF, 0xFFFF,
- 0x1007F, 0x100FF, 0x1013F, 0x1018F, 0x101CF, 0x101FF, 0x1029F, 0x102DF,
- 0x1032F, 0x1034F, 0x1039F, 0x103DF, 0x1044F, 0x1047F, 0x104AF, 0x1083F,
- 0x1085F, 0x1091F, 0x1093F, 0x10A5F, 0x10A7F, 0x10B3F, 0x10B5F, 0x10B7F,
- 0x10C4F, 0x10E7F, 0x110CF, 0x123FF, 0x1247F, 0x1342F, 0x1D0FF, 0x1D1FF,
- 0x1D24F, 0x1D35F, 0x1D37F, 0x1D7FF, 0x1F02F, 0x1F09F, 0x1F1FF, 0x1F2FF,
+ 0x007F, 0x00FF, 0x017F, 0x024F, 0x02AF, 0x02FF, 0x036F, 0x03FF, 0x04FF,
+ 0x052F, 0x058F, 0x05FF, 0x06FF, 0x074F, 0x077F, 0x07BF, 0x07FF, 0x083F,
+ 0x097F, 0x09FF, 0x0A7F, 0x0AFF, 0x0B7F, 0x0BFF, 0x0C7F, 0x0CFF, 0x0D7F,
+ 0x0DFF, 0x0E7F, 0x0EFF, 0x0FFF, 0x109F, 0x10FF, 0x11FF, 0x137F, 0x139F,
+ 0x13FF, 0x167F, 0x169F, 0x16FF, 0x171F, 0x173F, 0x175F, 0x177F, 0x17FF,
+ 0x18AF, 0x18FF, 0x194F, 0x197F, 0x19DF, 0x19FF, 0x1A1F, 0x1AAF, 0x1B7F,
+ 0x1BBF, 0x1C4F, 0x1C7F, 0x1CFF, 0x1D7F, 0x1DBF, 0x1DFF, 0x1EFF, 0x1FFF,
+ 0x206F, 0x209F, 0x20CF, 0x20FF, 0x214F, 0x218F, 0x21FF, 0x22FF, 0x23FF,
+ 0x243F, 0x245F, 0x24FF, 0x257F, 0x259F, 0x25FF, 0x26FF, 0x27BF, 0x27EF,
+ 0x27FF, 0x28FF, 0x297F, 0x29FF, 0x2AFF, 0x2BFF, 0x2C5F, 0x2C7F, 0x2CFF,
+ 0x2D2F, 0x2D7F, 0x2DDF, 0x2DFF, 0x2E7F, 0x2EFF, 0x2FDF, 0x2FFF, 0x303F,
+ 0x309F, 0x30FF, 0x312F, 0x318F, 0x319F, 0x31BF, 0x31EF, 0x31FF, 0x32FF,
+ 0x33FF, 0x4DBF, 0x4DFF, 0x9FFF, 0xA48F, 0xA4CF, 0xA4FF, 0xA63F, 0xA69F,
+ 0xA6FF, 0xA71F, 0xA7FF, 0xA82F, 0xA83F, 0xA87F, 0xA8DF, 0xA8FF, 0xA92F,
+ 0xA95F, 0xA97F, 0xA9DF, 0xAA5F, 0xAA7F, 0xAADF, 0xABFF, 0xD7AF, 0xD7FF,
+ 0xF8FF, 0xFAFF, 0xFB4F, 0xFDFF, 0xFE0F, 0xFE1F,
+ 0xFE2F, 0xFE4F, 0xFE6F, 0xFEFF, 0xFFEF, 0xFFFF,
+ 0x1007F, 0x100FF, 0x1013F, 0x1018F, 0x101CF, 0x101FF, 0x1029F, 0x102DF,
+ 0x1032F, 0x1034F, 0x1039F, 0x103DF, 0x1044F, 0x1047F, 0x104AF, 0x1083F,
+ 0x1085F, 0x1091F, 0x1093F, 0x10A5F, 0x10A7F, 0x10B3F, 0x10B5F, 0x10B7F,
+ 0x10C4F, 0x10E7F, 0x110CF, 0x123FF, 0x1247F, 0x1342F, 0x1D0FF, 0x1D1FF,
+ 0x1D24F, 0x1D35F, 0x1D37F, 0x1D7FF, 0x1F02F, 0x1F09F, 0x1F1FF, 0x1F2FF,
0x2A6DF, 0x2B73F, 0x2FA1F, 0xE007F, 0xE01EF, 0xFFFFF, 0x10FFFF
};
-
+
/** Returns random string, all codepoints within the same unicode block. */
public static String randomRealisticUnicodeString(Random r) {
return randomRealisticUnicodeString(r, 20);
}
-
+
/** Returns random string, all codepoints within the same unicode block. */
public static String randomRealisticUnicodeString(Random r, int maxLength) {
final int end = r.nextInt(maxLength);
Modified: lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/automaton/AutomatonTestUtil.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/automaton/AutomatonTestUtil.java?rev=1073192&r1=1073113&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/automaton/AutomatonTestUtil.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test-framework/org/apache/lucene/util/automaton/AutomatonTestUtil.java Tue Feb 22 01:00:39 2011
@@ -80,9 +80,9 @@ public class AutomatonTestUtil {
return new String(buffer, 0, end);
}
- /** picks a random int code point, avoiding surrogates;
- * throws IllegalArgumentException if this transition only
- * accepts surrogates */
+ // picks a random int code point, avoiding surrogates;
+ // throws IllegalArgumentException if this transition only
+ // accepts surrogates
private static int getRandomCodePoint(final Random r, final Transition t) {
final int code;
if (t.max < UnicodeUtil.UNI_SUR_HIGH_START ||
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestAssertions.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestAssertions.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestAssertions.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestAssertions.java Tue Feb 22 01:00:39 2011
@@ -35,34 +35,45 @@ public class TestAssertions extends Luce
}
static class TestAnalyzer1 extends Analyzer {
+ @Override
public final TokenStream tokenStream(String s, Reader r) { return null; }
+ @Override
public final TokenStream reusableTokenStream(String s, Reader r) { return null; }
}
static final class TestAnalyzer2 extends Analyzer {
+ @Override
public TokenStream tokenStream(String s, Reader r) { return null; }
+ @Override
public TokenStream reusableTokenStream(String s, Reader r) { return null; }
}
static class TestAnalyzer3 extends Analyzer {
+ @Override
public TokenStream tokenStream(String s, Reader r) { return null; }
+ @Override
public TokenStream reusableTokenStream(String s, Reader r) { return null; }
}
static class TestAnalyzer4 extends Analyzer {
+ @Override
public final TokenStream tokenStream(String s, Reader r) { return null; }
+ @Override
public TokenStream reusableTokenStream(String s, Reader r) { return null; }
}
static class TestTokenStream1 extends TokenStream {
+ @Override
public final boolean incrementToken() { return false; }
}
static final class TestTokenStream2 extends TokenStream {
+ @Override
public boolean incrementToken() { return false; }
}
static class TestTokenStream3 extends TokenStream {
+ @Override
public boolean incrementToken() { return false; }
}
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestExternalCodecs.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestExternalCodecs.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestExternalCodecs.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestExternalCodecs.java Tue Feb 22 01:00:39 2011
@@ -63,6 +63,7 @@ public class TestExternalCodecs extends
return t2.length-t1.length;
}
+ @Override
public boolean equals(Object other) {
return this == other;
}
@@ -344,6 +345,7 @@ public class TestExternalCodecs extends
return ramField.termToDocs.get(current).totalTermFreq;
}
+ @Override
public DocsEnum docs(Bits skipDocs, DocsEnum reuse) {
return new RAMDocsEnum(ramField.termToDocs.get(current), skipDocs);
}
@@ -494,142 +496,17 @@ public class TestExternalCodecs extends
}
}
- public static class MyCodecs extends CodecProvider {
- MyCodecs() {
- Codec ram = new RAMOnlyCodec();
- register(ram);
- setDefaultFieldCodec(ram.name);
- }
- }
-
- // copied from PulsingCodec, just changing the terms
- // comparator
- private static class PulsingReverseTermsCodec extends Codec {
-
- public PulsingReverseTermsCodec() {
- name = "PulsingReverseTerms";
- }
-
- @Override
- public FieldsConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
- PostingsWriterBase docsWriter = new StandardPostingsWriter(state);
-
- // Terms that have <= freqCutoff number of docs are
- // "pulsed" (inlined):
- final int freqCutoff = 1;
- PostingsWriterBase pulsingWriter = new PulsingPostingsWriterImpl(freqCutoff, docsWriter);
-
- // Terms dict index
- TermsIndexWriterBase indexWriter;
- boolean success = false;
- try {
- indexWriter = new FixedGapTermsIndexWriter(state) {
- // We sort in reverse unicode order, so, we must
- // disable the suffix-stripping opto that
- // FixedGapTermsIndexWriter does by default!
- @Override
- protected int indexedTermPrefixLength(BytesRef priorTerm, BytesRef indexedTerm) {
- return indexedTerm.length;
- }
- };
- success = true;
- } finally {
- if (!success) {
- pulsingWriter.close();
- }
- }
-
- // Terms dict
- success = false;
- try {
- FieldsConsumer ret = new BlockTermsWriter(indexWriter, state, pulsingWriter, reverseUnicodeComparator);
- success = true;
- return ret;
- } finally {
- if (!success) {
- try {
- pulsingWriter.close();
- } finally {
- indexWriter.close();
- }
- }
- }
- }
-
- @Override
- public FieldsProducer fieldsProducer(SegmentReadState state) throws IOException {
-
- PostingsReaderBase docsReader = new StandardPostingsReader(state.dir, state.segmentInfo, state.readBufferSize, state.codecId);
- PostingsReaderBase pulsingReader = new PulsingPostingsReaderImpl(docsReader);
-
- // Terms dict index reader
- TermsIndexReaderBase indexReader;
-
- boolean success = false;
- try {
- indexReader = new FixedGapTermsIndexReader(state.dir,
- state.fieldInfos,
- state.segmentInfo.name,
- state.termsIndexDivisor,
- reverseUnicodeComparator,
- state.codecId);
- success = true;
- } finally {
- if (!success) {
- pulsingReader.close();
- }
- }
-
- // Terms dict reader
- success = false;
- try {
- FieldsProducer ret = new BlockTermsReader(indexReader,
- state.dir,
- state.fieldInfos,
- state.segmentInfo.name,
- pulsingReader,
- state.readBufferSize,
- reverseUnicodeComparator,
- StandardCodec.TERMS_CACHE_SIZE,
- state.codecId);
- success = true;
- return ret;
- } finally {
- if (!success) {
- try {
- pulsingReader.close();
- } finally {
- indexReader.close();
- }
- }
- }
- }
-
- @Override
- public void files(Directory dir, SegmentInfo segmentInfo, String codecId, Set<String> files) throws IOException {
- StandardPostingsReader.files(dir, segmentInfo, codecId, files);
- BlockTermsReader.files(dir, segmentInfo, codecId, files);
- FixedGapTermsIndexReader.files(dir, segmentInfo, codecId, files);
- }
-
- @Override
- public void getExtensions(Set<String> extensions) {
- StandardCodec.getStandardExtensions(extensions);
- }
- }
-
-
// tests storing "id" and "field2" fields as pulsing codec,
// whose term sort is backwards unicode code point, and
// storing "field1" as a custom entirely-in-RAM codec
public void testPerFieldCodec() throws Exception {
- CodecProvider provider = new MyCodecs();
- Codec pulsing = new PulsingReverseTermsCodec();
- provider.register(pulsing);
-
+ CodecProvider provider = new CoreCodecProvider();
+ provider.register(new RAMOnlyCodec());
+ provider.setDefaultFieldCodec("RamOnly");
final int NUM_DOCS = 173;
- Directory dir = newDirectory();
+ MockDirectoryWrapper dir = newDirectory();
+ dir.setCheckIndexOnClose(false); // we use a custom codec provider
IndexWriter w = new IndexWriter(
dir,
newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(MockTokenizer.WHITESPACE, true, true)).
@@ -642,11 +519,11 @@ public class TestExternalCodecs extends
doc.add(newField("field1", "this field uses the standard codec as the test", Field.Store.NO, Field.Index.ANALYZED));
// uses pulsing codec:
Field field2 = newField("field2", "this field uses the pulsing codec as the test", Field.Store.NO, Field.Index.ANALYZED);
- provider.setFieldCodec(field2.name(), pulsing.name);
+ provider.setFieldCodec(field2.name(), "Pulsing");
doc.add(field2);
Field idField = newField("id", "", Field.Store.NO, Field.Index.NOT_ANALYZED);
- provider.setFieldCodec(idField.name(), pulsing.name);
+ provider.setFieldCodec(idField.name(), "Pulsing");
doc.add(idField);
for(int i=0;i<NUM_DOCS;i++) {
@@ -656,19 +533,16 @@ public class TestExternalCodecs extends
w.commit();
}
}
+ if (VERBOSE) {
+ System.out.println("TEST: now delete id=77");
+ }
w.deleteDocuments(new Term("id", "77"));
- IndexReader r = IndexReader.open(w);
+ IndexReader r = IndexReader.open(w, true);
IndexReader[] subs = r.getSequentialSubReaders();
- // test each segment
- for(int i=0;i<subs.length;i++) {
- testTermsOrder(subs[i]);
- }
- // test each multi-reader
- testTermsOrder(r);
assertEquals(NUM_DOCS-1, r.numDocs());
- IndexSearcher s = new IndexSearcher(r);
+ IndexSearcher s = newSearcher(r);
assertEquals(NUM_DOCS-1, s.search(new TermQuery(new Term("field1", "standard")), 1).totalHits);
assertEquals(NUM_DOCS-1, s.search(new TermQuery(new Term("field2", "pulsing")), 1).totalHits);
r.close();
@@ -676,17 +550,16 @@ public class TestExternalCodecs extends
w.deleteDocuments(new Term("id", "44"));
w.optimize();
- r = IndexReader.open(w);
+ r = IndexReader.open(w, true);
assertEquals(NUM_DOCS-2, r.maxDoc());
assertEquals(NUM_DOCS-2, r.numDocs());
- s = new IndexSearcher(r);
+ s = newSearcher(r);
assertEquals(NUM_DOCS-2, s.search(new TermQuery(new Term("field1", "standard")), 1).totalHits);
assertEquals(NUM_DOCS-2, s.search(new TermQuery(new Term("field2", "pulsing")), 1).totalHits);
assertEquals(1, s.search(new TermQuery(new Term("id", "76")), 1).totalHits);
assertEquals(0, s.search(new TermQuery(new Term("id", "77")), 1).totalHits);
assertEquals(0, s.search(new TermQuery(new Term("id", "44")), 1).totalHits);
- testTermsOrder(r);
r.close();
s.close();
@@ -694,25 +567,4 @@ public class TestExternalCodecs extends
dir.close();
}
-
- private void testTermsOrder(IndexReader r) throws Exception {
-
- // Verify sort order matches what my comparator said:
- BytesRef lastBytesRef = null;
- TermsEnum terms = MultiFields.getFields(r).terms("id").iterator();
- //System.out.println("id terms:");
- while(true) {
- BytesRef t = terms.next();
- if (t == null) {
- break;
- }
- //System.out.println(" " + t);
- if (lastBytesRef == null) {
- lastBytesRef = new BytesRef(t);
- } else {
- assertTrue("terms in wrong order last=" + lastBytesRef.utf8ToString() + " current=" + t.utf8ToString(), reverseUnicodeComparator.compare(lastBytesRef, t) < 0);
- lastBytesRef.copy(t);
- }
- }
- }
}
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestMergeSchedulerExternal.java Tue Feb 22 01:00:39 2011
@@ -91,8 +91,8 @@ public class TestMergeSchedulerExternal
IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(
TEST_VERSION_CURRENT, new MockAnalyzer()).setMergeScheduler(new MyMergeScheduler())
- .setMaxBufferedDocs(2).setRAMBufferSizeMB(
- IndexWriterConfig.DISABLE_AUTO_FLUSH));
+ .setMaxBufferedDocs(2).setRAMBufferSizeMB(IndexWriterConfig.DISABLE_AUTO_FLUSH)
+ .setMergePolicy(newLogMergePolicy()));
LogMergePolicy logMP = (LogMergePolicy) writer.getConfig().getMergePolicy();
logMP.setMergeFactor(10);
for(int i=0;i<20;i++)
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestSearch.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestSearch.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestSearch.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestSearch.java Tue Feb 22 01:00:39 2011
@@ -74,8 +74,11 @@ public class TestSearch extends LuceneTe
Directory directory = newDirectory();
Analyzer analyzer = new MockAnalyzer();
IndexWriterConfig conf = newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
- LogMergePolicy lmp = (LogMergePolicy) conf.getMergePolicy();
- lmp.setUseCompoundFile(useCompoundFile);
+ MergePolicy mp = conf.getMergePolicy();
+ if (mp instanceof LogMergePolicy) {
+ ((LogMergePolicy) mp).setUseCompoundFile(useCompoundFile);
+ }
+
IndexWriter writer = new IndexWriter(directory, conf);
String[] docs = {
@@ -90,6 +93,7 @@ public class TestSearch extends LuceneTe
for (int j = 0; j < docs.length; j++) {
Document d = new Document();
d.add(newField("contents", docs[j], Field.Store.YES, Field.Index.ANALYZED));
+ d.add(newField("id", ""+j, Field.Index.NOT_ANALYZED_NO_NORMS));
writer.addDocument(d);
}
writer.close();
@@ -106,6 +110,10 @@ public class TestSearch extends LuceneTe
};
ScoreDoc[] hits = null;
+ Sort sort = new Sort(new SortField[] {
+ SortField.FIELD_SCORE,
+ new SortField("id", SortField.INT)});
+
QueryParser parser = new QueryParser(TEST_VERSION_CURRENT, "contents", analyzer);
parser.setPhraseSlop(4);
for (int j = 0; j < queries.length; j++) {
@@ -115,7 +123,7 @@ public class TestSearch extends LuceneTe
System.out.println("TEST: query=" + query);
}
- hits = searcher.search(query, null, 1000).scoreDocs;
+ hits = searcher.search(query, null, 1000, sort).scoreDocs;
out.println(hits.length + " total results");
for (int i = 0 ; i < hits.length && i < 10; i++) {
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestSearchForDuplicates.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestSearchForDuplicates.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestSearchForDuplicates.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/TestSearchForDuplicates.java Tue Feb 22 01:00:39 2011
@@ -80,8 +80,10 @@ public class TestSearchForDuplicates ext
Directory directory = newDirectory();
Analyzer analyzer = new MockAnalyzer();
IndexWriterConfig conf = newIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
- LogMergePolicy lmp = (LogMergePolicy) conf.getMergePolicy();
- lmp.setUseCompoundFile(useCompoundFiles);
+ final MergePolicy mp = conf.getMergePolicy();
+ if (mp instanceof LogMergePolicy) {
+ ((LogMergePolicy) mp).setUseCompoundFile(useCompoundFiles);
+ }
IndexWriter writer = new IndexWriter(directory, conf);
if (VERBOSE) {
System.out.println("TEST: now build index");
@@ -93,9 +95,6 @@ public class TestSearchForDuplicates ext
for (int j = 0; j < MAX_DOCS; j++) {
Document d = new Document();
d.add(newField(PRIORITY_FIELD, HIGH_PRIORITY, Field.Store.YES, Field.Index.ANALYZED));
-
- // NOTE: this ID_FIELD produces no tokens since
- // MockAnalyzer discards numbers
d.add(newField(ID_FIELD, Integer.toString(j), Field.Store.YES, Field.Index.ANALYZED));
writer.addDocument(d);
}
@@ -112,7 +111,11 @@ public class TestSearchForDuplicates ext
System.out.println("TEST: search query=" + query);
}
- ScoreDoc[] hits = searcher.search(query, null, MAX_DOCS).scoreDocs;
+ final Sort sort = new Sort(new SortField[] {
+ SortField.FIELD_SCORE,
+ new SortField(ID_FIELD, SortField.INT)});
+
+ ScoreDoc[] hits = searcher.search(query, null, MAX_DOCS, sort).scoreDocs;
printHits(out, hits, searcher);
checkHits(hits, MAX_DOCS, searcher);
@@ -127,7 +130,7 @@ public class TestSearchForDuplicates ext
query = parser.parse(HIGH_PRIORITY + " OR " + MED_PRIORITY);
out.println("Query: " + query.toString(PRIORITY_FIELD));
- hits = searcher.search(query, null, MAX_DOCS).scoreDocs;
+ hits = searcher.search(query, null, MAX_DOCS, sort).scoreDocs;
printHits(out, hits, searcher);
checkHits(hits, MAX_DOCS, searcher);
@@ -149,7 +152,7 @@ public class TestSearchForDuplicates ext
private void checkHits(ScoreDoc[] hits, int expectedCount, IndexSearcher searcher) throws IOException {
assertEquals("total results", expectedCount, hits.length);
for (int i = 0 ; i < hits.length; i++) {
- if ( i < 10 || (i > 94 && i < 105) ) {
+ if (i < 10 || (i > 94 && i < 105) ) {
Document d = searcher.doc(hits[i].doc);
assertEquals("check " + i, String.valueOf(i), d.get(ID_FIELD));
}
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/analysis/tokenattributes/TestCharTermAttributeImpl.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/analysis/tokenattributes/TestCharTermAttributeImpl.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/analysis/tokenattributes/TestCharTermAttributeImpl.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/analysis/tokenattributes/TestCharTermAttributeImpl.java Tue Feb 22 01:00:39 2011
@@ -227,6 +227,7 @@ public class TestCharTermAttributeImpl e
public char charAt(int i) { return longTestString.charAt(i); }
public int length() { return longTestString.length(); }
public CharSequence subSequence(int start, int end) { return longTestString.subSequence(start, end); }
+ @Override
public String toString() { return longTestString; }
});
assertEquals("4567890123456"+longTestString, t.toString());
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/document/TestDocument.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/document/TestDocument.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/document/TestDocument.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/document/TestDocument.java Tue Feb 22 01:00:39 2011
@@ -156,7 +156,7 @@ public class TestDocument extends Lucene
writer.addDocument(makeDocumentWithFields());
IndexReader reader = writer.getReader();
- IndexSearcher searcher = new IndexSearcher(reader);
+ IndexSearcher searcher = newSearcher(reader);
// search for something that does exists
Query query = new TermQuery(new Term("keyword", "test1"));
@@ -238,7 +238,7 @@ public class TestDocument extends Lucene
writer.addDocument(doc);
IndexReader reader = writer.getReader();
- IndexSearcher searcher = new IndexSearcher(reader);
+ IndexSearcher searcher = newSearcher(reader);
Query query = new TermQuery(new Term("keyword", "test"));
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestAddIndexes.java Tue Feb 22 01:00:39 2011
@@ -157,6 +157,7 @@ public class TestAddIndexes extends Luce
setUpDirs(dir, aux);
IndexWriter writer = newWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer()).setOpenMode(OpenMode.APPEND));
+ writer.setInfoStream(VERBOSE ? System.out : null);
writer.addIndexes(aux);
// Adds 10 docs, then replaces them with another 10
@@ -428,7 +429,7 @@ public class TestAddIndexes extends Luce
);
writer.addIndexes(aux, new MockDirectoryWrapper(random, new RAMDirectory(aux)));
- assertEquals(1060, writer.maxDoc());
+ assertEquals(1020, writer.maxDoc());
assertEquals(1000, writer.getDocCount(0));
writer.close();
dir.close();
@@ -452,6 +453,7 @@ public class TestAddIndexes extends Luce
setMaxBufferedDocs(100).
setMergePolicy(newLogMergePolicy(10))
);
+ writer.setInfoStream(VERBOSE ? System.out : null);
writer.addIndexes(aux);
assertEquals(30, writer.maxDoc());
assertEquals(3, writer.getSegmentCount());
@@ -480,7 +482,7 @@ public class TestAddIndexes extends Luce
);
writer.addIndexes(aux, aux2);
- assertEquals(1060, writer.maxDoc());
+ assertEquals(1040, writer.maxDoc());
assertEquals(1000, writer.getDocCount(0));
writer.close();
dir.close();
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestAtomicUpdate.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestAtomicUpdate.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestAtomicUpdate.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestAtomicUpdate.java Tue Feb 22 01:00:39 2011
@@ -131,6 +131,7 @@ public class TestAtomicUpdate extends Lu
.setMaxBufferedDocs(7);
((LogMergePolicy) conf.getMergePolicy()).setMergeFactor(3);
IndexWriter writer = new MockIndexWriter(directory, conf);
+ writer.setInfoStream(VERBOSE ? System.out : null);
// Establish a base index of 100 docs:
for(int i=0;i<100;i++) {
Modified: lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java
URL: http://svn.apache.org/viewvc/lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java?rev=1073192&r1=1073191&r2=1073192&view=diff
==============================================================================
--- lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java (original)
+++ lucene/dev/branches/realtime_search/lucene/src/test/org/apache/lucene/index/TestBackwardsCompatibility.java Tue Feb 22 01:00:39 2011
@@ -17,20 +17,13 @@ package org.apache.lucene.index;
* limitations under the License.
*/
-import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
-import java.io.FileOutputStream;
import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Arrays;
-import java.util.Enumeration;
import java.util.List;
import java.util.Random;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
import org.apache.lucene.analysis.MockAnalyzer;
import org.apache.lucene.document.Document;
@@ -78,39 +71,6 @@ public class TestBackwardsCompatibility
}
*/
- /* Unzips zipName --> dirName, removing dirName
- first */
- public void unzip(File zipName, String destDirName) throws IOException {
-
- ZipFile zipFile = new ZipFile(zipName);
-
- Enumeration<? extends ZipEntry> entries = zipFile.entries();
-
- String dirName = fullDir(destDirName);
-
- File fileDir = new File(dirName);
- rmDir(destDirName);
-
- fileDir.mkdir();
-
- while (entries.hasMoreElements()) {
- ZipEntry entry = entries.nextElement();
-
- InputStream in = zipFile.getInputStream(entry);
- OutputStream out = new BufferedOutputStream(new FileOutputStream(new File(fileDir, entry.getName())));
-
- byte[] buffer = new byte[8192];
- int len;
- while((len = in.read(buffer)) >= 0) {
- out.write(buffer, 0, len);
- }
-
- in.close();
- out.close();
- }
-
- zipFile.close();
- }
/*
public void testCreateCFS() throws IOException {
String dirName = "testindex.cfs";
@@ -153,10 +113,9 @@ public class TestBackwardsCompatibility
if (VERBOSE) {
System.out.println("TEST: index " + unsupportedNames[i]);
}
- unzip(getDataFile("unsupported." + unsupportedNames[i] + ".zip"), unsupportedNames[i]);
-
- String fullPath = fullDir(unsupportedNames[i]);
- Directory dir = newFSDirectory(new File(fullPath));
+ File oldIndxeDir = _TestUtil.getTempDir(unsupportedNames[i]);
+ _TestUtil.unzip(getDataFile("unsupported." + unsupportedNames[i] + ".zip"), oldIndxeDir);
+ Directory dir = newFSDirectory(oldIndxeDir);
IndexReader reader = null;
IndexWriter writer = null;
@@ -200,7 +159,7 @@ public class TestBackwardsCompatibility
assertTrue(bos.toString().contains(IndexFormatTooOldException.class.getName()));
dir.close();
- rmDir(unsupportedNames[i]);
+ _TestUtil.rmDir(oldIndxeDir);
}
}
@@ -209,10 +168,9 @@ public class TestBackwardsCompatibility
if (VERBOSE) {
System.out.println("\nTEST: index=" + oldNames[i]);
}
- unzip(getDataFile("index." + oldNames[i] + ".zip"), oldNames[i]);
-
- String fullPath = fullDir(oldNames[i]);
- Directory dir = newFSDirectory(new File(fullPath));
+ File oldIndxeDir = _TestUtil.getTempDir(oldNames[i]);
+ _TestUtil.unzip(getDataFile("index." + oldNames[i] + ".zip"), oldIndxeDir);
+ Directory dir = newFSDirectory(oldIndxeDir);
IndexWriter w = new IndexWriter(dir, new IndexWriterConfig(
TEST_VERSION_CURRENT, new MockAnalyzer()));
@@ -223,15 +181,15 @@ public class TestBackwardsCompatibility
_TestUtil.checkIndex(dir);
dir.close();
- rmDir(oldNames[i]);
+ _TestUtil.rmDir(oldIndxeDir);
}
}
public void testAddOldIndexes() throws IOException {
for (String name : oldNames) {
- unzip(getDataFile("index." + name + ".zip"), name);
- String fullPath = fullDir(name);
- Directory dir = newFSDirectory(new File(fullPath));
+ File oldIndxeDir = _TestUtil.getTempDir(name);
+ _TestUtil.unzip(getDataFile("index." + name + ".zip"), oldIndxeDir);
+ Directory dir = newFSDirectory(oldIndxeDir);
Directory targetDir = newDirectory();
IndexWriter w = new IndexWriter(targetDir, newIndexWriterConfig(
@@ -243,15 +201,15 @@ public class TestBackwardsCompatibility
dir.close();
targetDir.close();
- rmDir(name);
+ _TestUtil.rmDir(oldIndxeDir);
}
}
public void testAddOldIndexesReader() throws IOException {
for (String name : oldNames) {
- unzip(getDataFile("index." + name + ".zip"), name);
- String fullPath = fullDir(name);
- Directory dir = newFSDirectory(new File(fullPath));
+ File oldIndxeDir = _TestUtil.getTempDir(name);
+ _TestUtil.unzip(getDataFile("index." + name + ".zip"), oldIndxeDir);
+ Directory dir = newFSDirectory(oldIndxeDir);
IndexReader reader = IndexReader.open(dir);
Directory targetDir = newDirectory();
@@ -265,23 +223,25 @@ public class TestBackwardsCompatibility
dir.close();
targetDir.close();
- rmDir(name);
+ _TestUtil.rmDir(oldIndxeDir);
}
}
public void testSearchOldIndex() throws IOException {
for(int i=0;i<oldNames.length;i++) {
- unzip(getDataFile("index." + oldNames[i] + ".zip"), oldNames[i]);
- searchIndex(oldNames[i], oldNames[i]);
- rmDir(oldNames[i]);
+ File oldIndxeDir = _TestUtil.getTempDir(oldNames[i]);
+ _TestUtil.unzip(getDataFile("index." + oldNames[i] + ".zip"), oldIndxeDir);
+ searchIndex(oldIndxeDir, oldNames[i]);
+ _TestUtil.rmDir(oldIndxeDir);
}
}
public void testIndexOldIndexNoAdds() throws IOException {
for(int i=0;i<oldNames.length;i++) {
- unzip(getDataFile("index." + oldNames[i] + ".zip"), oldNames[i]);
- changeIndexNoAdds(random, oldNames[i]);
- rmDir(oldNames[i]);
+ File oldIndxeDir = _TestUtil.getTempDir(oldNames[i]);
+ _TestUtil.unzip(getDataFile("index." + oldNames[i] + ".zip"), oldIndxeDir);
+ changeIndexNoAdds(random, oldIndxeDir);
+ _TestUtil.rmDir(oldIndxeDir);
}
}
@@ -290,9 +250,10 @@ public class TestBackwardsCompatibility
if (VERBOSE) {
System.out.println("TEST: oldName=" + oldNames[i]);
}
- unzip(getDataFile("index." + oldNames[i] + ".zip"), oldNames[i]);
- changeIndexWithAdds(random, oldNames[i]);
- rmDir(oldNames[i]);
+ File oldIndxeDir = _TestUtil.getTempDir(oldNames[i]);
+ _TestUtil.unzip(getDataFile("index." + oldNames[i] + ".zip"), oldIndxeDir);
+ changeIndexWithAdds(random, oldIndxeDir, oldNames[i]);
+ _TestUtil.rmDir(oldIndxeDir);
}
}
@@ -305,13 +266,11 @@ public class TestBackwardsCompatibility
}
}
- public void searchIndex(String dirName, String oldName) throws IOException {
+ public void searchIndex(File indexDir, String oldName) throws IOException {
//QueryParser parser = new QueryParser("contents", new MockAnalyzer());
//Query query = parser.parse("handle:1");
- dirName = fullDir(dirName);
-
- Directory dir = newFSDirectory(new File(dirName));
+ Directory dir = newFSDirectory(indexDir);
IndexSearcher searcher = new IndexSearcher(dir, true);
IndexReader reader = searcher.getIndexReader();
@@ -343,7 +302,7 @@ public class TestBackwardsCompatibility
}
TermFreqVector tfv = reader.getTermFreqVector(i, "utf8");
- assertNotNull("docID=" + i + " index=" + dirName, tfv);
+ assertNotNull("docID=" + i + " index=" + indexDir.getName(), tfv);
assertTrue(tfv instanceof TermPositionVector);
} else
// Only ID 7 is deleted
@@ -376,11 +335,9 @@ public class TestBackwardsCompatibility
return v0 - v1;
}
- public void changeIndexWithAdds(Random random, String dirName) throws IOException {
- String origDirName = dirName;
- dirName = fullDir(dirName);
+ public void changeIndexWithAdds(Random random, File oldIndexDir, String origOldName) throws IOException {
- Directory dir = newFSDirectory(new File(dirName));
+ Directory dir = newFSDirectory(oldIndexDir);
// open writer
IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer()).setOpenMode(OpenMode.APPEND));
writer.setInfoStream(VERBOSE ? System.out : null);
@@ -391,7 +348,7 @@ public class TestBackwardsCompatibility
// make sure writer sees right total -- writer seems not to know about deletes in .del?
final int expected;
- if (compare(origDirName, "24") < 0) {
+ if (compare(origOldName, "24") < 0) {
expected = 44;
} else {
expected = 45;
@@ -409,7 +366,7 @@ public class TestBackwardsCompatibility
// make sure we can do delete & setNorm against this segment:
IndexReader reader = IndexReader.open(dir, false);
- searcher = new IndexSearcher(reader);
+ searcher = newSearcher(reader);
Term searchTerm = new Term("id", "6");
int delCount = reader.deleteDocuments(searchTerm);
assertEquals("wrong delete count", 1, delCount);
@@ -442,11 +399,9 @@ public class TestBackwardsCompatibility
dir.close();
}
- public void changeIndexNoAdds(Random random, String dirName) throws IOException {
-
- dirName = fullDir(dirName);
+ public void changeIndexNoAdds(Random random, File oldIndexDir) throws IOException {
- Directory dir = newFSDirectory(new File(dirName));
+ Directory dir = newFSDirectory(oldIndexDir);
// make sure searching sees right # hits
IndexSearcher searcher = new IndexSearcher(dir, true);
@@ -489,13 +444,12 @@ public class TestBackwardsCompatibility
dir.close();
}
- public void createIndex(Random random, String dirName, boolean doCFS) throws IOException {
-
- rmDir(dirName);
-
- dirName = fullDir(dirName);
+ public File createIndex(Random random, String dirName, boolean doCFS) throws IOException {
- Directory dir = newFSDirectory(new File(dirName));
+ File indexDir = _TestUtil.getTempDir(dirName);
+ _TestUtil.rmDir(indexDir);
+ Directory dir = newFSDirectory(indexDir);
+
IndexWriterConfig conf = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer()).setMaxBufferedDocs(10);
((LogMergePolicy) conf.getMergePolicy()).setUseCompoundFile(doCFS);
IndexWriter writer = new IndexWriter(dir, conf);
@@ -522,17 +476,21 @@ public class TestBackwardsCompatibility
// Set one norm so we get a .s0 file:
reader.setNorm(21, "content", conf.getSimilarityProvider().get("content").encodeNormValue(1.5f));
reader.close();
+ dir.close();
+
+ return indexDir;
}
/* Verifies that the expected file names were produced */
public void testExactFileNames() throws IOException {
- String outputDir = "lucene.backwardscompat0.index";
- rmDir(outputDir);
+ String outputDirName = "lucene.backwardscompat0.index";
+ File outputDir = _TestUtil.getTempDir(outputDirName);
+ _TestUtil.rmDir(outputDir);
try {
- Directory dir = newFSDirectory(new File(fullDir(outputDir)));
+ Directory dir = newFSDirectory(outputDir);
LogMergePolicy mergePolicy = newLogMergePolicy(true, 10);
mergePolicy.setNoCFSRatio(1); // This test expects all of its segments to be in CFS
@@ -570,10 +528,9 @@ public class TestBackwardsCompatibility
CompoundFileReader cfsReader = new CompoundFileReader(dir, "_0.cfs");
FieldInfos fieldInfos = new FieldInfos(cfsReader, "_0.fnm");
int contentFieldIndex = -1;
- for(int i=0;i<fieldInfos.size();i++) {
- FieldInfo fi = fieldInfos.fieldInfo(i);
+ for (FieldInfo fi : fieldInfos) {
if (fi.name.equals("content")) {
- contentFieldIndex = i;
+ contentFieldIndex = fi.number;
break;
}
}
@@ -595,7 +552,7 @@ public class TestBackwardsCompatibility
}
dir.close();
} finally {
- rmDir(outputDir);
+ _TestUtil.rmDir(outputDir);
}
}
@@ -636,23 +593,6 @@ public class TestBackwardsCompatibility
writer.addDocument(doc);
}
- private void rmDir(String dir) throws IOException {
- File fileDir = new File(fullDir(dir));
- if (fileDir.exists()) {
- File[] files = fileDir.listFiles();
- if (files != null) {
- for (int i = 0; i < files.length; i++) {
- files[i].delete();
- }
- }
- fileDir.delete();
- }
- }
-
- public static String fullDir(String dirName) throws IOException {
- return new File(TEMP_DIR, dirName).getCanonicalPath();
- }
-
private int countDocs(DocsEnum docs) throws IOException {
int count = 0;
while((docs.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {
@@ -664,9 +604,9 @@ public class TestBackwardsCompatibility
// flex: test basics of TermsEnum api on non-flex index
public void testNextIntoWrongField() throws Exception {
for(int i=0;i<oldNames.length;i++) {
- unzip(getDataFile("index." + oldNames[i] + ".zip"), oldNames[i]);
- String fullPath = fullDir(oldNames[i]);
- Directory dir = newFSDirectory(new File(fullPath));
+ File oldIndexDir = _TestUtil.getTempDir(oldNames[i]);
+ _TestUtil.unzip(getDataFile("index." + oldNames[i] + ".zip"), oldIndexDir);
+ Directory dir = newFSDirectory(oldIndexDir);
IndexReader r = IndexReader.open(dir);
TermsEnum terms = MultiFields.getFields(r).terms("content").iterator();
BytesRef t = terms.next();
@@ -703,16 +643,16 @@ public class TestBackwardsCompatibility
r.close();
dir.close();
- rmDir(oldNames[i]);
+ _TestUtil.rmDir(oldIndexDir);
}
}
public void testNumericFields() throws Exception {
for(int i=0;i<oldNames.length;i++) {
- unzip(getDataFile("index." + oldNames[i] + ".zip"), oldNames[i]);
- String fullPath = fullDir(oldNames[i]);
- Directory dir = newFSDirectory(new File(fullPath));
+ File oldIndexDir = _TestUtil.getTempDir(oldNames[i]);
+ _TestUtil.unzip(getDataFile("index." + oldNames[i] + ".zip"), oldIndexDir);
+ Directory dir = newFSDirectory(oldIndexDir);
IndexSearcher searcher = new IndexSearcher(dir, true);
for (int id=10; id<15; id++) {
@@ -747,7 +687,7 @@ public class TestBackwardsCompatibility
searcher.close();
dir.close();
- rmDir(oldNames[i]);
+ _TestUtil.rmDir(oldIndexDir);
}
}