lucene-java-3.4.0/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/precedence/TestPrecedenceQueryParser.java

   1 package org.apache.lucene.queryParser.precedence;
   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 import java.text.DateFormat;
  23 import java.util.Calendar;
  24 import java.util.Collections;
  25 import java.util.Date;
  26 import java.util.GregorianCalendar;
  27 import java.util.HashMap;
  28 import java.util.Map;
  29
  30 import org.apache.lucene.analysis.Analyzer;
  31 import org.apache.lucene.analysis.LowerCaseTokenizer;
  32 import org.apache.lucene.analysis.MockAnalyzer;
  33 import org.apache.lucene.analysis.MockTokenizer;
  34 import org.apache.lucene.analysis.TokenFilter;
  35 import org.apache.lucene.analysis.TokenStream;
  36
  37 import org.apache.lucene.analysis.standard.StandardAnalyzer;
  38 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
  39
  40 import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
  41 import org.apache.lucene.document.DateField;
  42 import org.apache.lucene.document.DateTools;
  43 import org.apache.lucene.queryParser.core.QueryNodeException;
  44 import org.apache.lucene.queryParser.core.QueryNodeParseException;
  45 import org.apache.lucene.queryParser.standard.config.StandardQueryConfigHandler;
  46 import org.apache.lucene.queryParser.standard.parser.ParseException;
  47 import org.apache.lucene.search.BooleanQuery;
  48 import org.apache.lucene.search.FuzzyQuery;
  49 import org.apache.lucene.search.PhraseQuery;
  50 import org.apache.lucene.search.PrefixQuery;
  51 import org.apache.lucene.search.Query;
  52
  53 import org.apache.lucene.search.TermQuery;
  54 import org.apache.lucene.search.TermRangeQuery;
  55 import org.apache.lucene.search.WildcardQuery;
  56 import org.apache.lucene.util.LuceneTestCase;
  57
  58 /**
  59  * <p>
  60  * This test case tests {@link PrecedenceQueryParser}.
  61  * </p>
  62  * <p>
  63  * It contains all tests from {@link QueryParserTestBase} with some adjusted to
  64  * fit the precedence requirement, plus some precedence test cases.
  65  * </p>
  66  *
  67  * @see QueryParserTestBase
  68  */
  69 // TODO: refactor this to actually extend that class, overriding the tests
  70 // that it adjusts to fit the precedence requirement, adding its extra tests.
  71 public class TestPrecedenceQueryParser extends LuceneTestCase {
  72
  73   public static Analyzer qpAnalyzer = new QPTestAnalyzer();
  74
  75   public static final class QPTestFilter extends TokenFilter {
  76     /**
  77      * Filter which discards the token 'stop' and which expands the token
  78      * 'phrase' into 'phrase1 phrase2'
  79      */
  80     public QPTestFilter(TokenStream in) {
  81       super(in);
  82     }
  83
  84     private boolean inPhrase = false;
  85
  86     private int savedStart = 0;
  87     private int savedEnd = 0;
  88
  89     private final CharTermAttribute termAtt = addAttribute(CharTermAttribute.class);
  90
  91     private final OffsetAttribute offsetAtt = addAttribute(OffsetAttribute.class);
  92
  93     @Override
  94     public boolean incrementToken() throws IOException {
  95       if (inPhrase) {
  96         inPhrase = false;
  97         termAtt.setEmpty().append("phrase2");
  98         offsetAtt.setOffset(savedStart, savedEnd);
  99         return true;
 100       } else
 101         while (input.incrementToken())
 102           if (termAtt.toString().equals("phrase")) {
 103             inPhrase = true;
 104             savedStart = offsetAtt.startOffset();
 105             savedEnd = offsetAtt.endOffset();
 106             termAtt.setEmpty().append("phrase1");
 107             offsetAtt.setOffset(savedStart, savedEnd);
 108             return true;
 109           } else if (!termAtt.toString().equals("stop"))
 110             return true;
 111       return false;
 112     }
 113
 114     @Override
 115     public void reset() throws IOException {
 116       super.reset();
 117       this.inPhrase = false;
 118       this.savedStart = 0;
 119       this.savedEnd = 0;
 120     }
 121   }
 122
 123   public static final class QPTestAnalyzer extends Analyzer {
 124
 125     /** Filters LowerCaseTokenizer with StopFilter. */
 126     @Override
 127     public final TokenStream tokenStream(String fieldName, Reader reader) {
 128       return new QPTestFilter(new LowerCaseTokenizer(TEST_VERSION_CURRENT, reader));
 129     }
 130   }
 131
 132   private int originalMaxClauses;
 133
 134   @Override
 135   public void setUp() throws Exception {
 136     super.setUp();
 137     originalMaxClauses = BooleanQuery.getMaxClauseCount();
 138   }
 139
 140   public PrecedenceQueryParser getParser(Analyzer a) throws Exception {
 141     if (a == null)
 142       a = new MockAnalyzer(random, MockTokenizer.SIMPLE, true);
 143     PrecedenceQueryParser qp = new PrecedenceQueryParser();
 144     qp.setAnalyzer(a);
 145     qp.setDefaultOperator(StandardQueryConfigHandler.Operator.OR);
 146     return qp;
 147   }
 148
 149   public Query getQuery(String query, Analyzer a) throws Exception {
 150     return getParser(a).parse(query, "field");
 151   }
 152
 153   public void assertQueryEquals(String query, Analyzer a, String result)
 154       throws Exception {
 155     Query q = getQuery(query, a);
 156     String s = q.toString("field");
 157     if (!s.equals(result)) {
 158       fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
 159           + "/");
 160     }
 161   }
 162
 163   public void assertWildcardQueryEquals(String query, boolean lowercase,
 164       String result) throws Exception {
 165     PrecedenceQueryParser qp = getParser(null);
 166     qp.setLowercaseExpandedTerms(lowercase);
 167     Query q = qp.parse(query, "field");
 168     String s = q.toString("field");
 169     if (!s.equals(result)) {
 170       fail("WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /"
 171           + result + "/");
 172     }
 173   }
 174
 175   public void assertWildcardQueryEquals(String query, String result)
 176       throws Exception {
 177     PrecedenceQueryParser qp = getParser(null);
 178     Query q = qp.parse(query, "field");
 179     String s = q.toString("field");
 180     if (!s.equals(result)) {
 181       fail("WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /"
 182           + result + "/");
 183     }
 184   }
 185
 186   public Query getQueryDOA(String query, Analyzer a) throws Exception {
 187     if (a == null)
 188       a = new MockAnalyzer(random, MockTokenizer.SIMPLE, true);
 189     PrecedenceQueryParser qp = new PrecedenceQueryParser();
 190     qp.setAnalyzer(a);
 191     qp.setDefaultOperator(StandardQueryConfigHandler.Operator.AND);
 192     return qp.parse(query, "field");
 193   }
 194
 195   public void assertQueryEqualsDOA(String query, Analyzer a, String result)
 196       throws Exception {
 197     Query q = getQueryDOA(query, a);
 198     String s = q.toString("field");
 199     if (!s.equals(result)) {
 200       fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
 201           + "/");
 202     }
 203   }
 204
 205   public void testSimple() throws Exception {
 206     assertQueryEquals("term term term", null, "term term term");
 207     assertQueryEquals("türm term term", null, "türm term term");
 208     assertQueryEquals("ümlaut", null, "ümlaut");
 209
 210     assertQueryEquals("a AND b", null, "+a +b");
 211     assertQueryEquals("(a AND b)", null, "+a +b");
 212     assertQueryEquals("c OR (a AND b)", null, "c (+a +b)");
 213     assertQueryEquals("a AND NOT b", null, "+a -b");
 214     assertQueryEquals("a AND -b", null, "+a -b");
 215     assertQueryEquals("a AND !b", null, "+a -b");
 216     assertQueryEquals("a && b", null, "+a +b");
 217     assertQueryEquals("a && ! b", null, "+a -b");
 218
 219     assertQueryEquals("a OR b", null, "a b");
 220     assertQueryEquals("a || b", null, "a b");
 221
 222     assertQueryEquals("+term -term term", null, "+term -term term");
 223     assertQueryEquals("foo:term AND field:anotherTerm", null,
 224         "+foo:term +anotherterm");
 225     assertQueryEquals("term AND \"phrase phrase\"", null,
 226         "+term +\"phrase phrase\"");
 227     assertQueryEquals("\"hello there\"", null, "\"hello there\"");
 228     assertTrue(getQuery("a AND b", null) instanceof BooleanQuery);
 229     assertTrue(getQuery("hello", null) instanceof TermQuery);
 230     assertTrue(getQuery("\"hello there\"", null) instanceof PhraseQuery);
 231
 232     assertQueryEquals("germ term^2.0", null, "germ term^2.0");
 233     assertQueryEquals("(term)^2.0", null, "term^2.0");
 234     assertQueryEquals("(germ term)^2.0", null, "(germ term)^2.0");
 235     assertQueryEquals("term^2.0", null, "term^2.0");
 236     assertQueryEquals("term^2", null, "term^2.0");
 237     assertQueryEquals("\"germ term\"^2.0", null, "\"germ term\"^2.0");
 238     assertQueryEquals("\"term germ\"^2", null, "\"term germ\"^2.0");
 239
 240     assertQueryEquals("(foo OR bar) AND (baz OR boo)", null,
 241         "+(foo bar) +(baz boo)");
 242     assertQueryEquals("((a OR b) AND NOT c) OR d", null, "(+(a b) -c) d");
 243     assertQueryEquals("+(apple \"steve jobs\") -(foo bar baz)", null,
 244         "+(apple \"steve jobs\") -(foo bar baz)");
 245     assertQueryEquals("+title:(dog OR cat) -author:\"bob dole\"", null,
 246         "+(title:dog title:cat) -author:\"bob dole\"");
 247
 248     PrecedenceQueryParser qp = new PrecedenceQueryParser();
 249     qp.setAnalyzer(new MockAnalyzer(random));
 250     // make sure OR is the default:
 251     assertEquals(StandardQueryConfigHandler.Operator.OR, qp.getDefaultOperator());
 252     qp.setDefaultOperator(StandardQueryConfigHandler.Operator.AND);
 253     assertEquals(StandardQueryConfigHandler.Operator.AND, qp.getDefaultOperator());
 254     qp.setDefaultOperator(StandardQueryConfigHandler.Operator.OR);
 255     assertEquals(StandardQueryConfigHandler.Operator.OR, qp.getDefaultOperator());
 256
 257     assertQueryEquals("a OR !b", null, "a -b");
 258     assertQueryEquals("a OR ! b", null, "a -b");
 259     assertQueryEquals("a OR -b", null, "a -b");
 260   }
 261
 262   public void testPunct() throws Exception {
 263     Analyzer a = new MockAnalyzer(random, MockTokenizer.WHITESPACE, false);
 264     assertQueryEquals("a&b", a, "a&b");
 265     assertQueryEquals("a&&b", a, "a&&b");
 266     assertQueryEquals(".NET", a, ".NET");
 267   }
 268
 269   public void testSlop() throws Exception {
 270     assertQueryEquals("\"term germ\"~2", null, "\"term germ\"~2");
 271     assertQueryEquals("\"term germ\"~2 flork", null, "\"term germ\"~2 flork");
 272     assertQueryEquals("\"term\"~2", null, "term");
 273     assertQueryEquals("\" \"~2 germ", null, "germ");
 274     assertQueryEquals("\"term germ\"~2^2", null, "\"term germ\"~2^2.0");
 275   }
 276
 277   public void testNumber() throws Exception {
 278     // The numbers go away because SimpleAnalzyer ignores them
 279     assertQueryEquals("3", null, "");
 280     assertQueryEquals("term 1.0 1 2", null, "term");
 281     assertQueryEquals("term term1 term2", null, "term term term");
 282
 283     Analyzer a = new MockAnalyzer(random);
 284     assertQueryEquals("3", a, "3");
 285     assertQueryEquals("term 1.0 1 2", a, "term 1.0 1 2");
 286     assertQueryEquals("term term1 term2", a, "term term1 term2");
 287   }
 288
 289   public void testWildcard() throws Exception {
 290     assertQueryEquals("term*", null, "term*");
 291     assertQueryEquals("term*^2", null, "term*^2.0");
 292     assertQueryEquals("term~", null, "term~0.5");
 293     assertQueryEquals("term~0.7", null, "term~0.7");
 294     assertQueryEquals("term~^3", null, "term~0.5^3.0");
 295     assertQueryEquals("term^3~", null, "term~0.5^3.0");
 296     assertQueryEquals("term*germ", null, "term*germ");
 297     assertQueryEquals("term*germ^3", null, "term*germ^3.0");
 298
 299     assertTrue(getQuery("term*", null) instanceof PrefixQuery);
 300     assertTrue(getQuery("term*^2", null) instanceof PrefixQuery);
 301     assertTrue(getQuery("term~", null) instanceof FuzzyQuery);
 302     assertTrue(getQuery("term~0.7", null) instanceof FuzzyQuery);
 303     FuzzyQuery fq = (FuzzyQuery) getQuery("term~0.7", null);
 304     assertEquals(0.7f, fq.getMinSimilarity(), 0.1f);
 305     assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());
 306     fq = (FuzzyQuery) getQuery("term~", null);
 307     assertEquals(0.5f, fq.getMinSimilarity(), 0.1f);
 308     assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());
 309     try {
 310       getQuery("term~1.1", null); // value > 1, throws exception
 311       fail();
 312     } catch (ParseException pe) {
 313       // expected exception
 314     }
 315     assertTrue(getQuery("term*germ", null) instanceof WildcardQuery);
 316
 317     /*
 318      * Tests to see that wild card terms are (or are not) properly lower-cased
 319      * with propery parser configuration
 320      */
 321     // First prefix queries:
 322     // by default, convert to lowercase:
 323     assertWildcardQueryEquals("Term*", true, "term*");
 324     // explicitly set lowercase:
 325     assertWildcardQueryEquals("term*", true, "term*");
 326     assertWildcardQueryEquals("Term*", true, "term*");
 327     assertWildcardQueryEquals("TERM*", true, "term*");
 328     // explicitly disable lowercase conversion:
 329     assertWildcardQueryEquals("term*", false, "term*");
 330     assertWildcardQueryEquals("Term*", false, "Term*");
 331     assertWildcardQueryEquals("TERM*", false, "TERM*");
 332     // Then 'full' wildcard queries:
 333     // by default, convert to lowercase:
 334     assertWildcardQueryEquals("Te?m", "te?m");
 335     // explicitly set lowercase:
 336     assertWildcardQueryEquals("te?m", true, "te?m");
 337     assertWildcardQueryEquals("Te?m", true, "te?m");
 338     assertWildcardQueryEquals("TE?M", true, "te?m");
 339     assertWildcardQueryEquals("Te?m*gerM", true, "te?m*germ");
 340     // explicitly disable lowercase conversion:
 341     assertWildcardQueryEquals("te?m", false, "te?m");
 342     assertWildcardQueryEquals("Te?m", false, "Te?m");
 343     assertWildcardQueryEquals("TE?M", false, "TE?M");
 344     assertWildcardQueryEquals("Te?m*gerM", false, "Te?m*gerM");
 345     // Fuzzy queries:
 346     assertWildcardQueryEquals("Term~", "term~0.5");
 347     assertWildcardQueryEquals("Term~", true, "term~0.5");
 348     assertWildcardQueryEquals("Term~", false, "Term~0.5");
 349     // Range queries:
 350     assertWildcardQueryEquals("[A TO C]", "[a TO c]");
 351     assertWildcardQueryEquals("[A TO C]", true, "[a TO c]");
 352     assertWildcardQueryEquals("[A TO C]", false, "[A TO C]");
 353   }
 354
 355   public void testQPA() throws Exception {
 356     assertQueryEquals("term term term", qpAnalyzer, "term term term");
 357     assertQueryEquals("term +stop term", qpAnalyzer, "term term");
 358     assertQueryEquals("term -stop term", qpAnalyzer, "term term");
 359     assertQueryEquals("drop AND stop AND roll", qpAnalyzer, "+drop +roll");
 360     assertQueryEquals("term phrase term", qpAnalyzer,
 361         "term (phrase1 phrase2) term");
 362     // note the parens in this next assertion differ from the original
 363     // QueryParser behavior
 364     assertQueryEquals("term AND NOT phrase term", qpAnalyzer,
 365         "(+term -(phrase1 phrase2)) term");
 366     assertQueryEquals("stop", qpAnalyzer, "");
 367     assertQueryEquals("stop OR stop AND stop", qpAnalyzer, "");
 368     assertTrue(getQuery("term term term", qpAnalyzer) instanceof BooleanQuery);
 369     assertTrue(getQuery("term +stop", qpAnalyzer) instanceof TermQuery);
 370   }
 371
 372   public void testRange() throws Exception {
 373     assertQueryEquals("[ a TO z]", null, "[a TO z]");
 374     assertTrue(getQuery("[ a TO z]", null) instanceof TermRangeQuery);
 375     assertQueryEquals("[ a TO z ]", null, "[a TO z]");
 376     assertQueryEquals("{ a TO z}", null, "{a TO z}");
 377     assertQueryEquals("{ a TO z }", null, "{a TO z}");
 378     assertQueryEquals("{ a TO z }^2.0", null, "{a TO z}^2.0");
 379     assertQueryEquals("[ a TO z] OR bar", null, "[a TO z] bar");
 380     assertQueryEquals("[ a TO z] AND bar", null, "+[a TO z] +bar");
 381     assertQueryEquals("( bar blar { a TO z}) ", null, "bar blar {a TO z}");
 382     assertQueryEquals("gack ( bar blar { a TO z}) ", null,
 383         "gack (bar blar {a TO z})");
 384   }
 385
 386   private String escapeDateString(String s) {
 387     if (s.contains(" ")) {
 388       return "\"" + s + "\"";
 389     } else {
 390       return s;
 391     }
 392   }
 393
 394   public String getDate(String s) throws Exception {
 395     DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
 396     return DateTools.dateToString(df.parse(s), DateTools.Resolution.DAY);
 397   }
 398
 399   private String getLocalizedDate(int year, int month, int day,
 400       boolean extendLastDate) {
 401     DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
 402     Calendar calendar = new GregorianCalendar();
 403     calendar.set(year, month, day);
 404     if (extendLastDate) {
 405       calendar.set(Calendar.HOUR_OF_DAY, 23);
 406       calendar.set(Calendar.MINUTE, 59);
 407       calendar.set(Calendar.SECOND, 59);
 408       calendar.set(Calendar.MILLISECOND, 999);
 409     }
 410     return df.format(calendar.getTime());
 411   }
 412
 413   public void testDateRange() throws Exception {
 414     String startDate = getLocalizedDate(2002, 1, 1, false);
 415     String endDate = getLocalizedDate(2002, 1, 4, false);
 416     Calendar endDateExpected = new GregorianCalendar();
 417     endDateExpected.set(2002, 1, 4, 23, 59, 59);
 418     endDateExpected.set(Calendar.MILLISECOND, 999);
 419     final String defaultField = "default";
 420     final String monthField = "month";
 421     final String hourField = "hour";
 422     PrecedenceQueryParser qp = new PrecedenceQueryParser(new MockAnalyzer(random));
 423
 424     // Don't set any date resolution and verify if DateField is used
 425     assertDateRangeQueryEquals(qp, defaultField, startDate, endDate,
 426         endDateExpected.getTime(), null);
 427
 428     Map<CharSequence, DateTools.Resolution> fieldMap = new HashMap<CharSequence,DateTools.Resolution>();
 429     // set a field specific date resolution
 430     fieldMap.put(monthField, DateTools.Resolution.MONTH);
 431     qp.setDateResolution(fieldMap);
 432
 433     // DateField should still be used for defaultField
 434     assertDateRangeQueryEquals(qp, defaultField, startDate, endDate,
 435         endDateExpected.getTime(), null);
 436
 437     // set default date resolution to MILLISECOND
 438     qp.setDateResolution(DateTools.Resolution.MILLISECOND);
 439
 440     // set second field specific date resolution
 441     fieldMap.put(hourField, DateTools.Resolution.HOUR);
 442     qp.setDateResolution(fieldMap);
 443
 444     // for this field no field specific date resolution has been set,
 445     // so verify if the default resolution is used
 446     assertDateRangeQueryEquals(qp, defaultField, startDate, endDate,
 447         endDateExpected.getTime(), DateTools.Resolution.MILLISECOND);
 448
 449     // verify if field specific date resolutions are used for these two fields
 450     assertDateRangeQueryEquals(qp, monthField, startDate, endDate,
 451         endDateExpected.getTime(), DateTools.Resolution.MONTH);
 452
 453     assertDateRangeQueryEquals(qp, hourField, startDate, endDate,
 454         endDateExpected.getTime(), DateTools.Resolution.HOUR);
 455   }
 456
 457   /** for testing DateTools support */
 458   private String getDate(String s, DateTools.Resolution resolution)
 459       throws Exception {
 460     DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
 461     return getDate(df.parse(s), resolution);
 462   }
 463
 464   /** for testing DateTools support */
 465   private String getDate(Date d, DateTools.Resolution resolution)
 466       throws Exception {
 467     if (resolution == null) {
 468       return DateField.dateToString(d);
 469     } else {
 470       return DateTools.dateToString(d, resolution);
 471     }
 472   }
 473
 474   public void assertQueryEquals(PrecedenceQueryParser qp, String field, String query,
 475       String result) throws Exception {
 476     Query q = qp.parse(query, field);
 477     String s = q.toString(field);
 478     if (!s.equals(result)) {
 479       fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
 480           + "/");
 481     }
 482   }
 483
 484   public void assertDateRangeQueryEquals(PrecedenceQueryParser qp, String field,
 485       String startDate, String endDate, Date endDateInclusive,
 486       DateTools.Resolution resolution) throws Exception {
 487     assertQueryEquals(qp, field, field + ":[" + escapeDateString(startDate)
 488         + " TO " + escapeDateString(endDate) + "]", "["
 489         + getDate(startDate, resolution) + " TO "
 490         + getDate(endDateInclusive, resolution) + "]");
 491     assertQueryEquals(qp, field, field + ":{" + escapeDateString(startDate)
 492         + " TO " + escapeDateString(endDate) + "}", "{"
 493         + getDate(startDate, resolution) + " TO "
 494         + getDate(endDate, resolution) + "}");
 495   }
 496
 497   public void testEscaped() throws Exception {
 498     Analyzer a = new MockAnalyzer(random, MockTokenizer.WHITESPACE, false);
 499
 500     assertQueryEquals("a\\-b:c", a, "a-b:c");
 501     assertQueryEquals("a\\+b:c", a, "a+b:c");
 502     assertQueryEquals("a\\:b:c", a, "a:b:c");
 503     assertQueryEquals("a\\\\b:c", a, "a\\b:c");
 504
 505     assertQueryEquals("a:b\\-c", a, "a:b-c");
 506     assertQueryEquals("a:b\\+c", a, "a:b+c");
 507     assertQueryEquals("a:b\\:c", a, "a:b:c");
 508     assertQueryEquals("a:b\\\\c", a, "a:b\\c");
 509
 510     assertQueryEquals("a:b\\-c*", a, "a:b-c*");
 511     assertQueryEquals("a:b\\+c*", a, "a:b+c*");
 512     assertQueryEquals("a:b\\:c*", a, "a:b:c*");
 513
 514     assertQueryEquals("a:b\\\\c*", a, "a:b\\c*");
 515
 516     assertQueryEquals("a:b\\-?c", a, "a:b-?c");
 517     assertQueryEquals("a:b\\+?c", a, "a:b+?c");
 518     assertQueryEquals("a:b\\:?c", a, "a:b:?c");
 519
 520     assertQueryEquals("a:b\\\\?c", a, "a:b\\?c");
 521
 522     assertQueryEquals("a:b\\-c~", a, "a:b-c~0.5");
 523     assertQueryEquals("a:b\\+c~", a, "a:b+c~0.5");
 524     assertQueryEquals("a:b\\:c~", a, "a:b:c~0.5");
 525     assertQueryEquals("a:b\\\\c~", a, "a:b\\c~0.5");
 526
 527     assertQueryEquals("[ a\\- TO a\\+ ]", null, "[a- TO a+]");
 528     assertQueryEquals("[ a\\: TO a\\~ ]", null, "[a: TO a~]");
 529     assertQueryEquals("[ a\\\\ TO a\\* ]", null, "[a\\ TO a*]");
 530   }
 531
 532   public void testTabNewlineCarriageReturn() throws Exception {
 533     assertQueryEqualsDOA("+weltbank +worlbank", null, "+weltbank +worlbank");
 534
 535     assertQueryEqualsDOA("+weltbank\n+worlbank", null, "+weltbank +worlbank");
 536     assertQueryEqualsDOA("weltbank \n+worlbank", null, "+weltbank +worlbank");
 537     assertQueryEqualsDOA("weltbank \n +worlbank", null, "+weltbank +worlbank");
 538
 539     assertQueryEqualsDOA("+weltbank\r+worlbank", null, "+weltbank +worlbank");
 540     assertQueryEqualsDOA("weltbank \r+worlbank", null, "+weltbank +worlbank");
 541     assertQueryEqualsDOA("weltbank \r +worlbank", null, "+weltbank +worlbank");
 542
 543     assertQueryEqualsDOA("+weltbank\r\n+worlbank", null, "+weltbank +worlbank");
 544     assertQueryEqualsDOA("weltbank \r\n+worlbank", null, "+weltbank +worlbank");
 545     assertQueryEqualsDOA("weltbank \r\n +worlbank", null, "+weltbank +worlbank");
 546     assertQueryEqualsDOA("weltbank \r \n +worlbank", null,
 547         "+weltbank +worlbank");
 548
 549     assertQueryEqualsDOA("+weltbank\t+worlbank", null, "+weltbank +worlbank");
 550     assertQueryEqualsDOA("weltbank \t+worlbank", null, "+weltbank +worlbank");
 551     assertQueryEqualsDOA("weltbank \t +worlbank", null, "+weltbank +worlbank");
 552   }
 553
 554   public void testSimpleDAO() throws Exception {
 555     assertQueryEqualsDOA("term term term", null, "+term +term +term");
 556     assertQueryEqualsDOA("term +term term", null, "+term +term +term");
 557     assertQueryEqualsDOA("term term +term", null, "+term +term +term");
 558     assertQueryEqualsDOA("term +term +term", null, "+term +term +term");
 559     assertQueryEqualsDOA("-term term term", null, "-term +term +term");
 560   }
 561
 562   public void testBoost() throws Exception {
 563     StandardAnalyzer oneStopAnalyzer = new StandardAnalyzer(TEST_VERSION_CURRENT, Collections.singleton("on"));
 564
 565     PrecedenceQueryParser qp = new PrecedenceQueryParser();
 566     qp.setAnalyzer(oneStopAnalyzer);
 567     Query q = qp.parse("on^1.0", "field");
 568     assertNotNull(q);
 569     q = qp.parse("\"hello\"^2.0", "field");
 570     assertNotNull(q);
 571     assertEquals(q.getBoost(), (float) 2.0, (float) 0.5);
 572     q = qp.parse("hello^2.0", "field");
 573     assertNotNull(q);
 574     assertEquals(q.getBoost(), (float) 2.0, (float) 0.5);
 575     q = qp.parse("\"on\"^1.0", "field");
 576     assertNotNull(q);
 577
 578     q = getParser(new StandardAnalyzer(TEST_VERSION_CURRENT)).parse("the^3", "field");
 579     assertNotNull(q);
 580   }
 581
 582   public void testException() throws Exception {
 583     try {
 584       assertQueryEquals("\"some phrase", null, "abc");
 585       fail("ParseException expected, not thrown");
 586     } catch (QueryNodeParseException expected) {
 587     }
 588   }
 589
 590   public void testBooleanQuery() throws Exception {
 591     BooleanQuery.setMaxClauseCount(2);
 592     try {
 593       getParser(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false)).parse("one two three", "field");
 594       fail("ParseException expected due to too many boolean clauses");
 595     } catch (QueryNodeException expected) {
 596       // too many boolean clauses, so ParseException is expected
 597     }
 598   }
 599
 600   // LUCENE-792
 601   public void testNOT() throws Exception {
 602     Analyzer a = new MockAnalyzer(random, MockTokenizer.WHITESPACE, false);
 603     assertQueryEquals("NOT foo AND bar", a, "-foo +bar");
 604   }
 605
 606   /**
 607    * This test differs from the original QueryParser, showing how the precedence
 608    * issue has been corrected.
 609    */
 610   public void testPrecedence() throws Exception {
 611     PrecedenceQueryParser parser = getParser(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false));
 612     Query query1 = parser.parse("A AND B OR C AND D", "field");
 613     Query query2 = parser.parse("(A AND B) OR (C AND D)", "field");
 614     assertEquals(query1, query2);
 615
 616     query1 = parser.parse("A OR B C", "field");
 617     query2 = parser.parse("(A B) C", "field");
 618     assertEquals(query1, query2);
 619
 620     query1 = parser.parse("A AND B C", "field");
 621     query2 = parser.parse("(+A +B) C", "field");
 622     assertEquals(query1, query2);
 623
 624     query1 = parser.parse("A AND NOT B", "field");
 625     query2 = parser.parse("+A -B", "field");
 626     assertEquals(query1, query2);
 627
 628     query1 = parser.parse("A OR NOT B", "field");
 629     query2 = parser.parse("A -B", "field");
 630     assertEquals(query1, query2);
 631
 632     query1 = parser.parse("A OR NOT B AND C", "field");
 633     query2 = parser.parse("A (-B +C)", "field");
 634     assertEquals(query1, query2);
 635
 636     parser.setDefaultOperator(StandardQueryConfigHandler.Operator.AND);
 637     query1 = parser.parse("A AND B OR C AND D", "field");
 638     query2 = parser.parse("(A AND B) OR (C AND D)", "field");
 639     assertEquals(query1, query2);
 640
 641     query1 = parser.parse("A AND B C", "field");
 642     query2 = parser.parse("(A B) C", "field");
 643     assertEquals(query1, query2);
 644
 645     query1 = parser.parse("A AND B C", "field");
 646     query2 = parser.parse("(+A +B) C", "field");
 647     assertEquals(query1, query2);
 648
 649     query1 = parser.parse("A AND NOT B", "field");
 650     query2 = parser.parse("+A -B", "field");
 651     assertEquals(query1, query2);
 652
 653     query1 = parser.parse("A AND NOT B OR C", "field");
 654     query2 = parser.parse("(+A -B) OR C", "field");
 655     assertEquals(query1, query2);
 656
 657   }
 658
 659   @Override
 660   public void tearDown() throws Exception {
 661     BooleanQuery.setMaxClauseCount(originalMaxClauses);
 662     super.tearDown();
 663   }
 664
 665 }