← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/src/test/org/apache/lucene/index/TestIndexReaderCloneNorms.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 java.io.IOException;
21
 
import java.util.ArrayList;
22
 
import java.util.Random;
23
 
 
24
 
import java.util.concurrent.atomic.AtomicInteger;
25
 
import org.apache.lucene.analysis.Analyzer;
26
 
import org.apache.lucene.analysis.MockAnalyzer;
27
 
import org.apache.lucene.document.Document;
28
 
import org.apache.lucene.document.Field;
29
 
import org.apache.lucene.document.Field.Index;
30
 
import org.apache.lucene.document.Field.Store;
31
 
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
32
 
import org.apache.lucene.search.DefaultSimilarity;
33
 
import org.apache.lucene.search.Similarity;
34
 
import org.apache.lucene.store.Directory;
35
 
import org.apache.lucene.util.LuceneTestCase;
36
 
 
37
 
/**
38
 
 * Tests cloning IndexReader norms
39
 
 */
40
 
public class TestIndexReaderCloneNorms extends LuceneTestCase {
41
 
 
42
 
  private class SimilarityOne extends DefaultSimilarity {
43
 
    @Override
44
 
    public float computeNorm(String fieldName, FieldInvertState state) {
45
 
      // diable length norm
46
 
      return state.getBoost();
47
 
    }
48
 
  }
49
 
 
50
 
  private static final int NUM_FIELDS = 10;
51
 
 
52
 
  private Similarity similarityOne;
53
 
 
54
 
  private Analyzer anlzr;
55
 
 
56
 
  private int numDocNorms;
57
 
 
58
 
  private ArrayList<Float> norms;
59
 
 
60
 
  private ArrayList<Float> modifiedNorms;
61
 
 
62
 
  private float lastNorm = 0;
63
 
 
64
 
  private float normDelta = (float) 0.001;
65
 
 
66
 
  @Override
67
 
  public void setUp() throws Exception {
68
 
    super.setUp();
69
 
    similarityOne = new SimilarityOne();
70
 
    anlzr = new MockAnalyzer(random);
71
 
  }
72
 
  
73
 
  /**
74
 
   * Test that norms values are preserved as the index is maintained. Including
75
 
   * separate norms. Including merging indexes with seprate norms. Including
76
 
   * full merge.
77
 
   */
78
 
  public void testNorms() throws IOException {
79
 
    // test with a single index: index1
80
 
    Directory dir1 = newDirectory();
81
 
    IndexWriter.unlock(dir1);
82
 
 
83
 
    norms = new ArrayList<Float>();
84
 
    modifiedNorms = new ArrayList<Float>();
85
 
 
86
 
    createIndex(random, dir1);
87
 
    doTestNorms(random, dir1);
88
 
 
89
 
    // test with a single index: index2
90
 
    ArrayList<Float> norms1 = norms;
91
 
    ArrayList<Float> modifiedNorms1 = modifiedNorms;
92
 
    int numDocNorms1 = numDocNorms;
93
 
 
94
 
    norms = new ArrayList<Float>();
95
 
    modifiedNorms = new ArrayList<Float>();
96
 
    numDocNorms = 0;
97
 
 
98
 
    Directory dir2 = newDirectory();
99
 
 
100
 
    createIndex(random, dir2);
101
 
    doTestNorms(random, dir2);
102
 
 
103
 
    // add index1 and index2 to a third index: index3
104
 
    Directory dir3 = newDirectory();
105
 
 
106
 
    createIndex(random, dir3);
107
 
    if (VERBOSE) {
108
 
      System.out.println("TEST: now addIndexes/full merge");
109
 
    }
110
 
    IndexWriter iw = new IndexWriter(
111
 
        dir3,
112
 
        newIndexWriterConfig(TEST_VERSION_CURRENT, anlzr).
113
 
            setOpenMode(OpenMode.APPEND).
114
 
            setMaxBufferedDocs(5).
115
 
            setMergePolicy(newLogMergePolicy(3)));
116
 
    iw.addIndexes(dir1, dir2);
117
 
    iw.forceMerge(1);
118
 
    iw.close();
119
 
 
120
 
    norms1.addAll(norms);
121
 
    norms = norms1;
122
 
    modifiedNorms1.addAll(modifiedNorms);
123
 
    modifiedNorms = modifiedNorms1;
124
 
    numDocNorms += numDocNorms1;
125
 
 
126
 
    // test with index3
127
 
    verifyIndex(dir3);
128
 
    doTestNorms(random, dir3);
129
 
 
130
 
    // now with full merge
131
 
    iw = new IndexWriter(dir3, newIndexWriterConfig( TEST_VERSION_CURRENT,
132
 
                                                     anlzr).setOpenMode(OpenMode.APPEND).setMaxBufferedDocs(5).setMergePolicy(newLogMergePolicy(3)));
133
 
    iw.forceMerge(1);
134
 
    iw.close();
135
 
    verifyIndex(dir3);
136
 
 
137
 
    dir1.close();
138
 
    dir2.close();
139
 
    dir3.close();
140
 
  }
141
 
 
142
 
