src/Test/Search/TestExplanations.cs - lucenenet - Git at Google

 /*
  * 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 NUnit.Framework;

 using Document = Lucene.Net.Documents.Document;
 using Field = Lucene.Net.Documents.Field;
 using IndexReader = Lucene.Net.Index.IndexReader;
 using IndexWriter = Lucene.Net.Index.IndexWriter;
 using Term = Lucene.Net.Index.Term;
 using ParseException = Lucene.Net.QueryParsers.ParseException;
 using QueryParser = Lucene.Net.QueryParsers.QueryParser;
 using RAMDirectory = Lucene.Net.Store.RAMDirectory;
 using WhitespaceAnalyzer = Lucene.Net.Analysis.WhitespaceAnalyzer;
 using Lucene.Net.Search.Spans;
 using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;

 namespace Lucene.Net.Search
 {

 	/// <summary> Tests primative queries (ie: that rewrite to themselves) to
 	/// insure they match the expected set of docs, and that the score of each
 	/// match is equal to the value of the scores explanation.
 	///
 	/// <p>
 	/// The assumption is that if all of the "primative" queries work well,
 	/// then anythingthat rewrites to a primative will work well also.
 	/// </p>
 	///
 	/// </summary>
 	/// <seealso cref=""Subclasses for actual tests"">
 	/// </seealso>
 	[TestFixture]
 	public class TestExplanations : LuceneTestCase
 	{
 		protected internal IndexSearcher searcher;

 		public const System.String FIELD = "field";
 		public static readonly Lucene.Net.QueryParsers.QueryParser qp = new Lucene.Net.QueryParsers.QueryParser(FIELD, new WhitespaceAnalyzer());

 		[TearDown]
 		public override void TearDown()
 		{
 			base.TearDown();
 			if (searcher != null)
 			{
 				searcher.Close();
 				searcher = null;
 			}
 		}

 		[SetUp]
 		public override void SetUp()
 		{
 			base.SetUp();
 			RAMDirectory directory = new RAMDirectory();
 			IndexWriter writer = new IndexWriter(directory, new WhitespaceAnalyzer(), true);
 			for (int i = 0; i < docFields.Length; i++)
 			{
 				Document doc = new Document();
 				doc.Add(new Field(FIELD, docFields[i], Field.Store.NO, Field.Index.TOKENIZED));
 				writer.AddDocument(doc);
 			}
 			writer.Close();
 			searcher = new IndexSearcher(directory);
 		}

 		protected internal System.String[] docFields = new System.String[]{"w1 w2 w3 w4 w5", "w1 w3 w2 w3 zz", "w1 xx w2 yy w3", "w1 w3 xx w2 yy w3 zz"};

 		public virtual Query MakeQuery(System.String queryText)
 		{
 			return qp.Parse(queryText);
 		}

 		/// <summary>check the expDocNrs first, then check the query (and the explanations) </summary>
 		public virtual void  Qtest(System.String queryText, int[] expDocNrs)
 		{
 			Qtest(MakeQuery(queryText), expDocNrs);
 		}

 		/// <summary>check the expDocNrs first, then check the query (and the explanations) </summary>
 		public virtual void  Qtest(Query q, int[] expDocNrs)
 		{
 			CheckHits.CheckHitCollector(q, FIELD, searcher, expDocNrs);
 		}

 		/// <summary> Tests a query using qtest after wrapping it with both optB and reqB</summary>
 		/// <seealso cref="Qtest">
 		/// </seealso>
 		/// <seealso cref="ReqB">
 		/// </seealso>
 		/// <seealso cref="OptB">
 		/// </seealso>
 		public virtual void  Bqtest(Query q, int[] expDocNrs)
 		{
 			Qtest(ReqB(q), expDocNrs);
 			Qtest(OptB(q), expDocNrs);
 		}
 		/// <summary> Tests a query using qtest after wrapping it with both optB and reqB</summary>
 		/// <seealso cref="Qtest">
 		/// </seealso>
 		/// <seealso cref="ReqB">
 		/// </seealso>
 		/// <seealso cref="OptB">
 		/// </seealso>
 		public virtual void  Bqtest(System.String queryText, int[] expDocNrs)
 		{
 			Bqtest(MakeQuery(queryText), expDocNrs);
 		}

 		/// <summary>A filter that only lets the specified document numbers pass </summary>
 		[Serializable]
 		public class ItemizedFilter : Filter
 		{
 			internal int[] docs;
 			public ItemizedFilter(int[] docs)
 			{
 				this.docs = docs;
 			}
 			public override System.Collections.BitArray Bits(IndexReader r)
 			{
 				System.Collections.BitArray b = new System.Collections.BitArray((r.MaxDoc() % 64 == 0?r.MaxDoc() / 64:r.MaxDoc() / 64 + 1) * 64);
 				for (int i = 0; i < docs.Length; i++)
 				{
 					b.Set(docs[i], true);
 				}
 				return b;
 			}
 		}

 		/// <summary>helper for generating MultiPhraseQueries </summary>
 		public static Term[] Ta(System.String[] s)
 		{
 			Term[] t = new Term[s.Length];
 			for (int i = 0; i < s.Length; i++)
 			{
 				t[i] = new Term(FIELD, s[i]);
 			}
 			return t;
 		}

 		/// <summary>MACRO for SpanTermQuery </summary>
 		public virtual SpanTermQuery St(System.String s)
 		{
 			return new SpanTermQuery(new Term(FIELD, s));
 		}

 		/// <summary>MACRO for SpanNotQuery </summary>
 		public virtual SpanNotQuery Snot(SpanQuery i, SpanQuery e)
 		{
 			return new SpanNotQuery(i, e);
 		}

 		/// <summary>MACRO for SpanOrQuery containing two SpanTerm queries </summary>
 		public virtual SpanOrQuery Sor(System.String s, System.String e)
 		{
 			return Sor(St(s), St(e));
 		}
 		/// <summary>MACRO for SpanOrQuery containing two SpanQueries </summary>
 		public virtual SpanOrQuery Sor(SpanQuery s, SpanQuery e)
 		{
 			return new SpanOrQuery(new SpanQuery[]{s, e});
 		}

 		/// <summary>MACRO for SpanOrQuery containing three SpanTerm queries </summary>
 		public virtual SpanOrQuery Sor(System.String s, System.String m, System.String e)
 		{
 			return Sor(St(s), St(m), St(e));
 		}
 		/// <summary>MACRO for SpanOrQuery containing two SpanQueries </summary>
 		public virtual SpanOrQuery Sor(SpanQuery s, SpanQuery m, SpanQuery e)
 		{
 			return new SpanOrQuery(new SpanQuery[]{s, m, e});
 		}

 		/// <summary>MACRO for SpanNearQuery containing two SpanTerm queries </summary>
 		public virtual SpanNearQuery Snear(System.String s, System.String e, int slop, bool inOrder)
 		{
 			return Snear(St(s), St(e), slop, inOrder);
 		}
 		/// <summary>MACRO for SpanNearQuery containing two SpanQueries </summary>
 		public virtual SpanNearQuery Snear(SpanQuery s, SpanQuery e, int slop, bool inOrder)
 		{
 			return new SpanNearQuery(new SpanQuery[]{s, e}, slop, inOrder);
 		}


 		/// <summary>MACRO for SpanNearQuery containing three SpanTerm queries </summary>
 		public virtual SpanNearQuery Snear(System.String s, System.String m, System.String e, int slop, bool inOrder)
 		{
 			return Snear(St(s), St(m), St(e), slop, inOrder);
 		}
 		/// <summary>MACRO for SpanNearQuery containing three SpanQueries </summary>
 		public virtual SpanNearQuery Snear(SpanQuery s, SpanQuery m, SpanQuery e, int slop, bool inOrder)
 		{
 			return new SpanNearQuery(new SpanQuery[]{s, m, e}, slop, inOrder);
 		}

 		/// <summary>MACRO for SpanFirst(SpanTermQuery) </summary>
 		public virtual SpanFirstQuery Sf(System.String s, int b)
 		{
 			return new SpanFirstQuery(St(s), b);
 		}

 		/// <summary> MACRO: Wraps a Query in a BooleanQuery so that it is optional, along
 		/// with a second prohibited clause which will never match anything
 		/// </summary>
 		public virtual Query OptB(System.String q)
 		{
 			return OptB(MakeQuery(q));
 		}
 		/// <summary> MACRO: Wraps a Query in a BooleanQuery so that it is optional, along
 		/// with a second prohibited clause which will never match anything
 		/// </summary>
 		public virtual Query OptB(Query q)
 		{
 			BooleanQuery bq = new BooleanQuery(true);
 			bq.Add(q, BooleanClause.Occur.SHOULD);
 			bq.Add(new TermQuery(new Term("NEVER", "MATCH")), BooleanClause.Occur.MUST_NOT);
 			return bq;
 		}

 		/// <summary> MACRO: Wraps a Query in a BooleanQuery so that it is required, along
 		/// with a second optional clause which will match everything
 		/// </summary>
 		public virtual Query ReqB(System.String q)
 		{
 			return ReqB(MakeQuery(q));
 		}
 		/// <summary> MACRO: Wraps a Query in a BooleanQuery so that it is required, along
 		/// with a second optional clause which will match everything
 		/// </summary>
 		public virtual Query ReqB(Query q)
 		{
 			BooleanQuery bq = new BooleanQuery(true);
 			bq.Add(q, BooleanClause.Occur.MUST);
 			bq.Add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
 			return bq;
 		}

 		/// <summary> Placeholder: JUnit freaks if you don't have one test ... making
 		/// class abstract doesn't help
 		/// </summary>
 		[Test]
 		public virtual void  TestNoop()
 		{
 			/* NOOP */
 		}
 	}
 }
	/*
	* 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 NUnit.Framework;

	using Document = Lucene.Net.Documents.Document;
	using Field = Lucene.Net.Documents.Field;
	using IndexReader = Lucene.Net.Index.IndexReader;
	using IndexWriter = Lucene.Net.Index.IndexWriter;
	using Term = Lucene.Net.Index.Term;
	using ParseException = Lucene.Net.QueryParsers.ParseException;
	using QueryParser = Lucene.Net.QueryParsers.QueryParser;
	using RAMDirectory = Lucene.Net.Store.RAMDirectory;
	using WhitespaceAnalyzer = Lucene.Net.Analysis.WhitespaceAnalyzer;
	using Lucene.Net.Search.Spans;
	using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;

	namespace Lucene.Net.Search
	{

	/// <summary> Tests primative queries (ie: that rewrite to themselves) to
	/// insure they match the expected set of docs, and that the score of each
	/// match is equal to the value of the scores explanation.
	///
	/// <p>
	/// The assumption is that if all of the "primative" queries work well,
	/// then anythingthat rewrites to a primative will work well also.
	/// </p>
	///
	/// </summary>
	/// <seealso cref=""Subclasses for actual tests"">
	/// </seealso>
	[TestFixture]
	public class TestExplanations : LuceneTestCase
	{
	protected internal IndexSearcher searcher;

	public const System.String FIELD = "field";
	public static readonly Lucene.Net.QueryParsers.QueryParser qp = new Lucene.Net.QueryParsers.QueryParser(FIELD, new WhitespaceAnalyzer());

	[TearDown]
	public override void TearDown()
	{
	base.TearDown();
	if (searcher != null)
	{
	searcher.Close();
	searcher = null;
	}
	}

	[SetUp]
	public override void SetUp()
	{
	base.SetUp();
	RAMDirectory directory = new RAMDirectory();
	IndexWriter writer = new IndexWriter(directory, new WhitespaceAnalyzer(), true);
	for (int i = 0; i < docFields.Length; i++)
	{
	Document doc = new Document();
	doc.Add(new Field(FIELD, docFields[i], Field.Store.NO, Field.Index.TOKENIZED));
	writer.AddDocument(doc);
	}
	writer.Close();
	searcher = new IndexSearcher(directory);
	}

	protected internal System.String[] docFields = new System.String[]{"w1 w2 w3 w4 w5", "w1 w3 w2 w3 zz", "w1 xx w2 yy w3", "w1 w3 xx w2 yy w3 zz"};

	public virtual Query MakeQuery(System.String queryText)
	{
	return qp.Parse(queryText);
	}

	/// <summary>check the expDocNrs first, then check the query (and the explanations) </summary>
	public virtual void Qtest(System.String queryText, int[] expDocNrs)
	{
	Qtest(MakeQuery(queryText), expDocNrs);
	}

	/// <summary>check the expDocNrs first, then check the query (and the explanations) </summary>
	public virtual void Qtest(Query q, int[] expDocNrs)
	{
	CheckHits.CheckHitCollector(q, FIELD, searcher, expDocNrs);
	}

	/// <summary> Tests a query using qtest after wrapping it with both optB and reqB</summary>
	/// <seealso cref="Qtest">
	/// </seealso>
	/// <seealso cref="ReqB">
	/// </seealso>
	/// <seealso cref="OptB">
	/// </seealso>
	public virtual void Bqtest(Query q, int[] expDocNrs)
	{
	Qtest(ReqB(q), expDocNrs);
	Qtest(OptB(q), expDocNrs);
	}
	/// <summary> Tests a query using qtest after wrapping it with both optB and reqB</summary>
	/// <seealso cref="Qtest">
	/// </seealso>
	/// <seealso cref="ReqB">
	/// </seealso>
	/// <seealso cref="OptB">
	/// </seealso>
	public virtual void Bqtest(System.String queryText, int[] expDocNrs)
	{
	Bqtest(MakeQuery(queryText), expDocNrs);
	}

	/// <summary>A filter that only lets the specified document numbers pass </summary>
	[Serializable]
	public class ItemizedFilter : Filter
	{
	internal int[] docs;
	public ItemizedFilter(int[] docs)
	{
	this.docs = docs;
	}
	public override System.Collections.BitArray Bits(IndexReader r)
	{
	System.Collections.BitArray b = new System.Collections.BitArray((r.MaxDoc() % 64 == 0?r.MaxDoc() / 64:r.MaxDoc() / 64 + 1) * 64);
	for (int i = 0; i < docs.Length; i++)
	{
	b.Set(docs[i], true);
	}
	return b;
	}
	}

	/// <summary>helper for generating MultiPhraseQueries </summary>
	public static Term[] Ta(System.String[] s)
	{
	Term[] t = new Term[s.Length];
	for (int i = 0; i < s.Length; i++)
	{
	t[i] = new Term(FIELD, s[i]);
	}
	return t;
	}

	/// <summary>MACRO for SpanTermQuery </summary>
	public virtual SpanTermQuery St(System.String s)
	{
	return new SpanTermQuery(new Term(FIELD, s));
	}

	/// <summary>MACRO for SpanNotQuery </summary>
	public virtual SpanNotQuery Snot(SpanQuery i, SpanQuery e)
	{
	return new SpanNotQuery(i, e);
	}

	/// <summary>MACRO for SpanOrQuery containing two SpanTerm queries </summary>
	public virtual SpanOrQuery Sor(System.String s, System.String e)
	{
	return Sor(St(s), St(e));
	}
	/// <summary>MACRO for SpanOrQuery containing two SpanQueries </summary>
	public virtual SpanOrQuery Sor(SpanQuery s, SpanQuery e)
	{
	return new SpanOrQuery(new SpanQuery[]{s, e});
	}

	/// <summary>MACRO for SpanOrQuery containing three SpanTerm queries </summary>
	public virtual SpanOrQuery Sor(System.String s, System.String m, System.String e)
	{
	return Sor(St(s), St(m), St(e));
	}
	/// <summary>MACRO for SpanOrQuery containing two SpanQueries </summary>
	public virtual SpanOrQuery Sor(SpanQuery s, SpanQuery m, SpanQuery e)
	{
	return new SpanOrQuery(new SpanQuery[]{s, m, e});
	}

	/// <summary>MACRO for SpanNearQuery containing two SpanTerm queries </summary>
	public virtual SpanNearQuery Snear(System.String s, System.String e, int slop, bool inOrder)
	{
	return Snear(St(s), St(e), slop, inOrder);
	}
	/// <summary>MACRO for SpanNearQuery containing two SpanQueries </summary>
	public virtual SpanNearQuery Snear(SpanQuery s, SpanQuery e, int slop, bool inOrder)
	{
	return new SpanNearQuery(new SpanQuery[]{s, e}, slop, inOrder);
	}


	/// <summary>MACRO for SpanNearQuery containing three SpanTerm queries </summary>
	public virtual SpanNearQuery Snear(System.String s, System.String m, System.String e, int slop, bool inOrder)
	{
	return Snear(St(s), St(m), St(e), slop, inOrder);
	}
	/// <summary>MACRO for SpanNearQuery containing three SpanQueries </summary>
	public virtual SpanNearQuery Snear(SpanQuery s, SpanQuery m, SpanQuery e, int slop, bool inOrder)
	{
	return new SpanNearQuery(new SpanQuery[]{s, m, e}, slop, inOrder);
	}

	/// <summary>MACRO for SpanFirst(SpanTermQuery) </summary>
	public virtual SpanFirstQuery Sf(System.String s, int b)
	{
	return new SpanFirstQuery(St(s), b);
	}

	/// <summary> MACRO: Wraps a Query in a BooleanQuery so that it is optional, along
	/// with a second prohibited clause which will never match anything
	/// </summary>
	public virtual Query OptB(System.String q)
	{
	return OptB(MakeQuery(q));
	}
	/// <summary> MACRO: Wraps a Query in a BooleanQuery so that it is optional, along
	/// with a second prohibited clause which will never match anything
	/// </summary>
	public virtual Query OptB(Query q)
	{
	BooleanQuery bq = new BooleanQuery(true);
	bq.Add(q, BooleanClause.Occur.SHOULD);
	bq.Add(new TermQuery(new Term("NEVER", "MATCH")), BooleanClause.Occur.MUST_NOT);
	return bq;
	}

	/// <summary> MACRO: Wraps a Query in a BooleanQuery so that it is required, along
	/// with a second optional clause which will match everything
	/// </summary>
	public virtual Query ReqB(System.String q)
	{
	return ReqB(MakeQuery(q));
	}
	/// <summary> MACRO: Wraps a Query in a BooleanQuery so that it is required, along
	/// with a second optional clause which will match everything
	/// </summary>
	public virtual Query ReqB(Query q)
	{
	BooleanQuery bq = new BooleanQuery(true);
	bq.Add(q, BooleanClause.Occur.MUST);
	bq.Add(new TermQuery(new Term(FIELD, "w1")), BooleanClause.Occur.SHOULD);
	return bq;
	}

	/// <summary> Placeholder: JUnit freaks if you don't have one test ... making
	/// class abstract doesn't help
	/// </summary>
	[Test]
	public virtual void TestNoop()
	{
	/* NOOP */
	}
	}
	}