| /* |
| * 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. |
| */ |
| |
| package org.apache.lucene.monitor; |
| |
| import java.io.IOException; |
| |
| import org.apache.lucene.analysis.Analyzer; |
| import org.apache.lucene.analysis.TokenStream; |
| import org.apache.lucene.analysis.core.WhitespaceAnalyzer; |
| import org.apache.lucene.analysis.tokenattributes.TermToBytesRefAttribute; |
| import org.apache.lucene.document.Document; |
| import org.apache.lucene.document.Field; |
| import org.apache.lucene.document.FieldType; |
| import org.apache.lucene.index.IndexOptions; |
| import org.apache.lucene.index.Term; |
| import org.apache.lucene.search.BooleanClause; |
| import org.apache.lucene.search.BooleanQuery; |
| import org.apache.lucene.search.MatchAllDocsQuery; |
| import org.apache.lucene.search.Query; |
| import org.apache.lucene.search.TermQuery; |
| import org.apache.lucene.util.AttributeImpl; |
| import org.apache.lucene.util.AttributeReflector; |
| import org.apache.lucene.util.BytesRef; |
| |
| public abstract class PresearcherTestBase extends MonitorTestBase { |
| |
| public Monitor newMonitor() throws IOException { |
| return new Monitor(WHITESPACE, createPresearcher()); |
| } |
| |
| protected abstract Presearcher createPresearcher(); |
| |
| static final String TEXTFIELD = FIELD; |
| static final Analyzer WHITESPACE = new WhitespaceAnalyzer(); |
| |
| public static Document buildDoc(String field, String text) { |
| Document doc = new Document(); |
| doc.add(newTextField(field, text, Field.Store.NO)); |
| return doc; |
| } |
| |
| public void testNullFieldHandling() throws IOException { |
| try (Monitor monitor = newMonitor()) { |
| monitor.register(new MonitorQuery("1", parse("field_1:test"))); |
| |
| assertEquals(0, |
| monitor.match(buildDoc("field_2", "test"), QueryMatch.SIMPLE_MATCHER).getMatchCount()); |
| } |
| |
| } |
| |
| public void testEmptyMonitorHandling() throws IOException { |
| try (Monitor monitor = newMonitor()) { |
| MatchingQueries<QueryMatch> matches = monitor.match(buildDoc("field_2", "test"), QueryMatch.SIMPLE_MATCHER); |
| assertEquals(0, matches.getMatchCount()); |
| assertEquals(0, matches.getQueriesRun()); |
| } |
| } |
| |
| public void testMatchAllQueryHandling() throws IOException { |
| try (Monitor monitor = newMonitor()) { |
| monitor.register(new MonitorQuery("1", new MatchAllDocsQuery())); |
| assertEquals(1, |
| monitor.match(buildDoc("f", "wibble"), QueryMatch.SIMPLE_MATCHER).getMatchCount()); |
| } |
| } |
| |
| public void testNegativeQueryHandling() throws IOException { |
| Query q = new BooleanQuery.Builder() |
| .add(new MatchAllDocsQuery(), BooleanClause.Occur.SHOULD) |
| .add(new TermQuery(new Term("f", "foo")), BooleanClause.Occur.MUST_NOT) |
| .build(); |
| try (Monitor monitor = newMonitor()) { |
| monitor.register(new MonitorQuery("1", q)); |
| |
| MultiMatchingQueries<QueryMatch> matches = monitor.match(new Document[]{ |
| buildDoc("f", "bar"), buildDoc("f", "foo") |
| }, QueryMatch.SIMPLE_MATCHER); |
| assertEquals(1, matches.getMatchCount(0)); |
| assertEquals(0, matches.getMatchCount(1)); |
| } |
| } |
| |
| public void testAnyTokenHandling() throws IOException { |
| |
| try (Monitor monitor = newMonitor()) { |
| monitor.register(new MonitorQuery("1", new MatchAllDocsQuery())); |
| MatchingQueries<QueryMatch> matches = monitor.match(buildDoc("f", "wibble"), QueryMatch.SIMPLE_MATCHER); |
| assertEquals(1, matches.getMatchCount()); |
| assertEquals(1, matches.getQueriesRun()); |
| } |
| } |
| |
| private static final BytesRef NON_STRING_TERM = new BytesRef(new byte[]{60, 8, 0, 0, 0, 9}); |
| |
| static class BytesRefAttribute extends AttributeImpl implements TermToBytesRefAttribute { |
| |
| @Override |
| public BytesRef getBytesRef() { |
| return NON_STRING_TERM; |
| } |
| |
| @Override |
| public void clear() { |
| |
| } |
| |
| @Override |
| public void reflectWith(AttributeReflector attributeReflector) { |
| |
| } |
| |
| @Override |
| public void copyTo(AttributeImpl attribute) { |
| |
| } |
| } |
| |
| static final class NonStringTokenStream extends TokenStream { |
| |
| final TermToBytesRefAttribute att; |
| boolean done = false; |
| |
| NonStringTokenStream() { |
| addAttributeImpl(new BytesRefAttribute()); |
| this.att = addAttribute(TermToBytesRefAttribute.class); |
| } |
| |
| @Override |
| public boolean incrementToken() { |
| if (done) |
| return false; |
| return done = true; |
| } |
| } |
| |
| public void testNonStringTermHandling() throws IOException { |
| |
| FieldType ft = new FieldType(); |
| ft.setTokenized(true); |
| ft.setIndexOptions(IndexOptions.DOCS_AND_FREQS); |
| |
| try (Monitor monitor = newMonitor()) { |
| monitor.register(new MonitorQuery("1", new TermQuery(new Term("f", NON_STRING_TERM)))); |
| |
| Document doc = new Document(); |
| doc.add(new Field("f", new NonStringTokenStream(), ft)); |
| MatchingQueries<QueryMatch> m = monitor.match(doc, QueryMatch.SIMPLE_MATCHER); |
| assertEquals(1, m.getMatchCount()); |
| assertEquals(1, m.getQueriesRun()); |
| } |
| |
| } |
| |
| public static BooleanClause must(Query q) { |
| return new BooleanClause(q, BooleanClause.Occur.MUST); |
| } |
| |
| public static BooleanClause should(Query q) { |
| return new BooleanClause(q, BooleanClause.Occur.SHOULD); |
| } |
| |
| } |