lucene-java-3.5.0/lucene/backwards/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 &gt; 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 }