← 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/TestParallelTermEnum.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/TestParallelTermEnum.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
 
 
22
 
import org.apache.lucene.util.LuceneTestCase;
23
 
import org.apache.lucene.analysis.MockAnalyzer;
24
 
import org.apache.lucene.document.Document;
25
 
import org.apache.lucene.document.Field.Index;
26
 
import org.apache.lucene.document.Field.Store;
27
 
import org.apache.lucene.store.Directory;
28
 
 
29
 
public class TestParallelTermEnum extends LuceneTestCase {
30
 
    private IndexReader ir1;
31
 
    private IndexReader ir2;
32
 
    private Directory rd1;
33
 
    private Directory rd2;
34
 
    
35
 
    @Override
36
 
    public void setUp() throws Exception {
37
 
        super.setUp();
38
 
        Document doc;
39
 
        rd1 = newDirectory();
40
 
        IndexWriter iw1 = new IndexWriter(rd1, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
41
 
 
42
 
        doc = new Document();
43
 
        doc.add(newField("field1", "the quick brown fox jumps", Store.YES,
44
 
            Index.ANALYZED));
45
 
        doc.add(newField("field2", "the quick brown fox jumps", Store.YES,
46
 
            Index.ANALYZED));
47
 
        doc.add(newField("field4", "", Store.NO, Index.ANALYZED));
48
 
        iw1.addDocument(doc);
49
 
 
50
 
        iw1.close();
51
 
 
52
 
        rd2 = newDirectory();
53
 
        IndexWriter iw2 = new IndexWriter(rd2, newIndexWriterConfig( TEST_VERSION_CURRENT, new MockAnalyzer(random)));
54
 
 
55
 
        doc = new Document();
56
 
        doc.add(newField("field0", "", Store.NO, Index.ANALYZED));
57
 
        doc.add(newField("field1", "the fox jumps over the lazy dog",
58
 
            Store.YES, Index.ANALYZED));
59
 
        doc.add(newField("field3", "the fox jumps over the lazy dog",
60
 
            Store.YES, Index.ANALYZED));
61
 
        iw2.addDocument(doc);
62
 
 
63
 
        iw2.close();
64
 
 
65
 
        this.ir1 = IndexReader.open(rd1, true);
66
 
        this.ir2 = IndexReader.open(rd2, true);
67
 
    }
68
 
 
69
 
    @Override
70
 
    public void tearDown() throws Exception {
71
 
        ir1.close();
72
 
        ir2.close();
73
 
        rd1.close();
74
 
        rd2.close();
75
 
        super.tearDown();
76
 
    }
77
 
 
78
 
    public void test1() throws IOException {
79
 
        ParallelReader pr = new ParallelReader();
80
 
        pr.add(ir1);
81
 
        pr.add(ir2);
82
 
 
83
 
        TermDocs td = pr.termDocs();
84
 
 
85
 
        TermEnum te = pr.terms();
86
 
        assertTrue(te.next());
87
 
        assertEquals("field1:brown", te.term().toString());
88
 
        td.seek(te.term());
89
 
        assertTrue(td.next());
90
 
        assertEquals(0, td.doc());
91
 
        assertFalse(td.next());
92
 
        assertTrue(te.next());
93
 
        assertEquals("field1:fox", te.term().toString());
94
 
        td.seek(te.term());
95
 
        assertTrue(td.next());
96
 
        assertEquals(0, td.doc());
97
 
        assertFalse(td.next());
98
 
        assertTrue(te.next());
99
 
        assertEquals("field1:jumps", te.term().toString());
100
 
        td.seek(te.term());
101
 
        assertTrue(td.next());
102
 
        assertEquals(0, td.doc());
103
 
        assertFalse(td.next());
104
 
        assertTrue(te.next());
105
 
        assertEquals("field1:quick", te.term().toString());
106
 
        td.seek(te.term());
107
 
        assertTrue(td.next());
108
 
        assertEquals(0, td.doc());
109
 
        assertFalse(td.next());
110
 
        assertTrue(te.next());
111
 
        assertEquals("field1:the", te.term().toString());
112
 
        td.seek(te.term());
113
 
        assertTrue(td.next());
114
 
        assertEquals(0, td.doc());
115
 
        assertFalse(td.next());
116
 
        assertTrue(te.next());
117
 
        assertEquals("field2:brown", te.term().toString());
118
 
        td.seek(te.term());
119
 
        assertTrue(td.next());
120
 
        assertEquals(0, td.doc());
121
 
        assertFalse(td.next());
122
 
        assertTrue(te.next());
123
 
        assertEquals("field2:fox", te.term().toString());
124
 
        td.seek(te.term());
125
 
        assertTrue(td.next());
126
 
        assertEquals(0, td.doc());
127
 
        assertFalse(td.next());
128
 
        assertTrue(te.next());
129
 
        assertEquals("field2:jumps", te.term().toString());
130
 
        td.seek(te.term());
131
 
        assertTrue(td.next());
132
 
        assertEquals(0, td.doc());
133
 
        assertFalse(td.next());
134
 
        assertTrue(te.next());
135
 
        assertEquals("field2:quick", te.term().toString());
136
 
        td.seek(te.term());
137
 
        assertTrue(td.next());
138
 
        assertEquals(0, td.doc());
139
 
        assertFalse(td.next());
140
 
        assertTrue(te.next());
141
 
        assertEquals("field2:the", te.term().toString());
142
 
        td.seek(te.term());
143
 
        assertTrue(td.next());
144
 
        assertEquals(0, td.doc());
145
 
        assertFalse(td.next());
146
 
        assertTrue(te.next());
147
 
        assertEquals("field3:dog", te.term().toString());
148
 
        td.seek(te.term());
149
 
        assertTrue(td.next());
150
 
        assertEquals(0, td.doc());
151
 
        assertFalse(td.next());
152
 
        assertTrue(te.next());
153
 
        assertEquals("field3:fox", te.term().toString());
154
 
        td.seek(te.term());
155
 
        assertTrue(td.next());
156
 
        assertEquals(0, td.doc());
157
 
        assertFalse(td.next());
158
 
        assertTrue(te.next());
159
 
        assertEquals("field3:jumps", te.term().toString());
160
 
        td.seek(te.term());
161
 
        assertTrue(td.next());
162
 
        assertEquals(0, td.doc());
163
 
        assertFalse(td.next());
164
 
        assertTrue(te.next());
165
 
        assertEquals("field3:lazy", te.term().toString());
166
 
        td.seek(te.term());
167
 
        assertTrue(td.next());
168
 
        assertEquals(0, td.doc());
169
 
        assertFalse(td.next());
170
 
        assertTrue(te.next());
171
 
        assertEquals("field3:over", te.term().toString());
172
 
        td.seek(te.term());
173
 
        assertTrue(td.next());
174
 
        assertEquals(0, td.doc());
175
 
        assertFalse(td.next());
176
 
        assertTrue(te.next());
177
 
        assertEquals("field3:the", te.term().toString());
178
 
        td.seek(te.term());
179
 
        assertTrue(td.next());
180
 
        assertEquals(0, td.doc());
181
 
        assertFalse(td.next());
182
 
        assertFalse(te.next());
183
 
    }
184
 
}