lucene-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ehatc...@apache.org
Subject cvs commit: jakarta-lucene/src/test/org/apache/lucene/queryParser TestQueryParser.java
Date Tue, 30 Sep 2003 04:41:03 GMT
ehatcher    2003/09/29 21:41:03

  Modified:    src/test/org/apache/lucene/queryParser TestQueryParser.java
  Log:
  Add tests for new ParseException capability for subclasses, demonstrating a way to reject
fuzzy and wildcard queries; general spacing cleanup
  
  Revision  Changes    Path
  1.22      +331 -303  jakarta-lucene/src/test/org/apache/lucene/queryParser/TestQueryParser.java
  
  Index: TestQueryParser.java
  ===================================================================
  RCS file: /home/cvs/jakarta-lucene/src/test/org/apache/lucene/queryParser/TestQueryParser.java,v
  retrieving revision 1.21
  retrieving revision 1.22
  diff -u -r1.21 -r1.22
  --- TestQueryParser.java	29 Apr 2003 01:34:00 -0000	1.21
  +++ TestQueryParser.java	30 Sep 2003 04:41:02 -0000	1.22
  @@ -54,18 +54,28 @@
    * <http://www.apache.org/>.
    */
   
  -import java.io.*;
  -import java.text.*;
  -import java.util.*;
  -import junit.framework.*;
  -
  -import org.apache.lucene.*;
  -import org.apache.lucene.queryParser.*;
  -import org.apache.lucene.search.*;
  -import org.apache.lucene.document.DateField;
  -import org.apache.lucene.analysis.*;
  -import org.apache.lucene.analysis.standard.*;
  +import junit.framework.TestCase;
  +import org.apache.lucene.analysis.Analyzer;
  +import org.apache.lucene.analysis.LowerCaseTokenizer;
  +import org.apache.lucene.analysis.SimpleAnalyzer;
   import org.apache.lucene.analysis.Token;
  +import org.apache.lucene.analysis.TokenFilter;
  +import org.apache.lucene.analysis.TokenStream;
  +import org.apache.lucene.analysis.WhitespaceAnalyzer;
  +import org.apache.lucene.analysis.standard.StandardAnalyzer;
  +import org.apache.lucene.document.DateField;
  +import org.apache.lucene.search.BooleanQuery;
  +import org.apache.lucene.search.FuzzyQuery;
  +import org.apache.lucene.search.PhraseQuery;
  +import org.apache.lucene.search.PrefixQuery;
  +import org.apache.lucene.search.Query;
  +import org.apache.lucene.search.RangeQuery;
  +import org.apache.lucene.search.TermQuery;
  +import org.apache.lucene.search.WildcardQuery;
  +import java.io.IOException;
  +import java.io.Reader;
  +import java.text.DateFormat;
  +import java.util.Calendar;
   
   /**
    * Tests QueryParser.
  @@ -74,303 +84,321 @@
    */
   public class TestQueryParser extends TestCase {
   
  -    public TestQueryParser(String name) {
  -	super(name);
  -    }
  -
  -    public static Analyzer qpAnalyzer = new QPTestAnalyzer();
  +  public static Analyzer qpAnalyzer = new QPTestAnalyzer();
   
  -    public static class QPTestFilter extends TokenFilter {
  +  public static class QPTestFilter extends TokenFilter {
  +    /**
  +     * Filter which discards the token 'stop' and which expands the
  +     * token 'phrase' into 'phrase1 phrase2'
  +     */
  +    public QPTestFilter(TokenStream in) {
  +      super(in);
  +    }
  +
  +    boolean inPhrase = false;
  +    int savedStart = 0, savedEnd = 0;
  +
  +    public Token next() throws IOException {
  +      if (inPhrase) {
  +        inPhrase = false;
  +        return new Token("phrase2", savedStart, savedEnd);
  +      } else
  +        for (Token token = input.next(); token != null; token = input.next()) {
  +          if (token.termText().equals("phrase")) {
  +            inPhrase = true;
  +            savedStart = token.startOffset();
  +            savedEnd = token.endOffset();
  +            return new Token("phrase1", savedStart, savedEnd);
  +          } else if (!token.termText().equals("stop"))
  +            return token;
  +        }
  +      return null;
  +    }
  +  }
  +
  +  public static class QPTestAnalyzer extends Analyzer {
  +
  +    /** Filters LowerCaseTokenizer with StopFilter. */
  +    public final TokenStream tokenStream(String fieldName, Reader reader) {
  +      return new QPTestFilter(new LowerCaseTokenizer(reader));
  +    }
  +  }
  +
  +  public static class QPTestParser extends QueryParser {
  +    public QPTestParser(String f, Analyzer a) {
  +      super(f, a);
  +    }
  +
  +    protected Query getFuzzyQuery(String field, String termStr) throws ParseException {
  +      throw new ParseException("Fuzzy queries not allowed");
  +    }
  +
  +    protected Query getWildcardQuery(String field, String termStr) throws ParseException
{
  +      throw new ParseException("Wildcard queries not allowed");
  +    }
  +  }
  +
  +  public QueryParser getParser(Analyzer a) throws Exception {
  +    if (a == null)
  +      a = new SimpleAnalyzer();
  +    QueryParser qp = new QueryParser("field", a);
  +    qp.setOperator(QueryParser.DEFAULT_OPERATOR_OR);
  +    return qp;
  +  }
  +
  +  public Query getQuery(String query, Analyzer a) throws Exception {
  +    return getParser(a).parse(query);
  +  }
  +
  +  public void assertQueryEquals(String query, Analyzer a, String result)
  +    throws Exception {
  +    Query q = getQuery(query, a);
  +    String s = q.toString("field");
  +    if (!s.equals(result)) {
  +      fail("Query /" + query + "/ yielded /" + s
  +           + "/, expecting /" + result + "/");
  +    }
  +  }
  +
  +  public void assertWildcardQueryEquals(String query, boolean lowercase, String result)
  +    throws Exception {
  +    QueryParser qp = getParser(null);
  +    qp.setLowercaseWildcardTerms(lowercase);
  +    Query q = qp.parse(query);
  +    String s = q.toString("field");
  +    if (!s.equals(result)) {
  +      fail("WildcardQuery /" + query + "/ yielded /" + s
  +           + "/, expecting /" + result + "/");
  +    }
  +  }
  +
  +  public Query getQueryDOA(String query, Analyzer a)
  +    throws Exception {
  +    if (a == null)
  +      a = new SimpleAnalyzer();
  +    QueryParser qp = new QueryParser("field", a);
  +    qp.setOperator(QueryParser.DEFAULT_OPERATOR_AND);
  +    return qp.parse(query);
  +  }
  +
  +  public void assertQueryEqualsDOA(String query, Analyzer a, String result)
  +    throws Exception {
  +    Query q = getQueryDOA(query, a);
  +    String s = q.toString("field");
  +    if (!s.equals(result)) {
  +      fail("Query /" + query + "/ yielded /" + s
  +           + "/, expecting /" + result + "/");
  +    }
  +  }
  +
  +  public void testSimple() throws Exception {
  +    assertQueryEquals("term term term", null, "term term term");
  +    assertQueryEquals("türm term term", null, "türm term term");
  +    assertQueryEquals("ümlaut", null, "ümlaut");
  +
  +    assertQueryEquals("a AND b", null, "+a +b");
  +    assertQueryEquals("(a AND b)", null, "+a +b");
  +    assertQueryEquals("c OR (a AND b)", null, "c (+a +b)");
  +    assertQueryEquals("a AND NOT b", null, "+a -b");
  +    assertQueryEquals("a AND -b", null, "+a -b");
  +    assertQueryEquals("a AND !b", null, "+a -b");
  +    assertQueryEquals("a && b", null, "+a +b");
  +    assertQueryEquals("a && ! b", null, "+a -b");
  +
  +    assertQueryEquals("a OR b", null, "a b");
  +    assertQueryEquals("a || b", null, "a b");
  +    assertQueryEquals("a OR !b", null, "a -b");
  +    assertQueryEquals("a OR ! b", null, "a -b");
  +    assertQueryEquals("a OR -b", null, "a -b");
  +
  +    assertQueryEquals("+term -term term", null, "+term -term term");
  +    assertQueryEquals("foo:term AND field:anotherTerm", null,
  +                      "+foo:term +anotherterm");
  +    assertQueryEquals("term AND \"phrase phrase\"", null,
  +                      "+term +\"phrase phrase\"");
  +    assertQueryEquals("\"hello there\"", null, "\"hello there\"");
  +    assertTrue(getQuery("a AND b", null) instanceof BooleanQuery);
  +    assertTrue(getQuery("hello", null) instanceof TermQuery);
  +    assertTrue(getQuery("\"hello there\"", null) instanceof PhraseQuery);
  +
  +    assertQueryEquals("germ term^2.0", null, "germ term^2.0");
  +    assertQueryEquals("(term)^2.0", null, "term^2.0");
  +    assertQueryEquals("(germ term)^2.0", null, "(germ term)^2.0");
  +    assertQueryEquals("term^2.0", null, "term^2.0");
  +    assertQueryEquals("term^2", null, "term^2.0");
  +    assertQueryEquals("\"germ term\"^2.0", null, "\"germ term\"^2.0");
  +    assertQueryEquals("\"term germ\"^2", null, "\"term germ\"^2.0");
  +
  +    assertQueryEquals("(foo OR bar) AND (baz OR boo)", null,
  +                      "+(foo bar) +(baz boo)");
  +    assertQueryEquals("((a OR b) AND NOT c) OR d", null,
  +                      "(+(a b) -c) d");
  +    assertQueryEquals("+(apple \"steve jobs\") -(foo bar baz)", null,
  +                      "+(apple \"steve jobs\") -(foo bar baz)");
  +    assertQueryEquals("+title:(dog OR cat) -author:\"bob dole\"", null,
  +                      "+(title:dog title:cat) -author:\"bob dole\"");
  +  }
  +
  +  public void testPunct() throws Exception {
  +    Analyzer a = new WhitespaceAnalyzer();
  +    assertQueryEquals("a&b", a, "a&b");
  +    assertQueryEquals("a&&b", a, "a&&b");
  +    assertQueryEquals(".NET", a, ".NET");
  +  }
  +
  +  public void testSlop() throws Exception {
  +    assertQueryEquals("\"term germ\"~2", null, "\"term germ\"~2");
  +    assertQueryEquals("\"term germ\"~2 flork", null, "\"term germ\"~2 flork");
  +    assertQueryEquals("\"term\"~2", null, "term");
  +    assertQueryEquals("\" \"~2 germ", null, "germ");
  +    assertQueryEquals("\"term germ\"~2^2", null, "\"term germ\"~2^2.0");
  +  }
  +
  +  public void testNumber() throws Exception {
  +// The numbers go away because SimpleAnalzyer ignores them
  +    assertQueryEquals("3", null, "");
  +    assertQueryEquals("term 1.0 1 2", null, "term");
  +    assertQueryEquals("term term1 term2", null, "term term term");
  +
  +    Analyzer a = new StandardAnalyzer();
  +    assertQueryEquals("3", a, "3");
  +    assertQueryEquals("term 1.0 1 2", a, "term 1.0 1 2");
  +    assertQueryEquals("term term1 term2", a, "term term1 term2");
  +  }
  +
  +  public void testWildcard() throws Exception {
  +    assertQueryEquals("term*", null, "term*");
  +    assertQueryEquals("term*^2", null, "term*^2.0");
  +    assertQueryEquals("term~", null, "term~");
  +    assertQueryEquals("term~^2", null, "term^2.0~");
  +    assertQueryEquals("term^2~", null, "term^2.0~");
  +    assertQueryEquals("term*germ", null, "term*germ");
  +    assertQueryEquals("term*germ^3", null, "term*germ^3.0");
  +
  +    assertTrue(getQuery("term*", null) instanceof PrefixQuery);
  +    assertTrue(getQuery("term*^2", null) instanceof PrefixQuery);
  +    assertTrue(getQuery("term~", null) instanceof FuzzyQuery);
  +    assertTrue(getQuery("term*germ", null) instanceof WildcardQuery);
   
  -	/**
  -	 * Filter which discards the token 'stop' and which expands the
  -	 * token 'phrase' into 'phrase1 phrase2'
  -	 */
  -	public QPTestFilter(TokenStream in) {
  -            super(in);
  -	}
  -
  -	boolean inPhrase = false;
  -	int savedStart = 0, savedEnd = 0;
  -
  -	public Token next() throws IOException {
  -	    if (inPhrase) {
  -		inPhrase = false;
  -		return new Token("phrase2", savedStart, savedEnd);
  -	    }
  -	    else
  -		for (Token token = input.next(); token != null; token = input.next()) {
  -		    if (token.termText().equals("phrase")) {
  -			inPhrase = true;
  -			savedStart = token.startOffset();
  -			savedEnd = token.endOffset();
  -			return new Token("phrase1", savedStart, savedEnd);
  -		    }
  -		    else if (!token.termText().equals("stop"))
  -			return token;
  -		}
  -	    return null;
  -	}
  -    }
  -
  -    public static class QPTestAnalyzer extends Analyzer {
  -
  -	public QPTestAnalyzer() {
  -	}
  -
  -	/** Filters LowerCaseTokenizer with StopFilter. */
  -	public final TokenStream tokenStream(String fieldName, Reader reader) {
  -	    return new QPTestFilter(new LowerCaseTokenizer(reader));
  -	}
  -    }
  -
  -    public QueryParser getParser(Analyzer a) throws Exception {
  -	if (a == null)
  -	    a = new SimpleAnalyzer();
  -	QueryParser qp = new QueryParser("field", a);
  -	qp.setOperator(QueryParser.DEFAULT_OPERATOR_OR);
  -	return qp;
  -    }
  -
  -    public Query getQuery(String query, Analyzer a) throws Exception {
  -	return getParser(a).parse(query);
  -    }
  -
  -    public void assertQueryEquals(String query, Analyzer a, String result)
  -	throws Exception {
  -	Query q = getQuery(query, a);
  -	String s = q.toString("field");
  -	if (!s.equals(result)) {
  -	    fail("Query /" + query + "/ yielded /" + s
  -		+ "/, expecting /" + result + "/");
  -	}
  -    }
  -
  -    public void assertWildcardQueryEquals(String query, boolean lowercase, String result)
  -	throws Exception {
  -	QueryParser qp = getParser(null);
  -	qp.setLowercaseWildcardTerms(lowercase);
  -	Query q = qp.parse(query);
  -	String s = q.toString("field");
  -	if (!s.equals(result)) {
  -	    fail("WildcardQuery /" + query + "/ yielded /" + s
  -		+ "/, expecting /" + result + "/");
  -	}
  -    }
  -
  -    public Query getQueryDOA(String query, Analyzer a)
  -	throws Exception
  -    {
  -	if (a == null)
  -	    a = new SimpleAnalyzer();
  -	QueryParser qp = new QueryParser("field", a);
  -	qp.setOperator(QueryParser.DEFAULT_OPERATOR_AND);
  -	return qp.parse(query);
  -    }
  -
  -    public void assertQueryEqualsDOA(String query, Analyzer a, String result)
  -	throws Exception
  -    {
  -	Query q = getQueryDOA(query, a);
  -	String s = q.toString("field");
  -	if (!s.equals(result))
  -	{
  -	    fail("Query /" + query + "/ yielded /" + s
  -		+ "/, expecting /" + result + "/");
  -	}
  -    }
  -
  -    public void testSimple() throws Exception {
  -	assertQueryEquals("term term term", null, "term term term");
  -	assertQueryEquals("türm term term", null, "türm term term");
  -	assertQueryEquals("ümlaut", null, "ümlaut");
  -
  -	assertQueryEquals("a AND b", null, "+a +b");
  -	assertQueryEquals("(a AND b)", null, "+a +b");
  -	assertQueryEquals("c OR (a AND b)", null, "c (+a +b)");
  -	assertQueryEquals("a AND NOT b", null, "+a -b");
  -	assertQueryEquals("a AND -b", null, "+a -b");
  -	assertQueryEquals("a AND !b", null, "+a -b");
  -	assertQueryEquals("a && b", null, "+a +b");
  -	assertQueryEquals("a && ! b", null, "+a -b");
  -
  -	assertQueryEquals("a OR b", null, "a b");
  -	assertQueryEquals("a || b", null, "a b");
  -	assertQueryEquals("a OR !b", null, "a -b");
  -	assertQueryEquals("a OR ! b", null, "a -b");
  -	assertQueryEquals("a OR -b", null, "a -b");
  -
  -	assertQueryEquals("+term -term term", null, "+term -term term");
  -	assertQueryEquals("foo:term AND field:anotherTerm", null,
  -	    "+foo:term +anotherterm");
  -	assertQueryEquals("term AND \"phrase phrase\"", null,
  -	    "+term +\"phrase phrase\"");
  -	assertQueryEquals("\"hello there\"", null, "\"hello there\"");
  -	assertTrue(getQuery("a AND b", null) instanceof BooleanQuery);
  -	assertTrue(getQuery("hello", null) instanceof TermQuery);
  -	assertTrue(getQuery("\"hello there\"", null) instanceof PhraseQuery);
  -
  -	assertQueryEquals("germ term^2.0", null, "germ term^2.0");
  -	assertQueryEquals("(term)^2.0", null, "term^2.0");
  -	assertQueryEquals("(germ term)^2.0", null, "(germ term)^2.0");
  -	assertQueryEquals("term^2.0", null, "term^2.0");
  -	assertQueryEquals("term^2", null, "term^2.0");
  -	assertQueryEquals("\"germ term\"^2.0", null, "\"germ term\"^2.0");
  -	assertQueryEquals("\"term germ\"^2", null, "\"term germ\"^2.0");
  -
  -	assertQueryEquals("(foo OR bar) AND (baz OR boo)", null,
  -	    "+(foo bar) +(baz boo)");
  -	assertQueryEquals("((a OR b) AND NOT c) OR d", null,
  -	    "(+(a b) -c) d");
  -	assertQueryEquals("+(apple \"steve jobs\") -(foo bar baz)", null,
  -	    "+(apple \"steve jobs\") -(foo bar baz)");
  -	assertQueryEquals("+title:(dog OR cat) -author:\"bob dole\"", null,
  -	    "+(title:dog title:cat) -author:\"bob dole\"");
  -    }
  -
  -    public void testPunct() throws Exception {
  -	Analyzer a = new WhitespaceAnalyzer();
  -	assertQueryEquals("a&b", a, "a&b");
  -	assertQueryEquals("a&&b", a, "a&&b");
  -	assertQueryEquals(".NET", a, ".NET");
  -    }
  -
  -    public void testSlop() throws Exception {
  -	assertQueryEquals("\"term germ\"~2", null, "\"term germ\"~2");
  -	assertQueryEquals("\"term germ\"~2 flork", null, "\"term germ\"~2 flork");
  -	assertQueryEquals("\"term\"~2", null, "term");
  -	assertQueryEquals("\" \"~2 germ", null, "germ");
  -	assertQueryEquals("\"term germ\"~2^2", null, "\"term germ\"~2^2.0");
  -    }
  -
  -    public void testNumber() throws Exception {
  -	// The numbers go away because SimpleAnalzyer ignores them
  -	assertQueryEquals("3", null, "");
  -	assertQueryEquals("term 1.0 1 2", null, "term");
  -	assertQueryEquals("term term1 term2", null, "term term term");
  -
  -	Analyzer a = new StandardAnalyzer();
  -	assertQueryEquals("3", a, "3");
  -	assertQueryEquals("term 1.0 1 2", a, "term 1.0 1 2");
  -	assertQueryEquals("term term1 term2", a, "term term1 term2");
  -    }
  -
  -    public void testWildcard() throws Exception {
  -	assertQueryEquals("term*", null, "term*");
  -	assertQueryEquals("term*^2", null, "term*^2.0");
  -	assertQueryEquals("term~", null, "term~");
  -	assertQueryEquals("term~^2", null, "term^2.0~");
  -	assertQueryEquals("term^2~", null, "term^2.0~");
  -	assertQueryEquals("term*germ", null, "term*germ");
  -	assertQueryEquals("term*germ^3", null, "term*germ^3.0");
  -
  -	assertTrue(getQuery("term*", null) instanceof PrefixQuery);
  -	assertTrue(getQuery("term*^2", null) instanceof PrefixQuery);
  -	assertTrue(getQuery("term~", null) instanceof FuzzyQuery);
  -	assertTrue(getQuery("term*germ", null) instanceof WildcardQuery);
  -
  -	/* Tests to see that wild card terms are (or are not) properly
  +/* Tests to see that wild card terms are (or are not) properly
   	 * lower-cased with propery parser configuration
   	 */
  -	// First prefix queries:
  -	assertWildcardQueryEquals("term*", true, "term*");
  -	assertWildcardQueryEquals("Term*", true, "term*");
  -	assertWildcardQueryEquals("TERM*", true, "term*");
  -	assertWildcardQueryEquals("term*", false, "term*");
  -	assertWildcardQueryEquals("Term*", false, "Term*");
  -	assertWildcardQueryEquals("TERM*", false, "TERM*");
  -	// Then 'full' wildcard queries:
  -	assertWildcardQueryEquals("te?m", true, "te?m");
  -	assertWildcardQueryEquals("Te?m", true, "te?m");
  -	assertWildcardQueryEquals("TE?M", true, "te?m");
  -	assertWildcardQueryEquals("Te?m*gerM", true, "te?m*germ");
  -	assertWildcardQueryEquals("te?m", false, "te?m");
  -	assertWildcardQueryEquals("Te?m", false, "Te?m");
  -	assertWildcardQueryEquals("TE?M", false, "TE?M");
  -	assertWildcardQueryEquals("Te?m*gerM", false, "Te?m*gerM");
  -    }
  -
  -    public void testQPA() throws Exception {
  -	assertQueryEquals("term term term", qpAnalyzer, "term term term");
  -	assertQueryEquals("term +stop term", qpAnalyzer, "term term");
  -	assertQueryEquals("term -stop term", qpAnalyzer, "term term");
  -	assertQueryEquals("drop AND stop AND roll", qpAnalyzer, "+drop +roll");
  -	assertQueryEquals("term phrase term", qpAnalyzer,
  -	    "term \"phrase1 phrase2\" term");
  -	assertQueryEquals("term AND NOT phrase term", qpAnalyzer,
  -	    "+term -\"phrase1 phrase2\" term");
  -	assertQueryEquals("stop", qpAnalyzer, "");
  -	assertTrue(getQuery("term term term", qpAnalyzer) instanceof BooleanQuery);
  -	assertTrue(getQuery("term +stop", qpAnalyzer) instanceof TermQuery);
  -    }
  -
  -    public void testRange() throws Exception {
  -	assertQueryEquals("[ a TO z]", null, "[a TO z]");
  -	assertTrue(getQuery("[ a TO z]", null) instanceof RangeQuery);
  -	assertQueryEquals("[ a TO z ]", null, "[a TO z]");
  -	assertQueryEquals("{ a TO z}", null, "{a TO z}");
  -	assertQueryEquals("{ a TO z }", null, "{a TO z}");
  -	assertQueryEquals("{ a TO z }^2.0", null, "{a TO z}^2.0");
  -	assertQueryEquals("[ a TO z] OR bar", null, "[a TO z] bar");
  -	assertQueryEquals("[ a TO z] AND bar", null, "+[a TO z] +bar");
  -	assertQueryEquals("( bar blar { a TO z}) ", null, "bar blar {a TO z}");
  -	assertQueryEquals("gack ( bar blar { a TO z}) ", null, "gack (bar blar {a TO z})");
  -    }
  -
  -    public String getDate(String s) throws Exception {
  -	DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
  -	return DateField.dateToString(df.parse(s));
  -    }
  -
  -	public String getLocalizedDate(int year, int month, int day) {
  -		DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
  -		Calendar calendar = Calendar.getInstance();
  -		calendar.set(year, month, day);
  -		return df.format(calendar.getTime());
  -	}
  +// First prefix queries:
  +    assertWildcardQueryEquals("term*", true, "term*");
  +    assertWildcardQueryEquals("Term*", true, "term*");
  +    assertWildcardQueryEquals("TERM*", true, "term*");
  +    assertWildcardQueryEquals("term*", false, "term*");
  +    assertWildcardQueryEquals("Term*", false, "Term*");
  +    assertWildcardQueryEquals("TERM*", false, "TERM*");
  +// Then 'full' wildcard queries:
  +    assertWildcardQueryEquals("te?m", true, "te?m");
  +    assertWildcardQueryEquals("Te?m", true, "te?m");
  +    assertWildcardQueryEquals("TE?M", true, "te?m");
  +    assertWildcardQueryEquals("Te?m*gerM", true, "te?m*germ");
  +    assertWildcardQueryEquals("te?m", false, "te?m");
  +    assertWildcardQueryEquals("Te?m", false, "Te?m");
  +    assertWildcardQueryEquals("TE?M", false, "TE?M");
  +    assertWildcardQueryEquals("Te?m*gerM", false, "Te?m*gerM");
  +  }
  +
  +  public void testQPA() throws Exception {
  +    assertQueryEquals("term term term", qpAnalyzer, "term term term");
  +    assertQueryEquals("term +stop term", qpAnalyzer, "term term");
  +    assertQueryEquals("term -stop term", qpAnalyzer, "term term");
  +    assertQueryEquals("drop AND stop AND roll", qpAnalyzer, "+drop +roll");
  +    assertQueryEquals("term phrase term", qpAnalyzer,
  +                      "term \"phrase1 phrase2\" term");
  +    assertQueryEquals("term AND NOT phrase term", qpAnalyzer,
  +                      "+term -\"phrase1 phrase2\" term");
  +    assertQueryEquals("stop", qpAnalyzer, "");
  +    assertTrue(getQuery("term term term", qpAnalyzer) instanceof BooleanQuery);
  +    assertTrue(getQuery("term +stop", qpAnalyzer) instanceof TermQuery);
  +  }
  +
  +  public void testRange() throws Exception {
  +    assertQueryEquals("[ a TO z]", null, "[a TO z]");
  +    assertTrue(getQuery("[ a TO z]", null) instanceof RangeQuery);
  +    assertQueryEquals("[ a TO z ]", null, "[a TO z]");
  +    assertQueryEquals("{ a TO z}", null, "{a TO z}");
  +    assertQueryEquals("{ a TO z }", null, "{a TO z}");
  +    assertQueryEquals("{ a TO z }^2.0", null, "{a TO z}^2.0");
  +    assertQueryEquals("[ a TO z] OR bar", null, "[a TO z] bar");
  +    assertQueryEquals("[ a TO z] AND bar", null, "+[a TO z] +bar");
  +    assertQueryEquals("( bar blar { a TO z}) ", null, "bar blar {a TO z}");
  +    assertQueryEquals("gack ( bar blar { a TO z}) ", null, "gack (bar blar {a TO z})");
  +  }
  +
  +  public String getDate(String s) throws Exception {
  +    DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
  +    return DateField.dateToString(df.parse(s));
  +  }
  +
  +  public String getLocalizedDate(int year, int month, int day) {
  +    DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
  +    Calendar calendar = Calendar.getInstance();
  +    calendar.set(year, month, day);
  +    return df.format(calendar.getTime());
  +  }
   
  -    public void testDateRange() throws Exception {
  +  public void testDateRange() throws Exception {
       String startDate = getLocalizedDate(2002, 1, 1);
       String endDate = getLocalizedDate(2002, 1, 4);
  -	assertQueryEquals("[ " + startDate + " TO " + endDate + "]", null,
  -	    "[" + getDate(startDate) + " TO " + getDate(endDate) + "]");
  -	assertQueryEquals("{  " + startDate + "    " + endDate + "   }", null,
  -	    "{" + getDate(startDate) + " TO " + getDate(endDate) + "}");
  -    }
  -
  -    public void testEscaped() throws Exception {
  -	Analyzer a = new WhitespaceAnalyzer();
  -	assertQueryEquals("\\[brackets", a, "\\[brackets");
  -	assertQueryEquals("\\[brackets", null, "brackets");
  -	assertQueryEquals("\\\\", a, "\\\\");
  -	assertQueryEquals("\\+blah", a, "\\+blah");
  -	assertQueryEquals("\\(blah", a, "\\(blah");
  -    }
  -
  -    public void testSimpleDAO()
  -	throws Exception
  -    {
  -	assertQueryEqualsDOA("term term term", null, "+term +term +term");
  -	assertQueryEqualsDOA("term +term term", null, "+term +term +term");
  -	assertQueryEqualsDOA("term term +term", null, "+term +term +term");
  -	assertQueryEqualsDOA("term +term +term", null, "+term +term +term");
  -	assertQueryEqualsDOA("-term term term", null, "-term +term +term");
  -    }
  -
  -    public void testBoost()
  -        throws Exception
  -    {
  -        StandardAnalyzer oneStopAnalyzer = new StandardAnalyzer(new String[]{"on"});
  -        QueryParser qp = new QueryParser("field", oneStopAnalyzer);
  -        Query q = qp.parse("on^1.0");
  -        assertNotNull(q);
  -        q = qp.parse("\"hello\"^2.0");
  -        assertNotNull(q);
  -        assertEquals(q.getBoost(), (float)2.0, (float)0.5);
  -        q = qp.parse("hello^2.0");
  -        assertNotNull(q);
  -        assertEquals(q.getBoost(), (float)2.0, (float)0.5);
  -        q = qp.parse("\"on\"^1.0");
  -        assertNotNull(q);
  +    assertQueryEquals("[ " + startDate + " TO " + endDate + "]", null,
  +                      "[" + getDate(startDate) + " TO " + getDate(endDate) + "]");
  +    assertQueryEquals("{  " + startDate + "    " + endDate + "   }", null,
  +                      "{" + getDate(startDate) + " TO " + getDate(endDate) + "}");
  +  }
  +
  +  public void testEscaped() throws Exception {
  +    Analyzer a = new WhitespaceAnalyzer();
  +    assertQueryEquals("\\[brackets", a, "\\[brackets");
  +    assertQueryEquals("\\[brackets", null, "brackets");
  +    assertQueryEquals("\\\\", a, "\\\\");
  +    assertQueryEquals("\\+blah", a, "\\+blah");
  +    assertQueryEquals("\\(blah", a, "\\(blah");
  +  }
  +
  +  public void testSimpleDAO()
  +    throws Exception {
  +    assertQueryEqualsDOA("term term term", null, "+term +term +term");
  +    assertQueryEqualsDOA("term +term term", null, "+term +term +term");
  +    assertQueryEqualsDOA("term term +term", null, "+term +term +term");
  +    assertQueryEqualsDOA("term +term +term", null, "+term +term +term");
  +    assertQueryEqualsDOA("-term term term", null, "-term +term +term");
  +  }
  +
  +  public void testBoost()
  +    throws Exception {
  +    StandardAnalyzer oneStopAnalyzer = new StandardAnalyzer(new String[]{"on"});
  +    QueryParser qp = new QueryParser("field", oneStopAnalyzer);
  +    Query q = qp.parse("on^1.0");
  +    assertNotNull(q);
  +    q = qp.parse("\"hello\"^2.0");
  +    assertNotNull(q);
  +    assertEquals(q.getBoost(), (float) 2.0, (float) 0.5);
  +    q = qp.parse("hello^2.0");
  +    assertNotNull(q);
  +    assertEquals(q.getBoost(), (float) 2.0, (float) 0.5);
  +    q = qp.parse("\"on\"^1.0");
  +    assertNotNull(q);
  +  }
  +
  +  public void testCustomQueryParserWildcard() {
  +    try {
  +      new QPTestParser("contents", new WhitespaceAnalyzer()).parse("a?t");
  +    } catch (ParseException expected) {
  +      return;
  +    }
  +    fail("Wildcard queries should not be allowed");
  +  }
  +
  +  public void testCustomQueryParserFuzzy() throws Exception {
  +    try {
  +      new QPTestParser("contents", new WhitespaceAnalyzer()).parse("xunit~");
  +    } catch (ParseException expected) {
  +      return;
       }
  +    fail("Fuzzy queries should not be allowed");
  +  }
  +
   }
  
  
  

Mime
View raw message