← 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/queryParser/TestMultiAnalyzer.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/queryParser/TestMultiAnalyzer.java
1
 
package org.apache.lucene.queryParser;
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.io.Reader;
22
 
 
23
 
import org.apache.lucene.analysis.Analyzer;
24
 
import org.apache.lucene.analysis.BaseTokenStreamTestCase;
25
 
import org.apache.lucene.analysis.LowerCaseFilter;
26
 
import org.apache.lucene.analysis.TokenFilter;
27
 
import org.apache.lucene.analysis.TokenStream;
28
 
import org.apache.lucene.analysis.standard.StandardTokenizer;
29
 
import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
30
 
import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
31
 
import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
32
 
import org.apache.lucene.analysis.tokenattributes.TypeAttribute;
33
 
import org.apache.lucene.search.Query;
34
 
import org.apache.lucene.util.Version;
35
 
 
36
 
/**
37
 
 * Test QueryParser's ability to deal with Analyzers that return more
38
 
 * than one token per position or that return tokens with a position
39
 
 * increment > 1.
40
 
 *
41
 
 */
42
 
public class TestMultiAnalyzer extends BaseTokenStreamTestCase {
43
 
 
44
 
  private static int multiToken = 0;
45
 
 
46
 
  public void testMultiAnalyzer() throws ParseException {
47
 
    
48
 
    QueryParser qp = new QueryParser(TEST_VERSION_CURRENT, "", new MultiAnalyzer());
49
 
 
50
 
    // trivial, no multiple tokens:
51
 
    assertEquals("foo", qp.parse("foo").toString());
52
 
    assertEquals("foo", qp.parse("\"foo\"").toString());
53
 
    assertEquals("foo foobar", qp.parse("foo foobar").toString());
54
 
    assertEquals("\"foo foobar\"", qp.parse("\"foo foobar\"").toString());
55
 
    assertEquals("\"foo foobar blah\"", qp.parse("\"foo foobar blah\"").toString());
56
 
 
57
 
    // two tokens at the same position:
58
 
    assertEquals("(multi multi2) foo", qp.parse("multi foo").toString());
59
 
    assertEquals("foo (multi multi2)", qp.parse("foo multi").toString());
60
 
    assertEquals("(multi multi2) (multi multi2)", qp.parse("multi multi").toString());
61
 
    assertEquals("+(foo (multi multi2)) +(bar (multi multi2))",
62
 
        qp.parse("+(foo multi) +(bar multi)").toString());
63
 
    assertEquals("+(foo (multi multi2)) field:\"bar (multi multi2)\"",
64
 
        qp.parse("+(foo multi) field:\"bar multi\"").toString());
65
 
 
66
 
    // phrases:
67
 
    assertEquals("\"(multi multi2) foo\"", qp.parse("\"multi foo\"").toString());
68
 
    assertEquals("\"foo (multi multi2)\"", qp.parse("\"foo multi\"").toString());
69
 
    assertEquals("\"foo (multi multi2) foobar (multi multi2)\"",
70
 
        qp.parse("\"foo multi foobar multi\"").toString());
71
 
 
72
 
    // fields:
73
 
    assertEquals("(field:multi field:multi2) field:foo", qp.parse("field:multi field:foo").toString());
74
 
    assertEquals("field:\"(multi multi2) foo\"", qp.parse("field:\"multi foo\"").toString());
75
 
 
76
 
    // three tokens at one position:
77
 
    assertEquals("triplemulti multi3 multi2", qp.parse("triplemulti").toString());
78
 
    assertEquals("foo (triplemulti multi3 multi2) foobar",
79
 
        qp.parse("foo triplemulti foobar").toString());
80
 
 
81
 
    // phrase with non-default slop:
82
 
    assertEquals("\"(multi multi2) foo\"~10", qp.parse("\"multi foo\"~10").toString());
83
 
 
84
 
    // phrase with non-default boost:
85
 
    assertEquals("\"(multi multi2) foo\"^2.0", qp.parse("\"multi foo\"^2").toString());
86
 
 
87
 
    // phrase after changing default slop
88
 
    qp.setPhraseSlop(99);
89
 
    assertEquals("\"(multi multi2) foo\"~99 bar",
90
 
                 qp.parse("\"multi foo\" bar").toString());
91
 
    assertEquals("\"(multi multi2) foo\"~99 \"foo bar\"~2",
92
 
                 qp.parse("\"multi foo\" \"foo bar\"~2").toString());
93
 
    qp.setPhraseSlop(0);
94
 
 
95
 
    // non-default operator:
96
 
    qp.setDefaultOperator(QueryParser.AND_OPERATOR);
97
 
    assertEquals("+(multi multi2) +foo", qp.parse("multi foo").toString());
98
 
 
99
 
  }
100
 
    
101
 
