test demonstrating problem cloning active IndexInput in LazyField: LUCENE-690

git-svn-id: https://svn.apache.org/repos/asf/lucene/java/trunk@465995 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Yonik Seeley 2006-10-20 05:10:49 +00:00
parent 247a4e2f4c
commit c270fa8a2f
1 changed files with 156 additions and 0 deletions

View File

@ -0,0 +1,156 @@
package org.apache.lucene.search;
/**
* Copyright 2006 The Apache Software Foundation
*
* Licensed 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 junit.framework.TestCase;
import org.apache.lucene.store.Directory;
import org.apache.lucene.store.RAMDirectory;
import org.apache.lucene.index.IndexReader;
import org.apache.lucene.index.IndexWriter;
import org.apache.lucene.analysis.WhitespaceAnalyzer;
import org.apache.lucene.document.*;
import java.util.Random;
import java.util.List;
import java.io.IOException;
/**
* @author yonik
* @version $Id$
*/
public class TestThreadSafe extends TestCase {
Random r = new Random();
Directory dir1;
Directory dir2;
IndexReader ir1;
IndexReader ir2;
String failure=null;
class Thr extends Thread {
final int iter;
final Random rand;
// pass in random in case we want to make things reproducable
public Thr(int iter, Random rand, int level) {
this.iter = iter;
this.rand = rand;
}
public void run() {
try {
for (int i=0; i<iter; i++) {
/*** future
// pick a random index reader... a shared one, or create your own
IndexReader ir;
***/
switch(rand.nextInt(2)) {
case 0: loadDoc(ir1); break;
}
}
} catch (Throwable th) {
failure=th.toString();
TestCase.fail(failure);
}
}
void loadDoc(IndexReader ir) throws IOException {
// beware of deleted docs in the future
Document doc = ir.document(rand.nextInt(ir.maxDoc()),
new FieldSelector() {
public FieldSelectorResult accept(String fieldName) {
switch(rand.nextInt(2)) {
case 0: return FieldSelectorResult.LAZY_LOAD;
case 1: return FieldSelectorResult.LOAD;
// TODO: add other options
default: return FieldSelectorResult.LOAD;
}
}
}
);
List fields = doc.getFields();
for (int i=0; i<fields.size(); i++) {
Fieldable f = (Fieldable)fields.get(i);
validateField(f);
}
}
}
void validateField(Fieldable f) {
String val = f.stringValue();
if (!val.startsWith("^") || !val.endsWith("$")) {
throw new RuntimeException("Invalid field:" + f.toString() + " val=" +val);
}
}
String[] words = "now is the time for all good men to come to the aid of their country".split(" ");
void buildDir(Directory dir, int nDocs, int maxFields, int maxFieldLen) throws IOException {
IndexWriter iw = new IndexWriter(dir, new WhitespaceAnalyzer(), true);
iw.setMaxBufferedDocs(10);
for (int j=0; j<nDocs; j++) {
Document d = new Document();
int nFields = r.nextInt(maxFields);
for (int i=0; i<nFields; i++) {
int flen = r.nextInt(maxFieldLen);
StringBuffer sb = new StringBuffer("^ ");
while (sb.length() < flen) sb.append(" " + words[r.nextInt(words.length)]);
sb.append(" $");
Field.Store store = Field.Store.YES; // make random later
Field.Index index = Field.Index.TOKENIZED; // make random later
d.add(new Field("f"+i, sb.toString(), store, index));
}
iw.addDocument(d);
}
iw.close();
}
void doTest(int iter, int nThreads) throws Exception {
Thr[] tarr = new Thr[nThreads];
for (int i=0; i<nThreads; i++) {
tarr[i] = new Thr(iter, new Random(), 1);
tarr[i].start();
}
for (int i=0; i<nThreads; i++) {
tarr[i].join();
}
if (failure!=null) {
TestCase.fail(failure);
}
}
public void testLazyLoadThreadSafety() throws Exception{
dir1 = new RAMDirectory();
// test w/ field sizes bigger than the buffer of an index input
buildDir(dir1, 15, 5, 2000);
// do many small tests so the thread locals go away inbetween
for (int i=0; i<100; i++) {
ir1 = IndexReader.open(dir1);
doTest(10,100);
}
}
}