lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject svn commit: r1310635 [8/8] - in /incubator/lucene.net/trunk: build/vs2010/contrib/ build/vs2010/test/ src/contrib/FastVectorHighlighter/ src/contrib/Highlighter/ src/contrib/Memory/ src/contrib/Memory/Properties/ src/contrib/Queries/ src/contrib/Querie...
Date Fri, 06 Apr 2012 23:37:54 GMT
Modified: incubator/lucene.net/trunk/test/core/Search/TestBooleanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestBooleanQuery.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestBooleanQuery.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestBooleanQuery.cs Fri Apr  6 23:37:48 2012
@@ -40,20 +40,20 @@ namespace Lucene.Net.Search
 		public virtual void  TestEquality()
 		{
 			BooleanQuery bq1 = new BooleanQuery();
-			bq1.Add(new TermQuery(new Term("field", "value1")), BooleanClause.Occur.SHOULD);
-			bq1.Add(new TermQuery(new Term("field", "value2")), BooleanClause.Occur.SHOULD);
+			bq1.Add(new TermQuery(new Term("field", "value1")), Occur.SHOULD);
+			bq1.Add(new TermQuery(new Term("field", "value2")), Occur.SHOULD);
 			BooleanQuery nested1 = new BooleanQuery();
-			nested1.Add(new TermQuery(new Term("field", "nestedvalue1")), BooleanClause.Occur.SHOULD);
-			nested1.Add(new TermQuery(new Term("field", "nestedvalue2")), BooleanClause.Occur.SHOULD);
-			bq1.Add(nested1, BooleanClause.Occur.SHOULD);
+			nested1.Add(new TermQuery(new Term("field", "nestedvalue1")), Occur.SHOULD);
+			nested1.Add(new TermQuery(new Term("field", "nestedvalue2")), Occur.SHOULD);
+			bq1.Add(nested1, Occur.SHOULD);
 			
 			BooleanQuery bq2 = new BooleanQuery();
-			bq2.Add(new TermQuery(new Term("field", "value1")), BooleanClause.Occur.SHOULD);
-			bq2.Add(new TermQuery(new Term("field", "value2")), BooleanClause.Occur.SHOULD);
+			bq2.Add(new TermQuery(new Term("field", "value1")), Occur.SHOULD);
+			bq2.Add(new TermQuery(new Term("field", "value2")), Occur.SHOULD);
 			BooleanQuery nested2 = new BooleanQuery();
-			nested2.Add(new TermQuery(new Term("field", "nestedvalue1")), BooleanClause.Occur.SHOULD);
-			nested2.Add(new TermQuery(new Term("field", "nestedvalue2")), BooleanClause.Occur.SHOULD);
-			bq2.Add(nested2, BooleanClause.Occur.SHOULD);
+			nested2.Add(new TermQuery(new Term("field", "nestedvalue1")), Occur.SHOULD);
+			nested2.Add(new TermQuery(new Term("field", "nestedvalue2")), Occur.SHOULD);
+			bq2.Add(nested2, Occur.SHOULD);
 			
 			Assert.AreEqual(bq1, bq2);
 		}
@@ -85,13 +85,13 @@ namespace Lucene.Net.Search
 			IndexReader r = w.GetReader();
 			IndexSearcher s = new IndexSearcher(r);
 			BooleanQuery q = new BooleanQuery();
-			q.Add(new TermQuery(new Term("field", "a")), BooleanClause.Occur.SHOULD);
+			q.Add(new TermQuery(new Term("field", "a")), Occur.SHOULD);
 
             // LUCENE-2617: make sure that a term not in the index still contributes to the
score via coord factor
             float score = s.Search(q, 10).MaxScore;
             Query subQuery = new TermQuery(new Term("field", "not_in_index"));
             subQuery.Boost = 0;
-            q.Add(subQuery, BooleanClause.Occur.SHOULD);
+            q.Add(subQuery, Occur.SHOULD);
             float score2 = s.Search(q, 10).MaxScore;
             Assert.AreEqual(score * .5, score2, 1e-6);
 
@@ -101,28 +101,28 @@ namespace Lucene.Net.Search
             phrase.Add(new Term("field", "not_in_index"));
             phrase.Add(new Term("field", "another_not_in_index"));
             phrase.Boost = 0;
-            qq.Add(phrase, BooleanClause.Occur.SHOULD);
+            qq.Add(phrase, Occur.SHOULD);
             score2 = s.Search(qq, 10).MaxScore;
             Assert.AreEqual(score * (1.0 / 3), score2, 1e-6);
 
             // now test BooleanScorer2
             subQuery = new TermQuery(new Term("field", "b"));
             subQuery.Boost = 0;
-            q.Add(subQuery, BooleanClause.Occur.MUST);
+            q.Add(subQuery, Occur.MUST);
             score2 = s.Search(q, 10).MaxScore;
             Assert.AreEqual(score * (2.0 / 3), score2, 1e-6);
 
 			// PhraseQuery w/ no terms added returns a null scorer
 			PhraseQuery pq = new PhraseQuery();