  public void testMultiAnalyzerWithSubclassOfQueryParser() throws ParseException {
102
 
 
103
 
    DumbQueryParser qp = new DumbQueryParser("", new MultiAnalyzer());
104
 
    qp.setPhraseSlop(99); // modified default slop
105
 
 
106
 
    // direct call to (super's) getFieldQuery to demonstrate differnce
107
 
    // between phrase and multiphrase with modified default slop
108
 
    assertEquals("\"foo bar\"~99",
109
 
                 qp.getSuperFieldQuery("","foo bar", true).toString());
110
 
    assertEquals("\"(multi multi2) bar\"~99",
111
 
                 qp.getSuperFieldQuery("","multi bar", true).toString());
112
 
 
113
 
    
114
 
    // ask sublcass to parse phrase with modified default slop
115
 
    assertEquals("\"(multi multi2) foo\"~99 bar",
116
 
                 qp.parse("\"multi foo\" bar").toString());
117
 
    
118
 
  }
119
 
    
120
 
  public void testPosIncrementAnalyzer() throws ParseException {
121
 
    QueryParser qp = new QueryParser(Version.LUCENE_24, "", new PosIncrementAnalyzer());
122
 
    assertEquals("quick brown", qp.parse("the quick brown").toString());
123
 
    assertEquals("\"quick brown\"", qp.parse("\"the quick brown\"").toString());
124
 
    assertEquals("quick brown fox", qp.parse("the quick brown fox").toString());
125
 
    assertEquals("\"quick brown fox\"", qp.parse("\"the quick brown fox\"").toString());
126
 
  }
127
 
  
128
 
  /**
129
 
   * Expands "multi" to "multi" and "multi2", both at the same position,
130
 
   * and expands "triplemulti" to "triplemulti", "multi3", and "multi2".  
131
 
   */
132
 
  private class MultiAnalyzer extends Analyzer {
133
 
 
134
 
    public MultiAnalyzer() {
135
 
    }
136
 
 
137
 
    @Override
138
 
    public TokenStream tokenStream(String fieldName, Reader reader) {
139
 
      TokenStream result = new StandardTokenizer(TEST_VERSION_CURRENT, reader);
140
 
      result = new TestFilter(result);
141
 
      result = new LowerCaseFilter(TEST_VERSION_CURRENT, result);
142
 
      return result;
143
 
    }
144
 
  }
145
 
 
146
 
  private final class TestFilter extends TokenFilter {
147
 
    
148
 
    private String prevType;
149
 
    private int prevStartOffset;
150
 
    private int prevEndOffset;
151
 
    
152
 
    private final CharTermAttribute termAtt;
153
 
    private final PositionIncrementAttribute posIncrAtt;
154
 
    private final OffsetAttribute offsetAtt;
155
 
    private final TypeAttribute typeAtt;
156
 
    
157
 
    public TestFilter(TokenStream in) {
158
 
      super(in);
159
 
      termAtt = addAttribute(CharTermAttribute.class);
160
 
      posIncrAtt = addAttribute(PositionIncrementAttribute.class);
161
 
      offsetAtt = addAttribute(OffsetAttribute.class);
162
 
      typeAtt = addAttribute(TypeAttribute.class);
163
 
    }
164
 
 
165
 
    @Override
166
 
