public void testLeadingWildcardType() throws Exception { QueryParserWrapper qp = getParser(null); qp.setAllowLeadingWildcard(true); assertEquals(WildcardQuery.class, qp.parse("t*erm*").getClass()); assertEquals(WildcardQuery.class, qp.parse("?term*").getClass()); assertEquals(WildcardQuery.class, qp.parse("*term*").getClass()); }
/** This test differs from TestPrecedenceQueryParser */ public void testPrecedence() throws Exception { QueryParserWrapper qp = new QueryParserWrapper("field", new WhitespaceAnalyzer()); Query query1 = qp.parse("A AND B OR C AND D"); Query query2 = qp.parse("+A +B +C +D"); assertEquals(query1, query2); }
public void testMatchAllDocs() throws Exception { QueryParserWrapper qp = new QueryParserWrapper("field", new WhitespaceAnalyzer()); assertEquals(new MatchAllDocsQuery(), qp.parse("*:*")); assertEquals(new MatchAllDocsQuery(), qp.parse("(*:*)")); BooleanQuery bq = (BooleanQuery) qp.parse("+*:* -*:*"); assertTrue(bq.getClauses()[0].getQuery() instanceof MatchAllDocsQuery); assertTrue(bq.getClauses()[1].getQuery() instanceof MatchAllDocsQuery); }
public void testPositionIncrement() throws Exception { boolean dflt = StopFilter.getEnablePositionIncrementsDefault(); StopFilter.setEnablePositionIncrementsDefault(true); try { QueryParserWrapper qp = new QueryParserWrapper("a", new StopAnalyzer(new String[] {"the", "in", "are", "this"})); qp.setEnablePositionIncrements(true); String qtxt = "\"the words in poisitions pos02578 are stopped in this phrasequery\""; // 0 2 5 7 8 int expectedPositions[] = {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]); assertEquals( "term " + i + " = " + t[i] + " has wrong term-position!", expectedPositions[i], pos[i]); } } finally { StopFilter.setEnablePositionIncrementsDefault(dflt); } }
public void assertWildcardQueryEquals(String query, String result) throws Exception { QueryParserWrapper qp = getParser(null); Query q = qp.parse(query); String s = q.toString("field"); if (!s.equals(result)) { fail("WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /" + result + "/"); } }
public void assertQueryEquals(QueryParserWrapper qp, String field, String query, String result) throws Exception { Query q = qp.parse(query); String s = q.toString(field); if (!s.equals(result)) { fail("Query /" + query + "/ yielded /" + s + "/, expecting /" + result + "/"); } }
private void assertHits(int expected, String query, IndexSearcher is) throws ParseException, IOException { QueryParserWrapper qp = new QueryParserWrapper("date", new WhitespaceAnalyzer()); qp.setLocale(Locale.ENGLISH); Query q = qp.parse(query); ScoreDoc[] hits = is.search(q, null, 1000).scoreDocs; assertEquals(expected, hits.length); }
public void testBooleanQuery() throws Exception { BooleanQuery.setMaxClauseCount(2); try { QueryParserWrapper qp = new QueryParserWrapper("field", new WhitespaceAnalyzer()); qp.parse("one two three"); fail("ParseException expected due to too many boolean clauses"); } catch (ParseException expected) { // too many boolean clauses, so ParseException is expected } }
public void testFarsiRangeCollating() throws Exception { 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.UN_TOKENIZED)); iw.addDocument(doc); iw.close(); IndexSearcher is = new IndexSearcher(ramDir); QueryParserWrapper qp = new QueryParserWrapper("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. Collator c = Collator.getInstance(new Locale("ar")); qp.setRangeCollator(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.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE); ScoreDoc[] result = is.search(qp.parse("[ \u062F TO \u0698 ]"), null, 1000).scoreDocs; assertEquals("The index Term should not be included.", 0, result.length); result = is.search(qp.parse("[ \u0633 TO \u0638 ]"), null, 1000).scoreDocs; assertEquals("The index Term should be included.", 1, result.length); // Test RangeQuery qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); result = is.search(qp.parse("[ \u062F TO \u0698 ]"), null, 1000).scoreDocs; assertEquals("The index Term should not be included.", 0, result.length); result = is.search(qp.parse("[ \u0633 TO \u0638 ]"), null, 1000).scoreDocs; assertEquals("The index Term should be included.", 1, result.length); is.close(); }
public void testStopwords() throws Exception { QueryParserWrapper qp = new QueryParserWrapper("a", new StopAnalyzer(new String[] {"the", "foo"})); Query result = qp.parse("a:the OR a:foo"); assertNotNull("result is null and it shouldn't be", result); assertTrue("result is not a BooleanQuery", result instanceof BooleanQuery); assertTrue( ((BooleanQuery) result).clauses().size() + " does not equal: " + 0, ((BooleanQuery) result).clauses().size() == 0); result = qp.parse("a:woo OR a:the"); assertNotNull("result is null and it shouldn't be", result); assertTrue("result is not a TermQuery", result instanceof TermQuery); result = qp.parse("(fieldX:xxxxx OR fieldy:xxxxxxxx)^2 AND (fieldx:the OR fieldy:foo)"); assertNotNull("result is null and it shouldn't be", result); assertTrue("result is not a BooleanQuery", result instanceof BooleanQuery); System.out.println("Result: " + result); assertTrue( ((BooleanQuery) result).clauses().size() + " does not equal: " + 2, ((BooleanQuery) result).clauses().size() == 2); }
public void testBoost() throws Exception { StandardAnalyzer oneStopAnalyzer = new StandardAnalyzer(new String[] {"on"}); QueryParserWrapper qp = new QueryParserWrapper("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); QueryParserWrapper qp2 = new QueryParserWrapper("field", new StandardAnalyzer()); q = qp2.parse("the^3"); // "the" is a stop word so the result is an empty query: assertNotNull(q); assertEquals("", q.toString()); assertEquals(1.0f, q.getBoost(), 0.01f); }
public void assertWildcardQueryEquals( String query, boolean lowercase, String result, boolean allowLeadingWildcard) throws Exception { QueryParserWrapper qp = getParser(null); qp.setLowercaseExpandedTerms(lowercase); qp.setAllowLeadingWildcard(allowLeadingWildcard); Query q = qp.parse(query); String s = q.toString("field"); if (!s.equals(result)) { fail("WildcardQuery /" + query + "/ yielded /" + s + "/, expecting /" + result + "/"); } }
public void testRange() throws Exception { assertQueryEquals("[ a TO z]", null, "[a TO z]"); assertEquals( MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT, ((TermRangeQuery) getQuery("[ a TO z]", null)).getRewriteMethod()); QueryParserWrapper qp = new QueryParserWrapper("field", new SimpleAnalyzer()); qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE); assertEquals( MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE, ((TermRangeQuery) qp.parse("[ a TO z]")).getRewriteMethod()); 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 Query getQueryDOA(String query, Analyzer a) throws Exception { if (a == null) a = new SimpleAnalyzer(); QueryParserWrapper qp = new QueryParserWrapper("field", a); qp.setDefaultOperator(QueryParserWrapper.AND_OPERATOR); return qp.parse(query); }
public Query getQueryAllowLeadingWildcard(String query, Analyzer a) throws Exception { QueryParserWrapper parser = getParser(a); parser.setAllowLeadingWildcard(true); return parser.parse(query); }