-			q.Add(pq, BooleanClause.Occur.SHOULD);
+			q.Add(pq, Occur.SHOULD);
 			Assert.AreEqual(1, s.Search(q, 10).TotalHits);
 			
 			// A required clause which returns null scorer should return null scorer to
 			// IndexSearcher.
 			q = new BooleanQuery();
 			pq = new PhraseQuery();
-			q.Add(new TermQuery(new Term("field", "a")), BooleanClause.Occur.SHOULD);
-			q.Add(pq, BooleanClause.Occur.MUST);
+			q.Add(new TermQuery(new Term("field", "a")), Occur.SHOULD);
+			q.Add(pq, Occur.MUST);
 			Assert.AreEqual(0, s.Search(q, 10).TotalHits);
 			
 			DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(1.0f);

Modified: incubator/lucene.net/trunk/test/core/Search/TestBooleanScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestBooleanScorer.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestBooleanScorer.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestBooleanScorer.cs Fri Apr  6 23:37:48 2012
@@ -98,12 +98,12 @@ namespace Lucene.Net.Search
 				writer.Close();
 				
 				BooleanQuery booleanQuery1 = new BooleanQuery();
-				booleanQuery1.Add(new TermQuery(new Term(FIELD, "1")), BooleanClause.Occur.SHOULD);
-				booleanQuery1.Add(new TermQuery(new Term(FIELD, "2")), BooleanClause.Occur.SHOULD);
+				booleanQuery1.Add(new TermQuery(new Term(FIELD, "1")), Occur.SHOULD);
+				booleanQuery1.Add(new TermQuery(new Term(FIELD, "2")), Occur.SHOULD);
 				
 				BooleanQuery query = new BooleanQuery();
-				query.Add(booleanQuery1, BooleanClause.Occur.MUST);
-				query.Add(new TermQuery(new Term(FIELD, "9")), BooleanClause.Occur.MUST_NOT);
+				query.Add(booleanQuery1, Occur.MUST);
+				query.Add(new TermQuery(new Term(FIELD, "9")), Occur.MUST_NOT);
 				
 				IndexSearcher indexSearcher = new IndexSearcher(directory, true);
 				ScoreDoc[] hits = indexSearcher.Search(query, null, 1000).ScoreDocs;

Modified: incubator/lucene.net/trunk/test/core/Search/TestComplexExplanations.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestComplexExplanations.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestComplexExplanations.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestComplexExplanations.cs Fri Apr  6 23:37:48
2012
@@ -19,7 +19,7 @@ using System;
 
 using NUnit.Framework;
 
-using Occur = Lucene.Net.Search.BooleanClause.Occur;
+using Occur = Lucene.Net.Search.Occur;
 using Lucene.Net.Search.Spans;
 
 namespace Lucene.Net.Search

