lucene-java-3.4.0/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQPHelper.java

   1 package org.apache.lucene.queryParser.standard;
   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.Collator;
  23 import java.text.DateFormat;
  24 import java.util.Calendar;
  25 import java.util.Date;
  26 import java.util.GregorianCalendar;
  27 import java.util.HashMap;
  28 import java.util.List;
  29 import java.util.Locale;
  30 import java.util.Map;
  31 import java.util.Collections;
  32
  33 import org.apache.lucene.analysis.Analyzer;
  34 import org.apache.lucene.analysis.KeywordAnalyzer;
  35 import org.apache.lucene.analysis.LowerCaseTokenizer;
  36 import org.apache.lucene.analysis.MockAnalyzer;
  37 import org.apache.lucene.analysis.MockTokenizer;
  38 import org.apache.lucene.analysis.SimpleAnalyzer;
  39 import org.apache.lucene.analysis.StopAnalyzer;
  40 import org.apache.lucene.analysis.StopFilter;
  41 import org.apache.lucene.analysis.TokenFilter;
  42 import org.apache.lucene.analysis.TokenStream;
  43 import org.apache.lucene.analysis.Tokenizer;
  44 import org.apache.lucene.analysis.WhitespaceAnalyzer;
  45 import org.apache.lucene.analysis.standard.StandardAnalyzer;
  46 import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
  47 import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
  48 import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
  49 import org.apache.lucene.document.DateField;
  50 import org.apache.lucene.document.DateTools;
  51 import org.apache.lucene.document.Document;
  52 import org.apache.lucene.document.Field;
  53 import org.apache.lucene.index.IndexWriter;
  54 import org.apache.lucene.index.IndexReader;
  55 import org.apache.lucene.index.Term;
  56 import org.apache.lucene.messages.MessageImpl;
  57 import org.apache.lucene.queryParser.core.QueryNodeException;
  58 import org.apache.lucene.queryParser.core.messages.QueryParserMessages;
  59 import org.apache.lucene.queryParser.core.nodes.FuzzyQueryNode;
  60 import org.apache.lucene.queryParser.core.nodes.QueryNode;
  61 import org.apache.lucene.queryParser.core.processors.QueryNodeProcessorImpl;
  62 import org.apache.lucene.queryParser.core.processors.QueryNodeProcessorPipeline;
  63 import org.apache.lucene.queryParser.standard.config.StandardQueryConfigHandler;
  64 import org.apache.lucene.queryParser.standard.config.StandardQueryConfigHandler.Operator;
  65 import org.apache.lucene.queryParser.standard.nodes.WildcardQueryNode;
  66 import org.apache.lucene.search.BooleanClause;
  67 import org.apache.lucene.search.BooleanQuery;
  68 import org.apache.lucene.search.FuzzyQuery;
  69 import org.apache.lucene.search.IndexSearcher;
  70 import org.apache.lucene.search.MatchAllDocsQuery;
  71 import org.apache.lucene.search.MultiPhraseQuery;
  72 import org.apache.lucene.search.MultiTermQuery;
  73 import org.apache.lucene.search.PhraseQuery;
  74 import org.apache.lucene.search.PrefixQuery;
  75 import org.apache.lucene.search.Query;
  76 import org.apache.lucene.search.ScoreDoc;
  77 import org.apache.lucene.search.TermQuery;
  78 import org.apache.lucene.search.TermRangeQuery;
  79 import org.apache.lucene.search.WildcardQuery;
  80 import org.apache.lucene.store.Directory;
  81 import org.apache.lucene.util.LuceneTestCase;
  82
  83 /**
  84  * This test case is a copy of the core Lucene query parser test, it was adapted
  85  * to use new QueryParserHelper instead of the old query parser.
  86  *
  87  * Tests QueryParser.
  88  */
  89 public class TestQPHelper extends LuceneTestCase {
  90
  91   public static Analyzer qpAnalyzer = new QPTestAnalyzer();
  92
  93   public static final class QPTestFilter extends TokenFilter {
  94     private final CharTermAttribute termAtt = addAttribute(CharTermAttribute.class);
  95     private final OffsetAttribute offsetAtt = addAttribute(OffsetAttribute.class);
  96
  97     /**
  98      * Filter which discards the token 'stop' and which expands the token
  99      * 'phrase' into 'phrase1 phrase2'
 100      */
 101     public QPTestFilter(TokenStream in) {
 102       super(in);
 103     }
 104
 105     private boolean inPhrase = false;
 106     private int savedStart = 0;
 107     private int savedEnd = 0;
 108
 109     @Override
 110     public boolean incrementToken() throws IOException {
 111       if (inPhrase) {
 112         inPhrase = false;
 113         clearAttributes();
 114         termAtt.setEmpty().append("phrase2");
 115         offsetAtt.setOffset(savedStart, savedEnd);
 116         return true;
 117       } else
 118         while (input.incrementToken()) {
 119           if (termAtt.toString().equals("phrase")) {
 120             inPhrase = true;
 121             savedStart = offsetAtt.startOffset();
 122             savedEnd = offsetAtt.endOffset();
 123             termAtt.setEmpty().append("phrase1");
 124             offsetAtt.setOffset(savedStart, savedEnd);
 125             return true;
 126           } else if (!termAtt.toString().equals("stop"))
 127             return true;
 128         }
 129       return false;
 130     }
 131
 132     @Override
 133     public void reset() throws IOException {
 134       super.reset();
 135       this.inPhrase = false;
 136       this.savedStart = 0;
 137       this.savedEnd = 0;
 138     }
 139   }
 140
 141   public static final class QPTestAnalyzer extends Analyzer {
 142
 143     /** Filters LowerCaseTokenizer with StopFilter. */
 144     @Override
 145     public final TokenStream tokenStream(String fieldName, Reader reader) {
 146       return new QPTestFilter(new LowerCaseTokenizer(TEST_VERSION_CURRENT, reader));
 147     }
 148   }
 149
 150   public static class QPTestParser extends StandardQueryParser {
 151     public QPTestParser(Analyzer a) {
 152       ((QueryNodeProcessorPipeline)getQueryNodeProcessor())
 153           .add(new QPTestParserQueryNodeProcessor());
 154       this.setAnalyzer(a);
 155
 156     }
 157
 158     private static class QPTestParserQueryNodeProcessor extends
 159         QueryNodeProcessorImpl {
 160
 161       @Override
 162       protected QueryNode postProcessNode(QueryNode node)
 163           throws QueryNodeException {
 164
 165         return node;
 166
 167       }
 168
 169       @Override
 170       protected QueryNode preProcessNode(QueryNode node)
 171           throws QueryNodeException {
 172
 173         if (node instanceof WildcardQueryNode || node instanceof FuzzyQueryNode) {
 174
 175           throw new QueryNodeException(new MessageImpl(
 176               QueryParserMessages.EMPTY_MESSAGE));
 177
 178         }
 179
 180         return node;
 181
 182       }
 183
 184       @Override
 185       protected List<QueryNode> setChildrenOrder(List<QueryNode> children)
 186           throws QueryNodeException {
 187
 188         return children;
 189
 190       }
 191
 192     }
 193
 194   }
 195
 196   private int originalMaxClauses;
 197
 198   @Override
 199   public void setUp() throws Exception {
 200     super.setUp();
 201     originalMaxClauses = BooleanQuery.getMaxClauseCount();
 202   }
 203
 204   public StandardQueryParser getParser(Analyzer a) throws Exception {
 205     if (a == null)
 206       a = new SimpleAnalyzer(TEST_VERSION_CURRENT);
 207     StandardQueryParser qp = new StandardQueryParser();
 208     qp.setAnalyzer(a);
 209
 210     qp.setDefaultOperator(StandardQueryConfigHandler.Operator.OR);
 211
 212     return qp;
 213
 214   }
 215
 216   public Query getQuery(String query, Analyzer a) throws Exception {
 217     return getParser(a).parse(query, "field");
 218   }
 219
 220   public Query getQueryAllowLeadingWildcard(String query, Analyzer a) throws Exception {
 221     StandardQueryParser parser = getParser(a);
 222     parser.setAllowLeadingWildcard(true);
 223     return parser.parse(query, "field");
 224   }
 225
 226   public void assertQueryEquals(String query, Analyzer a, String result)
 227       throws Exception {
 228     Query q = getQuery(query, a);
 229     String s = q.toString("field");
 230     if (!s.equals(result)) {
 231       fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
 232           + "/");
 233     }
 234   }
 235
 236   public void assertQueryEqualsAllowLeadingWildcard(String query, Analyzer a, String result)
 237       throws Exception {
 238     Query q = getQueryAllowLeadingWildcard(query, a);
 239     String s = q.toString("field");
 240     if (!s.equals(result)) {
 241       fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
 242           + "/");
 243     }
 244   }
 245
 246   public void assertQueryEquals(StandardQueryParser qp, String field,
 247       String query, String result) throws Exception {
 248     Query q = qp.parse(query, field);
 249     String s = q.toString(field);
 250     if (!s.equals(result)) {
 251       fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
 252           + "/");
 253     }
 254   }
 255
 256   public void assertEscapedQueryEquals(String query, Analyzer a, String result)
 257       throws Exception {
 258     String escapedQuery = QueryParserUtil.escape(query);
 259     if (!escapedQuery.equals(result)) {
 260       fail("Query /" + query + "/ yielded /" + escapedQuery + "/, expecting /"
 261           + result + "/");
 262     }
 263   }
 264
 265   public void assertWildcardQueryEquals(String query, boolean lowercase,
 266       String result, boolean allowLeadingWildcard) throws Exception {
 267     StandardQueryParser qp = getParser(null);
 268     qp.setLowercaseExpandedTerms(lowercase);
 269     qp.setAllowLeadingWildcard(allowLeadingWildcard);
 270     Query q = qp.parse(query, "field");
 271     String s = q.toString("field");
 272     if (!s.equals(result)) {
 273       fail("WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /"
 274           + result + "/");
 275     }
 276   }
 277
 278   public void assertWildcardQueryEquals(String query, boolean lowercase,
 279       String result) throws Exception {
 280     assertWildcardQueryEquals(query, lowercase, result, false);
 281   }
 282
 283   public void assertWildcardQueryEquals(String query, String result)
 284       throws Exception {
 285     StandardQueryParser qp = getParser(null);
 286     Query q = qp.parse(query, "field");
 287     String s = q.toString("field");
 288     if (!s.equals(result)) {
 289       fail("WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /"
 290           + result + "/");
 291     }
 292   }
 293
 294   public Query getQueryDOA(String query, Analyzer a) throws Exception {
 295     if (a == null)
 296       a = new SimpleAnalyzer(TEST_VERSION_CURRENT);
 297     StandardQueryParser qp = new StandardQueryParser();
 298     qp.setAnalyzer(a);
 299     qp.setDefaultOperator(Operator.AND);
 300
 301     return qp.parse(query, "field");
 302
 303   }
 304
 305   public void assertQueryEqualsDOA(String query, Analyzer a, String result)
 306       throws Exception {
 307     Query q = getQueryDOA(query, a);
 308     String s = q.toString("field");
 309     if (!s.equals(result)) {
 310       fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result
 311           + "/");
 312     }
 313   }
 314
 315   public void testConstantScoreAutoRewrite() throws Exception {
 316     StandardQueryParser qp = new StandardQueryParser(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false));
 317     Query q = qp.parse("foo*bar", "field");
 318     assertTrue(q instanceof WildcardQuery);
 319     assertEquals(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT, ((MultiTermQuery) q).getRewriteMethod());
 320
 321     q = qp.parse("foo*", "field");
 322     assertTrue(q instanceof PrefixQuery);
 323     assertEquals(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT, ((MultiTermQuery) q).getRewriteMethod());
 324
 325     q = qp.parse("[a TO z]", "field");
 326     assertTrue(q instanceof TermRangeQuery);
 327     assertEquals(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT, ((MultiTermQuery) q).getRewriteMethod());
 328   }
 329
 330   public void testCJK() throws Exception {
 331     // Test Ideographic Space - As wide as a CJK character cell (fullwidth)
 332     // used google to translate the word "term" to japanese -> ??
 333     assertQueryEquals("term\u3000term\u3000term", null,
 334         "term\u0020term\u0020term");
 335     assertQueryEqualsAllowLeadingWildcard("??\u3000??\u3000??", null, "??\u0020??\u0020??");
 336   }
 337
 338   public void testCJKTerm() throws Exception {
 339     // individual CJK chars as terms
 340     StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
 341
 342     BooleanQuery expected = new BooleanQuery();
 343     expected.add(new TermQuery(new Term("field", "中")), BooleanClause.Occur.SHOULD);
 344     expected.add(new TermQuery(new Term("field", "国")), BooleanClause.Occur.SHOULD);
 345
 346     assertEquals(expected, getQuery("中国", analyzer));
 347   }
 348
 349   public void testCJKBoostedTerm() throws Exception {
 350     // individual CJK chars as terms
 351     StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
 352
 353     BooleanQuery expected = new BooleanQuery();
 354     expected.setBoost(0.5f);
 355     expected.add(new TermQuery(new Term("field", "中")), BooleanClause.Occur.SHOULD);
 356     expected.add(new TermQuery(new Term("field", "国")), BooleanClause.Occur.SHOULD);
 357
 358     assertEquals(expected, getQuery("中国^0.5", analyzer));
 359   }
 360
 361   public void testCJKPhrase() throws Exception {
 362     // individual CJK chars as terms
 363     StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
 364
 365     PhraseQuery expected = new PhraseQuery();
 366     expected.add(new Term("field", "中"));
 367     expected.add(new Term("field", "国"));
 368
 369     assertEquals(expected, getQuery("\"中国\"", analyzer));
 370   }
 371
 372   public void testCJKBoostedPhrase() throws Exception {
 373     // individual CJK chars as terms
 374     StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
 375
 376     PhraseQuery expected = new PhraseQuery();
 377     expected.setBoost(0.5f);
 378     expected.add(new Term("field", "中"));
 379     expected.add(new Term("field", "国"));
 380
 381     assertEquals(expected, getQuery("\"中国\"^0.5", analyzer));
 382   }
 383
 384   public void testCJKSloppyPhrase() throws Exception {
 385     // individual CJK chars as terms
 386     StandardAnalyzer analyzer = new StandardAnalyzer(TEST_VERSION_CURRENT);
 387
 388     PhraseQuery expected = new PhraseQuery();
 389     expected.setSlop(3);
 390     expected.add(new Term("field", "中"));
 391     expected.add(new Term("field", "国"));
 392
 393     assertEquals(expected, getQuery("\"中国\"~3", analyzer));
 394   }
 395
 396   public void testSimple() throws Exception {
 397     assertQueryEquals("\"term germ\"~2", null, "\"term germ\"~2");
 398     assertQueryEquals("term term term", null, "term term term");
 399     assertQueryEquals("t�rm term term", new MockAnalyzer(random, MockTokenizer.WHITESPACE, false),
 400         "t�rm term term");
 401     assertQueryEquals("�mlaut", new MockAnalyzer(random, MockTokenizer.WHITESPACE, false), "�mlaut");
 402
 403     assertQueryEquals("\"\"", new KeywordAnalyzer(), "");
 404     assertQueryEquals("foo:\"\"", new KeywordAnalyzer(), "foo:");
 405
 406     assertQueryEquals("a AND b", null, "+a +b");
 407     assertQueryEquals("(a AND b)", null, "+a +b");
 408     assertQueryEquals("c OR (a AND b)", null, "c (+a +b)");
 409
 410     assertQueryEquals("a AND NOT b", null, "+a -b");
 411
 412     assertQueryEquals("a AND -b", null, "+a -b");
 413
 414     assertQueryEquals("a AND !b", null, "+a -b");
 415
 416     assertQueryEquals("a && b", null, "+a +b");
 417
 418     assertQueryEquals("a && ! b", null, "+a -b");
 419
 420     assertQueryEquals("a OR b", null, "a b");
 421     assertQueryEquals("a || b", null, "a b");
 422
 423     assertQueryEquals("a OR !b", null, "a -b");
 424
 425     assertQueryEquals("a OR ! b", null, "a -b");
 426
 427     assertQueryEquals("a OR -b", null, "a -b");
 428
 429     assertQueryEquals("+term -term term", null, "+term -term term");
 430     assertQueryEquals("foo:term AND field:anotherTerm", null,
 431         "+foo:term +anotherterm");
 432     assertQueryEquals("term AND \"phrase phrase\"", null,
 433         "+term +\"phrase phrase\"");
 434     assertQueryEquals("\"hello there\"", null, "\"hello there\"");
 435     assertTrue(getQuery("a AND b", null) instanceof BooleanQuery);
 436     assertTrue(getQuery("hello", null) instanceof TermQuery);
 437     assertTrue(getQuery("\"hello there\"", null) instanceof PhraseQuery);
 438
 439     assertQueryEquals("germ term^2.0", null, "germ term^2.0");
 440     assertQueryEquals("(term)^2.0", null, "term^2.0");
 441     assertQueryEquals("(germ term)^2.0", null, "(germ term)^2.0");
 442     assertQueryEquals("term^2.0", null, "term^2.0");
 443     assertQueryEquals("term^2", null, "term^2.0");
 444     assertQueryEquals("\"germ term\"^2.0", null, "\"germ term\"^2.0");
 445     assertQueryEquals("\"term germ\"^2", null, "\"term germ\"^2.0");
 446
 447     assertQueryEquals("(foo OR bar) AND (baz OR boo)", null,
 448         "+(foo bar) +(baz boo)");
 449     assertQueryEquals("((a OR b) AND NOT c) OR d", null, "(+(a b) -c) d");
 450     assertQueryEquals("+(apple \"steve jobs\") -(foo bar baz)", null,
 451         "+(apple \"steve jobs\") -(foo bar baz)");
 452     assertQueryEquals("+title:(dog OR cat) -author:\"bob dole\"", null,
 453         "+(title:dog title:cat) -author:\"bob dole\"");
 454
 455   }
 456
 457   public void testPunct() throws Exception {
 458     Analyzer a = new MockAnalyzer(random, MockTokenizer.WHITESPACE, false);
 459     assertQueryEquals("a&b", a, "a&b");
 460     assertQueryEquals("a&&b", a, "a&&b");
 461     assertQueryEquals(".NET", a, ".NET");
 462   }
 463
 464   public void testSlop() throws Exception {
 465
 466     assertQueryEquals("\"term germ\"~2", null, "\"term germ\"~2");
 467     assertQueryEquals("\"term germ\"~2 flork", null, "\"term germ\"~2 flork");
 468     assertQueryEquals("\"term\"~2", null, "term");
 469     assertQueryEquals("\" \"~2 germ", null, "germ");
 470     assertQueryEquals("\"term germ\"~2^2", null, "\"term germ\"~2^2.0");
 471   }
 472
 473   public void testNumber() throws Exception {
 474     // The numbers go away because SimpleAnalzyer ignores them
 475     assertQueryEquals("3", null, "");
 476     assertQueryEquals("term 1.0 1 2", null, "term");
 477     assertQueryEquals("term term1 term2", null, "term term term");
 478
 479     Analyzer a = new MockAnalyzer(random, MockTokenizer.WHITESPACE, false);
 480     assertQueryEquals("3", a, "3");
 481     assertQueryEquals("term 1.0 1 2", a, "term 1.0 1 2");
 482     assertQueryEquals("term term1 term2", a, "term term1 term2");
 483   }
 484
 485   public void testWildcard() throws Exception {
 486     assertQueryEquals("term*", null, "term*");
 487     assertQueryEquals("term*^2", null, "term*^2.0");
 488     assertQueryEquals("term~", null, "term~0.5");
 489     assertQueryEquals("term~0.7", null, "term~0.7");
 490
 491     assertQueryEquals("term~^2", null, "term~0.5^2.0");
 492
 493     assertQueryEquals("term^2~", null, "term~0.5^2.0");
 494     assertQueryEquals("term*germ", null, "term*germ");
 495     assertQueryEquals("term*germ^3", null, "term*germ^3.0");
 496
 497     assertTrue(getQuery("term*", null) instanceof PrefixQuery);
 498     assertTrue(getQuery("term*^2", null) instanceof PrefixQuery);
 499     assertTrue(getQuery("term~", null) instanceof FuzzyQuery);
 500     assertTrue(getQuery("term~0.7", null) instanceof FuzzyQuery);
 501     FuzzyQuery fq = (FuzzyQuery) getQuery("term~0.7", null);
 502     assertEquals(0.7f, fq.getMinSimilarity(), 0.1f);
 503     assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());
 504     fq = (FuzzyQuery) getQuery("term~", null);
 505     assertEquals(0.5f, fq.getMinSimilarity(), 0.1f);
 506     assertEquals(FuzzyQuery.defaultPrefixLength, fq.getPrefixLength());
 507
 508     assertQueryNodeException("term~1.1"); // value > 1, throws exception
 509
 510     assertTrue(getQuery("term*germ", null) instanceof WildcardQuery);
 511
 512     /*
 513      * Tests to see that wild card terms are (or are not) properly lower-cased
 514      * with propery parser configuration
 515      */
 516     // First prefix queries:
 517     // by default, convert to lowercase:
 518     assertWildcardQueryEquals("Term*", true, "term*");
 519     // explicitly set lowercase:
 520     assertWildcardQueryEquals("term*", true, "term*");
 521     assertWildcardQueryEquals("Term*", true, "term*");
 522     assertWildcardQueryEquals("TERM*", true, "term*");
 523     // explicitly disable lowercase conversion:
 524     assertWildcardQueryEquals("term*", false, "term*");
 525     assertWildcardQueryEquals("Term*", false, "Term*");
 526     assertWildcardQueryEquals("TERM*", false, "TERM*");
 527     // Then 'full' wildcard queries:
 528     // by default, convert to lowercase:
 529     assertWildcardQueryEquals("Te?m", "te?m");
 530     // explicitly set lowercase:
 531     assertWildcardQueryEquals("te?m", true, "te?m");
 532     assertWildcardQueryEquals("Te?m", true, "te?m");
 533     assertWildcardQueryEquals("TE?M", true, "te?m");
 534     assertWildcardQueryEquals("Te?m*gerM", true, "te?m*germ");
 535     // explicitly disable lowercase conversion:
 536     assertWildcardQueryEquals("te?m", false, "te?m");
 537     assertWildcardQueryEquals("Te?m", false, "Te?m");
 538     assertWildcardQueryEquals("TE?M", false, "TE?M");
 539     assertWildcardQueryEquals("Te?m*gerM", false, "Te?m*gerM");
 540     // Fuzzy queries:
 541     assertWildcardQueryEquals("Term~", "term~0.5");
 542     assertWildcardQueryEquals("Term~", true, "term~0.5");
 543     assertWildcardQueryEquals("Term~", false, "Term~0.5");
 544     // Range queries:
 545
 546     // TODO: implement this on QueryParser
 547     // Q0002E_INVALID_SYNTAX_CANNOT_PARSE: Syntax Error, cannot parse '[A TO
 548     // C]': Lexical error at line 1, column 1. Encountered: "[" (91), after
 549     // : ""
 550     assertWildcardQueryEquals("[A TO C]", "[a TO c]");
 551     assertWildcardQueryEquals("[A TO C]", true, "[a TO c]");
 552     assertWildcardQueryEquals("[A TO C]", false, "[A TO C]");
 553     // Test suffix queries: first disallow
 554     try {
 555       assertWildcardQueryEquals("*Term", true, "*term");
 556       fail();
 557     } catch (QueryNodeException pe) {
 558       // expected exception
 559     }
 560     try {
 561       assertWildcardQueryEquals("?Term", true, "?term");
 562       fail();
 563     } catch (QueryNodeException pe) {
 564       // expected exception
 565     }
 566     // Test suffix queries: then allow
 567     assertWildcardQueryEquals("*Term", true, "*term", true);
 568     assertWildcardQueryEquals("?Term", true, "?term", true);
 569   }
 570
 571   public void testLeadingWildcardType() throws Exception {
 572     StandardQueryParser qp = getParser(null);
 573     qp.setAllowLeadingWildcard(true);
 574     assertEquals(WildcardQuery.class, qp.parse("t*erm*", "field").getClass());
 575     assertEquals(WildcardQuery.class, qp.parse("?term*", "field").getClass());
 576     assertEquals(WildcardQuery.class, qp.parse("*term*", "field").getClass());
 577   }
 578
 579   public void testQPA() throws Exception {
 580     assertQueryEquals("term term^3.0 term", qpAnalyzer, "term term^3.0 term");
 581     assertQueryEquals("term stop^3.0 term", qpAnalyzer, "term term");
 582
 583     assertQueryEquals("term term term", qpAnalyzer, "term term term");
 584     assertQueryEquals("term +stop term", qpAnalyzer, "term term");
 585     assertQueryEquals("term -stop term", qpAnalyzer, "term term");
 586
 587     assertQueryEquals("drop AND (stop) AND roll", qpAnalyzer, "+drop +roll");
 588     assertQueryEquals("term +(stop) term", qpAnalyzer, "term term");
 589     assertQueryEquals("term -(stop) term", qpAnalyzer, "term term");
 590
 591     assertQueryEquals("drop AND stop AND roll", qpAnalyzer, "+drop +roll");
 592     assertQueryEquals("term phrase term", qpAnalyzer,
 593         "term phrase1 phrase2 term");
 594
 595     assertQueryEquals("term AND NOT phrase term", qpAnalyzer,
 596         "+term -(phrase1 phrase2) term");
 597
 598     assertQueryEquals("stop^3", qpAnalyzer, "");
 599     assertQueryEquals("stop", qpAnalyzer, "");
 600     assertQueryEquals("(stop)^3", qpAnalyzer, "");
 601     assertQueryEquals("((stop))^3", qpAnalyzer, "");
 602     assertQueryEquals("(stop^3)", qpAnalyzer, "");
 603     assertQueryEquals("((stop)^3)", qpAnalyzer, "");
 604     assertQueryEquals("(stop)", qpAnalyzer, "");
 605     assertQueryEquals("((stop))", qpAnalyzer, "");
 606     assertTrue(getQuery("term term term", qpAnalyzer) instanceof BooleanQuery);
 607     assertTrue(getQuery("term +stop", qpAnalyzer) instanceof TermQuery);
 608   }
 609
 610   public void testRange() throws Exception {
 611     assertQueryEquals("[ a TO z]", null, "[a TO z]");
 612     assertEquals(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT, ((TermRangeQuery)getQuery("[ a TO z]", null)).getRewriteMethod());
 613
 614     StandardQueryParser qp = new StandardQueryParser();
 615
 616     qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
 617     assertEquals(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE,((TermRangeQuery)qp.parse("[ a TO z]", "field")).getRewriteMethod());
 618
 619     assertQueryEquals("[ a TO z ]", null, "[a TO z]");
 620     assertQueryEquals("{ a TO z}", null, "{a TO z}");
 621     assertQueryEquals("{ a TO z }", null, "{a TO z}");
 622     assertQueryEquals("{ a TO z }^2.0", null, "{a TO z}^2.0");
 623     assertQueryEquals("[ a TO z] OR bar", null, "[a TO z] bar");
 624     assertQueryEquals("[ a TO z] AND bar", null, "+[a TO z] +bar");
 625     assertQueryEquals("( bar blar { a TO z}) ", null, "bar blar {a TO z}");
 626     assertQueryEquals("gack ( bar blar { a TO z}) ", null,
 627         "gack (bar blar {a TO z})");
 628   }
 629
 630   public void testFarsiRangeCollating() throws Exception {
 631     Directory ramDir = newDirectory();
 632     IndexWriter iw = new IndexWriter(ramDir, newIndexWriterConfig(TEST_VERSION_CURRENT, new WhitespaceAnalyzer(TEST_VERSION_CURRENT)));
 633     Document doc = new Document();
 634     doc.add(newField("content", "\u0633\u0627\u0628", Field.Store.YES,
 635         Field.Index.NOT_ANALYZED));
 636     iw.addDocument(doc);
 637     iw.close();
 638     IndexSearcher is = new IndexSearcher(ramDir, true);
 639
 640     StandardQueryParser qp = new StandardQueryParser();
 641     qp.setAnalyzer(new WhitespaceAnalyzer(TEST_VERSION_CURRENT));
 642
 643     // Neither Java 1.4.2 nor 1.5.0 has Farsi Locale collation available in
 644     // RuleBasedCollator. However, the Arabic Locale seems to order the
 645     // Farsi
 646     // characters properly.
 647     Collator c = Collator.getInstance(new Locale("ar"));
 648     qp.setRangeCollator(c);
 649
 650     // Unicode order would include U+0633 in [ U+062F - U+0698 ], but Farsi
 651     // orders the U+0698 character before the U+0633 character, so the
 652     // single
 653     // index Term below should NOT be returned by a ConstantScoreRangeQuery
 654     // with a Farsi Collator (or an Arabic one for the case when Farsi is
 655     // not
 656     // supported).
 657
 658     // Test ConstantScoreRangeQuery
 659     qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
 660     ScoreDoc[] result = is.search(qp.parse("[ \u062F TO \u0698 ]", "content"),
 661         null, 1000).scoreDocs;
 662     assertEquals("The index Term should not be included.", 0, result.length);
 663
 664     result = is.search(qp.parse("[ \u0633 TO \u0638 ]", "content"), null, 1000).scoreDocs;
 665     assertEquals("The index Term should be included.", 1, result.length);
 666
 667     // Test RangeQuery
 668     qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
 669     result = is.search(qp.parse("[ \u062F TO \u0698 ]", "content"), null, 1000).scoreDocs;
 670     assertEquals("The index Term should not be included.", 0, result.length);
 671
 672     result = is.search(qp.parse("[ \u0633 TO \u0638 ]", "content"), null, 1000).scoreDocs;
 673     assertEquals("The index Term should be included.", 1, result.length);
 674
 675     is.close();
 676     ramDir.close();
 677   }
 678
 679   /** for testing legacy DateField support */
 680   private String getLegacyDate(String s) throws Exception {
 681     DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
 682     return DateField.dateToString(df.parse(s));
 683   }
 684
 685   /** for testing DateTools support */
 686   private String getDate(String s, DateTools.Resolution resolution)
 687       throws Exception {
 688     DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
 689     return getDate(df.parse(s), resolution);
 690   }
 691
 692   /** for testing DateTools support */
 693   private String getDate(Date d, DateTools.Resolution resolution)
 694       throws Exception {
 695     if (resolution == null) {
 696       return DateField.dateToString(d);
 697     } else {
 698       return DateTools.dateToString(d, resolution);
 699     }
 700   }
 701
 702   private String escapeDateString(String s) {
 703     if (s.contains(" ")) {
 704       return "\"" + s + "\"";
 705     } else {
 706       return s;
 707     }
 708   }
 709
 710   private String getLocalizedDate(int year, int month, int day) {
 711     DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
 712     Calendar calendar = new GregorianCalendar();
 713     calendar.clear();
 714     calendar.set(year, month, day);
 715     calendar.set(Calendar.HOUR_OF_DAY, 23);
 716     calendar.set(Calendar.MINUTE, 59);
 717     calendar.set(Calendar.SECOND, 59);
 718     calendar.set(Calendar.MILLISECOND, 999);
 719     return df.format(calendar.getTime());
 720   }
 721
 722   /** for testing legacy DateField support */
 723   public void testLegacyDateRange() throws Exception {
 724     String startDate = getLocalizedDate(2002, 1, 1);
 725     String endDate = getLocalizedDate(2002, 1, 4);
 726     Calendar endDateExpected = new GregorianCalendar();
 727     endDateExpected.clear();
 728     endDateExpected.set(2002, 1, 4, 23, 59, 59);
 729     endDateExpected.set(Calendar.MILLISECOND, 999);
 730     assertQueryEquals("[ " + escapeDateString(startDate) + " TO " + escapeDateString(endDate) + "]", null, "["
 731         + getLegacyDate(startDate) + " TO "
 732         + DateField.dateToString(endDateExpected.getTime()) + "]");
 733     assertQueryEquals("{  " + escapeDateString(startDate) + "    " + escapeDateString(endDate) + "   }", null, "{"
 734         + getLegacyDate(startDate) + " TO " + getLegacyDate(endDate) + "}");
 735   }
 736
 737   public void testDateRange() throws Exception {
 738     String startDate = getLocalizedDate(2002, 1, 1);
 739     String endDate = getLocalizedDate(2002, 1, 4);
 740     Calendar endDateExpected = new GregorianCalendar();
 741     endDateExpected.clear();
 742     endDateExpected.set(2002, 1, 4, 23, 59, 59);
 743     endDateExpected.set(Calendar.MILLISECOND, 999);
 744     final String defaultField = "default";
 745     final String monthField = "month";
 746     final String hourField = "hour";
 747     StandardQueryParser qp = new StandardQueryParser();
 748
 749     // Don't set any date resolution and verify if DateField is used
 750     assertDateRangeQueryEquals(qp, defaultField, startDate, endDate,
 751         endDateExpected.getTime(), null);
 752
 753     Map<CharSequence, DateTools.Resolution> dateRes =  new HashMap<CharSequence, DateTools.Resolution>();
 754
 755     // set a field specific date resolution
 756     dateRes.put(monthField, DateTools.Resolution.MONTH);
 757     qp.setDateResolution(dateRes);
 758
 759     // DateField should still be used for defaultField
 760     assertDateRangeQueryEquals(qp, defaultField, startDate, endDate,
 761         endDateExpected.getTime(), null);
 762
 763     // set default date resolution to MILLISECOND
 764     qp.setDateResolution(DateTools.Resolution.MILLISECOND);
 765
 766     // set second field specific date resolution
 767     dateRes.put(hourField, DateTools.Resolution.HOUR);
 768     qp.setDateResolution(dateRes);
 769
 770     // for this field no field specific date resolution has been set,
 771     // so verify if the default resolution is used
 772     assertDateRangeQueryEquals(qp, defaultField, startDate, endDate,
 773         endDateExpected.getTime(), DateTools.Resolution.MILLISECOND);
 774
 775     // verify if field specific date resolutions are used for these two
 776     // fields
 777     assertDateRangeQueryEquals(qp, monthField, startDate, endDate,
 778         endDateExpected.getTime(), DateTools.Resolution.MONTH);
 779
 780     assertDateRangeQueryEquals(qp, hourField, startDate, endDate,
 781         endDateExpected.getTime(), DateTools.Resolution.HOUR);
 782   }
 783
 784   public void assertDateRangeQueryEquals(StandardQueryParser qp,
 785       String field, String startDate, String endDate, Date endDateInclusive,
 786       DateTools.Resolution resolution) throws Exception {
 787     assertQueryEquals(qp, field, field + ":[" + escapeDateString(startDate) + " TO " + escapeDateString(endDate)
 788         + "]", "[" + getDate(startDate, resolution) + " TO "
 789         + getDate(endDateInclusive, resolution) + "]");
 790     assertQueryEquals(qp, field, field + ":{" + escapeDateString(startDate) + " TO " + escapeDateString(endDate)
 791         + "}", "{" + getDate(startDate, resolution) + " TO "
 792         + getDate(endDate, resolution) + "}");
 793   }
 794
 795   public void testEscaped() throws Exception {
 796     Analyzer a = new MockAnalyzer(random, MockTokenizer.WHITESPACE, false);
 797
 798     /*
 799      * assertQueryEquals("\\[brackets", a, "\\[brackets");
 800      * assertQueryEquals("\\[brackets", null, "brackets");
 801      * assertQueryEquals("\\\\", a, "\\\\"); assertQueryEquals("\\+blah", a,
 802      * "\\+blah"); assertQueryEquals("\\(blah", a, "\\(blah");
 803      *
 804      * assertQueryEquals("\\-blah", a, "\\-blah"); assertQueryEquals("\\!blah",
 805      * a, "\\!blah"); assertQueryEquals("\\{blah", a, "\\{blah");
 806      * assertQueryEquals("\\}blah", a, "\\}blah"); assertQueryEquals("\\:blah",
 807      * a, "\\:blah"); assertQueryEquals("\\^blah", a, "\\^blah");
 808      * assertQueryEquals("\\[blah", a, "\\[blah"); assertQueryEquals("\\]blah",
 809      * a, "\\]blah"); assertQueryEquals("\\\"blah", a, "\\\"blah");
 810      * assertQueryEquals("\\(blah", a, "\\(blah"); assertQueryEquals("\\)blah",
 811      * a, "\\)blah"); assertQueryEquals("\\~blah", a, "\\~blah");
 812      * assertQueryEquals("\\*blah", a, "\\*blah"); assertQueryEquals("\\?blah",
 813      * a, "\\?blah"); //assertQueryEquals("foo \\&\\& bar", a,
 814      * "foo \\&\\& bar"); //assertQueryEquals("foo \\|| bar", a,
 815      * "foo \\|| bar"); //assertQueryEquals("foo \\AND bar", a,
 816      * "foo \\AND bar");
 817      */
 818
 819     assertQueryEquals("\\*", a, "*");
 820
 821     assertQueryEquals("\\a", a, "a");
 822
 823     assertQueryEquals("a\\-b:c", a, "a-b:c");
 824     assertQueryEquals("a\\+b:c", a, "a+b:c");
 825     assertQueryEquals("a\\:b:c", a, "a:b:c");
 826     assertQueryEquals("a\\\\b:c", a, "a\\b:c");
 827
 828     assertQueryEquals("a:b\\-c", a, "a:b-c");
 829     assertQueryEquals("a:b\\+c", a, "a:b+c");
 830     assertQueryEquals("a:b\\:c", a, "a:b:c");
 831     assertQueryEquals("a:b\\\\c", a, "a:b\\c");
 832
 833     assertQueryEquals("a:b\\-c*", a, "a:b-c*");
 834     assertQueryEquals("a:b\\+c*", a, "a:b+c*");
 835     assertQueryEquals("a:b\\:c*", a, "a:b:c*");
 836
 837     assertQueryEquals("a:b\\\\c*", a, "a:b\\c*");
 838
 839     assertQueryEquals("a:b\\-?c", a, "a:b-?c");
 840     assertQueryEquals("a:b\\+?c", a, "a:b+?c");
 841     assertQueryEquals("a:b\\:?c", a, "a:b:?c");
 842
 843     assertQueryEquals("a:b\\\\?c", a, "a:b\\?c");
 844
 845     assertQueryEquals("a:b\\-c~", a, "a:b-c~0.5");
 846     assertQueryEquals("a:b\\+c~", a, "a:b+c~0.5");
 847     assertQueryEquals("a:b\\:c~", a, "a:b:c~0.5");
 848     assertQueryEquals("a:b\\\\c~", a, "a:b\\c~0.5");
 849
 850     // TODO: implement Range queries on QueryParser
 851     assertQueryEquals("[ a\\- TO a\\+ ]", null, "[a- TO a+]");
 852     assertQueryEquals("[ a\\: TO a\\~ ]", null, "[a: TO a~]");
 853     assertQueryEquals("[ a\\\\ TO a\\* ]", null, "[a\\ TO a*]");
 854
 855     assertQueryEquals(
 856         "[\"c\\:\\\\temp\\\\\\~foo0.txt\" TO \"c\\:\\\\temp\\\\\\~foo9.txt\"]",
 857         a, "[c:\\temp\\~foo0.txt TO c:\\temp\\~foo9.txt]");
 858
 859     assertQueryEquals("a\\\\\\+b", a, "a\\+b");
 860
 861     assertQueryEquals("a \\\"b c\\\" d", a, "a \"b c\" d");
 862     assertQueryEquals("\"a \\\"b c\\\" d\"", a, "\"a \"b c\" d\"");
 863     assertQueryEquals("\"a \\+b c d\"", a, "\"a +b c d\"");
 864
 865     assertQueryEquals("c\\:\\\\temp\\\\\\~foo.txt", a, "c:\\temp\\~foo.txt");
 866
 867     assertQueryNodeException("XY\\"); // there must be a character after the
 868     // escape char
 869
 870     // test unicode escaping
 871     assertQueryEquals("a\\u0062c", a, "abc");
 872     assertQueryEquals("XY\\u005a", a, "XYZ");
 873     assertQueryEquals("XY\\u005A", a, "XYZ");
 874     assertQueryEquals("\"a \\\\\\u0028\\u0062\\\" c\"", a, "\"a \\(b\" c\"");
 875
 876     assertQueryNodeException("XY\\u005G"); // test non-hex character in escaped
 877     // unicode sequence
 878     assertQueryNodeException("XY\\u005"); // test incomplete escaped unicode
 879     // sequence
 880
 881     // Tests bug LUCENE-800
 882     assertQueryEquals("(item:\\\\ item:ABCD\\\\)", a, "item:\\ item:ABCD\\");
 883     assertQueryNodeException("(item:\\\\ item:ABCD\\\\))"); // unmatched closing
 884     // paranthesis
 885     assertQueryEquals("\\*", a, "*");
 886     assertQueryEquals("\\\\", a, "\\"); // escaped backslash
 887
 888     assertQueryNodeException("\\"); // a backslash must always be escaped
 889
 890     // LUCENE-1189
 891     assertQueryEquals("(\"a\\\\\") or (\"b\")", a, "a\\ or b");
 892   }
 893
 894   public void testQueryStringEscaping() throws Exception {
 895     Analyzer a = new MockAnalyzer(random, MockTokenizer.WHITESPACE, false);
 896
 897     assertEscapedQueryEquals("a-b:c", a, "a\\-b\\:c");
 898     assertEscapedQueryEquals("a+b:c", a, "a\\+b\\:c");
 899     assertEscapedQueryEquals("a:b:c", a, "a\\:b\\:c");
 900     assertEscapedQueryEquals("a\\b:c", a, "a\\\\b\\:c");
 901
 902     assertEscapedQueryEquals("a:b-c", a, "a\\:b\\-c");
 903     assertEscapedQueryEquals("a:b+c", a, "a\\:b\\+c");
 904     assertEscapedQueryEquals("a:b:c", a, "a\\:b\\:c");
 905     assertEscapedQueryEquals("a:b\\c", a, "a\\:b\\\\c");
 906
 907     assertEscapedQueryEquals("a:b-c*", a, "a\\:b\\-c\\*");
 908     assertEscapedQueryEquals("a:b+c*", a, "a\\:b\\+c\\*");
 909     assertEscapedQueryEquals("a:b:c*", a, "a\\:b\\:c\\*");
 910
 911     assertEscapedQueryEquals("a:b\\\\c*", a, "a\\:b\\\\\\\\c\\*");
 912
 913     assertEscapedQueryEquals("a:b-?c", a, "a\\:b\\-\\?c");
 914     assertEscapedQueryEquals("a:b+?c", a, "a\\:b\\+\\?c");
 915     assertEscapedQueryEquals("a:b:?c", a, "a\\:b\\:\\?c");
 916
 917     assertEscapedQueryEquals("a:b?c", a, "a\\:b\\?c");
 918
 919     assertEscapedQueryEquals("a:b-c~", a, "a\\:b\\-c\\~");
 920     assertEscapedQueryEquals("a:b+c~", a, "a\\:b\\+c\\~");
 921     assertEscapedQueryEquals("a:b:c~", a, "a\\:b\\:c\\~");
 922     assertEscapedQueryEquals("a:b\\c~", a, "a\\:b\\\\c\\~");
 923
 924     assertEscapedQueryEquals("[ a - TO a+ ]", null, "\\[ a \\- TO a\\+ \\]");
 925     assertEscapedQueryEquals("[ a : TO a~ ]", null, "\\[ a \\: TO a\\~ \\]");
 926     assertEscapedQueryEquals("[ a\\ TO a* ]", null, "\\[ a\\\\ TO a\\* \\]");
 927
 928     // LUCENE-881
 929     assertEscapedQueryEquals("|| abc ||", a, "\\|\\| abc \\|\\|");
 930     assertEscapedQueryEquals("&& abc &&", a, "\\&\\& abc \\&\\&");
 931   }
 932
 933   public void testTabNewlineCarriageReturn() throws Exception {
 934     assertQueryEqualsDOA("+weltbank +worlbank", null, "+weltbank +worlbank");
 935
 936     assertQueryEqualsDOA("+weltbank\n+worlbank", null, "+weltbank +worlbank");
 937     assertQueryEqualsDOA("weltbank \n+worlbank", null, "+weltbank +worlbank");
 938     assertQueryEqualsDOA("weltbank \n +worlbank", null, "+weltbank +worlbank");
 939
 940     assertQueryEqualsDOA("+weltbank\r+worlbank", null, "+weltbank +worlbank");
 941     assertQueryEqualsDOA("weltbank \r+worlbank", null, "+weltbank +worlbank");
 942     assertQueryEqualsDOA("weltbank \r +worlbank", null, "+weltbank +worlbank");
 943
 944     assertQueryEqualsDOA("+weltbank\r\n+worlbank", null, "+weltbank +worlbank");
 945     assertQueryEqualsDOA("weltbank \r\n+worlbank", null, "+weltbank +worlbank");
 946     assertQueryEqualsDOA("weltbank \r\n +worlbank", null, "+weltbank +worlbank");
 947     assertQueryEqualsDOA("weltbank \r \n +worlbank", null,
 948         "+weltbank +worlbank");
 949
 950     assertQueryEqualsDOA("+weltbank\t+worlbank", null, "+weltbank +worlbank");
 951     assertQueryEqualsDOA("weltbank \t+worlbank", null, "+weltbank +worlbank");
 952     assertQueryEqualsDOA("weltbank \t +worlbank", null, "+weltbank +worlbank");
 953   }
 954
 955   public void testSimpleDAO() throws Exception {
 956     assertQueryEqualsDOA("term term term", null, "+term +term +term");
 957     assertQueryEqualsDOA("term +term term", null, "+term +term +term");
 958     assertQueryEqualsDOA("term term +term", null, "+term +term +term");
 959     assertQueryEqualsDOA("term +term +term", null, "+term +term +term");
 960     assertQueryEqualsDOA("-term term term", null, "-term +term +term");
 961   }
 962
 963   public void testBoost() throws Exception {
 964     StandardAnalyzer oneStopAnalyzer = new StandardAnalyzer(TEST_VERSION_CURRENT, Collections.singleton("on"));
 965     StandardQueryParser qp = new StandardQueryParser();
 966     qp.setAnalyzer(oneStopAnalyzer);
 967
 968     Query q = qp.parse("on^1.0", "field");
 969     assertNotNull(q);
 970     q = qp.parse("\"hello\"^2.0", "field");
 971     assertNotNull(q);
 972     assertEquals(q.getBoost(), (float) 2.0, (float) 0.5);
 973     q = qp.parse("hello^2.0", "field");
 974     assertNotNull(q);
 975     assertEquals(q.getBoost(), (float) 2.0, (float) 0.5);
 976     q = qp.parse("\"on\"^1.0", "field");
 977     assertNotNull(q);
 978
 979     StandardQueryParser qp2 = new StandardQueryParser();
 980     qp2.setAnalyzer(new StandardAnalyzer(TEST_VERSION_CURRENT));
 981
 982     q = qp2.parse("the^3", "field");
 983     // "the" is a stop word so the result is an empty query:
 984     assertNotNull(q);
 985     assertEquals("", q.toString());
 986     assertEquals(1.0f, q.getBoost(), 0.01f);
 987   }
 988
 989   public void assertQueryNodeException(String queryString) throws Exception {
 990     try {
 991       getQuery(queryString, null);
 992     } catch (QueryNodeException expected) {
 993       return;
 994     }
 995     fail("ParseException expected, not thrown");
 996   }
 997
 998   public void testException() throws Exception {
 999     assertQueryNodeException("*leadingWildcard"); // disallowed by default
1000     assertQueryNodeException("\"some phrase");
1001     assertQueryNodeException("(foo bar");
1002     assertQueryNodeException("foo bar))");
1003     assertQueryNodeException("field:term:with:colon some more terms");
1004     assertQueryNodeException("(sub query)^5.0^2.0 plus more");
1005     assertQueryNodeException("secret AND illegal) AND access:confidential");
1006   }
1007
1008   public void testCustomQueryParserWildcard() {
1009     try {
1010       new QPTestParser(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false)).parse("a?t", "contents");
1011       fail("Wildcard queries should not be allowed");
1012     } catch (QueryNodeException expected) {
1013       // expected exception
1014     }
1015   }
1016
1017   public void testCustomQueryParserFuzzy() throws Exception {
1018     try {
1019       new QPTestParser(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false)).parse("xunit~", "contents");
1020       fail("Fuzzy queries should not be allowed");
1021     } catch (QueryNodeException expected) {
1022       // expected exception
1023     }
1024   }
1025
1026   public void testBooleanQuery() throws Exception {
1027     BooleanQuery.setMaxClauseCount(2);
1028     try {
1029       StandardQueryParser qp = new StandardQueryParser();
1030       qp.setAnalyzer(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false));
1031       qp.parse("one two three", "field");
1032       fail("ParseException expected due to too many boolean clauses");
1033     } catch (QueryNodeException expected) {
1034       // too many boolean clauses, so ParseException is expected
1035     }
1036   }
1037
1038   /**
1039    * This test differs from TestPrecedenceQueryParser
1040    */
1041   public void testPrecedence() throws Exception {
1042     StandardQueryParser qp = new StandardQueryParser();
1043     qp.setAnalyzer(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false));
1044
1045     Query query1 = qp.parse("A AND B OR C AND D", "field");
1046     Query query2 = qp.parse("+A +B +C +D", "field");
1047
1048     assertEquals(query1, query2);
1049   }
1050
1051   public void testLocalDateFormat() throws IOException, QueryNodeException {
1052     Directory ramDir = newDirectory();
1053     IndexWriter iw = new IndexWriter(ramDir, newIndexWriterConfig(TEST_VERSION_CURRENT, new WhitespaceAnalyzer(TEST_VERSION_CURRENT)));
1054     addDateDoc("a", 2005, 12, 2, 10, 15, 33, iw);
1055     addDateDoc("b", 2005, 12, 4, 22, 15, 00, iw);
1056     iw.close();
1057     IndexSearcher is = new IndexSearcher(ramDir, true);
1058     assertHits(1, "[12/1/2005 TO 12/3/2005]", is);
1059     assertHits(2, "[12/1/2005 TO 12/4/2005]", is);
1060     assertHits(1, "[12/3/2005 TO 12/4/2005]", is);
1061     assertHits(1, "{12/1/2005 TO 12/3/2005}", is);
1062     assertHits(1, "{12/1/2005 TO 12/4/2005}", is);
1063     assertHits(0, "{12/3/2005 TO 12/4/2005}", is);
1064     is.close();
1065     ramDir.close();
1066   }
1067
1068   public void testStarParsing() throws Exception {
1069     // final int[] type = new int[1];
1070     // StandardQueryParser qp = new StandardQueryParser("field", new
1071     // WhitespaceAnalyzer()) {
1072     // protected Query getWildcardQuery(String field, String termStr) throws
1073     // ParseException {
1074     // // override error checking of superclass
1075     // type[0]=1;
1076     // return new TermQuery(new Term(field,termStr));
1077     // }
1078     // protected Query getPrefixQuery(String field, String termStr) throws
1079     // ParseException {
1080     // // override error checking of superclass
1081     // type[0]=2;
1082     // return new TermQuery(new Term(field,termStr));
1083     // }
1084     //
1085     // protected Query getFieldQuery(String field, String queryText) throws
1086     // ParseException {
1087     // type[0]=3;
1088     // return super.getFieldQuery(field, queryText);
1089     // }
1090     // };
1091     //
1092     // TermQuery tq;
1093     //
1094     // tq = (TermQuery)qp.parse("foo:zoo*");
1095     // assertEquals("zoo",tq.getTerm().text());
1096     // assertEquals(2,type[0]);
1097     //
1098     // tq = (TermQuery)qp.parse("foo:zoo*^2");
1099     // assertEquals("zoo",tq.getTerm().text());
1100     // assertEquals(2,type[0]);
1101     // assertEquals(tq.getBoost(),2,0);
1102     //
1103     // tq = (TermQuery)qp.parse("foo:*");
1104     // assertEquals("*",tq.getTerm().text());
1105     // assertEquals(1,type[0]); // could be a valid prefix query in the
1106     // future too
1107     //
1108     // tq = (TermQuery)qp.parse("foo:*^2");
1109     // assertEquals("*",tq.getTerm().text());
1110     // assertEquals(1,type[0]);
1111     // assertEquals(tq.getBoost(),2,0);
1112     //
1113     // tq = (TermQuery)qp.parse("*:foo");
1114     // assertEquals("*",tq.getTerm().field());
1115     // assertEquals("foo",tq.getTerm().text());
1116     // assertEquals(3,type[0]);
1117     //
1118     // tq = (TermQuery)qp.parse("*:*");
1119     // assertEquals("*",tq.getTerm().field());
1120     // assertEquals("*",tq.getTerm().text());
1121     // assertEquals(1,type[0]); // could be handled as a prefix query in the
1122     // future
1123     //
1124     // tq = (TermQuery)qp.parse("(*:*)");
1125     // assertEquals("*",tq.getTerm().field());
1126     // assertEquals("*",tq.getTerm().text());
1127     // assertEquals(1,type[0]);
1128
1129   }
1130
1131   public void testStopwords() throws Exception {
1132     StandardQueryParser qp = new StandardQueryParser();
1133     qp.setAnalyzer(
1134         new StopAnalyzer(TEST_VERSION_CURRENT, StopFilter.makeStopSet(TEST_VERSION_CURRENT, "the", "foo" )));
1135
1136     Query result = qp.parse("a:the OR a:foo", "a");
1137     assertNotNull("result is null and it shouldn't be", result);
1138     assertTrue("result is not a BooleanQuery", result instanceof BooleanQuery);
1139     assertTrue(((BooleanQuery) result).clauses().size() + " does not equal: "
1140         + 0, ((BooleanQuery) result).clauses().size() == 0);
1141     result = qp.parse("a:woo OR a:the", "a");
1142     assertNotNull("result is null and it shouldn't be", result);
1143     assertTrue("result is not a TermQuery", result instanceof TermQuery);
1144     result = qp.parse(
1145         "(fieldX:xxxxx OR fieldy:xxxxxxxx)^2 AND (fieldx:the OR fieldy:foo)",
1146         "a");
1147     assertNotNull("result is null and it shouldn't be", result);
1148     assertTrue("result is not a BooleanQuery", result instanceof BooleanQuery);
1149     if (VERBOSE)
1150       System.out.println("Result: " + result);
1151     assertTrue(((BooleanQuery) result).clauses().size() + " does not equal: "
1152         + 2, ((BooleanQuery) result).clauses().size() == 2);
1153   }
1154
1155   public void testPositionIncrement() throws Exception {
1156     StandardQueryParser qp = new StandardQueryParser();
1157     qp.setAnalyzer(
1158         new StopAnalyzer(TEST_VERSION_CURRENT, StopFilter.makeStopSet(TEST_VERSION_CURRENT, "the", "in", "are", "this" )));
1159
1160     qp.setEnablePositionIncrements(true);
1161
1162     String qtxt = "\"the words in poisitions pos02578 are stopped in this phrasequery\"";
1163     // 0 2 5 7 8
1164     int expectedPositions[] = { 1, 3, 4, 6, 9 };
1165     PhraseQuery pq = (PhraseQuery) qp.parse(qtxt, "a");
1166     // System.out.println("Query text: "+qtxt);
1167     // System.out.println("Result: "+pq);
1168     Term t[] = pq.getTerms();
1169     int pos[] = pq.getPositions();
1170     for (int i = 0; i < t.length; i++) {
1171       // System.out.println(i+". "+t[i]+"  pos: "+pos[i]);
1172       assertEquals("term " + i + " = " + t[i] + " has wrong term-position!",
1173           expectedPositions[i], pos[i]);
1174     }
1175   }
1176
1177   public void testMatchAllDocs() throws Exception {
1178     StandardQueryParser qp = new StandardQueryParser();
1179     qp.setAnalyzer(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false));
1180
1181     assertEquals(new MatchAllDocsQuery(), qp.parse("*:*", "field"));
1182     assertEquals(new MatchAllDocsQuery(), qp.parse("(*:*)", "field"));
1183     BooleanQuery bq = (BooleanQuery) qp.parse("+*:* -*:*", "field");
1184     assertTrue(bq.getClauses()[0].getQuery() instanceof MatchAllDocsQuery);
1185     assertTrue(bq.getClauses()[1].getQuery() instanceof MatchAllDocsQuery);
1186   }
1187
1188   private void assertHits(int expected, String query, IndexSearcher is)
1189       throws IOException, QueryNodeException {
1190     StandardQueryParser qp = new StandardQueryParser();
1191     qp.setAnalyzer(new MockAnalyzer(random, MockTokenizer.WHITESPACE, false));
1192     qp.setLocale(Locale.ENGLISH);
1193
1194     Query q = qp.parse(query, "date");
1195     ScoreDoc[] hits = is.search(q, null, 1000).scoreDocs;
1196     assertEquals(expected, hits.length);
1197   }
1198
1199   private void addDateDoc(String content, int year, int month, int day,
1200       int hour, int minute, int second, IndexWriter iw) throws IOException {
1201     Document d = new Document();
1202     d.add(newField("f", content, Field.Store.YES, Field.Index.ANALYZED));
1203     Calendar cal = Calendar.getInstance(Locale.ENGLISH);
1204     cal.set(year, month - 1, day, hour, minute, second);
1205     d.add(newField("date", DateField.dateToString(cal.getTime()),
1206         Field.Store.YES, Field.Index.NOT_ANALYZED));
1207     iw.addDocument(d);
1208   }
1209
1210   @Override
1211   public void tearDown() throws Exception {
1212     BooleanQuery.setMaxClauseCount(originalMaxClauses);
1213     super.tearDown();
1214   }
1215
1216   private class CannedTokenStream extends Tokenizer {
1217     private int upto = 0;
1218     private final PositionIncrementAttribute posIncr = addAttribute(PositionIncrementAttribute.class);
1219     private final CharTermAttribute term = addAttribute(CharTermAttribute.class);
1220
1221     @Override
1222     public boolean incrementToken() {
1223       clearAttributes();
1224       if (upto == 4) {
1225         return false;
1226       }
1227       if (upto == 0) {
1228         posIncr.setPositionIncrement(1);
1229         term.setEmpty().append("a");
1230       } else if (upto == 1) {
1231         posIncr.setPositionIncrement(1);
1232         term.setEmpty().append("b");
1233       } else if (upto == 2) {
1234         posIncr.setPositionIncrement(0);
1235         term.setEmpty().append("c");
1236       } else {
1237         posIncr.setPositionIncrement(0);
1238         term.setEmpty().append("d");
1239       }
1240       upto++;
1241       return true;
1242     }
1243
1244     @Override
1245     public void reset() throws IOException {
1246       super.reset();
1247       this.upto = 0;
1248     }
1249   }
1250
1251   private class CannedAnalyzer extends Analyzer {
1252     @Override
1253     public TokenStream tokenStream(String ignored, Reader alsoIgnored) {
1254       return new CannedTokenStream();
1255     }
1256   }
1257
1258   public void testMultiPhraseQuery() throws Exception {
1259     Directory dir = newDirectory();
1260     IndexWriter w = new IndexWriter(dir, newIndexWriterConfig(TEST_VERSION_CURRENT, new CannedAnalyzer()));
1261     Document doc = new Document();
1262     doc.add(newField("field", "", Field.Store.NO, Field.Index.ANALYZED));
1263     w.addDocument(doc);
1264     IndexReader r = IndexReader.open(w, true);
1265     IndexSearcher s = newSearcher(r);
1266
1267     Query q = new StandardQueryParser(new CannedAnalyzer()).parse("\"a\"", "field");
1268     assertTrue(q instanceof MultiPhraseQuery);
1269     assertEquals(1, s.search(q, 10).totalHits);
1270     s.close();
1271     r.close();
1272     w.close();
1273     dir.close();
1274   }
1275
1276 }