~ubuntu-branches/ubuntu/trusty/pylucene/trusty

« back to all changes in this revision

Viewing changes to lucene-java-3.5.0/lucene/src/test/org/apache/lucene/index/TestParallelTermEnum.java

  • Committer: Package Import Robot
  • Author(s): Dmitry Nezhevenko
  • Date: 2012-04-23 16:43:55 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120423164355-grqtepnwtecdjfk2
Tags: 3.5.0-1
* New maintainer (closes: 670179)
* New upstream release
* Switch to dpkg-source 3.0 (quilt) format
* Switch to machine-readable debian/copyright
* Bump debian/compat to 8, drop debian/pycompat
* Switch from cdbs to dh
* Add watch file
* Build for all supported versions of python2 (closes: 581198, 632240)
* Rename binary package to python-lucene (closes: 581197)
* Add -dbg package

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
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
}