You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by sy...@apache.org on 2015/02/09 03:03:05 UTC

lucenenet git commit: Adding Lucene.Net.Tests.Queries

Repository: lucenenet
Updated Branches:
  refs/heads/master c9f901b24 -> d5f61fd3b


Adding Lucene.Net.Tests.Queries

Still need to port more tests there


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/d5f61fd3
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/d5f61fd3
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/d5f61fd3

Branch: refs/heads/master
Commit: d5f61fd3b8f65b2fa4d294bc477628a7a9f95591
Parents: c9f901b
Author: Itamar Syn-Hershko <it...@code972.com>
Authored: Mon Feb 9 04:02:46 2015 +0200
Committer: Itamar Syn-Hershko <it...@code972.com>
Committed: Mon Feb 9 04:02:46 2015 +0200

----------------------------------------------------------------------
 Lucene.Net.sln                                  |  12 +
 .../Util/LuceneTestCase.cs                      |   5 +
 .../BooleanFilterTest.cs                        | 378 +++++++++++++++++++
 .../Lucene.Net.Tests.Queries.csproj             |  78 ++++
 .../Properties/AssemblyInfo.cs                  |  36 ++
 src/Lucene.Net.Tests.Queries/TermFilterTest.cs  | 179 +++++++++
 src/Lucene.Net.Tests.Queries/packages.config    |   4 +
 7 files changed, 692 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d5f61fd3/Lucene.Net.sln
----------------------------------------------------------------------
diff --git a/Lucene.Net.sln b/Lucene.Net.sln
index 8fe7746..e50e6a5 100644
--- a/Lucene.Net.sln
+++ b/Lucene.Net.sln
@@ -32,6 +32,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lucene.Net.Expressions", "s
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lucene.Net.Tests.Expressions", "src\Lucene.Net.Tests.Expressions\Lucene.Net.Tests.Expressions.csproj", "{F4873D95-4300-4E83-AFFA-EF796495D0F0}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Lucene.Net.Tests.Queries", "src\Lucene.Net.Tests.Queries\Lucene.Net.Tests.Queries.csproj", "{D7276EA2-71BE-4208-889B-B1BD48DBE023}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -143,6 +145,16 @@ Global
 		{F4873D95-4300-4E83-AFFA-EF796495D0F0}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{F4873D95-4300-4E83-AFFA-EF796495D0F0}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{F4873D95-4300-4E83-AFFA-EF796495D0F0}.Release|x86.ActiveCfg = Release|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{D7276EA2-71BE-4208-889B-B1BD48DBE023}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d5f61fd3/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
index ed0a17d..2619d85 100644
--- a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
@@ -611,6 +611,11 @@ namespace Lucene.Net.Util
             //return RandomizedContext.Current.Random;
         }
 
+        protected static Random randon()
+        {
+            return Random();
+        }
+
         [ThreadStatic]
         private static Random _random;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d5f61fd3/src/Lucene.Net.Tests.Queries/BooleanFilterTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Queries/BooleanFilterTest.cs b/src/Lucene.Net.Tests.Queries/BooleanFilterTest.cs
