lucene-java-3.5.0/lucene/backwards/src/test/org/apache/lucene/index/Test2BTerms.java

   1 package org.apache.lucene.index;
   2
   3 /**
   4  * Licensed to the Apache Software Foundation (ASF) under one or more
   5  * contributor license agreements.  See the NOTICE file distributed with
   6  * this work for additional information regarding copyright ownership.
   7  * The ASF licenses this file to You under the Apache License, Version 2.0
   8  * (the "License"); you may not use this file except in compliance with
   9  * the License.  You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 import org.apache.lucene.util.*;
  21 import org.apache.lucene.store.*;
  22 import org.apache.lucene.search.*;
  23 import org.apache.lucene.analysis.*;
  24 import org.apache.lucene.analysis.tokenattributes.*;
  25 import org.apache.lucene.document.*;
  26 import org.apache.lucene.index.FieldInfo.IndexOptions;
  27 import java.io.File;
  28 import java.io.IOException;
  29 import java.io.UnsupportedEncodingException;
  30 import java.util.ArrayList;
  31 import java.util.Collections;
  32 import java.util.List;
  33 import org.junit.Ignore;
  34
  35 // Best to run this test w/ plenty of RAM (because of the
  36 // terms index):
  37 //
  38 //   ant compile-test
  39 //
  40 //   java -server -Xmx8g -d64 -cp .:lib/junit-4.7.jar:./build/classes/test:./build/classes/test-framework:./build/classes/java -Dlucene.version=4.0-dev -Dtests.directory=MMapDirectory -DtempDir=build -ea org.junit.runner.JUnitCore org.apache.lucene.index.Test2BTerms
  41 //
  42
  43 public class Test2BTerms extends LuceneTestCase {
  44
  45   private final class MyTokenStream extends TokenStream {
  46
  47     private final int tokensPerDoc;
  48     private int tokenCount;
  49     private final CharTermAttribute charTerm;
  50     private final static int TOKEN_LEN = 5;
  51     private final char[] chars;
  52     public final List<String> savedTerms = new ArrayList<String>();
  53     private int nextSave;
  54
  55     public MyTokenStream(int tokensPerDoc) {
  56       super();
  57       this.tokensPerDoc = tokensPerDoc;
  58       charTerm = addAttribute(CharTermAttribute.class);
  59       chars = charTerm.resizeBuffer(TOKEN_LEN);
  60       charTerm.setLength(TOKEN_LEN);
  61       nextSave = _TestUtil.nextInt(random, 500000, 1000000);
  62     }
  63
  64     @Override
  65     public boolean incrementToken() {
  66       if (tokenCount >= tokensPerDoc) {
  67         return false;
  68       }
  69       _TestUtil.randomFixedLengthUnicodeString(random, chars, 0, TOKEN_LEN);
  70       tokenCount++;
  71       if (--nextSave == 0) {
  72         final String s = new String(chars, 0, TOKEN_LEN);
  73         System.out.println("TEST: save term=" + s + " [" + toHexString(s) + "]");
  74         savedTerms.add(s);
  75         nextSave = _TestUtil.nextInt(random, 500000, 1000000);
  76       }
  77       return true;
  78     }
  79
  80     @Override
  81     public void reset() {
  82       tokenCount = 0;
  83     }
  84   }
  85
  86   @Ignore("Takes ~4 hours to run on a fast machine!!")
  87   public void test2BTerms() throws IOException {
  88
  89     final long TERM_COUNT = ((long) Integer.MAX_VALUE) + 100000000;
  90
  91     final int TERMS_PER_DOC = _TestUtil.nextInt(random, 100000, 1000000);
  92
  93     List<String> savedTerms = null;
  94
  95     MockDirectoryWrapper dir = newFSDirectory(_TestUtil.getTempDir("2BTerms"));
  96     dir.setThrottling(MockDirectoryWrapper.Throttling.NEVER);
  97     dir.setCheckIndexOnClose(false); // don't double-checkindex
  98     //Directory dir = newFSDirectory(new File("/p/lucene/indices/2bindex"));
  99
 100     if (true) {
 101
 102       IndexWriter w = new IndexWriter(dir,
 103                                       new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(random))
 104                                       .setMaxBufferedDocs(IndexWriterConfig.DISABLE_AUTO_FLUSH)
 105                                       .setRAMBufferSizeMB(256.0)
 106                                       .setMergeScheduler(new ConcurrentMergeScheduler())
 107                                       .setMergePolicy(newLogMergePolicy(false, 10))
 108                                       .setOpenMode(IndexWriterConfig.OpenMode.CREATE));
 109
 110       MergePolicy mp = w.getConfig().getMergePolicy();
 111       if (mp instanceof LogByteSizeMergePolicy) {
 112         // 1 petabyte:
 113         ((LogByteSizeMergePolicy) mp).setMaxMergeMB(1024*1024*1024);
 114       }
 115
 116       Document doc = new Document();
 117
 118       final MyTokenStream ts = new MyTokenStream(TERMS_PER_DOC);
 119       Field field = new Field("field", ts);
 120       field.setIndexOptions(IndexOptions.DOCS_ONLY);
 121       field.setOmitNorms(true);
 122       doc.add(field);
 123       //w.setInfoStream(System.out);
 124       final int numDocs = (int) (TERM_COUNT/TERMS_PER_DOC);
 125
 126       System.out.println("TERMS_PER_DOC=" + TERMS_PER_DOC);
 127       System.out.println("numDocs=" + numDocs);
 128
 129       for(int i=0;i<numDocs;i++) {
 130         final long t0 = System.currentTimeMillis();
 131         w.addDocument(doc);
 132         System.out.println(i + " of " + numDocs + " " + (System.currentTimeMillis()-t0) + " msec");
 133       }
 134       savedTerms = ts.savedTerms;
 135
 136       System.out.println("TEST: optimize");
 137       w.optimize();
 138       System.out.println("TEST: close writer");
 139       w.close();
 140     }
 141
 142     System.out.println("TEST: open reader");
 143     final IndexReader r = IndexReader.open(dir);
 144     if (savedTerms == null) {
 145       savedTerms = findTerms(r);
 146     }
 147     final int numSavedTerms = savedTerms.size();
 148     final List<String> bigOrdTerms = new ArrayList<String>(savedTerms.subList(numSavedTerms-10, numSavedTerms));
 149     System.out.println("TEST: test big ord terms...");
 150     testSavedTerms(r, bigOrdTerms);
 151     System.out.println("TEST: test all saved terms...");
 152     testSavedTerms(r, savedTerms);
 153     r.close();
 154
 155     System.out.println("TEST: now CheckIndex...");
 156     CheckIndex.Status status = _TestUtil.checkIndex(dir);
 157     final long tc = status.segmentInfos.get(0).termIndexStatus.termCount;
 158     assertTrue("count " + tc + " is not > " + Integer.MAX_VALUE, tc > Integer.MAX_VALUE);
 159     dir.close();
 160   }
 161
 162   private List<String> findTerms(IndexReader r) throws IOException {
 163     System.out.println("TEST: findTerms");
 164     final TermEnum termEnum = r.terms();
 165     final List<String> savedTerms = new ArrayList<String>();
 166     int nextSave = _TestUtil.nextInt(random, 500000, 1000000);
 167     while(termEnum.next()) {
 168       if (--nextSave == 0) {
 169         savedTerms.add(termEnum.term().text());
 170         System.out.println("TEST: add " + termEnum.term());
 171         nextSave = _TestUtil.nextInt(random, 500000, 1000000);
 172       }
 173     }
 174     return savedTerms;
 175   }
 176
 177   private String toHexString(String s) {
 178     byte[] bytes;
 179     try {
 180       bytes = s.getBytes("UTF-8");
 181     } catch (UnsupportedEncodingException uee) {
 182       throw new RuntimeException(uee);
 183     }
 184     StringBuilder sb = new StringBuilder();
 185     for(byte b : bytes) {
 186       if (sb.length() > 0) {
 187         sb.append(' ');
 188       }
 189       sb.append(Integer.toHexString(b&0xFF));
 190     }
 191     return sb.toString();
 192   }
 193
 194   private void testSavedTerms(IndexReader r, List<String> terms) throws IOException {
 195     System.out.println("TEST: run " + terms.size() + " terms on reader=" + r);
 196     IndexSearcher s = new IndexSearcher(r);
 197     Collections.shuffle(terms);
 198     boolean failed = false;
 199     for(int iter=0;iter<10*terms.size();iter++) {
 200       final String term = terms.get(random.nextInt(terms.size()));
 201       System.out.println("TEST: search " + term + " [" + toHexString(term) + "]");
 202       final long t0 = System.currentTimeMillis();
 203       final int count = s.search(new TermQuery(new Term("field", term)), 1).totalHits;
 204       if (count <= 0) {
 205         System.out.println("  FAILED: count=" + count);
 206         failed = true;
 207       }
 208       final long t1 = System.currentTimeMillis();
 209       System.out.println("  took " + (t1-t0) + " millis");
 210
 211       final TermEnum termEnum = r.terms(new Term("field", term));
 212       final String text = termEnum.term().text();
 213       if (!term.equals(text)) {
 214         System.out.println("  FAILED: wrong term: got " + text + " [" + toHexString(text) + "]");
 215         failed = true;
 216       }
 217     }
 218     assertFalse(failed);
 219   }
 220 }