Modified: incubator/lucene.net/trunk/test/core/Search/TestCustomSearcherSort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestCustomSearcherSort.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestCustomSearcherSort.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestCustomSearcherSort.cs Fri Apr  6 23:37:48
2012
@@ -254,8 +254,8 @@ namespace Lucene.Net.Search
 			public override TopFieldDocs Search(Query query, Filter filter, int nDocs, Sort sort)
 			{
 				BooleanQuery bq = new BooleanQuery();
-				bq.Add(query, BooleanClause.Occur.MUST);
-				bq.Add(new TermQuery(new Term("mandant", System.Convert.ToString(switcher))), BooleanClause.Occur.MUST);
+				bq.Add(query, Occur.MUST);
+				bq.Add(new TermQuery(new Term("mandant", System.Convert.ToString(switcher))), Occur.MUST);
 				return base.Search(bq, filter, nDocs, sort);
 			}
 			/* (non-Javadoc)
@@ -264,8 +264,8 @@ namespace Lucene.Net.Search
 			public override TopDocs Search(Query query, Filter filter, int nDocs)
 			{
 				BooleanQuery bq = new BooleanQuery();
-				bq.Add(query, BooleanClause.Occur.MUST);
-				bq.Add(new TermQuery(new Term("mandant", System.Convert.ToString(switcher))), BooleanClause.Occur.MUST);
+				bq.Add(query, Occur.MUST);
+				bq.Add(new TermQuery(new Term("mandant", System.Convert.ToString(switcher))), Occur.MUST);
 				return base.Search(bq, filter, nDocs);
 			}
 		}

Modified: incubator/lucene.net/trunk/test/core/Search/TestDisjunctionMaxQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestDisjunctionMaxQuery.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestDisjunctionMaxQuery.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestDisjunctionMaxQuery.cs Fri Apr  6 23:37:48
2012
@@ -299,14 +299,14 @@ namespace Lucene.Net.Search
 				DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
 				q1.Add(Tq("hed", "albino"));
 				q1.Add(Tq("dek", "albino"));
-				q.Add(q1, BooleanClause.Occur.MUST); //true,false);
+				q.Add(q1, Occur.MUST); //true,false);
 				QueryUtils.Check(q1, s);
 			}
 			{
 				DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
 				q2.Add(Tq("hed", "elephant"));
 				q2.Add(Tq("dek", "elephant"));
-				q.Add(q2, BooleanClause.Occur.MUST); //true,false);
+				q.Add(q2, Occur.MUST); //true,false);
 				QueryUtils.Check(q2, s);
 			}
 			
@@ -340,13 +340,13 @@ namespace Lucene.Net.Search
 				DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.0f);
 				q1.Add(Tq("hed", "albino"));
 				q1.Add(Tq("dek", "albino"));
-				q.Add(q1, BooleanClause.Occur.SHOULD); //false,false);
+				q.Add(q1, Occur.SHOULD); //false,false);
 			}
 			{
 				DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.0f);
 				q2.Add(Tq("hed", "elephant"));
 				q2.Add(Tq("dek", "elephant"));
-				q.Add(q2, BooleanClause.Occur.SHOULD); //false,false);
+				q.Add(q2, Occur.SHOULD); //false,false);
 			}
 			QueryUtils.Check(q, s);
 			
@@ -383,13 +383,13 @@ namespace Lucene.Net.Search
 				DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
 				q1.Add(Tq("hed", "albino"));
 				q1.Add(Tq("dek", "albino"));
-				q.Add(q1, BooleanClause.Occur.SHOULD); //false,false);
+				q.Add(q1, Occur.SHOULD); //false,false);
 			}
 			{
 				DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
 				q2.Add(Tq("hed", "elephant"));
 				q2.Add(Tq("dek", "elephant"));
-				q.Add(q2, BooleanClause.Occur.SHOULD); //false,false);
+				q.Add(q2, Occur.SHOULD); //false,false);
 			}
 			QueryUtils.Check(q, s);
 			
@@ -437,13 +437,13 @@ namespace Lucene.Net.Search
 				DisjunctionMaxQuery q1 = new DisjunctionMaxQuery(0.01f);
 				q1.Add(Tq("hed", "albino", 1.5f));
 				q1.Add(Tq("dek", "albino"));
-				q.Add(q1, BooleanClause.Occur.SHOULD); //false,false);
+				q.Add(q1, Occur.SHOULD); //false,false);
 			}
 			{
 				DisjunctionMaxQuery q2 = new DisjunctionMaxQuery(0.01f);
 				q2.Add(Tq("hed", "elephant", 1.5f));
 				q2.Add(Tq("dek", "elephant"));
-				q.Add(q2, BooleanClause.Occur.SHOULD); //false,false);
+				q.Add(q2, Occur.SHOULD); //false,false);
 			}
 			QueryUtils.Check(q, s);
 			

Modified: incubator/lucene.net/trunk/test/core/Search/TestElevationComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestElevationComparator.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestElevationComparator.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestElevationComparator.cs Fri Apr  6 23:37:48
2012
@@ -69,8 +69,8 @@ namespace Lucene.Net.Search
 			BooleanQuery newq = new BooleanQuery(false);
 			TermQuery query = new TermQuery(new Term("title", "ipod"));
 			
-			newq.Add(query, BooleanClause.Occur.SHOULD);
-			newq.Add(GetElevatedQuery(new System.String[]{"id", "a", "id", "x"}), BooleanClause.Occur.SHOULD);
+			newq.Add(query, Occur.SHOULD);
+			newq.Add(GetElevatedQuery(new System.String[]{"id", "a", "id", "x"}), Occur.SHOULD);
 			
 			Sort sort = new Sort(new SortField("id", new ElevationComparatorSource(priority), false),
new SortField(null, SortField.SCORE, reversed));
 			
@@ -117,7 +117,7 @@ namespace Lucene.Net.Search
 			int max = (vals.Length / 2) + 5;
 			for (int i = 0; i < vals.Length - 1; i += 2)
 			{
-				q.Add(new TermQuery(new Term(vals[i], vals[i + 1])), BooleanClause.Occur.SHOULD);
+				q.Add(new TermQuery(new Term(vals[i], vals[i + 1])), Occur.SHOULD);
 				priority[vals[i + 1]] = (System.Int32) max--;
 				// System.out.println(" pri doc=" + vals[i+1] + " pri=" + (1+max));
 			}

Modified: incubator/lucene.net/trunk/test/core/Search/TestExplanations.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestExplanations.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestExplanations.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestExplanations.cs Fri Apr  6 23:37:48 2012
@@ -235,8 +235,8 @@ namespace Lucene.Net.Search
 		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);
+			bq.Add(q, Occur.SHOULD);
+			bq.Add(new TermQuery(new Term("NEVER", "MATCH")), Occur.MUST_NOT);
 			return bq;
 		}
 		
@@ -253,8 +253,8 @@ namespace Lucene.Net.Search
 		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);
+			bq.Add(q, Occur.MUST);
+			bq.Add(new TermQuery(new Term(FIELD, "w1")), Occur.SHOULD);
 			return bq;
 		}
 		

Modified: incubator/lucene.net/trunk/test/core/Search/TestFilteredQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestFilteredQuery.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestFilteredQuery.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestFilteredQuery.cs Fri Apr  6 23:37:48 2012
@@ -27,7 +27,7 @@ using IndexWriter = Lucene.Net.Index.Ind
 using Term = Lucene.Net.Index.Term;
 using RAMDirectory = Lucene.Net.Store.RAMDirectory;
 using DocIdBitSet = Lucene.Net.Util.DocIdBitSet;
-using Occur = Lucene.Net.Search.BooleanClause.Occur;
+using Occur = Lucene.Net.Search.Occur;
 using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
 namespace Lucene.Net.Search
@@ -203,9 +203,9 @@ namespace Lucene.Net.Search
 		{
 			BooleanQuery bq = new BooleanQuery();
 			Query query = new FilteredQuery(new MatchAllDocsQuery(), new SingleDocTestFilter(0));
-			bq.Add(query, BooleanClause.Occur.MUST);
+			bq.Add(query, Occur.MUST);
 			query = new FilteredQuery(new MatchAllDocsQuery(), new SingleDocTestFilter(1));
-			bq.Add(query, BooleanClause.Occur.MUST);
+			bq.Add(query, Occur.MUST);
 			ScoreDoc[] hits = searcher.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			QueryUtils.Check(query, searcher);
@@ -218,8 +218,8 @@ namespace Lucene.Net.Search
 		{
 			BooleanQuery bq = new BooleanQuery();
 			Query query = new FilteredQuery(bq, new SingleDocTestFilter(0));
-			bq.Add(new TermQuery(new Term("field", "one")), BooleanClause.Occur.SHOULD);
-			bq.Add(new TermQuery(new Term("field", "two")), BooleanClause.Occur.SHOULD);
+			bq.Add(new TermQuery(new Term("field", "one")), Occur.SHOULD);
+			bq.Add(new TermQuery(new Term("field", "two")), Occur.SHOULD);
 			ScoreDoc[] hits = searcher.Search(query, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			QueryUtils.Check(query, searcher);

Modified: incubator/lucene.net/trunk/test/core/Search/TestFilteredSearch.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestFilteredSearch.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestFilteredSearch.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestFilteredSearch.cs Fri Apr  6 23:37:48
2012
@@ -80,7 +80,7 @@ namespace Lucene.Net.Search
                 writer.Close();
 
                 BooleanQuery booleanQuery = new BooleanQuery();
-                booleanQuery.Add(new TermQuery(new Term(FIELD, "36")), BooleanClause.Occur.SHOULD);
+                booleanQuery.Add(new TermQuery(new Term(FIELD, "36")), Occur.SHOULD);
 
 
                 IndexSearcher indexSearcher = new IndexSearcher(directory);

Modified: incubator/lucene.net/trunk/test/core/Search/TestMatchAllDocsQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestMatchAllDocsQuery.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestMatchAllDocsQuery.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestMatchAllDocsQuery.cs Fri Apr  6 23:37:48
2012
@@ -97,14 +97,14 @@ namespace Lucene.Net.Search
 			// some artificial queries to trigger the use of skipTo():
 			
 			BooleanQuery bq = new BooleanQuery();
-			bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
-			bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
+			bq.Add(new MatchAllDocsQuery(), Occur.MUST);
+			bq.Add(new MatchAllDocsQuery(), Occur.MUST);
 			hits = is_Renamed.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			
 			bq = new BooleanQuery();
-			bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
-			bq.Add(new TermQuery(new Term("key", "three")), BooleanClause.Occur.MUST);
+			bq.Add(new MatchAllDocsQuery(), Occur.MUST);
+			bq.Add(new TermQuery(new Term("key", "three")), Occur.MUST);
 			hits = is_Renamed.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			

Modified: incubator/lucene.net/trunk/test/core/Search/TestMultiPhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestMultiPhraseQuery.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestMultiPhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestMultiPhraseQuery.cs Fri Apr  6 23:37:48
2012
@@ -155,11 +155,11 @@ namespace Lucene.Net.Search
 		    IndexSearcher searcher = new IndexSearcher(indexStore, true);
 			// This query will be equivalent to +body:pie +body:"blue*"
 			BooleanQuery q = new BooleanQuery();
-			q.Add(new TermQuery(new Term("body", "pie")), BooleanClause.Occur.MUST);
+			q.Add(new TermQuery(new Term("body", "pie")), Occur.MUST);
 			
 			MultiPhraseQuery trouble = new MultiPhraseQuery();
 			trouble.Add(new Term[]{new Term("body", "blueberry"), new Term("body", "blue")});
-			q.Add(trouble, BooleanClause.Occur.MUST);
+			q.Add(trouble, Occur.MUST);
 			
 			// exception will be thrown here without fix
 			ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
@@ -181,12 +181,12 @@ namespace Lucene.Net.Search
 			
 			// This query will be equivalent to +type:note +body:"a t*"
 			BooleanQuery q = new BooleanQuery();
-			q.Add(new TermQuery(new Term("type", "note")), BooleanClause.Occur.MUST);
+			q.Add(new TermQuery(new Term("type", "note")), Occur.MUST);
 			
 			MultiPhraseQuery trouble = new MultiPhraseQuery();
 			trouble.Add(new Term("body", "a"));
 			trouble.Add(new Term[]{new Term("body", "test"), new Term("body", "this")});
-			q.Add(trouble, BooleanClause.Occur.MUST);
+			q.Add(trouble, Occur.MUST);
 			
 			// exception will be thrown here without fix for #35626:
 			ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;

Modified: incubator/lucene.net/trunk/test/core/Search/TestMultiTermConstantScore.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestMultiTermConstantScore.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestMultiTermConstantScore.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestMultiTermConstantScore.cs Fri Apr  6 23:37:48
2012
@@ -238,8 +238,8 @@ namespace Lucene.Net.Search
 			q1.Boost = .1f;
 			Query q2 = Csrq("data", "Z", "Z", T, T); // matches document #1
 			BooleanQuery bq = new BooleanQuery(true);
-			bq.Add(q1, BooleanClause.Occur.SHOULD);
-			bq.Add(q2, BooleanClause.Occur.SHOULD);
+			bq.Add(q1, Occur.SHOULD);
+			bq.Add(q2, Occur.SHOULD);
 			
 			ScoreDoc[] hits = search.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits[0].Doc);
@@ -250,8 +250,8 @@ namespace Lucene.Net.Search
 			q1.Boost = .1f;
 			q2 = Csrq("data", "Z", "Z", T, T, MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE);
// matches document #1
 			bq = new BooleanQuery(true);
-			bq.Add(q1, BooleanClause.Occur.SHOULD);
-			bq.Add(q2, BooleanClause.Occur.SHOULD);
+			bq.Add(q1, Occur.SHOULD);
+			bq.Add(q2, Occur.SHOULD);
 			
 			hits = search.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits[0].Doc);
@@ -262,8 +262,8 @@ namespace Lucene.Net.Search
 			q1.Boost = 10f;
 			q2 = Csrq("data", "Z", "Z", T, T); // matches document #1
 			bq = new BooleanQuery(true);
-			bq.Add(q1, BooleanClause.Occur.SHOULD);
-			bq.Add(q2, BooleanClause.Occur.SHOULD);
+			bq.Add(q1, Occur.SHOULD);
+			bq.Add(q2, Occur.SHOULD);
 			
 			hits = search.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits[0].Doc);
@@ -291,8 +291,8 @@ namespace Lucene.Net.Search
 			// ConstantScoreRangeQuery and make sure hte order is the same
 			
 			BooleanQuery q = new BooleanQuery();
-			q.Add(rq, BooleanClause.Occur.MUST); // T, F);
-			q.Add(Csrq("data", "1", "6", T, T), BooleanClause.Occur.MUST); // T, F);
+			q.Add(rq, Occur.MUST); // T, F);
+			q.Add(Csrq("data", "1", "6", T, T), Occur.MUST); // T, F);
 			
 			ScoreDoc[] actual = search.Search(q, null, 1000).ScoreDocs;
 			

Modified: incubator/lucene.net/trunk/test/core/Search/TestPhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestPhraseQuery.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestPhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestPhraseQuery.cs Fri Apr  6 23:37:48 2012
@@ -296,8 +296,8 @@ namespace Lucene.Net.Search
 			
 			TermQuery termQuery = new TermQuery(new Term("contents", "foobar"));
 			BooleanQuery booleanQuery = new BooleanQuery();
-			booleanQuery.Add(termQuery, BooleanClause.Occur.MUST);
-			booleanQuery.Add(phraseQuery, BooleanClause.Occur.MUST);
+			booleanQuery.Add(termQuery, Occur.MUST);
+			booleanQuery.Add(phraseQuery, Occur.MUST);
 			hits = searcher.Search(booleanQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			QueryUtils.Check(termQuery, searcher);
@@ -335,14 +335,14 @@ namespace Lucene.Net.Search
 			
 			
 			booleanQuery = new BooleanQuery();
-			booleanQuery.Add(termQuery, BooleanClause.Occur.MUST);
-			booleanQuery.Add(phraseQuery, BooleanClause.Occur.MUST);
+			booleanQuery.Add(termQuery, Occur.MUST);
+			booleanQuery.Add(phraseQuery, Occur.MUST);
 			hits = searcher.Search(booleanQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			
 			booleanQuery = new BooleanQuery();
-			booleanQuery.Add(phraseQuery, BooleanClause.Occur.MUST);
-			booleanQuery.Add(termQuery, BooleanClause.Occur.MUST);
+			booleanQuery.Add(phraseQuery, Occur.MUST);
+			booleanQuery.Add(termQuery, Occur.MUST);
 			hits = searcher.Search(booleanQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			QueryUtils.Check(booleanQuery, searcher);
@@ -602,7 +602,7 @@ namespace Lucene.Net.Search
 		public virtual void  TestEmptyPhraseQuery()
 		{
 			BooleanQuery q2 = new BooleanQuery();
-			q2.Add(new PhraseQuery(), BooleanClause.Occur.MUST);
+			q2.Add(new PhraseQuery(), Occur.MUST);
 			q2.ToString();
 		}
 	}

Modified: incubator/lucene.net/trunk/test/core/Search/TestPositionIncrement.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestPositionIncrement.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestPositionIncrement.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestPositionIncrement.cs Fri Apr  6 23:37:48
2012
@@ -41,7 +41,7 @@ using TermPositions = Lucene.Net.Index.T
 using QueryParser = Lucene.Net.QueryParsers.QueryParser;
 using Directory = Lucene.Net.Store.Directory;
 using MockRAMDirectory = Lucene.Net.Store.MockRAMDirectory;
-using BaseTokenStreamTestCase = Lucene.Net.Analysis.BaseTokenStreamTestCase;
+using BaseTokenStreamTestCase = Lucene.Net.Test.Analysis.BaseTokenStreamTestCase;
 using PayloadSpanUtil = Lucene.Net.Search.Payloads.PayloadSpanUtil;
 using SpanNearQuery = Lucene.Net.Search.Spans.SpanNearQuery;
 using SpanQuery = Lucene.Net.Search.Spans.SpanQuery;

Modified: incubator/lucene.net/trunk/test/core/Search/TestPrefixInBooleanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestPrefixInBooleanQuery.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestPrefixInBooleanQuery.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestPrefixInBooleanQuery.cs Fri Apr  6 23:37:48
2012
@@ -101,8 +101,8 @@ namespace Lucene.Net.Search
 		{
 			IndexSearcher indexSearcher = new IndexSearcher(directory, true);
 			BooleanQuery query = new BooleanQuery();
-			query.Add(new TermQuery(new Term(FIELD, "tangfulin")), BooleanClause.Occur.SHOULD);
-			query.Add(new TermQuery(new Term(FIELD, "notexistnames")), BooleanClause.Occur.SHOULD);
+			query.Add(new TermQuery(new Term(FIELD, "tangfulin")), Occur.SHOULD);
+			query.Add(new TermQuery(new Term(FIELD, "notexistnames")), Occur.SHOULD);
 			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).TotalHits, "Number of matched
documents");
 		}
 		
@@ -111,8 +111,8 @@ namespace Lucene.Net.Search
 		{
 			IndexSearcher indexSearcher = new IndexSearcher(directory, true);
 			BooleanQuery query = new BooleanQuery();
-			query.Add(new PrefixQuery(new Term(FIELD, "tang")), BooleanClause.Occur.SHOULD);
-			query.Add(new TermQuery(new Term(FIELD, "notexistnames")), BooleanClause.Occur.SHOULD);
+			query.Add(new PrefixQuery(new Term(FIELD, "tang")), Occur.SHOULD);
+			query.Add(new TermQuery(new Term(FIELD, "notexistnames")), Occur.SHOULD);
 			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).TotalHits, "Number of matched
documents");
 		}
 	}

Modified: incubator/lucene.net/trunk/test/core/Search/TestQueryWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestQueryWrapperFilter.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestQueryWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestQueryWrapperFilter.cs Fri Apr  6 23:37:48
2012
@@ -28,7 +28,7 @@ using IndexWriter = Lucene.Net.Index.Ind
 using Term = Lucene.Net.Index.Term;
 using Directory = Lucene.Net.Store.Directory;
 using RAMDirectory = Lucene.Net.Store.RAMDirectory;
-using Occur = Lucene.Net.Search.BooleanClause.Occur;
+using Occur = Lucene.Net.Search.Occur;
 using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
 namespace Lucene.Net.Search

Modified: incubator/lucene.net/trunk/test/core/Search/TestScorerPerf.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestScorerPerf.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestScorerPerf.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestScorerPerf.cs Fri Apr  6 23:37:48 2012
@@ -198,7 +198,7 @@ namespace Lucene.Net.Search
 		{
 			System.Collections.BitArray rnd = sets[r.Next(sets.Length)];
 			Query q = new ConstantScoreQuery(new AnonymousClassFilter(rnd, this));
-			bq.Add(q, BooleanClause.Occur.MUST);
+			bq.Add(q, Occur.MUST);
 			if (validate)
 			{
 				if (result == null)
@@ -259,7 +259,7 @@ namespace Lucene.Net.Search
 						result = AddClause(bq, result);
 					}
 					
-					oq.Add(bq, BooleanClause.Occur.MUST);
+					oq.Add(bq, Occur.MUST);
 				} // outer
 				
 				CountingHitCollector hc = validate?new MatchingHitCollector(result):new CountingHitCollector();
@@ -296,7 +296,7 @@ namespace Lucene.Net.Search
 						tnum = BitSetSupport.NextClearBit(termflag, 0);
 					termflag.Set(tnum, true);
 					Query tq = new TermQuery(terms[tnum]);
-					bq.Add(tq, BooleanClause.Occur.MUST);
+					bq.Add(tq, Occur.MUST);
 				}
 				
 				CountingHitCollector hc = new CountingHitCollector();
@@ -335,10 +335,10 @@ namespace Lucene.Net.Search
 							tnum = BitSetSupport.NextClearBit(termflag, 0);
 						termflag.Set(tnum, true);
 						Query tq = new TermQuery(terms[tnum]);
-						bq.Add(tq, BooleanClause.Occur.MUST);
+						bq.Add(tq, Occur.MUST);
 					} // inner
 					
-					oq.Add(bq, BooleanClause.Occur.MUST);
+					oq.Add(bq, Occur.MUST);
 				} // outer
 				
 				

Modified: incubator/lucene.net/trunk/test/core/Search/TestSimilarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestSimilarity.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestSimilarity.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestSimilarity.cs Fri Apr  6 23:37:48 2012
@@ -263,8 +263,8 @@ namespace Lucene.Net.Search
 			searcher.Search(new TermQuery(b), new AnonymousClassCollector(this));
 			
 			BooleanQuery bq = new BooleanQuery();
-			bq.Add(new TermQuery(a), BooleanClause.Occur.SHOULD);
-			bq.Add(new TermQuery(b), BooleanClause.Occur.SHOULD);
+			bq.Add(new TermQuery(a), Occur.SHOULD);
+			bq.Add(new TermQuery(b), Occur.SHOULD);
 			//System.out.println(bq.toString("field"));
 			searcher.Search(bq, new AnonymousClassCollector1(this));
 			

Modified: incubator/lucene.net/trunk/test/core/Search/TestSimpleExplanations.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestSimpleExplanations.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestSimpleExplanations.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestSimpleExplanations.cs Fri Apr  6 23:37:48
2012
@@ -352,32 +352,32 @@ namespace Lucene.Net.Search
 		public virtual void  TestBQ14()
 		{
 			BooleanQuery q = new BooleanQuery(true);
-			q.Add(qp.Parse("QQQQQ"), BooleanClause.Occur.SHOULD);
-			q.Add(qp.Parse("w1"), BooleanClause.Occur.SHOULD);
+			q.Add(qp.Parse("QQQQQ"), Occur.SHOULD);
+			q.Add(qp.Parse("w1"), Occur.SHOULD);
 			Qtest(q, new int[]{0, 1, 2, 3});
 		}
 		[Test]
 		public virtual void  TestBQ15()
 		{
 			BooleanQuery q = new BooleanQuery(true);
-			q.Add(qp.Parse("QQQQQ"), BooleanClause.Occur.MUST_NOT);
-			q.Add(qp.Parse("w1"), BooleanClause.Occur.SHOULD);
+			q.Add(qp.Parse("QQQQQ"), Occur.MUST_NOT);
+			q.Add(qp.Parse("w1"), Occur.SHOULD);
 			Qtest(q, new int[]{0, 1, 2, 3});
 		}
 		[Test]
 		public virtual void  TestBQ16()
 		{
 			BooleanQuery q = new BooleanQuery(true);
-			q.Add(qp.Parse("QQQQQ"), BooleanClause.Occur.SHOULD);
-			q.Add(qp.Parse("w1 -xx"), BooleanClause.Occur.SHOULD);
+			q.Add(qp.Parse("QQQQQ"), Occur.SHOULD);
+			q.Add(qp.Parse("w1 -xx"), Occur.SHOULD);
 			Qtest(q, new int[]{0, 1});
 		}
         [Test]
         public virtual void TestBQ17()
 		{
 			BooleanQuery q = new BooleanQuery(true);
-			q.Add(qp.Parse("w2"), BooleanClause.Occur.SHOULD);
-			q.Add(qp.Parse("w1 -xx"), BooleanClause.Occur.SHOULD);
+			q.Add(qp.Parse("w2"), Occur.SHOULD);
+			q.Add(qp.Parse("w1 -xx"), Occur.SHOULD);
 			Qtest(q, new int[]{0, 1, 2, 3});
 		}
 		[Test]
@@ -391,11 +391,11 @@ namespace Lucene.Net.Search
 		{
 			BooleanQuery q = new BooleanQuery();
 			q.SetMinimumNumberShouldMatch(2);
-			q.Add(qp.Parse("QQQQQ"), BooleanClause.Occur.SHOULD);
-			q.Add(qp.Parse("yy"), BooleanClause.Occur.SHOULD);
-			q.Add(qp.Parse("zz"), BooleanClause.Occur.SHOULD);
-			q.Add(qp.Parse("w5"), BooleanClause.Occur.SHOULD);
-			q.Add(qp.Parse("w4"), BooleanClause.Occur.SHOULD);
+			q.Add(qp.Parse("QQQQQ"), Occur.SHOULD);
+			q.Add(qp.Parse("yy"), Occur.SHOULD);
+			q.Add(qp.Parse("zz"), Occur.SHOULD);
+			q.Add(qp.Parse("w5"), Occur.SHOULD);
+			q.Add(qp.Parse("w4"), Occur.SHOULD);
 			
 			Qtest(q, new int[]{0, 3});
 		}

Modified: incubator/lucene.net/trunk/test/core/Search/TestSort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestSort.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestSort.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestSort.cs Fri Apr  6 23:37:48 2012
@@ -30,7 +30,7 @@ using ParseException = Lucene.Net.QueryP
 using LockObtainFailedException = Lucene.Net.Store.LockObtainFailedException;
 using RAMDirectory = Lucene.Net.Store.RAMDirectory;
 using DocIdBitSet = Lucene.Net.Util.DocIdBitSet;
-using Occur = Lucene.Net.Search.BooleanClause.Occur;
+using Occur = Lucene.Net.Search.Occur;
 using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
 namespace Lucene.Net.Search

Modified: incubator/lucene.net/trunk/test/core/Search/TestTopScoreDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestTopScoreDocCollector.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestTopScoreDocCollector.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestTopScoreDocCollector.cs Fri Apr  6 23:37:48
2012
@@ -24,7 +24,7 @@ using IndexWriter = Lucene.Net.Index.Ind
 using MaxFieldLength = Lucene.Net.Index.IndexWriter.MaxFieldLength;
 using Directory = Lucene.Net.Store.Directory;
 using RAMDirectory = Lucene.Net.Store.RAMDirectory;
-using Occur = Lucene.Net.Search.BooleanClause.Occur;
+using Occur = Lucene.Net.Search.Occur;
 using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
 namespace Lucene.Net.Search

Modified: incubator/lucene.net/trunk/test/core/Search/TestWildcard.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Search/TestWildcard.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Search/TestWildcard.cs (original)
+++ incubator/lucene.net/trunk/test/core/Search/TestWildcard.cs Fri Apr  6 23:37:48 2012
@@ -167,11 +167,11 @@ namespace Lucene.Net.Search
 			Query query5 = new WildcardQuery(new Term("body", "m*tals"));
 			
 			BooleanQuery query6 = new BooleanQuery();
-			query6.Add(query5, BooleanClause.Occur.SHOULD);
+			query6.Add(query5, Occur.SHOULD);
 			
 			BooleanQuery query7 = new BooleanQuery();
-			query7.Add(query3, BooleanClause.Occur.SHOULD);
-			query7.Add(query5, BooleanClause.Occur.SHOULD);
+			query7.Add(query3, Occur.SHOULD);
+			query7.Add(query5, Occur.SHOULD);
 			
 			// Queries do not automatically lower-case search terms:
 			Query query8 = new WildcardQuery(new Term("body", "M*tal*"));

Modified: incubator/lucene.net/trunk/test/core/Support/TestOldPatches.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Support/TestOldPatches.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Support/TestOldPatches.cs (original)
+++ incubator/lucene.net/trunk/test/core/Support/TestOldPatches.cs Fri Apr  6 23:37:48 2012
@@ -58,8 +58,8 @@ namespace Lucene.Net.Support
         public void Test_Util_Parameter()
         {
             Lucene.Net.Search.BooleanQuery queryPreSerialized = new Lucene.Net.Search.BooleanQuery();
-            queryPreSerialized.Add(new Lucene.Net.Search.TermQuery(new Lucene.Net.Index.Term("country",
"Russia")), Lucene.Net.Search.BooleanClause.Occur.MUST);
-            queryPreSerialized.Add(new Lucene.Net.Search.TermQuery(new Lucene.Net.Index.Term("country",
"France")), Lucene.Net.Search.BooleanClause.Occur.MUST);
+            queryPreSerialized.Add(new Lucene.Net.Search.TermQuery(new Lucene.Net.Index.Term("country",
"Russia")), Occur.MUST);
+            queryPreSerialized.Add(new Lucene.Net.Search.TermQuery(new Lucene.Net.Index.Term("country",
"France")), Occur.MUST);
 
             //now serialize it 
             System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer = new
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

Modified: incubator/lucene.net/trunk/test/core/Support/TestSerialization.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/Support/TestSerialization.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/Support/TestSerialization.cs (original)
+++ incubator/lucene.net/trunk/test/core/Support/TestSerialization.cs Fri Apr  6 23:37:48
2012
@@ -19,6 +19,7 @@
  *
 */
 