new file mode 100644
index 0000000..2bd949a
--- /dev/null
+++ b/src/Lucene.Net.Tests.Queries/BooleanFilterTest.cs
@@ -0,0 +1,378 @@
+using Lucene.Net.Analysis;
+using Lucene.Net.Documents;
+using Lucene.Net.Index;
+using Lucene.Net.Queries;
+using Lucene.Net.Search;
+using Lucene.Net.Store;
+using Lucene.Net.Util;
+using NUnit.Framework;
+
+namespace Lucene.Net.Tests.Queries
+{
+    public class BooleanFilterTest : LuceneTestCase
+    {
+        private Directory directory;
+        private AtomicReader reader;
+
+        [SetUp]
+        public override void SetUp()
+        {
+            base.SetUp();
+            directory = NewDirectory();
+            RandomIndexWriter writer = new RandomIndexWriter(Random(), directory, new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false));
+
+            AddDoc(writer, @"admin guest", @"010", @"20040101", @"Y");
+            AddDoc(writer, @"guest", @"020", @"20040101", @"Y");
+            AddDoc(writer, @"guest", @"020", @"20050101", @"Y");
+            AddDoc(writer, @"admin", @"020", @"20050101", @"Maybe");
+            AddDoc(writer, @"admin guest", @"030", @"20050101", @"N");
+            reader = SlowCompositeReaderWrapper.Wrap(writer.Reader);
+            writer.Dispose();
+        }
+
+        [TearDown]
+        public override void TearDown()
+        {
+            reader.Dispose();
+            directory.Dispose();
+            base.TearDown();
+        }
+
+        private void AddDoc(RandomIndexWriter writer, string accessRights, string price, string date, string inStock)
+        {
+            Document doc = new Document();
+            doc.Add(NewTextField(@"accessRights", accessRights, Field.Store.YES));
+            doc.Add(NewTextField(@"price", price, Field.Store.YES));
+            doc.Add(NewTextField(@"date", date, Field.Store.YES));
+            doc.Add(NewTextField(@"inStock", inStock, Field.Store.YES));
+            writer.AddDocument(doc);
+        }
+
+        private Filter GetRangeFilter(string field, string lowerPrice, string upperPrice)
+        {
+            Filter f = TermRangeFilter.NewStringRange(field, lowerPrice, upperPrice, true, true);
+            return f;
+        }
+
+        private Filter GetTermsFilter(string field, string text)
+        {
+            return new TermsFilter(new Term(field, text));
+        }
+
+        private Filter GetWrappedTermQuery(string field, string text)
+        {
+            return new QueryWrapperFilter(new TermQuery(new Term(field, text)));
+        }
+
+        private Filter GetEmptyFilter()
+        {
+            return new AnonymousFilter(this);
+        }
+
+        private sealed class AnonymousFilter : Filter
+        {
+            public AnonymousFilter(BooleanFilterTest parent)
+            {
+                this.parent = parent;
+            }
+
+            private readonly BooleanFilterTest parent;
+            public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
+            {
+                return new FixedBitSet(context.AtomicReader.MaxDoc);
+            }
+        }
+
+        private Filter GetNullDISFilter()
+        {
+            return new AnonymousFilter1(this);
+        }
+
+        private sealed class AnonymousFilter1 : Filter
+        {
+            public AnonymousFilter1(BooleanFilterTest parent)
+            {
+                this.parent = parent;
+            }
+
+            private readonly BooleanFilterTest parent;
+            public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
+            {
+                return null;
+            }
+        }
+
+        private Filter GetNullDISIFilter()
+        {
+            return new AnonymousFilter2(this);
+        }
+
+        private sealed class AnonymousDocIdSet : DocIdSet
+        {
+            public override DocIdSetIterator GetIterator()
+            {
+                return null;
+            }
+
+            public override bool Cacheable
+            {
+                get
+                {
+                    {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        private sealed class AnonymousFilter2 : Filter
+        {
+            public AnonymousFilter2(BooleanFilterTest parent)
+            {
+                this.parent = parent;
+            }
+
+            private readonly BooleanFilterTest parent;
+            public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
+            {
+                return new AnonymousDocIdSet();
+            }
+        }
+
+        [Test]
+        private void TstFilterCard(string mes, int expected, Filter filt)
+        {
+            DocIdSet docIdSet = filt.GetDocIdSet(reader.AtomicContext, reader.LiveDocs);
+            int actual = 0;
+            if (docIdSet != null)
+            {
+                DocIdSetIterator disi = docIdSet.GetIterator();
+                while (disi.NextDoc() != DocIdSetIterator.NO_MORE_DOCS)
+                {
+                    actual++;
+                }
+            }
+
+            assertEquals(mes, expected, actual);
+        }
+
+        [Test]
+        public void TestShould()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.SHOULD);
+            TstFilterCard(@"Should retrieves only 1 doc", 1, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetWrappedTermQuery(@"price", @"030"), BooleanClause.Occur.SHOULD);
+            TstFilterCard(@"Should retrieves only 1 doc", 1, booleanFilter);
+        }
+
+        [Test]
+        public void TestShoulds()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
+            TstFilterCard(@"Shoulds are Ored together", 5, booleanFilter);
+        }
+
+        [Test]
+        public void TestShouldsAndMustNot()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"Shoulds Ored but AndNot", 4, booleanFilter);
+            booleanFilter.Add(GetTermsFilter(@"inStock", @"Maybe"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"Shoulds Ored but AndNots", 3, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"Shoulds Ored but AndNot", 4, booleanFilter);
+            booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"Maybe"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"Shoulds Ored but AndNots", 3, booleanFilter);
+        }
+
+        [Test]
+        public void TestShouldsAndMust()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            TstFilterCard(@"Shoulds Ored but MUST", 3, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetWrappedTermQuery(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            TstFilterCard(@"Shoulds Ored but MUST", 3, booleanFilter);
+        }
+
+        [Test]
+        public void TestShouldsAndMusts()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetRangeFilter(@"price", @"010", @"020"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetRangeFilter(@"price", @"020", @"030"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetRangeFilter(@"date", @"20040101", @"20041231"), BooleanClause.Occur.MUST);
+            TstFilterCard(@"Shoulds Ored but MUSTs ANDED", 1, booleanFilter);
+        }
+
+        [Test]
+        public void TestShouldsAndMustsAndMustNot()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetRangeFilter(@"price", @"030", @"040"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetRangeFilter(@"date", @"20050101", @"20051231"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"Shoulds Ored but MUSTs ANDED and MustNot", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetRangeFilter(@"price", @"030", @"040"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetWrappedTermQuery(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetRangeFilter(@"date", @"20050101", @"20051231"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"Shoulds Ored but MUSTs ANDED and MustNot", 0, booleanFilter);
+        }
+
+        [Test]
+        public void TestJustMust()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            TstFilterCard(@"MUST", 3, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetWrappedTermQuery(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            TstFilterCard(@"MUST", 3, booleanFilter);
+        }
+
+        [Test]
+        public void TestJustMustNot()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"MUST_NOT", 4, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"MUST_NOT", 4, booleanFilter);
+        }
+
+        [Test]
+        public void TestMustAndMustNot()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"MUST_NOT wins over MUST for same docs", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetWrappedTermQuery(@"inStock", @"N"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetWrappedTermQuery(@"price", @"030"), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"MUST_NOT wins over MUST for same docs", 0, booleanFilter);
+        }
+
+        [Test]
+        public void TestEmpty()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            TstFilterCard(@"empty BooleanFilter returns no results", 0, booleanFilter);
+        }
+
+        [Test]
+        public void TestCombinedNullDocIdSets()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.MUST);
+            TstFilterCard(@"A MUST filter that returns a null DIS should never return documents", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.MUST);
+            TstFilterCard(@"A MUST filter that returns a null DISI should never return documents", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.SHOULD);
+            TstFilterCard(@"A SHOULD filter that returns a null DIS should be invisible", 1, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.SHOULD);
+            TstFilterCard(@"A SHOULD filter that returns a null DISI should be invisible", 1, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"A MUST_NOT filter that returns a null DIS should be invisible", 1, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"price", @"030"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"A MUST_NOT filter that returns a null DISI should be invisible", 1, booleanFilter);
+        }
+
+        [Test]
+        public void TestJustNullDocIdSets()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.MUST);
+            TstFilterCard(@"A MUST filter that returns a null DIS should never return documents", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.MUST);
+            TstFilterCard(@"A MUST filter that returns a null DISI should never return documents", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.SHOULD);
+            TstFilterCard(@"A single SHOULD filter that returns a null DIS should never return documents", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.SHOULD);
+            TstFilterCard(@"A single SHOULD filter that returns a null DISI should never return documents", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"A single MUST_NOT filter that returns a null DIS should be invisible", 5, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.MUST_NOT);
+            TstFilterCard(@"A single MUST_NOT filter that returns a null DIS should be invisible", 5, booleanFilter);
+        }
+
+        [Test]
+        public void TestNonMatchingShouldsAndMusts()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetEmptyFilter(), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            TstFilterCard(@">0 shoulds with no matches should return no docs", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetNullDISFilter(), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            TstFilterCard(@">0 shoulds with no matches should return no docs", 0, booleanFilter);
+            booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetNullDISIFilter(), BooleanClause.Occur.SHOULD);
+            booleanFilter.Add(GetTermsFilter(@"accessRights", @"admin"), BooleanClause.Occur.MUST);
+            TstFilterCard(@">0 shoulds with no matches should return no docs", 0, booleanFilter);
+        }
+
+        [Test]
+        public void TestToStringOfBooleanFilterContainingTermsFilter()
+        {
+            BooleanFilter booleanFilter = new BooleanFilter();
+            booleanFilter.Add(GetTermsFilter(@"inStock", @"N"), BooleanClause.Occur.MUST);
+            booleanFilter.Add(GetTermsFilter(@"isFragile", @"Y"), BooleanClause.Occur.MUST);
+            assertEquals(@"BooleanFilter(+inStock:N +isFragile:Y)", booleanFilter.ToString());
+        }
+
+        [Test]
+        public void TestToStringOfWrappedBooleanFilters()
+        {
+            BooleanFilter orFilter = new BooleanFilter();
+            BooleanFilter stockFilter = new BooleanFilter();
+            stockFilter.Add(new FilterClause(GetTermsFilter(@"inStock", @"Y"), BooleanClause.Occur.MUST));
+            stockFilter.Add(new FilterClause(GetTermsFilter(@"barCode", @"12345678"), BooleanClause.Occur.MUST));
+            orFilter.Add(new FilterClause(stockFilter, BooleanClause.Occur.SHOULD));
+            BooleanFilter productPropertyFilter = new BooleanFilter();
+            productPropertyFilter.Add(new FilterClause(GetTermsFilter(@"isHeavy", @"N"), BooleanClause.Occur.MUST));
+            productPropertyFilter.Add(new FilterClause(GetTermsFilter(@"isDamaged", @"Y"), BooleanClause.Occur.MUST));
+            orFilter.Add(new FilterClause(productPropertyFilter, BooleanClause.Occur.SHOULD));
+            BooleanFilter composedFilter = new BooleanFilter();
+            composedFilter.Add(new FilterClause(orFilter, BooleanClause.Occur.MUST));
+            assertEquals(@"BooleanFilter(+BooleanFilter(BooleanFilter(+inStock:Y +barCode:12345678) BooleanFilter(+isHeavy:N +isDamaged:Y)))", composedFilter.ToString());
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d5f61fd3/src/Lucene.Net.Tests.Queries/Lucene.Net.Tests.Queries.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Queries/Lucene.Net.Tests.Queries.csproj b/src/Lucene.Net.Tests.Queries/Lucene.Net.Tests.Queries.csproj
new file mode 100644
index 0000000..bb48f5d
--- /dev/null
+++ b/src/Lucene.Net.Tests.Queries/Lucene.Net.Tests.Queries.csproj
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{D7276EA2-71BE-4208-889B-B1BD48DBE023}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Lucene.Net.Tests.Queries</RootNamespace>
+    <AssemblyName>Lucene.Net.Tests.Queries</AssemblyName>
+    <TargetFrameworkVersion>v4.5.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="nunit.framework">
+      <HintPath>..\..\packages\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="BooleanFilterTest.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TermFilterTest.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Lucene.Net.Core\Lucene.Net.csproj">
+      <Project>{5d4ad9be-1ffb-41ab-9943-25737971bf57}</Project>
+      <Name>Lucene.Net</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Lucene.Net.Queries\Lucene.Net.Queries.csproj">
+      <Project>{69d7956c-c2cc-4708-b399-a188fec384c4}</Project>
+      <Name>Lucene.Net.Queries</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Lucene.Net.TestFramework\Lucene.Net.TestFramework.csproj">
+      <Project>{b2c0d749-ce34-4f62-a15e-00cb2ff5ddb3}</Project>
+      <Name>Lucene.Net.TestFramework</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="Function\" />
+    <Folder Include="Mlt\" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d5f61fd3/src/Lucene.Net.Tests.Queries/Properties/AssemblyInfo.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Queries/Properties/AssemblyInfo.cs b/src/Lucene.Net.Tests.Queries/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..0e9695e
--- /dev/null
+++ b/src/Lucene.Net.Tests.Queries/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Lucene.Net.Tests.Queries")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Lucene.Net.Tests.Queries")]
+[assembly: AssemblyCopyright("Copyright ©  2015")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("ab4a0a26-30fc-4180-ade0-7409b0214107")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d5f61fd3/src/Lucene.Net.Tests.Queries/TermFilterTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Queries/TermFilterTest.cs b/src/Lucene.Net.Tests.Queries/TermFilterTest.cs
new file mode 100644
index 0000000..25c442f
--- /dev/null
+++ b/src/Lucene.Net.Tests.Queries/TermFilterTest.cs
@@ -0,0 +1,179 @@
+using System;
+using System.Collections.Generic;
+using Lucene.Net.Documents;
+using Lucene.Net.Index;
+using Lucene.Net.JavaCompatibility;
+using Lucene.Net.Queries;
+using Lucene.Net.Search;
+using Lucene.Net.Store;
+using Lucene.Net.Util;
+using NUnit.Framework;
+
+namespace Lucene.Net.Tests.Queries
+{
+    public class TermFilterTest : LuceneTestCase
+    {
+        [Test]
+        public void TestCachability()
+        {
+            TermFilter a = TermFilter(@"field1", @"a");
+            var cachedFilters = new HashSet<Filter>();
+            cachedFilters.Add(a);
+            assertTrue(@"Must be cached", cachedFilters.Contains(TermFilter(@"field1", @"a")));
+            assertFalse(@"Must not be cached", cachedFilters.Contains(TermFilter(@"field1", @"b")));
+            assertFalse(@"Must not be cached", cachedFilters.Contains(TermFilter(@"field2", @"a")));
+        }
+
+        [Test]
+        public void TestMissingTermAndField()
+        {
+            string fieldName = @"field1";
+            Directory rd = NewDirectory();
+            RandomIndexWriter w = new RandomIndexWriter(Random(), rd);
+            Document doc = new Document();
+            doc.Add(NewStringField(fieldName, @"value1", Field.Store.NO));
+            w.AddDocument(doc);
+            IndexReader reader = SlowCompositeReaderWrapper.Wrap(w.Reader);
+            assertTrue(reader.Context is AtomicReaderContext);
+            var context = (AtomicReaderContext)reader.Context;
+            w.Dispose();
+            DocIdSet idSet = TermFilter(fieldName, @"value1").GetDocIdSet(context, context.AtomicReader.LiveDocs);
+            assertNotNull(@"must not be null", idSet);
+            DocIdSetIterator iter = idSet.GetIterator();
+            assertEquals(iter.NextDoc(), 0);
+            assertEquals(iter.NextDoc(), DocIdSetIterator.NO_MORE_DOCS);
+            idSet = TermFilter(fieldName, @"value2").GetDocIdSet(context, context.AtomicReader.LiveDocs);
+            assertNull(@"must be null", idSet);
+            idSet = TermFilter(@"field2", @"value1").GetDocIdSet(context, context.AtomicReader.LiveDocs);
+            assertNull(@"must be null", idSet);
+            reader.Dispose();
+            rd.Dispose();
+        }
+
+        [Test]
+        public void TestRandom()
+        {
+            Directory dir = NewDirectory();
+            RandomIndexWriter w = new RandomIndexWriter(Random(), dir);
+            int num = AtLeast(100);
+            var terms = new List<Term>();
+            for (int i = 0; i < num; i++)
+            {
+                string field = @"field" + i;
+                string str = TestUtil.RandomRealisticUnicodeString(Random());
+                terms.Add(new Term(field, str));
+                Document doc = new Document();
+                doc.Add(NewStringField(field, str, Field.Store.NO));
+                w.AddDocument(doc);
+            }
+
+            IndexReader reader = w.Reader;
+            w.Dispose();
+            IndexSearcher searcher = NewSearcher(reader);
+            int numQueries = AtLeast(10);
+            for (int i = 0; i < numQueries; i++)
+            {
+                Term term = terms[Random().nextInt(num)];
+                TopDocs queryResult = searcher.Search(new TermQuery(term), reader.MaxDoc);
+                MatchAllDocsQuery matchAll = new MatchAllDocsQuery();
+                TermFilter filter = TermFilter(term);
+                TopDocs filterResult = searcher.Search(matchAll, filter, reader.MaxDoc);
+                assertEquals(filterResult.TotalHits, queryResult.TotalHits);
+                ScoreDoc[] scoreDocs = filterResult.ScoreDocs;
+                for (int j = 0; j < scoreDocs.Length; j++)
+                {
+                    assertEquals(scoreDocs[j].Doc, queryResult.ScoreDocs[j].Doc);
+                }
+            }
+
+            reader.Dispose();
+            dir.Dispose();
+        }
+
+        [Test]
+        public void TestHashCodeAndEquals()
+        {
+            int num = AtLeast(100);
+            for (int i = 0; i < num; i++)
+            {
+                string field1 = @"field" + i;
+                string field2 = @"field" + i + num;
+                string value1 = TestUtil.RandomRealisticUnicodeString(Random());
+                string value2 = value1 + @"x";
+                TermFilter filter1 = TermFilter(field1, value1);
+                TermFilter filter2 = TermFilter(field1, value2);
+                TermFilter filter3 = TermFilter(field2, value1);
+                TermFilter filter4 = TermFilter(field2, value2);
+                var filters = new TermFilter[]
+                {
+                    filter1, filter2, filter3, filter4
+                };
+
+                for (int j = 0; j < filters.Length; j++)
+                {
+                    TermFilter termFilter = filters[j];
+                    for (int k = 0; k < filters.Length; k++)
+                    {
+                        TermFilter otherTermFilter = filters[k];
+                        if (j == k)
+                        {
+                            assertEquals(termFilter, otherTermFilter);
+                            assertEquals(termFilter.GetHashCode(), otherTermFilter.GetHashCode());
+                            assertTrue(termFilter.Equals(otherTermFilter));
+                        }
+                        else
+                        {
+                            assertFalse(termFilter.Equals(otherTermFilter));
+                        }
+                    }
+                }
+
+                TermFilter filter5 = TermFilter(field2, value2);
+                assertEquals(filter5, filter4);
+                assertEquals(filter5.GetHashCode(), filter4.GetHashCode());
+                assertTrue(filter5.Equals(filter4));
+                assertEquals(filter5, filter4);
+                assertTrue(filter5.Equals(filter4));
+            }
+        }
+
+        [Test]
+        public void TestNoTerms()
+        {
+            try
+            {
+                new TermFilter(null);
+                Fail(@"must fail - no term!");
+            }
+            catch (ArgumentException e)
+            {
+            }
+
+            try
+            {
+                new TermFilter(new Term(null));
+                Fail(@"must fail - no field!");
+            }
+            catch (ArgumentException e)
+            {
+            }
+        }
+
+        [Test]
+        public void TestToString()
+        {
+            var termsFilter = new TermFilter(new Term("field1", "a"));
+            assertEquals(@"field1:a", termsFilter.ToString());
+        }
+
+        private TermFilter TermFilter(string field, string value)
+        {
+            return TermFilter(new Term(field, value));
+        }
+
+        private TermFilter TermFilter(Term term)
+        {
+            return new TermFilter(term);
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d5f61fd3/src/Lucene.Net.Tests.Queries/packages.config
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Queries/packages.config b/src/Lucene.Net.Tests.Queries/packages.config
new file mode 100644
index 0000000..139d513
--- /dev/null
+++ b/src/Lucene.Net.Tests.Queries/packages.config
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="NUnit" version="2.6.3" targetFramework="net451" />
+</packages>
\ No newline at end of file