1197 lines
49 KiB
C#
1197 lines
49 KiB
C#
|
/*
|
|||
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|||
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|||
|
|
* this work for additional information regarding copyright ownership.
|
|||
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|||
|
|
* (the "License"); you may not use this file except in compliance with
|
|||
|
|
* the License. You may obtain a copy of the License at
|
|||
|
|
*
|
|||
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|||
|
|
*
|
|||
|
|
* Unless required by applicable law or agreed to in writing, software
|
|||
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|||
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|||
|
|
* See the License for the specific language governing permissions and
|
|||
|
|
* limitations under the License.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
using System;
|
|||
|
|
using System.Collections.Generic;
|
|||
|
|
using Lucene.Net.Analysis.Tokenattributes;
|
|||
|
|
using Lucene.Net.Support;
|
|||
|
|
using NUnit.Framework;
|
|||
|
|
|
|||
|
|
using Analyzer = Lucene.Net.Analysis.Analyzer;
|
|||
|
|
using KeywordAnalyzer = Lucene.Net.Analysis.KeywordAnalyzer;
|
|||
|
|
using LowerCaseTokenizer = Lucene.Net.Analysis.LowerCaseTokenizer;
|
|||
|
|
using SimpleAnalyzer = Lucene.Net.Analysis.SimpleAnalyzer;
|
|||
|
|
using StopAnalyzer = Lucene.Net.Analysis.StopAnalyzer;
|
|||
|
|
using StopFilter = Lucene.Net.Analysis.StopFilter;
|
|||
|
|
using TokenFilter = Lucene.Net.Analysis.TokenFilter;
|
|||
|
|
using TokenStream = Lucene.Net.Analysis.TokenStream;
|
|||
|
|
using WhitespaceAnalyzer = Lucene.Net.Analysis.WhitespaceAnalyzer;
|
|||
|
|
using StandardAnalyzer = Lucene.Net.Analysis.Standard.StandardAnalyzer;
|
|||
|
|
using DateField = Lucene.Net.Documents.DateField;
|
|||
|
|
using DateTools = Lucene.Net.Documents.DateTools;
|
|||
|
|
using Document = Lucene.Net.Documents.Document;
|
|||
|
|
using Field = Lucene.Net.Documents.Field;
|
|||
|
|
using IndexWriter = Lucene.Net.Index.IndexWriter;
|
|||
|
|
using Term = Lucene.Net.Index.Term;
|
|||
|
|
using IndexReader = Lucene.Net.Index.IndexReader;
|
|||
|
|
using RAMDirectory = Lucene.Net.Store.RAMDirectory;
|
|||
|
|
using BooleanQuery = Lucene.Net.Search.BooleanQuery;
|
|||
|
|
using FuzzyQuery = Lucene.Net.Search.FuzzyQuery;
|
|||
|
|
using IndexSearcher = Lucene.Net.Search.IndexSearcher;
|
|||
|
|
using MatchAllDocsQuery = Lucene.Net.Search.MatchAllDocsQuery;
|
|||
|
|
using MultiTermQuery = Lucene.Net.Search.MultiTermQuery;
|
|||
|
|
using PhraseQuery = Lucene.Net.Search.PhraseQuery;
|
|||
|
|
using PrefixQuery = Lucene.Net.Search.PrefixQuery;
|
|||
|
|
using Query = Lucene.Net.Search.Query;
|
|||
|
|
using ScoreDoc = Lucene.Net.Search.ScoreDoc;
|
|||
|
|
using TermQuery = Lucene.Net.Search.TermQuery;
|
|||
|
|
using TermRangeQuery = Lucene.Net.Search.TermRangeQuery;
|
|||
|
|
using WildcardQuery = Lucene.Net.Search.WildcardQuery;
|
|||
|
|
using Directory = Lucene.Net.Store.Directory;
|
|||
|
|
using MockRAMDirectory = Lucene.Net.Store.MockRAMDirectory;
|
|||
|
|
using LocalizedTestCase = Lucene.Net.Util.LocalizedTestCase;
|
|||
|
|
using Version = Lucene.Net.Util.Version;
|
|||
|
|
|
|||
|
|
namespace Lucene.Net.QueryParsers
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
/// <summary> Tests QueryParser.</summary>
|
|||
|
|
[TestFixture]
|
|||
|
|
public class TestQueryParser:LocalizedTestCase
|
|||
|
|
{
|
|||
|
|
private static readonly HashSet<string> dataTestWithDifferentLocals = new HashSet<string>
|
|||
|
|
{
|
|||
|
|
"TestLegacyDateRange",
|
|||
|
|
"TestDateRange",
|
|||
|
|
"TestCJK",
|
|||
|
|
"TestNumber",
|
|||
|
|
"TestFarsiRangeCollating",
|
|||
|
|
"TestLocalDateFormat"
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
private class AnonymousClassQueryParser : QueryParser
|
|||
|
|
{
|
|||
|
|
private void InitBlock(int[] type, TestQueryParser enclosingInstance)
|
|||
|
|
{
|
|||
|
|
this.type = type;
|
|||
|
|
this.enclosingInstance = enclosingInstance;
|
|||
|
|
}
|
|||
|
|
private int[] type;
|
|||
|
|
private TestQueryParser enclosingInstance;
|
|||
|
|
public TestQueryParser Enclosing_Instance
|
|||
|
|
{
|
|||
|
|
get
|
|||
|
|
{
|
|||
|
|
return enclosingInstance;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
internal AnonymousClassQueryParser(int[] type, TestQueryParser enclosingInstance, System.String Param1, Lucene.Net.Analysis.Analyzer Param2)
|
|||
|
|
: base(Version.LUCENE_CURRENT, Param1, Param2)
|
|||
|
|
{
|
|||
|
|
InitBlock(type, enclosingInstance);
|
|||
|
|
}
|
|||
|
|
protected internal override Query GetWildcardQuery(System.String field, System.String termStr)
|
|||
|
|
{
|
|||
|
|
// override error checking of superclass
|
|||
|
|
type[0] = 1;
|
|||
|
|
return new TermQuery(new Term(field, termStr));
|
|||
|
|
}
|
|||
|
|
protected internal override Query GetPrefixQuery(System.String field, System.String termStr)
|
|||
|
|
{
|
|||
|
|
// override error checking of superclass
|
|||
|
|
type[0] = 2;
|
|||
|
|
return new TermQuery(new Term(field, termStr));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected internal override Query GetFieldQuery(System.String field, System.String queryText)
|
|||
|
|
{
|
|||
|
|
type[0] = 3;
|
|||
|
|
return base.GetFieldQuery(field, queryText);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public TestQueryParser(System.String name)
|
|||
|
|
: base(name, dataTestWithDifferentLocals) // TODO: was commented out
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public TestQueryParser() : base(string.Empty, dataTestWithDifferentLocals)
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public static Analyzer qpAnalyzer = new QPTestAnalyzer();
|
|||
|
|
|
|||
|
|
public class QPTestFilter : TokenFilter
|
|||
|
|
{
|
|||
|
|
internal ITermAttribute termAtt;
|
|||
|
|
internal IOffsetAttribute offsetAtt;
|
|||
|
|
|
|||
|
|
/// <summary> Filter which discards the token 'stop' and which expands the
|
|||
|
|
/// token 'phrase' into 'phrase1 phrase2'
|
|||
|
|
/// </summary>
|
|||
|
|
public QPTestFilter(TokenStream in_Renamed):base(in_Renamed)
|
|||
|
|
{
|
|||
|
|
termAtt = AddAttribute<ITermAttribute>();
|
|||
|
|
offsetAtt = AddAttribute<IOffsetAttribute>();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
internal bool inPhrase = false;
|
|||
|
|
internal int savedStart = 0, savedEnd = 0;
|
|||
|
|
|
|||
|
|
public override bool IncrementToken()
|
|||
|
|
{
|
|||
|
|
if (inPhrase)
|
|||
|
|
{
|
|||
|
|
inPhrase = false;
|
|||
|
|
ClearAttributes();
|
|||
|
|
termAtt.SetTermBuffer("phrase2");
|
|||
|
|
offsetAtt.SetOffset(savedStart, savedEnd);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
while (input.IncrementToken())
|
|||
|
|
{
|
|||
|
|
if (termAtt.Term.Equals("phrase"))
|
|||
|
|
{
|
|||
|
|
inPhrase = true;
|
|||
|
|
savedStart = offsetAtt.StartOffset;
|
|||
|
|
savedEnd = offsetAtt.EndOffset;
|
|||
|
|
termAtt.SetTermBuffer("phrase1");
|
|||
|
|
offsetAtt.SetOffset(savedStart, savedEnd);
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
else if (!termAtt.Term.Equals("stop"))
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
public class QPTestAnalyzer:Analyzer
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
/// <summary>Filters LowerCaseTokenizer with StopFilter. </summary>
|
|||
|
|
public override TokenStream TokenStream(System.String fieldName, System.IO.TextReader reader)
|
|||
|
|
{
|
|||
|
|
return new QPTestFilter(new LowerCaseTokenizer(reader));
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public class QPTestParser:QueryParser
|
|||
|
|
{
|
|||
|
|
public QPTestParser(System.String f, Analyzer a):base(Version.LUCENE_CURRENT, f, a)
|
|||
|
|
{
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected internal override Query GetFuzzyQuery(System.String field, System.String termStr, float minSimilarity)
|
|||
|
|
{
|
|||
|
|
throw new ParseException("Fuzzy queries not allowed");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
protected internal override Query GetWildcardQuery(System.String field, System.String termStr)
|
|||
|
|
{
|
|||
|
|
throw new ParseException("Wildcard queries not allowed");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private int originalMaxClauses;
|
|||
|
|
|
|||
|
|
[SetUp]
|
|||
|
|
public override void SetUp()
|
|||
|
|
{
|
|||
|
|
base.SetUp();
|
|||
|
|
originalMaxClauses = BooleanQuery.MaxClauseCount;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual QueryParser GetParser(Analyzer a)
|
|||
|
|
{
|
|||
|
|
if (a == null)
|
|||
|
|
a = new SimpleAnalyzer();
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", a);
|
|||
|
|
qp.DefaultOperator = QueryParser.OR_OPERATOR;
|
|||
|
|
return qp;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual Query GetQuery(System.String query, Analyzer a)
|
|||
|
|
{
|
|||
|
|
return GetParser(a).Parse(query);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertQueryEquals(System.String query, Analyzer a, System.String result)
|
|||
|
|
{
|
|||
|
|
Query q = GetQuery(query, a);
|
|||
|
|
var s = q.ToString("field");
|
|||
|
|
Assert.AreEqual(s, result, "Query /" + query + "/ yielded /" + s + "/, expecting /" + result + "/");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertQueryEquals(QueryParser qp, System.String field, System.String query, System.String result)
|
|||
|
|
{
|
|||
|
|
Query q = qp.Parse(query);
|
|||
|
|
System.String s = q.ToString(field);
|
|||
|
|
Assert.AreEqual(s, result, "Query /" + query + "/ yielded /" + s + "/, expecting /" + result + "/");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertEscapedQueryEquals(System.String query, Analyzer a, System.String result)
|
|||
|
|
{
|
|||
|
|
System.String escapedQuery = QueryParser.Escape(query);
|
|||
|
|
Assert.AreEqual(escapedQuery, result, "Query /" + query + "/ yielded /" + escapedQuery + "/, expecting /" + result + "/");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertWildcardQueryEquals(System.String query, bool lowercase, System.String result, bool allowLeadingWildcard)
|
|||
|
|
{
|
|||
|
|
QueryParser qp = GetParser(null);
|
|||
|
|
qp.LowercaseExpandedTerms = lowercase;
|
|||
|
|
qp.AllowLeadingWildcard = allowLeadingWildcard;
|
|||
|
|
Query q = qp.Parse(query);
|
|||
|
|
System.String s = q.ToString("field");
|
|||
|
|
Assert.AreEqual(s, result, "WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /" + result + "/");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertWildcardQueryEquals(System.String query, bool lowercase, System.String result)
|
|||
|
|
{
|
|||
|
|
AssertWildcardQueryEquals(query, lowercase, result, false);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertWildcardQueryEquals(System.String query, System.String result)
|
|||
|
|
{
|
|||
|
|
QueryParser qp = GetParser(null);
|
|||
|
|
Query q = qp.Parse(query);
|
|||
|
|
System.String s = q.ToString("field");
|
|||
|
|
Assert.AreEqual(s, result, "WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /" + result + "/");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual Query GetQueryDOA(System.String query, Analyzer a)
|
|||
|
|
{
|
|||
|
|
if (a == null)
|
|||
|
|
a = new SimpleAnalyzer();
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", a);
|
|||
|
|
qp.DefaultOperator = QueryParser.AND_OPERATOR;
|
|||
|
|
return qp.Parse(query);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertQueryEqualsDOA(System.String query, Analyzer a, System.String result)
|
|||
|
|
{
|
|||
|
|
Query q = GetQueryDOA(query, a);
|
|||
|
|
System.String s = q.ToString("field");
|
|||
|
|
Assert.AreEqual(s, result, "Query /" + query + "/ yielded /" + s + "/, expecting /" + result + "/");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestCJK()
|
|||
|
|
{
|
|||
|
|
// Test Ideographic Space - As wide as a CJK character cell (fullwidth)
|
|||
|
|
// used google to translate the word "term" to japanese -> 用語
|
|||
|
|
//
|
|||
|
|
// NOTE: What is printed above is not the translation of "term" into
|
|||
|
|
// Japanese. Google translate currently gives:
|
|||
|
|
//
|
|||
|
|
// 期間
|
|||
|
|
//
|
|||
|
|
// Which translates to unicode characters 26399 and 38291, or
|
|||
|
|
// the literals '\u671f' and '\u9593'.
|
|||
|
|
//
|
|||
|
|
// Unlike the second and third characters in the previous string ('\u201d' and '\u00a8')
|
|||
|
|
// which fail the test for IsCharacter when tokenized by LetterTokenizer (as it should
|
|||
|
|
// in Java), which causes the word to be split differently than if it actually used
|
|||
|
|
// letters as defined by Unicode.
|
|||
|
|
//
|
|||
|
|
// Using the string "\u671f\u9593\u3000\u671f\u9593\u3000\u671f\u9593" with just the two
|
|||
|
|
// characters is enough, as it uses two characters with the full width of a CJK character cell.
|
|||
|
|
AssertQueryEquals("term\u3000term\u3000term", null, "term\u0020term\u0020term");
|
|||
|
|
AssertQueryEquals("\u671f\u9593\u3000\u671f\u9593\u3000\u671f\u9593", null, "\u671f\u9593\u0020\u671f\u9593\u0020\u671f\u9593");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestSimple()
|
|||
|
|
{
|
|||
|
|
AssertQueryEquals("term term term", null, "term term term");
|
|||
|
|
AssertQueryEquals("türm term term", new WhitespaceAnalyzer(), "türm term term");
|
|||
|
|
AssertQueryEquals("ümlaut", new WhitespaceAnalyzer(), "ümlaut");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("\"\"", new KeywordAnalyzer(), "");
|
|||
|
|
AssertQueryEquals("foo:\"\"", new KeywordAnalyzer(), "foo:");
|
|||
|
|
|
|||
|
|
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\"");
|
|||
|
|
Assert.IsTrue(GetQuery("a AND b", null) is BooleanQuery);
|
|||
|
|
Assert.IsTrue(GetQuery("hello", null) is TermQuery);
|
|||
|
|
Assert.IsTrue(GetQuery("\"hello there\"", null) is 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\"");
|
|||
|
|
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", new StandardAnalyzer(Util.Version.LUCENE_CURRENT));
|
|||
|
|
// make sure OR is the default:
|
|||
|
|
Assert.AreEqual(QueryParser.OR_OPERATOR, qp.DefaultOperator);
|
|||
|
|
qp.DefaultOperator = QueryParser.AND_OPERATOR;
|
|||
|
|
Assert.AreEqual(QueryParser.AND_OPERATOR, qp.DefaultOperator);
|
|||
|
|
qp.DefaultOperator = QueryParser.OR_OPERATOR;
|
|||
|
|
Assert.AreEqual(QueryParser.OR_OPERATOR, qp.DefaultOperator);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestPunct()
|
|||
|
|
{
|
|||
|
|
Analyzer a = new WhitespaceAnalyzer();
|
|||
|
|
AssertQueryEquals("a&b", a, "a&b");
|
|||
|
|
AssertQueryEquals("a&&b", a, "a&&b");
|
|||
|
|
AssertQueryEquals(".NET", a, ".NET");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestSlop()
|
|||
|
|
{
|
|||
|
|
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");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestNumber()
|
|||
|
|
{
|
|||
|
|
// 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(Util.Version.LUCENE_CURRENT);
|
|||
|
|
AssertQueryEquals("3", a, "3");
|
|||
|
|
AssertQueryEquals("term 1.0 1 2", a, "term 1.0 1 2");
|
|||
|
|
AssertQueryEquals("term term1 term2", a, "term term1 term2");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestWildcard()
|
|||
|
|
{
|
|||
|
|
AssertQueryEquals("term*", null, "term*");
|
|||
|
|
AssertQueryEquals("term*^2", null, "term*^2.0");
|
|||
|
|
AssertQueryEquals("term~", null, "term~0.5");
|
|||
|
|
AssertQueryEquals("term~0.7", null, "term~0.7");
|
|||
|
|
AssertQueryEquals("term~^2", null, "term~0.5^2.0");
|
|||
|
|
AssertQueryEquals("term^2~", null, "term~0.5^2.0");
|
|||
|
|
AssertQueryEquals("term*germ", null, "term*germ");
|
|||
|
|
AssertQueryEquals("term*germ^3", null, "term*germ^3.0");
|
|||
|
|
|
|||
|
|
Assert.IsTrue(GetQuery("term*", null) is PrefixQuery);
|
|||
|
|
Assert.IsTrue(GetQuery("term*^2", null) is PrefixQuery);
|
|||
|
|
Assert.IsTrue(GetQuery("term~", null) is FuzzyQuery);
|
|||
|
|
Assert.IsTrue(GetQuery("term~0.7", null) is FuzzyQuery);
|
|||
|
|
FuzzyQuery fq = (FuzzyQuery) GetQuery("term~0.7", null);
|
|||
|
|
Assert.AreEqual(0.7f, fq.MinSimilarity, 0.1f);
|
|||
|
|
Assert.AreEqual(FuzzyQuery.defaultPrefixLength, fq.PrefixLength);
|
|||
|
|
fq = (FuzzyQuery) GetQuery("term~", null);
|
|||
|
|
Assert.AreEqual(0.5f, fq.MinSimilarity, 0.1f);
|
|||
|
|
Assert.AreEqual(FuzzyQuery.defaultPrefixLength, fq.PrefixLength);
|
|||
|
|
|
|||
|
|
AssertParseException("term~1.1"); // value > 1, throws exception
|
|||
|
|
|
|||
|
|
Assert.IsTrue(GetQuery("term*germ", null) is WildcardQuery);
|
|||
|
|
|
|||
|
|
/* Tests to see that wild card terms are (or are not) properly
|
|||
|
|
* lower-cased with propery parser configuration
|
|||
|
|
*/
|
|||
|
|
// First prefix queries:
|
|||
|
|
// by default, convert to lowercase:
|
|||
|
|
AssertWildcardQueryEquals("Term*", true, "term*");
|
|||
|
|
// explicitly set lowercase:
|
|||
|
|
AssertWildcardQueryEquals("term*", true, "term*");
|
|||
|
|
AssertWildcardQueryEquals("Term*", true, "term*");
|
|||
|
|
AssertWildcardQueryEquals("TERM*", true, "term*");
|
|||
|
|
// explicitly disable lowercase conversion:
|
|||
|
|
AssertWildcardQueryEquals("term*", false, "term*");
|
|||
|
|
AssertWildcardQueryEquals("Term*", false, "Term*");
|
|||
|
|
AssertWildcardQueryEquals("TERM*", false, "TERM*");
|
|||
|
|
// Then 'full' wildcard queries:
|
|||
|
|
// by default, convert to lowercase:
|
|||
|
|
AssertWildcardQueryEquals("Te?m", "te?m");
|
|||
|
|
// explicitly set lowercase:
|
|||
|
|
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");
|
|||
|
|
// explicitly disable lowercase conversion:
|
|||
|
|
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");
|
|||
|
|
// Fuzzy queries:
|
|||
|
|
AssertWildcardQueryEquals("Term~", "term~0.5");
|
|||
|
|
AssertWildcardQueryEquals("Term~", true, "term~0.5");
|
|||
|
|
AssertWildcardQueryEquals("Term~", false, "Term~0.5");
|
|||
|
|
// Range queries:
|
|||
|
|
AssertWildcardQueryEquals("[A TO C]", "[a TO c]");
|
|||
|
|
AssertWildcardQueryEquals("[A TO C]", true, "[a TO c]");
|
|||
|
|
AssertWildcardQueryEquals("[A TO C]", false, "[A TO C]");
|
|||
|
|
|
|||
|
|
// Test suffix queries: first disallow
|
|||
|
|
Assert.Throws<ParseException>(() => AssertWildcardQueryEquals("*Term", true, "*term"));
|
|||
|
|
Assert.Throws<ParseException>(() => AssertWildcardQueryEquals("?Term", true, "?term"));
|
|||
|
|
|
|||
|
|
// Test suffix queries: then allow
|
|||
|
|
AssertWildcardQueryEquals("*Term", true, "*term", true);
|
|||
|
|
AssertWildcardQueryEquals("?Term", true, "?term", true);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestLeadingWildcardType()
|
|||
|
|
{
|
|||
|
|
QueryParser qp = GetParser(null);
|
|||
|
|
qp.AllowLeadingWildcard = true;
|
|||
|
|
Assert.AreEqual(typeof(WildcardQuery), qp.Parse("t*erm*").GetType());
|
|||
|
|
Assert.AreEqual(typeof(WildcardQuery), qp.Parse("?term*").GetType());
|
|||
|
|
Assert.AreEqual(typeof(WildcardQuery), qp.Parse("*term*").GetType());
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestQPA()
|
|||
|
|
{
|
|||
|
|
AssertQueryEquals("term term^3.0 term", qpAnalyzer, "term term^3.0 term");
|
|||
|
|
AssertQueryEquals("term stop^3.0 term", qpAnalyzer, "term term");
|
|||
|
|
|
|||
|
|
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 +(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^3", qpAnalyzer, "");
|
|||
|
|
AssertQueryEquals("stop", qpAnalyzer, "");
|
|||
|
|
AssertQueryEquals("(stop)^3", qpAnalyzer, "");
|
|||
|
|
AssertQueryEquals("((stop))^3", qpAnalyzer, "");
|
|||
|
|
AssertQueryEquals("(stop^3)", qpAnalyzer, "");
|
|||
|
|
AssertQueryEquals("((stop)^3)", qpAnalyzer, "");
|
|||
|
|
AssertQueryEquals("(stop)", qpAnalyzer, "");
|
|||
|
|
AssertQueryEquals("((stop))", qpAnalyzer, "");
|
|||
|
|
Assert.IsTrue(GetQuery("term term term", qpAnalyzer) is BooleanQuery);
|
|||
|
|
Assert.IsTrue(GetQuery("term +stop", qpAnalyzer) is TermQuery);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestRange()
|
|||
|
|
{
|
|||
|
|
AssertQueryEquals("[ a TO z]", null, "[a TO z]");
|
|||
|
|
Assert.AreEqual(MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT, ((TermRangeQuery)GetQuery("[ a TO z]", null)).RewriteMethod);
|
|||
|
|
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", new SimpleAnalyzer());
|
|||
|
|
qp.MultiTermRewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
|
|||
|
|
Assert.AreEqual(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE, ((TermRangeQuery)qp.Parse("[ a TO z]")).RewriteMethod);
|
|||
|
|
|
|||
|
|
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})");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestFarsiRangeCollating()
|
|||
|
|
{
|
|||
|
|
|
|||
|
|
RAMDirectory ramDir = new RAMDirectory();
|
|||
|
|
IndexWriter iw = new IndexWriter(ramDir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
|
|||
|
|
Document doc = new Document();
|
|||
|
|
doc.Add(new Field("content", "\u0633\u0627\u0628", Field.Store.YES, Field.Index.NOT_ANALYZED));
|
|||
|
|
iw.AddDocument(doc);
|
|||
|
|
iw.Close();
|
|||
|
|
IndexSearcher is_Renamed = new IndexSearcher(ramDir, true);
|
|||
|
|
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "content", new WhitespaceAnalyzer());
|
|||
|
|
|
|||
|
|
// Neither Java 1.4.2 nor 1.5.0 has Farsi Locale collation available in
|
|||
|
|
// RuleBasedCollator. However, the Arabic Locale seems to order the Farsi
|
|||
|
|
// characters properly.
|
|||
|
|
System.Globalization.CompareInfo c = new System.Globalization.CultureInfo("ar").CompareInfo;
|
|||
|
|
qp.RangeCollator = c;
|
|||
|
|
|
|||
|
|
// Unicode order would include U+0633 in [ U+062F - U+0698 ], but Farsi
|
|||
|
|
// orders the U+0698 character before the U+0633 character, so the single
|
|||
|
|
// index Term below should NOT be returned by a ConstantScoreRangeQuery
|
|||
|
|
// with a Farsi Collator (or an Arabic one for the case when Farsi is not
|
|||
|
|
// supported).
|
|||
|
|
|
|||
|
|
// Test ConstantScoreRangeQuery
|
|||
|
|
qp.MultiTermRewriteMethod = MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE;
|
|||
|
|
ScoreDoc[] result = is_Renamed.Search(qp.Parse("[ \u062F TO \u0698 ]"), null, 1000).ScoreDocs;
|
|||
|
|
Assert.AreEqual(0, result.Length, "The index Term should not be included.");
|
|||
|
|
|
|||
|
|
result = is_Renamed.Search(qp.Parse("[ \u0633 TO \u0638 ]"), null, 1000).ScoreDocs;
|
|||
|
|
Assert.AreEqual(1, result.Length, "The index Term should be included.");
|
|||
|
|
|
|||
|
|
// Test TermRangeQuery
|
|||
|
|
qp.MultiTermRewriteMethod = MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE;
|
|||
|
|
result = is_Renamed.Search(qp.Parse("[ \u062F TO \u0698 ]"), null, 1000).ScoreDocs;
|
|||
|
|
Assert.AreEqual(0, result.Length, "The index Term should not be included.");
|
|||
|
|
|
|||
|
|
result = is_Renamed.Search(qp.Parse("[ \u0633 TO \u0638 ]"), null, 1000).ScoreDocs;
|
|||
|
|
Assert.AreEqual(1, result.Length, "The index Term should be included.");
|
|||
|
|
|
|||
|
|
is_Renamed.Close();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private System.String EscapeDateString(System.String s)
|
|||
|
|
{
|
|||
|
|
if (s.IndexOf(" ") > - 1)
|
|||
|
|
{
|
|||
|
|
return "\"" + s + "\"";
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
return s;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>for testing legacy DateField support </summary>
|
|||
|
|
private System.String GetLegacyDate(System.String s)
|
|||
|
|
{
|
|||
|
|
System.DateTime tempAux = System.DateTime.Parse(s, System.Globalization.CultureInfo.CurrentCulture);
|
|||
|
|
return DateField.DateToString(tempAux);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>for testing DateTools support </summary>
|
|||
|
|
private System.String GetDate(System.String s, DateTools.Resolution resolution)
|
|||
|
|
{
|
|||
|
|
System.DateTime tempAux = System.DateTime.Parse(s, System.Globalization.CultureInfo.CurrentCulture);
|
|||
|
|
return GetDate(tempAux, resolution);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>for testing DateTools support </summary>
|
|||
|
|
private System.String GetDate(System.DateTime d, DateTools.Resolution resolution)
|
|||
|
|
{
|
|||
|
|
if (resolution == null)
|
|||
|
|
{
|
|||
|
|
return DateField.DateToString(d);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
return DateTools.DateToString(d, resolution);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private System.String GetLocalizedDate(int year, int month, int day, bool extendLastDate)
|
|||
|
|
{
|
|||
|
|
System.Globalization.Calendar calendar = new System.Globalization.GregorianCalendar();
|
|||
|
|
System.DateTime temp = new System.DateTime(year, month, day, calendar);
|
|||
|
|
if (extendLastDate)
|
|||
|
|
{
|
|||
|
|
temp = temp.AddHours(23);
|
|||
|
|
temp = temp.AddMinutes(59);
|
|||
|
|
temp = temp.AddSeconds(59);
|
|||
|
|
temp = temp.AddMilliseconds(999);
|
|||
|
|
}
|
|||
|
|
return temp.ToShortDateString();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary>for testing legacy DateField support </summary>
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestLegacyDateRange()
|
|||
|
|
{
|
|||
|
|
System.String startDate = GetLocalizedDate(2002, 1, 1, false);
|
|||
|
|
System.String endDate = GetLocalizedDate(2002, 1, 4, false);
|
|||
|
|
System.Globalization.Calendar endDateExpected = new System.Globalization.GregorianCalendar();
|
|||
|
|
System.DateTime tempAux = new System.DateTime(2002, 1, 4, 23, 59, 59, 999, endDateExpected);
|
|||
|
|
AssertQueryEquals("[ " + EscapeDateString(startDate) + " TO " + EscapeDateString(endDate) + "]", null, "[" + GetLegacyDate(startDate) + " TO " + DateField.DateToString(tempAux) + "]");
|
|||
|
|
AssertQueryEquals("{ " + EscapeDateString(startDate) + " " + EscapeDateString(endDate) + " }", null, "{" + GetLegacyDate(startDate) + " TO " + GetLegacyDate(endDate) + "}");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestDateRange()
|
|||
|
|
{
|
|||
|
|
System.String startDate = GetLocalizedDate(2002, 1, 1, false);
|
|||
|
|
System.String endDate = GetLocalizedDate(2002, 1, 4, false);
|
|||
|
|
System.Globalization.Calendar calendar = new System.Globalization.GregorianCalendar();
|
|||
|
|
System.DateTime endDateExpected = new System.DateTime(2002, 1, 4, 23, 59, 59, 999, calendar);
|
|||
|
|
System.String defaultField = "default";
|
|||
|
|
System.String monthField = "month";
|
|||
|
|
System.String hourField = "hour";
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", new SimpleAnalyzer());
|
|||
|
|
|
|||
|
|
// Don't set any date resolution and verify if DateField is used
|
|||
|
|
System.DateTime tempAux = endDateExpected;
|
|||
|
|
AssertDateRangeQueryEquals(qp, defaultField, startDate, endDate, tempAux, null);
|
|||
|
|
|
|||
|
|
// set a field specific date resolution
|
|||
|
|
qp.SetDateResolution(monthField, DateTools.Resolution.MONTH);
|
|||
|
|
|
|||
|
|
// DateField should still be used for defaultField
|
|||
|
|
System.DateTime tempAux2 = endDateExpected;
|
|||
|
|
AssertDateRangeQueryEquals(qp, defaultField, startDate, endDate, tempAux2, null);
|
|||
|
|
|
|||
|
|
// set default date resolution to MILLISECOND
|
|||
|
|
qp.SetDateResolution(DateTools.Resolution.MILLISECOND);
|
|||
|
|
|
|||
|
|
// set second field specific date resolution
|
|||
|
|
qp.SetDateResolution(hourField, DateTools.Resolution.HOUR);
|
|||
|
|
|
|||
|
|
// for this field no field specific date resolution has been set,
|
|||
|
|
// so verify if the default resolution is used
|
|||
|
|
System.DateTime tempAux3 = endDateExpected;
|
|||
|
|
AssertDateRangeQueryEquals(qp, defaultField, startDate, endDate, tempAux3, DateTools.Resolution.MILLISECOND);
|
|||
|
|
|
|||
|
|
// verify if field specific date resolutions are used for these two fields
|
|||
|
|
System.DateTime tempAux4 = endDateExpected;
|
|||
|
|
AssertDateRangeQueryEquals(qp, monthField, startDate, endDate, tempAux4, DateTools.Resolution.MONTH);
|
|||
|
|
|
|||
|
|
System.DateTime tempAux5 = endDateExpected;
|
|||
|
|
AssertDateRangeQueryEquals(qp, hourField, startDate, endDate, tempAux5, DateTools.Resolution.HOUR);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertDateRangeQueryEquals(QueryParser qp, System.String field, System.String startDate, System.String endDate, System.DateTime endDateInclusive, DateTools.Resolution resolution)
|
|||
|
|
{
|
|||
|
|
AssertQueryEquals(qp, field, field + ":[" + EscapeDateString(startDate) + " TO " + EscapeDateString(endDate) + "]", "[" + GetDate(startDate, resolution) + " TO " + GetDate(endDateInclusive, resolution) + "]");
|
|||
|
|
AssertQueryEquals(qp, field, field + ":{" + EscapeDateString(startDate) + " TO " + EscapeDateString(endDate) + "}", "{" + GetDate(startDate, resolution) + " TO " + GetDate(endDate, resolution) + "}");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestEscaped()
|
|||
|
|
{
|
|||
|
|
Analyzer a = new WhitespaceAnalyzer();
|
|||
|
|
|
|||
|
|
/*assertQueryEquals("\\[brackets", a, "\\[brackets");
|
|||
|
|
assertQueryEquals("\\[brackets", null, "brackets");
|
|||
|
|
assertQueryEquals("\\\\", a, "\\\\");
|
|||
|
|
assertQueryEquals("\\+blah", a, "\\+blah");
|
|||
|
|
assertQueryEquals("\\(blah", a, "\\(blah");
|
|||
|
|
|
|||
|
|
assertQueryEquals("\\-blah", a, "\\-blah");
|
|||
|
|
assertQueryEquals("\\!blah", a, "\\!blah");
|
|||
|
|
assertQueryEquals("\\{blah", a, "\\{blah");
|
|||
|
|
assertQueryEquals("\\}blah", a, "\\}blah");
|
|||
|
|
assertQueryEquals("\\:blah", a, "\\:blah");
|
|||
|
|
assertQueryEquals("\\^blah", a, "\\^blah");
|
|||
|
|
assertQueryEquals("\\[blah", a, "\\[blah");
|
|||
|
|
assertQueryEquals("\\]blah", a, "\\]blah");
|
|||
|
|
assertQueryEquals("\\\"blah", a, "\\\"blah");
|
|||
|
|
assertQueryEquals("\\(blah", a, "\\(blah");
|
|||
|
|
assertQueryEquals("\\)blah", a, "\\)blah");
|
|||
|
|
assertQueryEquals("\\~blah", a, "\\~blah");
|
|||
|
|
assertQueryEquals("\\*blah", a, "\\*blah");
|
|||
|
|
assertQueryEquals("\\?blah", a, "\\?blah");
|
|||
|
|
//assertQueryEquals("foo \\&\\& bar", a, "foo \\&\\& bar");
|
|||
|
|
//assertQueryEquals("foo \\|| bar", a, "foo \\|| bar");
|
|||
|
|
//assertQueryEquals("foo \\AND bar", a, "foo \\AND bar");*/
|
|||
|
|
|
|||
|
|
AssertQueryEquals("\\a", a, "a");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a\\-b:c", a, "a-b:c");
|
|||
|
|
AssertQueryEquals("a\\+b:c", a, "a+b:c");
|
|||
|
|
AssertQueryEquals("a\\:b:c", a, "a:b:c");
|
|||
|
|
AssertQueryEquals("a\\\\b:c", a, "a\\b:c");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a:b\\-c", a, "a:b-c");
|
|||
|
|
AssertQueryEquals("a:b\\+c", a, "a:b+c");
|
|||
|
|
AssertQueryEquals("a:b\\:c", a, "a:b:c");
|
|||
|
|
AssertQueryEquals("a:b\\\\c", a, "a:b\\c");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a:b\\-c*", a, "a:b-c*");
|
|||
|
|
AssertQueryEquals("a:b\\+c*", a, "a:b+c*");
|
|||
|
|
AssertQueryEquals("a:b\\:c*", a, "a:b:c*");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a:b\\\\c*", a, "a:b\\c*");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a:b\\-?c", a, "a:b-?c");
|
|||
|
|
AssertQueryEquals("a:b\\+?c", a, "a:b+?c");
|
|||
|
|
AssertQueryEquals("a:b\\:?c", a, "a:b:?c");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a:b\\\\?c", a, "a:b\\?c");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a:b\\-c~", a, "a:b-c~0.5");
|
|||
|
|
AssertQueryEquals("a:b\\+c~", a, "a:b+c~0.5");
|
|||
|
|
AssertQueryEquals("a:b\\:c~", a, "a:b:c~0.5");
|
|||
|
|
AssertQueryEquals("a:b\\\\c~", a, "a:b\\c~0.5");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("[ a\\- TO a\\+ ]", null, "[a- TO a+]");
|
|||
|
|
AssertQueryEquals("[ a\\: TO a\\~ ]", null, "[a: TO a~]");
|
|||
|
|
AssertQueryEquals("[ a\\\\ TO a\\* ]", null, "[a\\ TO a*]");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("[\"c\\:\\\\temp\\\\\\~foo0.txt\" TO \"c\\:\\\\temp\\\\\\~foo9.txt\"]", a, "[c:\\temp\\~foo0.txt TO c:\\temp\\~foo9.txt]");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a\\\\\\+b", a, "a\\+b");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("a \\\"b c\\\" d", a, "a \"b c\" d");
|
|||
|
|
AssertQueryEquals("\"a \\\"b c\\\" d\"", a, "\"a \"b c\" d\"");
|
|||
|
|
AssertQueryEquals("\"a \\+b c d\"", a, "\"a +b c d\"");
|
|||
|
|
|
|||
|
|
AssertQueryEquals("c\\:\\\\temp\\\\\\~foo.txt", a, "c:\\temp\\~foo.txt");
|
|||
|
|
|
|||
|
|
AssertParseException("XY\\"); // there must be a character after the escape char
|
|||
|
|
|
|||
|
|
// test unicode escaping
|
|||
|
|
AssertQueryEquals("a\\u0062c", a, "abc");
|
|||
|
|
AssertQueryEquals("XY\\u005a", a, "XYZ");
|
|||
|
|
AssertQueryEquals("XY\\u005A", a, "XYZ");
|
|||
|
|
AssertQueryEquals("\"a \\\\\\u0028\\u0062\\\" c\"", a, "\"a \\(b\" c\"");
|
|||
|
|
|
|||
|
|
AssertParseException("XY\\u005G"); // test non-hex character in escaped unicode sequence
|
|||
|
|
AssertParseException("XY\\u005"); // test incomplete escaped unicode sequence
|
|||
|
|
|
|||
|
|
// Tests bug LUCENE-800
|
|||
|
|
AssertQueryEquals("(item:\\\\ item:ABCD\\\\)", a, "item:\\ item:ABCD\\");
|
|||
|
|
AssertParseException("(item:\\\\ item:ABCD\\\\))"); // unmatched closing paranthesis
|
|||
|
|
AssertQueryEquals("\\*", a, "*");
|
|||
|
|
AssertQueryEquals("\\\\", a, "\\"); // escaped backslash
|
|||
|
|
|
|||
|
|
AssertParseException("\\"); // a backslash must always be escaped
|
|||
|
|
|
|||
|
|
// LUCENE-1189
|
|||
|
|
AssertQueryEquals("(\"a\\\\\") or (\"b\")", a, "a\\ or b");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestQueryStringEscaping()
|
|||
|
|
{
|
|||
|
|
Analyzer a = new WhitespaceAnalyzer();
|
|||
|
|
|
|||
|
|
AssertEscapedQueryEquals("a-b:c", a, "a\\-b\\:c");
|
|||
|
|
AssertEscapedQueryEquals("a+b:c", a, "a\\+b\\:c");
|
|||
|
|
AssertEscapedQueryEquals("a:b:c", a, "a\\:b\\:c");
|
|||
|
|
AssertEscapedQueryEquals("a\\b:c", a, "a\\\\b\\:c");
|
|||
|
|
|
|||
|
|
AssertEscapedQueryEquals("a:b-c", a, "a\\:b\\-c");
|
|||
|
|
AssertEscapedQueryEquals("a:b+c", a, "a\\:b\\+c");
|
|||
|
|
AssertEscapedQueryEquals("a:b:c", a, "a\\:b\\:c");
|
|||
|
|
AssertEscapedQueryEquals("a:b\\c", a, "a\\:b\\\\c");
|
|||
|
|
|
|||
|
|
AssertEscapedQueryEquals("a:b-c*", a, "a\\:b\\-c\\*");
|
|||
|
|
AssertEscapedQueryEquals("a:b+c*", a, "a\\:b\\+c\\*");
|
|||
|
|
AssertEscapedQueryEquals("a:b:c*", a, "a\\:b\\:c\\*");
|
|||
|
|
|
|||
|
|
AssertEscapedQueryEquals("a:b\\\\c*", a, "a\\:b\\\\\\\\c\\*");
|
|||
|
|
|
|||
|
|
AssertEscapedQueryEquals("a:b-?c", a, "a\\:b\\-\\?c");
|
|||
|
|
AssertEscapedQueryEquals("a:b+?c", a, "a\\:b\\+\\?c");
|
|||
|
|
AssertEscapedQueryEquals("a:b:?c", a, "a\\:b\\:\\?c");
|
|||
|
|
|
|||
|
|
AssertEscapedQueryEquals("a:b?c", a, "a\\:b\\?c");
|
|||
|
|
|
|||
|
|
AssertEscapedQueryEquals("a:b-c~", a, "a\\:b\\-c\\~");
|
|||
|
|
AssertEscapedQueryEquals("a:b+c~", a, "a\\:b\\+c\\~");
|
|||
|
|
AssertEscapedQueryEquals("a:b:c~", a, "a\\:b\\:c\\~");
|
|||
|
|
AssertEscapedQueryEquals("a:b\\c~", a, "a\\:b\\\\c\\~");
|
|||
|
|
|
|||
|
|
AssertEscapedQueryEquals("[ a - TO a+ ]", null, "\\[ a \\- TO a\\+ \\]");
|
|||
|
|
AssertEscapedQueryEquals("[ a : TO a~ ]", null, "\\[ a \\: TO a\\~ \\]");
|
|||
|
|
AssertEscapedQueryEquals("[ a\\ TO a* ]", null, "\\[ a\\\\ TO a\\* \\]");
|
|||
|
|
|
|||
|
|
// LUCENE-881
|
|||
|
|
AssertEscapedQueryEquals("|| abc ||", a, "\\|\\| abc \\|\\|");
|
|||
|
|
AssertEscapedQueryEquals("&& abc &&", a, "\\&\\& abc \\&\\&");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestTabNewlineCarriageReturn()
|
|||
|
|
{
|
|||
|
|
AssertQueryEqualsDOA("+weltbank +worlbank", null, "+weltbank +worlbank");
|
|||
|
|
|
|||
|
|
AssertQueryEqualsDOA("+weltbank\n+worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \n+worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \n +worlbank", null, "+weltbank +worlbank");
|
|||
|
|
|
|||
|
|
AssertQueryEqualsDOA("+weltbank\r+worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \r+worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \r +worlbank", null, "+weltbank +worlbank");
|
|||
|
|
|
|||
|
|
AssertQueryEqualsDOA("+weltbank\r\n+worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \r\n+worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \r\n +worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \r \n +worlbank", null, "+weltbank +worlbank");
|
|||
|
|
|
|||
|
|
AssertQueryEqualsDOA("+weltbank\t+worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \t+worlbank", null, "+weltbank +worlbank");
|
|||
|
|
AssertQueryEqualsDOA("weltbank \t +worlbank", null, "+weltbank +worlbank");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestSimpleDAO()
|
|||
|
|
{
|
|||
|
|
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");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestBoost()
|
|||
|
|
{
|
|||
|
|
var stopWords = Support.Compatibility.SetFactory.CreateHashSet<string>();
|
|||
|
|
stopWords.Add("on");
|
|||
|
|
StandardAnalyzer oneStopAnalyzer = new StandardAnalyzer(Version.LUCENE_CURRENT, stopWords);
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", oneStopAnalyzer);
|
|||
|
|
Query q = qp.Parse("on^1.0");
|
|||
|
|
Assert.IsNotNull(q);
|
|||
|
|
q = qp.Parse("\"hello\"^2.0");
|
|||
|
|
Assert.IsNotNull(q);
|
|||
|
|
Assert.AreEqual(q.Boost, (float) 2.0, (float) 0.5);
|
|||
|
|
q = qp.Parse("hello^2.0");
|
|||
|
|
Assert.IsNotNull(q);
|
|||
|
|
Assert.AreEqual(q.Boost, (float) 2.0, (float) 0.5);
|
|||
|
|
q = qp.Parse("\"on\"^1.0");
|
|||
|
|
Assert.IsNotNull(q);
|
|||
|
|
|
|||
|
|
QueryParser qp2 = new QueryParser(Version.LUCENE_CURRENT, "field", new StandardAnalyzer(Util.Version.LUCENE_CURRENT));
|
|||
|
|
q = qp2.Parse("the^3");
|
|||
|
|
// "the" is a stop word so the result is an empty query:
|
|||
|
|
Assert.IsNotNull(q);
|
|||
|
|
Assert.AreEqual("", q.ToString());
|
|||
|
|
Assert.AreEqual(1.0f, q.Boost, 0.01f);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
public virtual void AssertParseException(System.String queryString)
|
|||
|
|
{
|
|||
|
|
Assert.Throws<ParseException>(() => GetQuery(queryString, null), "ParseException expected, not thrown");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestException()
|
|||
|
|
{
|
|||
|
|
AssertParseException("\"some phrase");
|
|||
|
|
AssertParseException("(foo bar");
|
|||
|
|
AssertParseException("foo bar))");
|
|||
|
|
AssertParseException("field:term:with:colon some more terms");
|
|||
|
|
AssertParseException("(sub query)^5.0^2.0 plus more");
|
|||
|
|
AssertParseException("secret AND illegal) AND access:confidential");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestCustomQueryParserWildcard()
|
|||
|
|
{
|
|||
|
|
Assert.Throws<ParseException>(() => new QPTestParser("contents", new WhitespaceAnalyzer()).Parse("a?t"),
|
|||
|
|
"Wildcard queries should not be allowed");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestCustomQueryParserFuzzy()
|
|||
|
|
{
|
|||
|
|
Assert.Throws<ParseException>(() => new QPTestParser("contents", new WhitespaceAnalyzer()).Parse("xunit~"),
|
|||
|
|
"Fuzzy queries should not be allowed");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestBooleanQuery()
|
|||
|
|
{
|
|||
|
|
BooleanQuery.MaxClauseCount = 2;
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", new WhitespaceAnalyzer());
|
|||
|
|
Assert.Throws<ParseException>(() => qp.Parse("one two three"),
|
|||
|
|
"ParseException expected due to too many boolean clauses");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/// <summary> This test differs from TestPrecedenceQueryParser</summary>
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestPrecedence()
|
|||
|
|
{
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", new WhitespaceAnalyzer());
|
|||
|
|
Query query1 = qp.Parse("A AND B OR C AND D");
|
|||
|
|
Query query2 = qp.Parse("+A +B +C +D");
|
|||
|
|
Assert.AreEqual(query1, query2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestLocalDateFormat()
|
|||
|
|
{
|
|||
|
|
RAMDirectory ramDir = new RAMDirectory();
|
|||
|
|
IndexWriter iw = new IndexWriter(ramDir, new WhitespaceAnalyzer(), true, IndexWriter.MaxFieldLength.LIMITED);
|
|||
|
|
AddDateDoc("a", 2005, 12, 2, 10, 15, 33, iw);
|
|||
|
|
AddDateDoc("b", 2005, 12, 4, 22, 15, 0, iw);
|
|||
|
|
iw.Close();
|
|||
|
|
IndexSearcher is_Renamed = new IndexSearcher(ramDir, true);
|
|||
|
|
AssertHits(1, "[12/1/2005 TO 12/3/2005]", is_Renamed);
|
|||
|
|
AssertHits(2, "[12/1/2005 TO 12/4/2005]", is_Renamed);
|
|||
|
|
AssertHits(1, "[12/3/2005 TO 12/4/2005]", is_Renamed);
|
|||
|
|
AssertHits(1, "{12/1/2005 TO 12/3/2005}", is_Renamed);
|
|||
|
|
AssertHits(1, "{12/1/2005 TO 12/4/2005}", is_Renamed);
|
|||
|
|
AssertHits(0, "{12/3/2005 TO 12/4/2005}", is_Renamed);
|
|||
|
|
is_Renamed.Close();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestStarParsing()
|
|||
|
|
{
|
|||
|
|
int[] type = new int[1];
|
|||
|
|
QueryParser qp = new AnonymousClassQueryParser(type, this, "field", new WhitespaceAnalyzer());
|
|||
|
|
|
|||
|
|
TermQuery tq;
|
|||
|
|
|
|||
|
|
tq = (TermQuery) qp.Parse("foo:zoo*");
|
|||
|
|
Assert.AreEqual("zoo", tq.Term.Text);
|
|||
|
|
Assert.AreEqual(2, type[0]);
|
|||
|
|
|
|||
|
|
tq = (TermQuery) qp.Parse("foo:zoo*^2");
|
|||
|
|
Assert.AreEqual("zoo", tq.Term.Text);
|
|||
|
|
Assert.AreEqual(2, type[0]);
|
|||
|
|
Assert.AreEqual(tq.Boost, 2, 0);
|
|||
|
|
|
|||
|
|
tq = (TermQuery) qp.Parse("foo:*");
|
|||
|
|
Assert.AreEqual("*", tq.Term.Text);
|
|||
|
|
Assert.AreEqual(1, type[0]); // could be a valid prefix query in the future too
|
|||
|
|
|
|||
|
|
tq = (TermQuery) qp.Parse("foo:*^2");
|
|||
|
|
Assert.AreEqual("*", tq.Term.Text);
|
|||
|
|
Assert.AreEqual(1, type[0]);
|
|||
|
|
Assert.AreEqual(tq.Boost, 2, 0);
|
|||
|
|
|
|||
|
|
tq = (TermQuery) qp.Parse("*:foo");
|
|||
|
|
Assert.AreEqual("*", tq.Term.Field);
|
|||
|
|
Assert.AreEqual("foo", tq.Term.Text);
|
|||
|
|
Assert.AreEqual(3, type[0]);
|
|||
|
|
|
|||
|
|
tq = (TermQuery) qp.Parse("*:*");
|
|||
|
|
Assert.AreEqual("*", tq.Term.Field);
|
|||
|
|
Assert.AreEqual("*", tq.Term.Text);
|
|||
|
|
Assert.AreEqual(1, type[0]); // could be handled as a prefix query in the future
|
|||
|
|
|
|||
|
|
tq = (TermQuery) qp.Parse("(*:*)");
|
|||
|
|
Assert.AreEqual("*", tq.Term.Field);
|
|||
|
|
Assert.AreEqual("*", tq.Term.Text);
|
|||
|
|
Assert.AreEqual(1, type[0]);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestStopwords()
|
|||
|
|
{
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "a",
|
|||
|
|
new StopAnalyzer(Version.LUCENE_CURRENT,
|
|||
|
|
StopFilter.MakeStopSet(new[] {"the", "foo"})));
|
|||
|
|
Query result = qp.Parse("a:the OR a:foo");
|
|||
|
|
Assert.IsNotNull(result, "result is null and it shouldn't be");
|
|||
|
|
Assert.IsTrue(result is BooleanQuery, "result is not a BooleanQuery");
|
|||
|
|
Assert.IsTrue(((BooleanQuery) result).Clauses.Count == 0, ((BooleanQuery) result).Clauses.Count + " does not equal: " + 0);
|
|||
|
|
result = qp.Parse("a:woo OR a:the");
|
|||
|
|
Assert.IsNotNull(result, "result is null and it shouldn't be");
|
|||
|
|
Assert.IsTrue(result is TermQuery, "result is not a TermQuery");
|
|||
|
|
result = qp.Parse("(fieldX:xxxxx OR fieldy:xxxxxxxx)^2 AND (fieldx:the OR fieldy:foo)");
|
|||
|
|
Assert.IsNotNull(result, "result is null and it shouldn't be");
|
|||
|
|
Assert.IsTrue(result is BooleanQuery, "result is not a BooleanQuery");
|
|||
|
|
System.Console.Out.WriteLine("Result: " + result);
|
|||
|
|
Assert.IsTrue(((BooleanQuery) result).Clauses.Count == 2, ((BooleanQuery) result).Clauses.Count + " does not equal: " + 2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestPositionIncrement()
|
|||
|
|
{
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "a",
|
|||
|
|
new StopAnalyzer(Version.LUCENE_CURRENT,
|
|||
|
|
StopFilter.MakeStopSet(new[] {"the", "in", "are", "this"})));
|
|||
|
|
qp.EnablePositionIncrements = true;
|
|||
|
|
string qtxt = "\"the words in poisitions pos02578 are stopped in this phrasequery\"";
|
|||
|
|
// 0 2 5 7 8
|
|||
|
|
int[] expectedPositions = new int[] {1, 3, 4, 6, 9};
|
|||
|
|
PhraseQuery pq = (PhraseQuery) qp.Parse(qtxt);
|
|||
|
|
//System.out.println("Query text: "+qtxt);
|
|||
|
|
//System.out.println("Result: "+pq);
|
|||
|
|
Term[] t = pq.GetTerms();
|
|||
|
|
int[] pos = pq.GetPositions();
|
|||
|
|
for (int i = 0; i < t.Length; i++)
|
|||
|
|
{
|
|||
|
|
//System.out.println(i+". "+t[i]+" pos: "+pos[i]);
|
|||
|
|
Assert.AreEqual(expectedPositions[i], pos[i], "term " + i + " = " + t[i] + " has wrong term-position!");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestMatchAllDocs()
|
|||
|
|
{
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "field", new WhitespaceAnalyzer());
|
|||
|
|
Assert.AreEqual(new MatchAllDocsQuery(), qp.Parse("*:*"));
|
|||
|
|
Assert.AreEqual(new MatchAllDocsQuery(), qp.Parse("(*:*)"));
|
|||
|
|
BooleanQuery bq = (BooleanQuery) qp.Parse("+*:* -*:*");
|
|||
|
|
Assert.IsTrue(bq.GetClauses()[0].Query is MatchAllDocsQuery);
|
|||
|
|
Assert.IsTrue(bq.GetClauses()[1].Query is MatchAllDocsQuery);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private void AssertHits(int expected, System.String query, IndexSearcher is_Renamed)
|
|||
|
|
{
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "date", new WhitespaceAnalyzer());
|
|||
|
|
qp.Locale = new System.Globalization.CultureInfo("en-US");
|
|||
|
|
Query q = qp.Parse(query);
|
|||
|
|
ScoreDoc[] hits = is_Renamed.Search(q, null, 1000).ScoreDocs;
|
|||
|
|
Assert.AreEqual(expected, hits.Length);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
private static void AddDateDoc(System.String content, int year, int month, int day, int hour, int minute, int second, IndexWriter iw)
|
|||
|
|
{
|
|||
|
|
Document d = new Document();
|
|||
|
|
d.Add(new Field("f", content, Field.Store.YES, Field.Index.ANALYZED));
|
|||
|
|
System.Globalization.Calendar cal = new System.Globalization.GregorianCalendar();
|
|||
|
|
System.DateTime tempAux = new System.DateTime(year, month, day, hour, minute, second, cal);
|
|||
|
|
d.Add(new Field("date", DateField.DateToString(tempAux), Field.Store.YES, Field.Index.NOT_ANALYZED));
|
|||
|
|
iw.AddDocument(d);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[TearDown]
|
|||
|
|
public override void TearDown()
|
|||
|
|
{
|
|||
|
|
base.TearDown();
|
|||
|
|
BooleanQuery.MaxClauseCount = originalMaxClauses;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// LUCENE-2002: make sure defaults for StandardAnalyzer's
|
|||
|
|
// enableStopPositionIncr & QueryParser's enablePosIncr
|
|||
|
|
// "match"
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestPositionIncrements()
|
|||
|
|
{
|
|||
|
|
Directory dir = new MockRAMDirectory();
|
|||
|
|
Analyzer a = new StandardAnalyzer(Version.LUCENE_CURRENT);
|
|||
|
|
IndexWriter w = new IndexWriter(dir, a, IndexWriter.MaxFieldLength.UNLIMITED);
|
|||
|
|
Document doc = new Document();
|
|||
|
|
doc.Add(new Field("f", "the wizard of ozzy", Field.Store.NO, Field.Index.ANALYZED));
|
|||
|
|
w.AddDocument(doc);
|
|||
|
|
IndexReader r = w.GetReader();
|
|||
|
|
w.Close();
|
|||
|
|
IndexSearcher s = new IndexSearcher(r);
|
|||
|
|
QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "f", a);
|
|||
|
|
Query q = qp.Parse("\"wizard of ozzy\"");
|
|||
|
|
Assert.AreEqual(1, s.Search(q, 1).TotalHits);
|
|||
|
|
r.Close();
|
|||
|
|
dir.Close();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// LUCENE-2002: when we run javacc to regen QueryParser,
|
|||
|
|
// we also run a replaceregexp step to fix 2 of the public
|
|||
|
|
// ctors (change them to protected):
|
|||
|
|
//
|
|||
|
|
// protected QueryParser(CharStream stream)
|
|||
|
|
//
|
|||
|
|
// protected QueryParser(QueryParserTokenManager tm)
|
|||
|
|
//
|
|||
|
|
// This test is here as a safety, in case that ant step
|
|||
|
|
// doesn't work for some reason.
|
|||
|
|
[Test]
|
|||
|
|
public virtual void TestProtectedCtors()
|
|||
|
|
{
|
|||
|
|
// If the return type is not null, then fail the assertion.
|
|||
|
|
Assert.IsNull(typeof (QueryParser).GetConstructor(new System.Type[] {typeof (ICharStream)}),
|
|||
|
|
"please switch public QueryParser(CharStream) to be protected");
|
|||
|
|
|
|||
|
|
// Same for the constructor for the constructor with the query parser token manager.
|
|||
|
|
Assert.IsNull(typeof(QueryParser).GetConstructor(new System.Type[] { typeof(QueryParserTokenManager) }),
|
|||
|
|
"please switch public QueryParser(QueryParserTokenManager) to be protected");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
[Test]
|
|||
|
|
public void TestVersioningOfJavaDateRangeBehavior()
|
|||
|
|
{
|
|||
|
|
var startDate = GetLocalizedDate(2002, 1, 1, false);
|
|||
|
|
var endDate = GetLocalizedDate(2002, 1, 4, false);
|
|||
|
|
|
|||
|
|
System.Globalization.Calendar calendar = new System.Globalization.GregorianCalendar();
|
|||
|
|
var endDateExpected = new DateTime(2002, 1, 4, 23, 59, 59, 999, calendar);
|
|||
|
|
|
|||
|
|
var qp = new QueryParser(Version.LUCENE_24, "field", new SimpleAnalyzer());
|
|||
|
|
|
|||
|
|
// Don't set any date resolution and verify if DateField is used
|
|||
|
|
AssertDateRangeQueryEquals(qp, "default", startDate, endDate, endDateExpected, null);
|
|||
|
|
|
|||
|
|
// Use dates with dashes in them, which aren't parsed out as dates in Java
|
|||
|
|
AssertDateRangeQueryEquals(qp, "default", "2002-1-1", "2002-1-4", endDateExpected, null);
|
|||
|
|
|
|||
|
|
qp = new QueryParser(Version.LUCENE_CURRENT, "field", new SimpleAnalyzer());
|
|||
|
|
|
|||
|
|
// We still want to make sure that a localized date of "M/d/YYYY" will be parsed out
|
|||
|
|
// as a datefield as expected.
|
|||
|
|
AssertDateRangeQueryEquals(qp, "default", startDate, endDate, endDateExpected, null);
|
|||
|
|
|
|||
|
|
// This should be a normal query, NOT a date query if we're emulating Java (on or above Version LUCENE_30)
|
|||
|
|
AssertQueryEquals(qp, "field", "default:[2002-1-1 TO 2002-1-4]", "default:[2002-1-1 TO 2002-1-4]");
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// LUCENENET-478: The QueryParser hadn't been updated in so long
|
|||
|
|
// it had an issue where stopwords inside of phrase queries
|
|||
|
|
// would be given a null query instead of skipped when EnablePositionIncrements
|
|||
|
|
// was set to false, so a ToString() on the query would make a query of "Query With Stopwords"
|
|||
|
|
// into "Query ? Stopwords", regardless of request behavior of position increments
|
|||
|
|
[Test]
|
|||
|
|
public void TestStopWordsInPhraseQuery()
|
|||
|
|
{
|
|||
|
|
var qp = new QueryParser(Version.LUCENE_CURRENT, "a", new StopAnalyzer(Version.LUCENE_CURRENT));
|
|||
|
|
|
|||
|
|
var result = qp.Parse("\"Query With Stopwords\"");
|
|||
|
|
Assert.IsNotNull(result);
|
|||
|
|
Assert.IsTrue(result is PhraseQuery);
|
|||
|
|
Assert.AreEqual("a:\"query ? stopwords\"", result.ToString());
|
|||
|
|
|
|||
|
|
result = qp.Parse("\"Query OR Stopwords\"");
|
|||
|
|
Assert.IsNotNull(result);
|
|||
|
|
Assert.IsTrue(result is PhraseQuery);
|
|||
|
|
Assert.AreEqual("a:\"query ? stopwords\"", result.ToString());
|
|||
|
|
|
|||
|
|
result = qp.Parse("\"Query and Stopwords\"");
|
|||
|
|
Assert.IsNotNull(result);
|
|||
|
|
Assert.IsTrue(result is PhraseQuery);
|
|||
|
|
Assert.AreEqual("a:\"query ? stopwords\"", result.ToString());
|
|||
|
|
|
|||
|
|
result = qp.Parse("\"Query AND Stopwords\"");
|
|||
|
|
Assert.IsNotNull(result);
|
|||
|
|
Assert.IsTrue(result is PhraseQuery);
|
|||
|
|
Assert.AreEqual("a:\"query ? stopwords\"", result.ToString());
|
|||
|
|
|
|||
|
|
// Disable position increments to attempt to remove ? from PhraseQuery.ToString()
|
|||
|
|
qp.EnablePositionIncrements = false;
|
|||
|
|
|
|||
|
|
result = qp.Parse("\"Query With Stopwords\"");
|
|||
|
|
Assert.IsNotNull(result);
|
|||
|
|
Assert.IsTrue(result is PhraseQuery);
|
|||
|
|
Assert.AreEqual("a:\"query stopwords\"", result.ToString());
|
|||
|
|
|
|||
|
|
result = qp.Parse("\"Query OR Stopwords\"");
|
|||
|
|
Assert.IsNotNull(result);
|
|||
|
|
Assert.IsTrue(result is PhraseQuery);
|
|||
|
|
Assert.AreEqual("a:\"query stopwords\"", result.ToString());
|
|||
|
|
|
|||
|
|
result = qp.Parse("\"Query and Stopwords\"");
|
|||
|
|
Assert.IsNotNull(result);
|
|||
|
|
Assert.IsTrue(result is PhraseQuery);
|
|||
|
|
Assert.AreEqual("a:\"query stopwords\"", result.ToString());
|
|||
|
|
|
|||
|
|
result = qp.Parse("\"Query AND Stopwords\"");
|
|||
|
|
Assert.IsNotNull(result);
|
|||
|
|
Assert.IsTrue(result is PhraseQuery);
|
|||
|
|
Assert.AreEqual("a:\"query stopwords\"", result.ToString());
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|