+using Lucene.Net.Search;
 using NUnit.Framework;
 
 namespace Lucene.Net.Support
@@ -72,7 +73,7 @@ namespace Lucene.Net.Support
         {
             Lucene.Net.Search.BooleanQuery lucQuery = new Lucene.Net.Search.BooleanQuery();
 
-            lucQuery.Add(new Lucene.Net.Search.TermQuery(new Lucene.Net.Index.Term("field",
"x")), Lucene.Net.Search.BooleanClause.Occur.MUST);
+            lucQuery.Add(new Lucene.Net.Search.TermQuery(new Lucene.Net.Index.Term("field",
"x")), Occur.MUST);
             
             System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
             System.IO.MemoryStream ms = new System.IO.MemoryStream();
@@ -89,10 +90,10 @@ namespace Lucene.Net.Support
             
             searcher.Close();
             searcher = new Lucene.Net.Search.IndexSearcher(dir, true);
-
+            
             int hitCount2 = searcher.Search(lucQuery2, 20).TotalHits;
 
-            Assert.AreEqual(hitCount, hitCount2,"Error in serialization - different hit counts");
+            Assert.AreEqual(hitCount, hitCount2, "Error in serialization - different hit
counts");
         }
     }
 }

Modified: incubator/lucene.net/trunk/test/core/TestDemo.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/test/core/TestDemo.cs?rev=1310635&r1=1310634&r2=1310635&view=diff
==============================================================================
--- incubator/lucene.net/trunk/test/core/TestDemo.cs (original)
+++ incubator/lucene.net/trunk/test/core/TestDemo.cs Fri Apr  6 23:37:48 2012
@@ -16,7 +16,8 @@
  */
 
 using System;
-
+using System.IO;
+using Lucene.Net.Store;
 using NUnit.Framework;
 
 using Analyzer = Lucene.Net.Analysis.Analyzer;
@@ -46,7 +47,6 @@ namespace Lucene.Net
 	[TestFixture]
 	public class TestDemo:LuceneTestCase
 	{
-		
 		[Test]
 		public virtual void  TestDemo_Renamed()
 		{



Mime
View raw message