  // try cloning and reopening the norms
143
 
  private void doTestNorms(Random random, Directory dir) throws IOException {
144
 
    addDocs(random, dir, 12, true);
145
 
    IndexReader ir = IndexReader.open(dir, false);
146
 
    verifyIndex(ir);
147
 
    modifyNormsForF1(ir);
148
 
    IndexReader irc = (IndexReader) ir.clone();// IndexReader.open(dir, false);//ir.clone();
149
 
    verifyIndex(irc);
150
 
 
151
 
    modifyNormsForF1(irc);
152
 
 
153
 
    IndexReader irc3 = (IndexReader) irc.clone();
154
 
    verifyIndex(irc3);
155
 
    modifyNormsForF1(irc3);
156
 
    verifyIndex(irc3);
157
 
    irc3.flush();
158
 
    irc3.close();
159
 
    
160
 
    irc.close();
161
 
    ir.close();
162
 
  }
163
 
  
164
 
  public void testNormsClose() throws IOException { 
165
 
    Directory dir1 = newDirectory(); 
166
 
    TestIndexReaderReopen.createIndex(random, dir1, false);
167
 
    SegmentReader reader1 = SegmentReader.getOnlySegmentReader(dir1);
168
 
    reader1.norms("field1");
169
 
    SegmentNorms r1norm = reader1.norms.get("field1");
170
 
    AtomicInteger r1BytesRef = r1norm.bytesRef();
171
 
    SegmentReader reader2 = (SegmentReader)reader1.clone();
172
 
    assertEquals(2, r1norm.bytesRef().get());
173
 
    reader1.close();
174
 
    assertEquals(1, r1BytesRef.get());
175
 
    reader2.norms("field1");
176
 
    reader2.close();
177
 
    dir1.close();
178
 
  }
179
 
  
180
 
  public void testNormsRefCounting() throws IOException { 
181
 
    Directory dir1 = newDirectory(); 
182
 
    TestIndexReaderReopen.createIndex(random, dir1, false);
183
 
    IndexReader reader1 = IndexReader.open(dir1, false);
184
 
        
185
 
    IndexReader reader2C = (IndexReader) reader1.clone();
186
 
    SegmentReader segmentReader2C = SegmentReader.getOnlySegmentReader(reader2C);
187
 
    segmentReader2C.norms("field1"); // load the norms for the field
188
 
    SegmentNorms reader2CNorm = segmentReader2C.norms.get("field1");
189
 
    assertTrue("reader2CNorm.bytesRef()=" + reader2CNorm.bytesRef(), reader2CNorm.bytesRef().get() == 2);
190
 
    
191
 
    
192
 
    
193
 
    IndexReader reader3C = (IndexReader) reader2C.clone();
194
 
    SegmentReader segmentReader3C = SegmentReader.getOnlySegmentReader(reader3C);
195
 
    SegmentNorms reader3CCNorm = segmentReader3C.norms.get("field1");
196
 
    assertEquals(3, reader3CCNorm.bytesRef().get());
197
 
    
198
 
    // edit a norm and the refcount should be 1
199
 
    IndexReader reader4C = (IndexReader) reader3C.clone();
200
 
    SegmentReader segmentReader4C = SegmentReader.getOnlySegmentReader(reader4C);
201
 
    assertEquals(4, reader3CCNorm.bytesRef().get());
202
 
    reader4C.setNorm(5, "field1", 0.33f);
203
 
    
204
 
    // generate a cannot update exception in reader1
205
 
    try {
206
 
      reader3C.setNorm(1, "field1", 0.99f);
207
 
      fail("did not hit expected exception");
208
 
    } catch (Exception ex) {
209
 
      // expected
210
 
    }
211
 
    
212
 
    // norm values should be different 
213
 
    assertTrue(Similarity.getDefault().decodeNormValue(segmentReader3C.norms("field1")[5]) 
214
 
                != Similarity.getDefault().decodeNormValue(segmentReader4C.norms("field1")[5]));
215
 
    SegmentNorms reader4CCNorm = segmentReader4C.norms.get("field1");
216
 
    assertEquals(3, reader3CCNorm.bytesRef().get());
217
 
    assertEquals(1, reader4CCNorm.bytesRef().get());
218
 
        
219
 
    IndexReader reader5C = (IndexReader) reader4C.clone();
220
 
    SegmentReader segmentReader5C = SegmentReader.getOnlySegmentReader(reader5C);
221
 
    SegmentNorms reader5CCNorm = segmentReader5C.norms.get("field1");
222
 
    reader5C.setNorm(5, "field1", 0.7f);
223
 
    assertEquals(1, reader5CCNorm.bytesRef().get());
224
 
 
225
 
    reader5C.close();
226
 
    reader4C.close();
227
 
    reader3C.close();
228
 
    reader2C.close();
229
 
    reader1.close();
230
 
    dir1.close();
231
 
  }
232
 
  
233
 
