public virtual void TestWhitespace() { Analyzer a = new MockAnalyzer(Random()); AssertAnalyzesTo(a, "A bc defg hiJklmn opqrstuv wxy z ", new string[] { "a", "bc", "defg", "hijklmn", "opqrstuv", "wxy", "z" }); AssertAnalyzesTo(a, "aba cadaba shazam", new string[] { "aba", "cadaba", "shazam" }); AssertAnalyzesTo(a, "break on whitespace", new string[] { "break", "on", "whitespace" }); }
public override void SetUp() { base.SetUp(); _dir = NewDirectory(); _indexWriter = new RandomIndexWriter(Random(), _dir, new MockAnalyzer(Random()), Similarity, TimeZone); FieldType ft = new FieldType(TextField.TYPE_STORED); ft.StoreTermVectors = true; ft.StoreTermVectorOffsets = true; ft.StoreTermVectorPositions = true; Analyzer analyzer = new MockAnalyzer(Random()); Document doc; for (int i = 0; i < 100; i++) { doc = new Document(); doc.Add(new Field(_idFieldName, Random().toString(), ft)); doc.Add(new Field(_textFieldName, new StringBuilder(Random().toString()).append(Random().toString()).append( Random().toString()).toString(), ft)); doc.Add(new Field(_classFieldName, Random().toString(), ft)); _indexWriter.AddDocument(doc, analyzer); } _indexWriter.Commit(); _originalIndex = SlowCompositeReaderWrapper.Wrap(_indexWriter.Reader); }
public void CreateIndex() { Analyzer analyzer = new MockAnalyzer(Random()); IndexWriter writer = new IndexWriter (dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer)); try { for (int docid = 0; docid < NUM_DOCS; docid++) { Document d = new Document(); d.Add(NewStringField("docid", "" + docid, Field.Store.YES)); d.Add(NewStringField("never_load", "fail", Field.Store.YES)); foreach (string f in FIELDS) { for (int val = 0; val < NUM_VALUES; val++) { d.Add(NewStringField(f, docid + "_" + f + "_" + val, Field.Store.YES)); } } d.Add(NewStringField("load_later", "yes", Field.Store.YES)); writer.AddDocument(d); } } finally { writer.Dispose(); } }
public virtual QueryParser GetParser(Analyzer a) { if (a == null) a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true); QueryParser qp = new QueryParser(TEST_VERSION_CURRENT, DefaultField, a); qp.DefaultOperator = (QueryParserBase.OR_OPERATOR); return qp; }
public virtual void TestSimple() { Analyzer a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true); AssertAnalyzesTo(a, "a-bc123 defg+hijklmn567opqrstuv78wxy_z ", new string[] { "a", "bc", "defg", "hijklmn", "opqrstuv", "wxy", "z" }); AssertAnalyzesTo(a, "aba4cadaba-Shazam", new string[] { "aba", "cadaba", "shazam" }); AssertAnalyzesTo(a, "break+on/Letters", new string[] { "break", "on", "letters" }); }
public StandardQueryParser GetParser(Analyzer a) { if (a == null) a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true); StandardQueryParser qp = new StandardQueryParser(a); qp.DefaultOperator = (Operator.OR); return qp; }
public Classic.QueryParser GetParser(Analyzer a, Extensions extensions) { if (a == null) a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true); Classic.QueryParser qp = extensions == null ? new ExtendableQueryParser( TEST_VERSION_CURRENT, DefaultField, a) : new ExtendableQueryParser( TEST_VERSION_CURRENT, DefaultField, a, extensions); qp.DefaultOperator = QueryParserBase.OR_OPERATOR; return qp; }
public virtual void TestKeyword() { Analyzer a = new MockAnalyzer(Random(), MockTokenizer.KEYWORD, false); AssertAnalyzesTo(a, "a-bc123 defg+hijklmn567opqrstuv78wxy_z ", new string[] { "a-bc123 defg+hijklmn567opqrstuv78wxy_z " }); AssertAnalyzesTo(a, "aba4cadaba-Shazam", new string[] { "aba4cadaba-Shazam" }); AssertAnalyzesTo(a, "break+on/Nothing", new string[] { "break+on/Nothing" }); // currently though emits no tokens for empty string: maybe we can do it, // but we don't want to emit tokens infinitely... AssertAnalyzesTo(a, "", new string[0]); }
private void DoTest(Random random, TextWriter @out, bool useCompoundFiles, int MAX_DOCS) { Store.Directory directory = NewDirectory(); Analyzer analyzer = new MockAnalyzer(random); IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer); MergePolicy mp = conf.MergePolicy; mp.NoCFSRatio = useCompoundFiles ? 1.0 : 0.0; IndexWriter writer = new IndexWriter(directory, conf); if (VERBOSE) { Console.WriteLine("TEST: now build index MAX_DOCS=" + MAX_DOCS); } for (int j = 0; j < MAX_DOCS; j++) { Documents.Document d = new Documents.Document(); d.Add(NewTextField(PRIORITY_FIELD, HIGH_PRIORITY, Field.Store.YES)); d.Add(NewTextField(ID_FIELD, Convert.ToString(j), Field.Store.YES)); writer.AddDocument(d); } writer.Dispose(); // try a search without OR IndexReader reader = DirectoryReader.Open(directory); IndexSearcher searcher = NewSearcher(reader); Query query = new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY)); @out.WriteLine("Query: " + query.ToString(PRIORITY_FIELD)); if (VERBOSE) { Console.WriteLine("TEST: search query=" + query); } Sort sort = new Sort(SortField.FIELD_SCORE, new SortField(ID_FIELD, SortField.Type_e.INT)); ScoreDoc[] hits = searcher.Search(query, null, MAX_DOCS, sort).ScoreDocs; PrintHits(@out, hits, searcher); CheckHits(hits, MAX_DOCS, searcher); // try a new search with OR searcher = NewSearcher(reader); hits = null; BooleanQuery booleanQuery = new BooleanQuery(); booleanQuery.Add(new TermQuery(new Term(PRIORITY_FIELD, HIGH_PRIORITY)), BooleanClause.Occur.SHOULD); booleanQuery.Add(new TermQuery(new Term(PRIORITY_FIELD, MED_PRIORITY)), BooleanClause.Occur.SHOULD); @out.WriteLine("Query: " + booleanQuery.ToString(PRIORITY_FIELD)); hits = searcher.Search(booleanQuery, null, MAX_DOCS, sort).ScoreDocs; PrintHits(@out, hits, searcher); CheckHits(hits, MAX_DOCS, searcher); reader.Dispose(); directory.Dispose(); }
public virtual void TestNegativeQueryBoost() { Query q = new TermQuery(new Term("foo", "bar")); q.Boost = -42f; Assert.AreEqual(-42f, q.Boost, 0.0f); Store.Directory directory = NewDirectory(); try { Analyzer analyzer = new MockAnalyzer(Random()); IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer); IndexWriter writer = new IndexWriter(directory, conf); try { Documents.Document d = new Documents.Document(); d.Add(NewTextField("foo", "bar", Field.Store.YES)); writer.AddDocument(d); } finally { writer.Dispose(); } IndexReader reader = DirectoryReader.Open(directory); try { IndexSearcher searcher = NewSearcher(reader); ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs; Assert.AreEqual(1, hits.Length); Assert.IsTrue(hits[0].Score < 0, "score is not negative: " + hits[0].Score); Explanation explain = searcher.Explain(q, hits[0].Doc); Assert.AreEqual(hits[0].Score, explain.Value, 0.001f, "score doesn't match explanation"); Assert.IsTrue(explain.IsMatch, "explain doesn't think doc is a match"); } finally { reader.Dispose(); } } finally { directory.Dispose(); } }
public override void SetUp() { base.SetUp(); dir = NewDirectory(); MockAnalyzer analyzer = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true); IndexWriterConfig config = NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer); config.SetMergePolicy(NewLogMergePolicy()); config.SetSimilarity(new TestSimilarity()); RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, config); Document doc = new Document(); Field foo = NewTextField("foo", "", Field.Store.NO); doc.Add(foo); for (int i = 0; i < 100; i++) { foo.StringValue = AddValue(); writer.AddDocument(doc); } reader = writer.Reader; writer.Dispose(); }
public virtual void TestChangeGaps() { // LUCENE-5324: check that it is possible to change the wrapper's gaps int positionGap = Random().Next(1000); int offsetGap = Random().Next(1000); Analyzer @delegate = new MockAnalyzer(Random()); Analyzer a = new AnalyzerWrapperAnonymousInnerClassHelper2(this, @delegate.Strategy, positionGap, offsetGap, @delegate); RandomIndexWriter writer = new RandomIndexWriter(Random(), NewDirectory()); Document doc = new Document(); FieldType ft = new FieldType(); ft.Indexed = true; ft.IndexOptions = FieldInfo.IndexOptions.DOCS_ONLY; ft.Tokenized = true; ft.StoreTermVectors = true; ft.StoreTermVectorPositions = true; ft.StoreTermVectorOffsets = true; doc.Add(new Field("f", "a", ft)); doc.Add(new Field("f", "a", ft)); writer.AddDocument(doc, a); AtomicReader reader = GetOnlySegmentReader(writer.Reader); Fields fields = reader.GetTermVectors(0); Terms terms = fields.Terms("f"); TermsEnum te = terms.Iterator(null); Assert.AreEqual(new BytesRef("a"), te.Next()); DocsAndPositionsEnum dpe = te.DocsAndPositions(null, null); Assert.AreEqual(0, dpe.NextDoc()); Assert.AreEqual(2, dpe.Freq()); Assert.AreEqual(0, dpe.NextPosition()); Assert.AreEqual(0, dpe.StartOffset()); int endOffset = dpe.EndOffset(); Assert.AreEqual(1 + positionGap, dpe.NextPosition()); Assert.AreEqual(1 + endOffset + offsetGap, dpe.EndOffset()); Assert.AreEqual(null, te.Next()); reader.Dispose(); writer.Dispose(); writer.w.Directory.Dispose(); }
public virtual void TestUppercase() { CharacterRunAutomaton single = new CharacterRunAutomaton((new RegExp("[A-Z][a-z]*")).ToAutomaton()); Analyzer a = new MockAnalyzer(Random(), single, false); AssertAnalyzesTo(a, "FooBarBAZ", new string[] { "Foo", "Bar", "B", "A", "Z" }, new int[] { 0, 3, 6, 7, 8 }, new int[] { 3, 6, 7, 8, 9 }); AssertAnalyzesTo(a, "aFooBar", new string[] { "Foo", "Bar" }, new int[] { 1, 4 }, new int[] { 4, 7 }); CheckRandomData(Random(), a, 100); }
public virtual void TestWrapReader() { // LUCENE-5153: test that wrapping an analyzer's reader is allowed Random random = Random(); Analyzer @delegate = new MockAnalyzer(random); Analyzer a = new AnalyzerWrapperAnonymousInnerClassHelper(this, @delegate.Strategy, @delegate); CheckOneTerm(a, "abc", "aabc"); }
public virtual void TestStop() { Analyzer a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true, MockTokenFilter.ENGLISH_STOPSET); AssertAnalyzesTo(a, "the quick brown a fox", new string[] { "quick", "brown", "fox" }, new int[] { 2, 1, 2 }); }
public virtual void TestTwoChars() { CharacterRunAutomaton single = new CharacterRunAutomaton((new RegExp("..")).ToAutomaton()); Analyzer a = new MockAnalyzer(Random(), single, false); AssertAnalyzesTo(a, "foobar", new string[] { "fo", "ob", "ar" }, new int[] { 0, 2, 4 }, new int[] { 2, 4, 6 }); // make sure when last term is a "partial" match that End() is correct AssertTokenStreamContents(a.TokenStream("bogus", new StringReader("fooba")), new string[] { "fo", "ob" }, new int[] { 0, 2 }, new int[] { 2, 4 }, new int[] { 1, 1 }, new int?(5)); CheckRandomData(Random(), a, 100); }
public virtual void TestStop() { Analyzer a = new MockAnalyzer(Random, MockTokenizer.SIMPLE, true, MockTokenFilter.ENGLISH_STOPSET); AssertAnalyzesTo(a, "the quick brown a fox", new string[] { "quick", "brown", "fox" }, new int[] { 2, 1, 2 }); }
public Query GetQueryDOA(String query, Analyzer a) { if (a == null) a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true); StandardQueryParser qp = new StandardQueryParser(); qp.Analyzer = (a); qp.DefaultOperator = (StandardQueryConfigHandler.Operator.AND); return qp.Parse(query, "field"); }
public virtual void TestKeep() { CharacterRunAutomaton keepWords = new CharacterRunAutomaton(BasicOperations.Complement(Automaton.Union(Arrays.AsList(BasicAutomata.MakeString("foo"), BasicAutomata.MakeString("bar"))))); Analyzer a = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true, keepWords); AssertAnalyzesTo(a, "quick foo brown bar bar fox foo", new string[] { "foo", "bar", "bar", "foo" }, new int[] { 2, 2, 1, 2 }); }
public virtual void TestLength() { CharacterRunAutomaton length5 = new CharacterRunAutomaton((new RegExp(".{5,}")).ToAutomaton()); Analyzer a = new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, true, length5); AssertAnalyzesTo(a, "ok toolong fine notfine", new string[] { "ok", "fine" }, new int[] { 1, 2 }); }
public void TestQueryStringEscaping() { Analyzer a = new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false); 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 \\&\\&"); }
public virtual void TestForwardOffsets() { int num = AtLeast(10000); for (int i = 0; i < num; i++) { string s = TestUtil.RandomHtmlishString(Random(), 20); StringReader reader = new StringReader(s); MockCharFilter charfilter = new MockCharFilter(reader, 2); MockAnalyzer analyzer = new MockAnalyzer(Random()); Exception priorException = null; TokenStream ts = analyzer.TokenStream("bogus", charfilter.input); try { ts.Reset(); while (ts.IncrementToken()) { ; } ts.End(); } catch (Exception e) { priorException = e; } finally { IOUtils.CloseWhileHandlingException(priorException, ts); } } }
public override void TestEscapedVsQuestionMarkAsWildcard() { Analyzer a = new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false); 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"); }
public 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 MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false); 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 TestPunct() { Analyzer a = new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false); AssertQueryEquals("a&b", a, "a&b"); AssertQueryEquals("a&&b", a, "a&&b"); AssertQueryEquals(".NET", a, ".NET"); }
/** helper to parse a query with keyword analyzer across "field" */ private Query ParseKeyword(string text, int flags) { Analyzer analyzer = new MockAnalyzer(Random(), MockTokenizer.KEYWORD, false); SimpleQueryParser parser = new SimpleQueryParser(analyzer, new HashMap<string, float>() { { "field", 1f } }, flags); return parser.Parse(text); }
public virtual void TestLUCENE_3042() { string testString = "t"; Analyzer analyzer = new MockAnalyzer(Random()); Exception priorException = null; TokenStream stream = analyzer.TokenStream("dummy", new StringReader(testString)); try { stream.Reset(); while (stream.IncrementToken()) { // consume } stream.End(); } catch (Exception e) { priorException = e; } finally { IOUtils.CloseWhileHandlingException(priorException, stream); } AssertAnalyzesTo(analyzer, testString, new string[] { "t" }); }
public void TestStopWordSearching() { Analyzer analyzer = new MockAnalyzer(Random()); Store.Directory ramDir = NewDirectory(); IndexWriter iw = new IndexWriter(ramDir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer)); Document doc = new Document(); doc.Add(NewTextField("body", "blah the footest blah", Field.Store.NO)); iw.AddDocument(doc); iw.Dispose(); StandardQueryParser mfqp = new StandardQueryParser(); mfqp.SetMultiFields(new String[] { "body" }); mfqp.Analyzer = (analyzer); mfqp.DefaultOperator = (StandardQueryConfigHandler.Operator.AND); Query q = mfqp.Parse("the footest", null); IndexReader ir = DirectoryReader.Open(ramDir); IndexSearcher @is = NewSearcher(ir); ScoreDoc[] hits = @is.Search(q, null, 1000).ScoreDocs; assertEquals(1, hits.Length); ir.Dispose(); ramDir.Dispose(); }
public virtual void TestSingleChar() { var single = new CharacterRunAutomaton((new RegExp(".")).ToAutomaton()); Analyzer a = new MockAnalyzer(Random(), single, false); AssertAnalyzesTo(a, "foobar", new[] { "f", "o", "o", "b", "a", "r" }, new[] { 0, 1, 2, 3, 4, 5 }, new[] { 1, 2, 3, 4, 5, 6 }); CheckRandomData(Random(), a, 100); }
public void TestEscaped() { Analyzer a = new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false); /* * 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, "*"); 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~2"); AssertQueryEquals("a:b\\+c~", a, "a:b+c~2"); AssertQueryEquals("a:b\\:c~", a, "a:b:c~2"); AssertQueryEquals("a:b\\\\c~", a, "a:b\\c~2"); // TODO: implement Range queries on QueryParser 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"); AssertQueryNodeException("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\""); AssertQueryNodeException("XY\\u005G"); // test non-hex character in escaped // unicode sequence AssertQueryNodeException("XY\\u005"); // test incomplete escaped unicode // sequence // Tests bug LUCENE-800 AssertQueryEquals("(item:\\\\ item:ABCD\\\\)", a, "item:\\ item:ABCD\\"); AssertQueryNodeException("(item:\\\\ item:ABCD\\\\))"); // unmatched closing // paranthesis AssertQueryEquals("\\*", a, "*"); AssertQueryEquals("\\\\", a, "\\"); // escaped backslash AssertQueryNodeException("\\"); // a backslash must always be escaped // LUCENE-1189 AssertQueryEquals("(\"a\\\\\") or (\"b\")", a, "a\\ or b"); }
public void TestBoost() { CharacterRunAutomaton stopSet = new CharacterRunAutomaton(BasicAutomata.MakeString("on")); Analyzer oneStopAnalyzer = new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true, stopSet); StandardQueryParser qp = new StandardQueryParser(); qp.Analyzer = (oneStopAnalyzer); Query q = qp.Parse("on^1.0", "field"); assertNotNull(q); q = qp.Parse("\"hello\"^2.0", "field"); assertNotNull(q); assertEquals(q.Boost, (float)2.0, (float)0.5); q = qp.Parse("hello^2.0", "field"); assertNotNull(q); assertEquals(q.Boost, (float)2.0, (float)0.5); q = qp.Parse("\"on\"^1.0", "field"); assertNotNull(q); StandardQueryParser qp2 = new StandardQueryParser(); qp2.Analyzer = (new MockAnalyzer(Random(), MockTokenizer.SIMPLE, true, MockTokenFilter.ENGLISH_STOPSET)); q = qp2.Parse("the^3", "field"); // "the" is a stop word so the result is an empty query: assertNotNull(q); assertEquals("", q.toString()); assertEquals(1.0f, q.Boost, 0.01f); }