    public final boolean incrementToken() throws java.io.IOException {
167
 
      if (multiToken > 0) {
168
 
        termAtt.setEmpty().append("multi"+(multiToken+1));
169
 
        offsetAtt.setOffset(prevStartOffset, prevEndOffset);
170
 
        typeAtt.setType(prevType);
171
 
        posIncrAtt.setPositionIncrement(0);
172
 
        multiToken--;
173
 
        return true;
174
 
      } else {
175
 
        boolean next = input.incrementToken();
176
 
        if (!next) {
177
 
          return false;
178
 
        }
179
 
        prevType = typeAtt.type();
180
 
        prevStartOffset = offsetAtt.startOffset();
181
 
        prevEndOffset = offsetAtt.endOffset();
182
 
        String text = termAtt.toString();
183
 
        if (text.equals("triplemulti")) {
184
 
          multiToken = 2;
185
 
          return true;
186
 
        } else if (text.equals("multi")) {
187
 
          multiToken = 1;
188
 
          return true;
189
 
        } else {
190
 
          return true;
191
 
        }
192
 
      }
193
 
    }
194
 
 
195
 
    public void reset() throws IOException {
196
 
      super.reset();
197
 
      this.prevType = null;
198
 
      this.prevStartOffset = 0;
199
 
      this.prevEndOffset = 0;
200
 
    }
201
 
  }
202
 
 
203
 
  /**
204
 
   * Analyzes "the quick brown" as: quick(incr=2) brown(incr=1).
205
 
   * Does not work correctly for input other than "the quick brown ...".
206
 
   */
207
 
  private class PosIncrementAnalyzer extends Analyzer {
208
 
 
209
 
    public PosIncrementAnalyzer() {
210
 
    }
211
 
 
212
 
    @Override
213
 
    public TokenStream tokenStream(String fieldName, Reader reader) {
214
 
      TokenStream result = new StandardTokenizer(TEST_VERSION_CURRENT, reader);
215
 
      result = new TestPosIncrementFilter(result);
216
 
      result = new LowerCaseFilter(TEST_VERSION_CURRENT, result);
217
 
      return result;
218
 
    }
219
 
  }
220
 
 
221
 
  private final class TestPosIncrementFilter extends TokenFilter {
222
 
    
223
 
    CharTermAttribute termAtt;
224
 
    PositionIncrementAttribute posIncrAtt;
225
 
    
226
 
    public TestPosIncrementFilter(TokenStream in) {
227
 
      super(in);
228
 
      termAtt = addAttribute(CharTermAttribute.class);
229
 
      posIncrAtt = addAttribute(PositionIncrementAttribute.class);
230
 
    }
231
 
 
232
 
    @Override
233
 
    public final boolean incrementToken () throws java.io.IOException {
234
 
      while(input.incrementToken()) {
235
 
        if (termAtt.toString().equals("the")) {
236
 
          // stopword, do nothing
237
 
        } else if (termAtt.toString().equals("quick")) {
238
 
          posIncrAtt.setPositionIncrement(2);
239
 
          return true;
240
 
        } else {
241
 
          posIncrAtt.setPositionIncrement(1);
242
 
          return true;
243
 
        }
244
 
      }
245
 
      return false;
246
 
    }
247
 
  }
248
 
 
249
 
    /** a very simple subclass of QueryParser */
250
 
    private final static class DumbQueryParser extends QueryParser {
251
 
        
252
 
        public DumbQueryParser(String f, Analyzer a) {
253
 
            super(TEST_VERSION_CURRENT, f, a);
254
 
        }
255
 
 
256
 
        /** expose super's version */
257
 
        public Query getSuperFieldQuery(String f, String t, boolean quoted) 
258
 
            throws ParseException {
259
 
            return super.getFieldQuery(f,t,quoted);
260
 
        }
261
 
        /** wrap super's version */
262
 
        @Override
263
 
        protected Query getFieldQuery(String f, String t, boolean quoted)
264
 
            throws ParseException {
265
 
            return new DumbQueryWrapper(getSuperFieldQuery(f,t,quoted));
266
 
        }
267
 
    }
268
 
    
269
 
    /**
270
 
     * A very simple wrapper to prevent instanceof checks but uses
271
 
     * the toString of the query it wraps.
272
 
     */
273
 
    private final static class DumbQueryWrapper extends Query {
274
 
 
275
 
        private Query q;
276
 
        public DumbQueryWrapper(Query q) {
277
 
            super();
278
 
            this.q = q;
279
 
        }
280
 
        @Override
281
 
        public String toString(String f) {
282
 
            return q.toString(f);
283
 
        }
284
 
    }
285
 
    
286
 
}