  private void createIndex(Random random, Directory dir) throws IOException {
234
 
    IndexWriter iw = new IndexWriter(dir, newIndexWriterConfig(
235
 
        TEST_VERSION_CURRENT, anlzr).setOpenMode(OpenMode.CREATE)
236
 
                                     .setMaxBufferedDocs(5).setSimilarity(similarityOne).setMergePolicy(newLogMergePolicy()));
237
 
    setUseCompoundFile(iw.getConfig().getMergePolicy(), true);
238
 
    setMergeFactor(iw.getConfig().getMergePolicy(), 3);
239
 
    iw.close();
240
 
  }
241
 
 
242
 
  private void modifyNormsForF1(IndexReader ir) throws IOException {
243
 
    int n = ir.maxDoc();
244
 
    // System.out.println("modifyNormsForF1 maxDoc: "+n);
245
 
    for (int i = 0; i < n; i += 3) { // modify for every third doc
246
 
      int k = (i * 3) % modifiedNorms.size();
247
 
      float origNorm =  modifiedNorms.get(i).floatValue();
248
 
      float newNorm =  modifiedNorms.get(k).floatValue();
249
 
      // System.out.println("Modifying: for "+i+" from "+origNorm+" to
250
 
      // "+newNorm);
251
 
      // System.out.println(" and: for "+k+" from "+newNorm+" to "+origNorm);
252
 
      modifiedNorms.set(i, Float.valueOf(newNorm));
253
 
      modifiedNorms.set(k, Float.valueOf(origNorm));
254
 
      ir.setNorm(i, "f" + 1, newNorm);
255
 
      ir.setNorm(k, "f" + 1, origNorm);
256
 
      // System.out.println("setNorm i: "+i);
257
 
      // break;
258
 
    }
259
 
    // ir.close();
260
 
  }
261
 
 
262
 
  private void verifyIndex(Directory dir) throws IOException {
263
 
    IndexReader ir = IndexReader.open(dir, false);
264
 
    verifyIndex(ir);
265
 
    ir.close();
266
 
  }
267
 
 
268
 
  private void verifyIndex(IndexReader ir) throws IOException {
269
 
    for (int i = 0; i < NUM_FIELDS; i++) {
270
 
      String field = "f" + i;
271
 
      byte b[] = ir.norms(field);
272
 
      assertEquals("number of norms mismatches", numDocNorms, b.length);
273
 
      ArrayList<Float> storedNorms = (i == 1 ? modifiedNorms : norms);
274
 
      for (int j = 0; j < b.length; j++) {
275
 
        float norm = Similarity.getDefault().decodeNormValue(b[j]);
276
 
        float norm1 =  storedNorms.get(j).floatValue();
277
 
        assertEquals("stored norm value of " + field + " for doc " + j + " is "
278
 
            + norm + " - a mismatch!", norm, norm1, 0.000001);
279
 
      }
280
 
    }
281
 
  }
282
 
 
283
 
  private void addDocs(Random random, Directory dir, int ndocs, boolean compound)
284
 
      throws IOException {
285
 
    IndexWriterConfig conf = newIndexWriterConfig(
286
 
            TEST_VERSION_CURRENT, anlzr).setOpenMode(OpenMode.APPEND)
287
 
      .setMaxBufferedDocs(5).setSimilarity(similarityOne).setMergePolicy(newLogMergePolicy());
288
 
    LogMergePolicy lmp = (LogMergePolicy) conf.getMergePolicy();
289
 
    lmp.setMergeFactor(3);
290
 
    lmp.setUseCompoundFile(compound);
291
 
    IndexWriter iw = new IndexWriter(dir, conf);
292
 
    for (int i = 0; i < ndocs; i++) {
293
 
      iw.addDocument(newDoc());
294
 
    }
295
 
    iw.close();
296
 
  }
297
 
 
298
 
  // create the next document
299
 
  private Document newDoc() {
300
 
    Document d = new Document();
301
 
    float boost = nextNorm();
302
 
    for (int i = 0; i < 10; i++) {
303
 
      Field f = newField("f" + i, "v" + i, Store.NO, Index.NOT_ANALYZED);
304
 
      f.setBoost(boost);
305
 
      d.add(f);
306
 
    }
307
 
    return d;
308
 
  }
309
 
 
310
 
  // return unique norm values that are unchanged by encoding/decoding
311
 
  private float nextNorm() {
312
 
    float norm = lastNorm + normDelta;
313
 
    do {
314
 
      float norm1 = Similarity.getDefault().decodeNormValue(
315
 
                  Similarity.getDefault().encodeNormValue(norm));
316
 
      if (norm1 > lastNorm) {
317
 
        // System.out.println(norm1+" > "+lastNorm);
318
 
        norm = norm1;
319
 
        break;
320
 
      }
321
 
      norm += normDelta;
322
 
    } while (true);
323
 
    norms.add(numDocNorms, Float.valueOf(norm));
324
 
    modifiedNorms.add(numDocNorms, Float.valueOf(norm));
325
 
    // System.out.println("creating norm("+numDocNorms+"): "+norm);
326
 
    numDocNorms++;
327
 
    lastNorm = (norm > 10 ? 0 : norm); // there's a limit to how many distinct
328
 
                                        // values can be stored in a ingle byte
329
 
    return norm;
330
 
  }
331
 
}