lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject [Lucene.Net] svn commit: r1084113 [1/4] - in /incubator/lucene.net/trunk/C#/src: Lucene.Net/Index/ Lucene.Net/Search/ Test/ Test/Analysis/ Test/Document/ Test/Index/ Test/QueryParser/ Test/Search/ Test/Search/Function/ Test/Search/Payloads/ Test/Search/Spans/ Test/...
Date Tue, 22 Mar 2011 09:31:12 GMT
Author: digy
Date: Tue Mar 22 09:31:10 2011
New Revision: 1084113

URL: http://svn.apache.org/viewvc?rev=1084113&view=rev
Log:
[LUCENENET-399] 
TestNumericUtils.TestLongExtremeValues + 
visibility of IndexWriter.GetNextMerge + 
TopDocs.TotalHits, TopDocs.ScoreDocs, TopDocs.MaxScore

Modified:
    incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/IndexWriter.cs
    incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs
    incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs
    incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs
    incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopDocs.cs
    incubator/lucene.net/trunk/C#/src/Test/Analysis/TestKeywordAnalyzer.cs
    incubator/lucene.net/trunk/C#/src/Test/Document/TestDocument.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestBackwardsCompatibility.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestDeletionPolicy.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexReader.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexReaderReopen.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriter.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriterDelete.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriterReader.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestLazyProxSkipping.cs
    incubator/lucene.net/trunk/C#/src/Test/Index/TestParallelReader.cs
    incubator/lucene.net/trunk/C#/src/Test/QueryParser/TestMultiFieldQueryParser.cs
    incubator/lucene.net/trunk/C#/src/Test/QueryParser/TestQueryParser.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/CheckHits.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestCustomScoreQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestFieldScoreQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestOrdValues.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestBoostingTermQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestPayloadNearQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestPayloadTermQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestPayloadSpans.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestSpans.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestSpansAdvanced.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestBoolean2.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanMinShouldMatch.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanOr.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanScorer.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestCachingSpanFilter.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestCachingWrapperFilter.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestCustomSearcherSort.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestDateFilter.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestDateSort.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestDisjunctionMaxQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestDocIdSet.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestElevationComparator.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheRangeFilter.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheTermsFilter.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredSearch.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestFuzzyQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestMatchAllDocsQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiPhraseQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcher.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcherRanking.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiTermConstantScore.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiValuedNumericRangeQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestNot.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestNumericRangeQuery32.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestNumericRangeQuery64.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestPhrasePrefixQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestPhraseQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestPositionIncrement.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestPositiveScoresOnlyCollector.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixFilter.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixInBooleanQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestQueryWrapperFilter.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestSimpleExplanations.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestSloppyPhraseQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestSort.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestStressSort.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeFilter.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeQuery.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestTermVectors.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestTopDocsCollector.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestTopScoreDocCollector.cs
    incubator/lucene.net/trunk/C#/src/Test/Search/TestWildcard.cs
    incubator/lucene.net/trunk/C#/src/Test/Store/TestBufferedIndexInput.cs
    incubator/lucene.net/trunk/C#/src/Test/Store/TestLockFactory.cs
    incubator/lucene.net/trunk/C#/src/Test/TestDemo.cs
    incubator/lucene.net/trunk/C#/src/Test/TestSearch.cs
    incubator/lucene.net/trunk/C#/src/Test/TestSearchForDuplicates.cs
    incubator/lucene.net/trunk/C#/src/Test/TestSupportClass.cs
    incubator/lucene.net/trunk/C#/src/Test/Util/TestNumericUtils.cs

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/IndexWriter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/IndexWriter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/IndexWriter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/IndexWriter.cs Tue Mar 22 09:31:10 2011
@@ -3588,12 +3588,17 @@ namespace Lucene.Net.Index
 				}
 			}
 		}
+
+        public virtual MergePolicy.OneMerge GetNextMerge_forNUnit()
+        {
+            return GetNextMerge();
+        }
 		
 		/// <summary>Expert: the {@link MergeScheduler} calls this method
 		/// to retrieve the next merge requested by the
 		/// MergePolicy 
 		/// </summary>
-		public /*internal*/ virtual MergePolicy.OneMerge GetNextMerge()
+		internal virtual MergePolicy.OneMerge GetNextMerge()
 		{
 			lock (this)
 			{

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Hits.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs Tue Mar 22 09:31:10 2011
@@ -121,8 +121,8 @@ namespace Lucene.Net.Search
 			int n = min * 2; // double # retrieved
 			TopDocs topDocs = (sort == null)?searcher.Search(weight, filter, n):searcher.Search(weight, filter, n, sort);
 			
-			length = topDocs.totalHits;
-			ScoreDoc[] scoreDocs = topDocs.scoreDocs;
+			length = topDocs.TotalHits;
+			ScoreDoc[] scoreDocs = topDocs.ScoreDocs;
 			
 			float scoreNorm = 1.0f;
 			

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/MultiSearcher.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/MultiSearcher.cs Tue Mar 22 09:31:10 2011
@@ -255,8 +255,8 @@ namespace Lucene.Net.Search
 			{
 				// search each searcher
 				TopDocs docs = searchables[i].Search(weight, filter, nDocs);
-				totalHits += docs.totalHits; // update totalHits
-				ScoreDoc[] scoreDocs = docs.scoreDocs;
+				totalHits += docs.TotalHits; // update totalHits
+				ScoreDoc[] scoreDocs = docs.ScoreDocs;
 				for (int j = 0; j < scoreDocs.Length; j++)
 				{
 					// merge scoreDocs into hq
@@ -296,9 +296,9 @@ namespace Lucene.Net.Search
 					if (docs.fields[j].GetType() == SortField.DOC)
 					{
 						// iterate over the score docs and change their fields value
-						for (int j2 = 0; j2 < docs.scoreDocs.Length; j2++)
+						for (int j2 = 0; j2 < docs.ScoreDocs.Length; j2++)
 						{
-							FieldDoc fd = (FieldDoc) docs.scoreDocs[j2];
+							FieldDoc fd = (FieldDoc) docs.ScoreDocs[j2];
 							fd.fields[j] = (System.Int32) (((System.Int32) fd.fields[j]) + starts[i]);
 						}
 						break;
@@ -306,9 +306,9 @@ namespace Lucene.Net.Search
 				}
 				if (hq == null)
 					hq = new FieldDocSortedHitQueue(docs.fields, n);
-				totalHits += docs.totalHits; // update totalHits
+				totalHits += docs.TotalHits; // update totalHits
 				maxScore = System.Math.Max(maxScore, docs.GetMaxScore());
-				ScoreDoc[] scoreDocs = docs.scoreDocs;
+				ScoreDoc[] scoreDocs = docs.ScoreDocs;
 				for (int j = 0; j < scoreDocs.Length; j++)
 				{
 					// merge scoreDocs into hq

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ParallelMultiSearcher.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ParallelMultiSearcher.cs Tue Mar 22 09:31:10 2011
@@ -300,9 +300,9 @@ namespace Lucene.Net.Search
 						if (docsFields.fields[j].GetType() == SortField.DOC)
 						{
 							// iterate over the score docs and change their fields value
-							for (int j2 = 0; j2 < docs.scoreDocs.Length; j2++)
+							for (int j2 = 0; j2 < docs.ScoreDocs.Length; j2++)
 							{
-								FieldDoc fd = (FieldDoc) docs.scoreDocs[j2];
+								FieldDoc fd = (FieldDoc) docs.ScoreDocs[j2];
 								fd.fields[j] = (System.Int32) (((System.Int32) fd.fields[j]) + starts[i]);
 							}
 							break;
@@ -311,7 +311,7 @@ namespace Lucene.Net.Search
 					
 					((FieldDocSortedHitQueue) hq).SetFields(docsFields.fields);
 				}
-				ScoreDoc[] scoreDocs = docs.scoreDocs;
+				ScoreDoc[] scoreDocs = docs.ScoreDocs;
 				for (int j = 0; j < scoreDocs.Length; j++)
 				{
 					// merge scoreDocs into hq
@@ -329,7 +329,7 @@ namespace Lucene.Net.Search
 		
 		public virtual int Hits()
 		{
-			return docs.totalHits;
+			return docs.TotalHits;
 		}
 		
 		public virtual float GetMaxScore()

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopDocs.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TopDocs.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopDocs.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TopDocs.cs Tue Mar 22 09:31:10 2011
@@ -30,24 +30,46 @@ namespace Lucene.Net.Search
 		/// <summary>The total number of hits for the query.</summary>
 		/// <seealso cref="Hits.Length()">
 		/// </seealso>
+        [Obsolete("For backward compatibility. Use TotalHits instead")]
 		public int totalHits;
 		/// <summary>The top hits for the query. </summary>
+        [Obsolete("For backward compatibility. Use ScoreDocs instead")]
 		public ScoreDoc[] scoreDocs;
 		/// <summary>Stores the maximum score value encountered, needed for normalizing. </summary>
+        [Obsolete("For backward compatibility. Use MaxScore instead")]
 		private float maxScore;
-		
+
+        public int TotalHits
+        {
+            get { return totalHits; }
+            set { totalHits = value; }
+        }
+
+        public ScoreDoc[] ScoreDocs
+        {
+            get { return scoreDocs; }
+            set { scoreDocs = value; }
+        }
+
+        public float MaxScore
+        {
+            get { return maxScore; }
+            set { maxScore = value; }
+        }
+
+
 		/// <summary>Returns the maximum score value encountered. Note that in case
 		/// scores are not tracked, this returns {@link Float#NaN}.
 		/// </summary>
 		public virtual float GetMaxScore()
 		{
-			return maxScore;
+			return MaxScore;
 		}
 		
 		/// <summary>Sets the maximum score value encountered. </summary>
 		public virtual void  SetMaxScore(float maxScore)
 		{
-			this.maxScore = maxScore;
+			this.MaxScore = maxScore;
 		}
 		
 		/// <summary>Constructs a TopDocs with a default maxScore=Float.NaN. </summary>
@@ -58,9 +80,9 @@ namespace Lucene.Net.Search
 		/// <summary></summary>
 		public TopDocs(int totalHits, ScoreDoc[] scoreDocs, float maxScore)
 		{
-			this.totalHits = totalHits;
-			this.scoreDocs = scoreDocs;
-			this.maxScore = maxScore;
+			this.TotalHits = totalHits;
+			this.ScoreDocs = scoreDocs;
+			this.MaxScore = maxScore;
 		}
 	}
 }
\ No newline at end of file

Modified: incubator/lucene.net/trunk/C#/src/Test/Analysis/TestKeywordAnalyzer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Analysis/TestKeywordAnalyzer.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Analysis/TestKeywordAnalyzer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Analysis/TestKeywordAnalyzer.cs Tue Mar 22 09:31:10 2011
@@ -68,7 +68,7 @@ namespace Lucene.Net.Analysis
 			QueryParser queryParser = new QueryParser("description", analyzer);
 			Query query = queryParser.Parse("partnum:Q36 AND SPACE");
 			
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual("+partnum:Q36 +space", query.ToString("description"), "Q36 kept as-is");
 			Assert.AreEqual(1, hits.Length, "doc found!");
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/Document/TestDocument.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Document/TestDocument.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Document/TestDocument.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Document/TestDocument.cs Tue Mar 22 09:31:10 2011
@@ -180,7 +180,7 @@ namespace Lucene.Net.Documents
 			Query query = new TermQuery(new Term("keyword", "test1"));
 			
 			// ensure that queries return expected results without DateFilter first
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			DoAssert(searcher.Doc(hits[0].doc), true);
@@ -256,7 +256,7 @@ namespace Lucene.Net.Documents
 			Query query = new TermQuery(new Term("keyword", "test"));
 			
 			// ensure that queries return expected results without DateFilter first
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			int result = 0;
 			for (int i = 0; i < 3; i++)

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestBackwardsCompatibility.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestBackwardsCompatibility.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestBackwardsCompatibility.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestBackwardsCompatibility.cs Tue Mar 22 09:31:10 2011
@@ -239,7 +239,7 @@ namespace Lucene.Net.Index
 					Assert.AreEqual(7, i);
 			}
 			
-			ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).ScoreDocs;
 			
 			// First document should be #21 since it's norm was
 			// increased:
@@ -251,11 +251,11 @@ namespace Lucene.Net.Index
 			if (!oldName.StartsWith("19.") && !oldName.StartsWith("20.") && !oldName.StartsWith("21.") && !oldName.StartsWith("22."))
 			{
 				// Test on indices >= 2.3
-				hits = searcher.Search(new TermQuery(new Term("utf8", "\u0000")), null, 1000).scoreDocs;
+				hits = searcher.Search(new TermQuery(new Term("utf8", "\u0000")), null, 1000).ScoreDocs;
 				Assert.AreEqual(34, hits.Length);
-				hits = searcher.Search(new TermQuery(new Term("utf8", "Lu\uD834\uDD1Ece\uD834\uDD60ne")), null, 1000).scoreDocs;
+				hits = searcher.Search(new TermQuery(new Term("utf8", "Lu\uD834\uDD1Ece\uD834\uDD60ne")), null, 1000).ScoreDocs;
 				Assert.AreEqual(34, hits.Length);
-				hits = searcher.Search(new TermQuery(new Term("utf8", "ab\ud917\udc17cd")), null, 1000).scoreDocs;
+				hits = searcher.Search(new TermQuery(new Term("utf8", "ab\ud917\udc17cd")), null, 1000).ScoreDocs;
 				Assert.AreEqual(34, hits.Length);
 			}
 			
@@ -303,7 +303,7 @@ namespace Lucene.Net.Index
 			
 			// make sure searching sees right # hits
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).ScoreDocs;
 			Document d = searcher.Doc(hits[0].doc);
 			Assert.AreEqual("21", d.Get("id"), "wrong first document");
 			TestHits(hits, 44, searcher.GetIndexReader());
@@ -320,7 +320,7 @@ namespace Lucene.Net.Index
 			
 			// make sure they "took":
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
+			hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).ScoreDocs;
 			Assert.AreEqual(43, hits.Length, "wrong number of hits");
 			d = searcher.Doc(hits[0].doc);
 			Assert.AreEqual("22", d.Get("id"), "wrong first document");
@@ -333,7 +333,7 @@ namespace Lucene.Net.Index
 			writer.Close();
 			
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
+			hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).ScoreDocs;
 			Assert.AreEqual(43, hits.Length, "wrong number of hits");
 			d = searcher.Doc(hits[0].doc);
 			TestHits(hits, 43, searcher.GetIndexReader());
@@ -354,7 +354,7 @@ namespace Lucene.Net.Index
 			
 			// make sure searching sees right # hits
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).ScoreDocs;
 			Assert.AreEqual(34, hits.Length, "wrong number of hits");
 			Document d = searcher.Doc(hits[0].doc);
 			Assert.AreEqual("21", d.Get("id"), "wrong first document");
@@ -371,7 +371,7 @@ namespace Lucene.Net.Index
 			
 			// make sure they "took":
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
+			hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).ScoreDocs;
 			Assert.AreEqual(33, hits.Length, "wrong number of hits");
 			d = searcher.Doc(hits[0].doc);
 			Assert.AreEqual("22", d.Get("id"), "wrong first document");
@@ -384,7 +384,7 @@ namespace Lucene.Net.Index
 			writer.Close();
 			
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).scoreDocs;
+			hits = searcher.Search(new TermQuery(new Term("content", "aaa")), null, 1000).ScoreDocs;
 			Assert.AreEqual(33, hits.Length, "wrong number of hits");
 			d = searcher.Doc(hits[0].doc);
 			Assert.AreEqual("22", d.Get("id"), "wrong first document");

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestDeletionPolicy.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestDeletionPolicy.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestDeletionPolicy.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestDeletionPolicy.cs Tue Mar 22 09:31:10 2011
@@ -707,7 +707,7 @@ namespace Lucene.Net.Index
 					reader.DeleteDocument(3 * i + 1);
 					reader.SetNorm(4 * i + 1, "content", 2.0F);
 					IndexSearcher searcher = new IndexSearcher(reader);
-					ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+					ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 					Assert.AreEqual(16 * (1 + i), hits.Length);
 					// this is a commit when autoCommit=false:
 					reader.Close();
@@ -724,7 +724,7 @@ namespace Lucene.Net.Index
 					Assert.AreEqual(2 * (N + 2) - 1, policy.numOnCommit);
 				
 				IndexSearcher searcher2 = new IndexSearcher(dir);
-				ScoreDoc[] hits2 = searcher2.Search(query, null, 1000).scoreDocs;
+				ScoreDoc[] hits2 = searcher2.Search(query, null, 1000).ScoreDocs;
 				Assert.AreEqual(176, hits2.Length);
 				
 				// Simplistic check: just verify only the past N segments_N's still
@@ -746,7 +746,7 @@ namespace Lucene.Net.Index
 						if (!autoCommit)
 						{
 							searcher2 = new IndexSearcher(reader);
-							hits2 = searcher2.Search(query, null, 1000).scoreDocs;
+							hits2 = searcher2.Search(query, null, 1000).ScoreDocs;
 							if (i > 1)
 							{
 								if (i % 2 == 0)
@@ -827,7 +827,7 @@ namespace Lucene.Net.Index
 					reader.DeleteDocument(3);
 					reader.SetNorm(5, "content", 2.0F);
 					IndexSearcher searcher = new IndexSearcher(reader);
-					ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+					ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 					Assert.AreEqual(16, hits.Length);
 					// this is a commit when autoCommit=false:
 					reader.Close();
@@ -844,7 +844,7 @@ namespace Lucene.Net.Index
 					Assert.AreEqual(3 * (N + 1), policy.numOnCommit);
 				
 				IndexSearcher searcher2 = new IndexSearcher(dir);
-				ScoreDoc[] hits2 = searcher2.Search(query, null, 1000).scoreDocs;
+				ScoreDoc[] hits2 = searcher2.Search(query, null, 1000).ScoreDocs;
 				Assert.AreEqual(0, hits2.Length);
 				
 				// Simplistic check: just verify only the past N segments_N's still
@@ -866,7 +866,7 @@ namespace Lucene.Net.Index
 						if (!autoCommit)
 						{
 							searcher2 = new IndexSearcher(reader);
-							hits2 = searcher2.Search(query, null, 1000).scoreDocs;
+							hits2 = searcher2.Search(query, null, 1000).ScoreDocs;
 							Assert.AreEqual(expectedCount, hits2.Length);
 							searcher2.Close();
 							if (expectedCount == 0)

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestIndexReader.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexReader.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexReader.cs Tue Mar 22 09:31:10 2011
@@ -1160,7 +1160,7 @@ namespace Lucene.Net.Index
 					ScoreDoc[] hits = null;
 					try
 					{
-						hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+						hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
 					}
 					catch (System.IO.IOException e)
 					{

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexReaderReopen.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestIndexReaderReopen.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexReaderReopen.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexReaderReopen.cs Tue Mar 22 09:31:10 2011
@@ -408,7 +408,7 @@ namespace Lucene.Net.Index
 						
 						
 						IndexSearcher searcher = new IndexSearcher(refreshed);
-						ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("field1", "a" + rnd.Next(refreshed.MaxDoc()))), null, 1000).scoreDocs;
+						ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("field1", "a" + rnd.Next(refreshed.MaxDoc()))), null, 1000).ScoreDocs;
 						if (hits.Length > 0)
 						{
 							searcher.Doc(hits[0].doc);

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestIndexWriter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriter.cs Tue Mar 22 09:31:10 2011
@@ -564,7 +564,7 @@ namespace Lucene.Net.Index
             Assert.AreEqual(57, reader.DocFreq(searchTerm), "first docFreq");
 
             IndexSearcher searcher = new IndexSearcher(reader);
-            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(57, hits.Length, "first number of hits");
             searcher.Close();
             reader.Close();
@@ -815,7 +815,7 @@ namespace Lucene.Net.Index
                         searcher = new IndexSearcher(reader);
                         try
                         {
-                            hits = searcher.Search(new TermQuery(searchTerm), null, END_COUNT).scoreDocs;
+                            hits = searcher.Search(new TermQuery(searchTerm), null, END_COUNT).ScoreDocs;
                         }
                         catch (System.IO.IOException e)
                         {
@@ -1527,7 +1527,7 @@ namespace Lucene.Net.Index
 
             Term searchTerm = new Term("content", "aaa");
             IndexSearcher searcher = new IndexSearcher(dir);
-            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(14, hits.Length, "first number of hits");
             searcher.Close();
 
@@ -1541,7 +1541,7 @@ namespace Lucene.Net.Index
                     AddDoc(writer);
                 }
                 searcher = new IndexSearcher(dir);
-                hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+                hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
                 Assert.AreEqual(14, hits.Length, "reader incorrectly sees changes from writer with autoCommit disabled");
                 searcher.Close();
                 Assert.IsTrue(reader.IsCurrent(), "reader should have still been current");
@@ -1552,7 +1552,7 @@ namespace Lucene.Net.Index
             Assert.IsFalse(reader.IsCurrent(), "reader should not be current now");
 
             searcher = new IndexSearcher(dir);
-            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(47, hits.Length, "reader did not see changes after writer was closed");
             searcher.Close();
         }
@@ -1580,7 +1580,7 @@ namespace Lucene.Net.Index
 
             Term searchTerm = new Term("content", "aaa");
             IndexSearcher searcher = new IndexSearcher(dir);
-            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(14, hits.Length, "first number of hits");
             searcher.Close();
 
@@ -1594,7 +1594,7 @@ namespace Lucene.Net.Index
             writer.DeleteDocuments(searchTerm);
 
             searcher = new IndexSearcher(dir);
-            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(14, hits.Length, "reader incorrectly sees changes from writer with autoCommit disabled");
             searcher.Close();
 
@@ -1604,7 +1604,7 @@ namespace Lucene.Net.Index
             AssertNoUnreferencedFiles(dir, "unreferenced files remain after abort()");
 
             searcher = new IndexSearcher(dir);
-            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(14, hits.Length, "saw changes after writer.abort");
             searcher.Close();
 
@@ -1624,14 +1624,14 @@ namespace Lucene.Net.Index
                     AddDoc(writer);
                 }
                 searcher = new IndexSearcher(dir);
-                hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+                hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
                 Assert.AreEqual(14, hits.Length, "reader incorrectly sees changes from writer with autoCommit disabled");
                 searcher.Close();
             }
 
             writer.Close();
             searcher = new IndexSearcher(dir);
-            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(218, hits.Length, "didn't see changes after close");
             searcher.Close();
 
@@ -2025,7 +2025,7 @@ namespace Lucene.Net.Index
             writer.Close();
 
             IndexSearcher searcher = new IndexSearcher(dir);
-            ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("field", "aaa")), null, 1000).scoreDocs;
+            ScoreDoc[] hits = searcher.Search(new TermQuery(new Term("field", "aaa")), null, 1000).ScoreDocs;
             Assert.AreEqual(300, hits.Length);
             searcher.Close();
 
@@ -2055,7 +2055,7 @@ namespace Lucene.Net.Index
             Term searchTerm = new Term("field", "aaa");
 
             IndexSearcher searcher = new IndexSearcher(dir);
-            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(10, hits.Length);
             searcher.Close();
 
@@ -2075,7 +2075,7 @@ namespace Lucene.Net.Index
             }
             writer.Close();
             searcher = new IndexSearcher(dir);
-            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(27, hits.Length);
             searcher.Close();
 
@@ -2136,7 +2136,7 @@ namespace Lucene.Net.Index
             writer.Close();
             Term searchTerm = new Term("content", "aaa");
             IndexSearcher searcher = new IndexSearcher(dir);
-            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+            ScoreDoc[] hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
             Assert.AreEqual(100, hits.Length, "did not get right number of hits");
             writer.Close();
 
@@ -2396,7 +2396,7 @@ namespace Lucene.Net.Index
 
                     while (true)
                     {
-                        MergePolicy.OneMerge merge = writer.GetNextMerge();
+                        MergePolicy.OneMerge merge = writer.GetNextMerge_forNUnit();
                         if (merge == null)
                             break;
                         for (int i = 0; i < merge.segments_ForNUnit.Count; i++)
@@ -4383,11 +4383,11 @@ namespace Lucene.Net.Index
             pq.Add(new Term("field", "a"));
             pq.Add(new Term("field", "b"));
             pq.Add(new Term("field", "c"));
-            ScoreDoc[] hits = s.Search(pq, null, 1000).scoreDocs;
+            ScoreDoc[] hits = s.Search(pq, null, 1000).ScoreDocs;
             Assert.AreEqual(1, hits.Length);
 
             Query q = new SpanTermQuery(new Term("field", "a"));
-            hits = s.Search(q, null, 1000).scoreDocs;
+            hits = s.Search(q, null, 1000).ScoreDocs;
             Assert.AreEqual(1, hits.Length);
             TermPositions tps = s.GetIndexReader().TermPositions(new Term("field", "a"));
             Assert.IsTrue(tps.Next());

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriterDelete.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestIndexWriterDelete.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriterDelete.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriterDelete.cs Tue Mar 22 09:31:10 2011
@@ -542,7 +542,7 @@ namespace Lucene.Net.Index
 		private int GetHitCount(Directory dir, Term term)
 		{
 			IndexSearcher searcher = new IndexSearcher(dir);
-			int hitCount = searcher.Search(new TermQuery(term), null, 1000).totalHits;
+			int hitCount = searcher.Search(new TermQuery(term), null, 1000).TotalHits;
 			searcher.Close();
 			return hitCount;
 		}
@@ -724,7 +724,7 @@ namespace Lucene.Net.Index
 						ScoreDoc[] hits = null;
 						try
 						{
-							hits = searcher.Search(new TermQuery(searchTerm), null, 1000).scoreDocs;
+							hits = searcher.Search(new TermQuery(searchTerm), null, 1000).ScoreDocs;
 						}
 						catch (System.IO.IOException e)
 						{

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriterReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestIndexWriterReader.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriterReader.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestIndexWriterReader.cs Tue Mar 22 09:31:10 2011
@@ -926,7 +926,7 @@ namespace Lucene.Net.Index
 			// reader should remain usable even after IndexWriter is closed:
 			Assert.AreEqual(100, r.NumDocs());
 			Query q = new TermQuery(new Term("indexname", "test"));
-			Assert.AreEqual(100, new IndexSearcher(r).Search(q, 10).totalHits);
+			Assert.AreEqual(100, new IndexSearcher(r).Search(q, 10).TotalHits);
 			
 			try
 			{
@@ -986,7 +986,7 @@ namespace Lucene.Net.Index
 					r = r2;
 				}
 				Query q = new TermQuery(new Term("indexname", "test"));
-				int count = new IndexSearcher(r).Search(q, 10).totalHits;
+				int count = new IndexSearcher(r).Search(q, 10).TotalHits;
 				Assert.IsTrue(count >= lastCount);
 				lastCount = count;
 			}
@@ -1045,7 +1045,7 @@ namespace Lucene.Net.Index
 					r = r2;
 				}
 				Query q = new TermQuery(new Term("indexname", "test"));
-				sum += new IndexSearcher(r).Search(q, 10).totalHits;
+				sum += new IndexSearcher(r).Search(q, 10).TotalHits;
 			}
 			
 			for (int i = 0; i < NUM_THREAD; i++)
@@ -1126,7 +1126,7 @@ namespace Lucene.Net.Index
             {
                 IndexSearcher s = new IndexSearcher(r);
                 Lucene.Net.Search.TopDocs hits = s.Search(new TermQuery(new Term("foo", "bar")), 10);
-                Assert.AreEqual(20, hits.totalHits);
+                Assert.AreEqual(20, hits.TotalHits);
             }
         }
 

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestLazyProxSkipping.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestLazyProxSkipping.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestLazyProxSkipping.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestLazyProxSkipping.cs Tue Mar 22 09:31:10 2011
@@ -127,7 +127,7 @@ namespace Lucene.Net.Index
 			PhraseQuery pq = new PhraseQuery();
 			pq.Add(new Term(this.field, this.term1));
 			pq.Add(new Term(this.field, this.term2));
-			return this.searcher.Search(pq, null, 1000).scoreDocs;
+			return this.searcher.Search(pq, null, 1000).ScoreDocs;
 		}
 		
 		private void  PerformTest(int numHits)

Modified: incubator/lucene.net/trunk/C#/src/Test/Index/TestParallelReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Index/TestParallelReader.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Index/TestParallelReader.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Index/TestParallelReader.cs Tue Mar 22 09:31:10 2011
@@ -238,8 +238,8 @@ namespace Lucene.Net.Index
 		
 		private void  QueryTest(Query query)
 		{
-			ScoreDoc[] parallelHits = parallel.Search(query, null, 1000).scoreDocs;
-			ScoreDoc[] singleHits = single.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] parallelHits = parallel.Search(query, null, 1000).ScoreDocs;
+			ScoreDoc[] singleHits = single.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(parallelHits.Length, singleHits.Length);
 			for (int i = 0; i < parallelHits.Length; i++)
 			{

Modified: incubator/lucene.net/trunk/C#/src/Test/QueryParser/TestMultiFieldQueryParser.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/QueryParser/TestMultiFieldQueryParser.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/QueryParser/TestMultiFieldQueryParser.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/QueryParser/TestMultiFieldQueryParser.cs Tue Mar 22 09:31:10 2011
@@ -327,7 +327,7 @@ namespace Lucene.Net.QueryParsers
 			mfqp.SetDefaultOperator(QueryParser.Operator.AND);
 			Query q = mfqp.Parse("the footest");
 			IndexSearcher is_Renamed = new IndexSearcher(ramDir);
-			ScoreDoc[] hits = is_Renamed.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] hits = is_Renamed.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			is_Renamed.Close();
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/QueryParser/TestQueryParser.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/QueryParser/TestQueryParser.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/QueryParser/TestQueryParser.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/QueryParser/TestQueryParser.cs Tue Mar 22 09:31:10 2011
@@ -580,18 +580,18 @@ namespace Lucene.Net.QueryParsers
 			
 			// Test ConstantScoreRangeQuery
 			qp.SetMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE);
-			ScoreDoc[] result = is_Renamed.Search(qp.Parse("[ \u062F TO \u0698 ]"), null, 1000).scoreDocs;
+			ScoreDoc[] result = is_Renamed.Search(qp.Parse("[ \u062F TO \u0698 ]"), null, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "The index Term should not be included.");
 			
-			result = is_Renamed.Search(qp.Parse("[ \u0633 TO \u0638 ]"), null, 1000).scoreDocs;
+			result = is_Renamed.Search(qp.Parse("[ \u0633 TO \u0638 ]"), null, 1000).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "The index Term should be included.");
 			
 			// Test TermRangeQuery
 			qp.SetMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE);
-			result = is_Renamed.Search(qp.Parse("[ \u062F TO \u0698 ]"), null, 1000).scoreDocs;
+			result = is_Renamed.Search(qp.Parse("[ \u062F TO \u0698 ]"), null, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "The index Term should not be included.");
 			
-			result = is_Renamed.Search(qp.Parse("[ \u0633 TO \u0638 ]"), null, 1000).scoreDocs;
+			result = is_Renamed.Search(qp.Parse("[ \u0633 TO \u0638 ]"), null, 1000).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "The index Term should be included.");
 			
 			is_Renamed.Close();
@@ -1107,7 +1107,7 @@ namespace Lucene.Net.QueryParsers
 			QueryParser qp = new QueryParser("date", new WhitespaceAnalyzer());
 			qp.SetLocale(new System.Globalization.CultureInfo("en-US"));
 			Query q = qp.Parse(query);
-			ScoreDoc[] hits = is_Renamed.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] hits = is_Renamed.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(expected, hits.Length);
 		}
 		
@@ -1145,7 +1145,7 @@ namespace Lucene.Net.QueryParsers
 			IndexSearcher s = new IndexSearcher(r);
 			QueryParser qp = new QueryParser(Version.LUCENE_CURRENT, "f", a);
 			Query q = qp.Parse("\"wizard of ozzy\"");
-			Assert.AreEqual(1, s.Search(q, 1).totalHits);
+			Assert.AreEqual(1, s.Search(q, 1).TotalHits);
 			r.Close();
 			dir.Close();
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/CheckHits.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/CheckHits.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/CheckHits.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/CheckHits.cs Tue Mar 22 09:31:10 2011
@@ -170,7 +170,7 @@ namespace Lucene.Net.Search
 				QueryUtils.Check(query, searcher);
 			}
 			
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			
 			System.Collections.ArrayList correct = new System.Collections.ArrayList();
 			for (int i = 0; i < results.Length; i++)
@@ -271,19 +271,19 @@ namespace Lucene.Net.Search
 		public static System.String TopdocsString(TopDocs docs, int start, int end)
 		{
 			System.Text.StringBuilder sb = new System.Text.StringBuilder();
-			sb.Append("TopDocs totalHits=").Append(docs.totalHits).Append(" top=").Append(docs.scoreDocs.Length).Append('\n');
+			sb.Append("TopDocs totalHits=").Append(docs.TotalHits).Append(" top=").Append(docs.ScoreDocs.Length).Append('\n');
 			if (end <= 0)
-				end = docs.scoreDocs.Length;
+				end = docs.ScoreDocs.Length;
 			else
-				end = System.Math.Min(end, docs.scoreDocs.Length);
+				end = System.Math.Min(end, docs.ScoreDocs.Length);
 			for (int i = start; i < end; i++)
 			{
 				sb.Append('\t');
 				sb.Append(i);
 				sb.Append(") doc=");
-				sb.Append(docs.scoreDocs[i].doc);
+				sb.Append(docs.ScoreDocs[i].doc);
 				sb.Append("\tscore=");
-				sb.Append(docs.scoreDocs[i].score);
+				sb.Append(docs.ScoreDocs[i].score);
 				sb.Append('\n');
 			}
 			return sb.ToString();

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestCustomScoreQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Function/TestCustomScoreQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestCustomScoreQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestCustomScoreQuery.cs Tue Mar 22 09:31:10 2011
@@ -237,11 +237,11 @@ namespace Lucene.Net.Search.Function
 
             IndexSearcher s = new IndexSearcher(dir);
             TopDocs hits = s.Search(q, 1000);
-            Assert.AreEqual(N_DOCS, hits.totalHits);
+            Assert.AreEqual(N_DOCS, hits.TotalHits);
             for(int i=0;i<N_DOCS;i++) 
             {
-                int doc = hits.scoreDocs[i].doc;
-                float score = hits.scoreDocs[i].score;
+                int doc = hits.ScoreDocs[i].doc;
+                float score = hits.ScoreDocs[i].score;
                 Assert.AreEqual(score, (float)1 + (4 * doc) % N_DOCS, 0.0001, "doc=" + doc);
             }
             s.Close();
@@ -358,9 +358,9 @@ namespace Lucene.Net.Search.Function
 		private System.Collections.Hashtable TopDocsToMap(TopDocs td)
 		{
 			System.Collections.Hashtable h = new System.Collections.Hashtable();
-			for (int i = 0; i < td.totalHits; i++)
+			for (int i = 0; i < td.TotalHits; i++)
 			{
-				h[(System.Int32) td.scoreDocs[i].doc] = (float) td.scoreDocs[i].score;
+				h[(System.Int32) td.ScoreDocs[i].doc] = (float) td.ScoreDocs[i].score;
 			}
 			return h;
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestFieldScoreQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Function/TestFieldScoreQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestFieldScoreQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestFieldScoreQuery.cs Tue Mar 22 09:31:10 2011
@@ -92,7 +92,7 @@ namespace Lucene.Net.Search.Function
 			Query q = new FieldScoreQuery(field, tp);
 			Log("test: " + q);
 			QueryUtils.Check(q, s);
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(N_DOCS, h.Length, "All docs should be matched!");
 			System.String prevID = "ID" + (N_DOCS + 1); // greater than all ids of docs in this test
 			for (int i = 0; i < h.Length; i++)
@@ -144,8 +144,8 @@ namespace Lucene.Net.Search.Function
 			IndexSearcher s = new IndexSearcher(dir);
 			Query q = new FieldScoreQuery(field, tp);
 			TopDocs td = s.Search(q, null, 1000);
-			Assert.AreEqual(N_DOCS, td.totalHits, "All docs should be matched!");
-			ScoreDoc[] sd = td.scoreDocs;
+			Assert.AreEqual(N_DOCS, td.TotalHits, "All docs should be matched!");
+			ScoreDoc[] sd = td.ScoreDocs;
 			for (int i = 0; i < sd.Length; i++)
 			{
 				float score = sd[i].score;
@@ -206,7 +206,7 @@ namespace Lucene.Net.Search.Function
 			for (int i = 0; i < 10; i++)
 			{
 				FieldScoreQuery q = new FieldScoreQuery(field, tp);
-				ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+				ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 				Assert.AreEqual(N_DOCS, h.Length, "All docs should be matched!");
 				IndexReader[] readers = s.GetIndexReader().GetSequentialSubReaders();
 				for (int j = 0; j < readers.Length; j++)
@@ -240,7 +240,7 @@ namespace Lucene.Net.Search.Function
 			// verify new values are reloaded (not reused) for a new reader
 			s = new IndexSearcher(dir);
 			FieldScoreQuery q2 = new FieldScoreQuery(field, tp);
-			ScoreDoc[] h2 = s.Search(q2, null, 1000).scoreDocs;
+			ScoreDoc[] h2 = s.Search(q2, null, 1000).ScoreDocs;
 			Assert.AreEqual(N_DOCS, h2.Length, "All docs should be matched!");
 			IndexReader[] readers2 = s.GetIndexReader().GetSequentialSubReaders();
 			for (int j = 0; j < readers2.Length; j++)

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestOrdValues.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Function/TestOrdValues.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestOrdValues.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Function/TestOrdValues.cs Tue Mar 22 09:31:10 2011
@@ -83,7 +83,7 @@ namespace Lucene.Net.Search.Function
 			Query q = new ValueSourceQuery(vs);
 			Log("test: " + q);
 			QueryUtils.Check(q, s);
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(N_DOCS, h.Length, "All docs should be matched!");
 			System.String prevID = inOrder?"IE":"IC"; // smaller than all ids of docs in this test ("ID0001", etc.)
 			
@@ -134,8 +134,8 @@ namespace Lucene.Net.Search.Function
 			}
 			Query q = new ValueSourceQuery(vs);
 			TopDocs td = s.Search(q, null, 1000);
-			Assert.AreEqual(N_DOCS, td.totalHits, "All docs should be matched!");
-			ScoreDoc[] sd = td.scoreDocs;
+			Assert.AreEqual(N_DOCS, td.TotalHits, "All docs should be matched!");
+			ScoreDoc[] sd = td.ScoreDocs;
 			for (int i = 0; i < sd.Length; i++)
 			{
 				float score = sd[i].score;
@@ -183,7 +183,7 @@ namespace Lucene.Net.Search.Function
 					vs = new ReverseOrdFieldSource(field);
 				}
 				ValueSourceQuery q = new ValueSourceQuery(vs);
-				ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+				ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 				try
 				{
 					Assert.AreEqual(N_DOCS, h.Length, "All docs should be matched!");
@@ -229,7 +229,7 @@ namespace Lucene.Net.Search.Function
 				vs2 = new ReverseOrdFieldSource(field2);
 			}
 			q2 = new ValueSourceQuery(vs2);
-			h2 = s.Search(q2, null, 1000).scoreDocs;
+			h2 = s.Search(q2, null, 1000).ScoreDocs;
 			Assert.AreEqual(N_DOCS, h2.Length, "All docs should be matched!");
 			IndexReader[] readers2 = s.GetIndexReader().GetSequentialSubReaders();
 			
@@ -262,7 +262,7 @@ namespace Lucene.Net.Search.Function
 				vs2 = new ReverseOrdFieldSource(field);
 			}
 			q2 = new ValueSourceQuery(vs2);
-			h2 = s.Search(q2, null, 1000).scoreDocs;
+			h2 = s.Search(q2, null, 1000).ScoreDocs;
 			Assert.AreEqual(N_DOCS, h2.Length, "All docs should be matched!");
 			readers2 = s.GetIndexReader().GetSequentialSubReaders();
 			

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestBoostingTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Payloads/TestBoostingTermQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestBoostingTermQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestBoostingTermQuery.cs Tue Mar 22 09:31:10 2011
@@ -180,15 +180,15 @@ namespace Lucene.Net.Search.Payloads
 			BoostingTermQuery query = new BoostingTermQuery(new Term("field", "seventy"));
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 100, "hits Size: " + hits.totalHits + " is not: " + 100);
+			Assert.IsTrue(hits.TotalHits == 100, "hits Size: " + hits.TotalHits + " is not: " + 100);
 			
 			//they should all have the exact same score, because they all contain seventy once, and we set
 			//all the other similarity factors to be 1
 			
 			Assert.IsTrue(hits.GetMaxScore() == 1, hits.GetMaxScore() + " does not equal: " + 1);
-			for (int i = 0; i < hits.scoreDocs.Length; i++)
+			for (int i = 0; i < hits.ScoreDocs.Length; i++)
 			{
-				ScoreDoc doc = hits.scoreDocs[i];
+				ScoreDoc doc = hits.ScoreDocs[i];
 				Assert.IsTrue(doc.score == 1, doc.score + " does not equal: " + 1);
 			}
 			CheckHits.CheckExplanations(query, PayloadHelper.FIELD, searcher, true);
@@ -208,7 +208,7 @@ namespace Lucene.Net.Search.Payloads
 			BoostingTermQuery query = new BoostingTermQuery(new Term(PayloadHelper.MULTI_FIELD, "seventy"));
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 100, "hits Size: " + hits.totalHits + " is not: " + 100);
+			Assert.IsTrue(hits.TotalHits == 100, "hits Size: " + hits.TotalHits + " is not: " + 100);
 			
 			//they should all have the exact same score, because they all contain seventy once, and we set
 			//all the other similarity factors to be 1
@@ -218,9 +218,9 @@ namespace Lucene.Net.Search.Payloads
 			//there should be exactly 10 items that score a 3, all the rest should score a 2
 			//The 10 items are: 70 + i*100 where i in [0-9]
 			int numTens = 0;
-			for (int i = 0; i < hits.scoreDocs.Length; i++)
+			for (int i = 0; i < hits.ScoreDocs.Length; i++)
 			{
-				ScoreDoc doc = hits.scoreDocs[i];
+				ScoreDoc doc = hits.ScoreDocs[i];
 				if (doc.doc % 10 == 0)
 				{
 					numTens++;
@@ -252,7 +252,7 @@ namespace Lucene.Net.Search.Payloads
 			BoostingTermQuery query = new BoostingTermQuery(new Term(PayloadHelper.FIELD, "junk"));
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 0, "hits Size: " + hits.totalHits + " is not: " + 0);
+			Assert.IsTrue(hits.TotalHits == 0, "hits Size: " + hits.TotalHits + " is not: " + 0);
 		}
 		
 		[Test]
@@ -267,7 +267,7 @@ namespace Lucene.Net.Search.Payloads
 			query.Add(c2);
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 1, "hits Size: " + hits.totalHits + " is not: " + 1);
+			Assert.IsTrue(hits.TotalHits == 1, "hits Size: " + hits.TotalHits + " is not: " + 1);
 			int[] results = new int[1];
 			results[0] = 0; //hits.scoreDocs[0].doc;
 			CheckHits.CheckHitCollector(query, PayloadHelper.NO_PAYLOAD_FIELD, searcher, results);

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestPayloadNearQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Payloads/TestPayloadNearQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestPayloadNearQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestPayloadNearQuery.cs Tue Mar 22 09:31:10 2011
@@ -185,10 +185,10 @@ namespace Lucene.Net.Search.Payloads
 			// and all the similarity factors are set to 1
 			hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 10, "should be 10 hits");
-			for (int j = 0; j < hits.scoreDocs.Length; j++)
+			Assert.IsTrue(hits.TotalHits == 10, "should be 10 hits");
+			for (int j = 0; j < hits.ScoreDocs.Length; j++)
 			{
-				ScoreDoc doc = hits.scoreDocs[j];
+				ScoreDoc doc = hits.ScoreDocs[j];
 				Assert.IsTrue(doc.score == 3, doc.score + " does not equal: " + 3);
 			}
 			for (int i = 1; i < 10; i++)
@@ -198,10 +198,10 @@ namespace Lucene.Net.Search.Payloads
 				// and all the similarity factors are set to 1
 				hits = searcher.Search(query, null, 100);
 				Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-				Assert.IsTrue(hits.totalHits == 100, "should be 100 hits");
-				for (int j = 0; j < hits.scoreDocs.Length; j++)
+				Assert.IsTrue(hits.TotalHits == 100, "should be 100 hits");
+				for (int j = 0; j < hits.ScoreDocs.Length; j++)
 				{
-					ScoreDoc doc = hits.scoreDocs[j];
+					ScoreDoc doc = hits.ScoreDocs[j];
 					//				System.out.println("Doc: " + doc.toString());
 					//				System.out.println("Explain: " + searcher.explain(query, doc.doc));
 					Assert.IsTrue(doc.score == 3, doc.score + " does not equal: " + 3);
@@ -223,7 +223,7 @@ namespace Lucene.Net.Search.Payloads
 			clauses[1] = q2;
 			query = new PayloadNearQuery(clauses, 10, false);
 			// System.out.println(query.toString());
-			Assert.AreEqual(12, searcher.Search(query, null, 100).totalHits);
+			Assert.AreEqual(12, searcher.Search(query, null, 100).TotalHits);
 			/*
 			* System.out.println(hits.totalHits); for (int j = 0; j <
 			* hits.scoreDocs.length; j++) { ScoreDoc doc = hits.scoreDocs[j];
@@ -249,11 +249,11 @@ namespace Lucene.Net.Search.Payloads
 			TopDocs hits;
 			query = NewPhraseQuery("field", "nine hundred ninety nine", true);
 			hits = searcher.Search(query, null, 100);
-			ScoreDoc doc = hits.scoreDocs[0];
+			ScoreDoc doc = hits.ScoreDocs[0];
 			//		System.out.println("Doc: " + doc.toString());
 			//		System.out.println("Explain: " + searcher.explain(query, doc.doc));
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 1, "there should only be one hit");
+			Assert.IsTrue(hits.TotalHits == 1, "there should only be one hit");
 			// should have score = 3 because adjacent terms have payloads of 2,4
 			Assert.IsTrue(doc.score == 3, doc.score + " does not equal: " + 3);
 		}
@@ -275,9 +275,9 @@ namespace Lucene.Net.Search.Payloads
 			hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
 			// should be only 1 hit - doc 999
-			Assert.IsTrue(hits.scoreDocs.Length == 1, "should only be one hit");
+			Assert.IsTrue(hits.ScoreDocs.Length == 1, "should only be one hit");
 			// the score should be 3 - the average of all the underlying payloads
-			ScoreDoc doc = hits.scoreDocs[0];
+			ScoreDoc doc = hits.ScoreDocs[0];
 			//		System.out.println("Doc: " + doc.toString());
 			//		System.out.println("Explain: " + searcher.explain(query, doc.doc));
 			Assert.IsTrue(doc.score == 3, doc.score + " does not equal: " + 3);

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestPayloadTermQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Payloads/TestPayloadTermQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestPayloadTermQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Payloads/TestPayloadTermQuery.cs Tue Mar 22 09:31:10 2011
@@ -188,15 +188,15 @@ namespace Lucene.Net.Search.Payloads
 			PayloadTermQuery query = new PayloadTermQuery(new Term("field", "seventy"), new MaxPayloadFunction());
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 100, "hits Size: " + hits.totalHits + " is not: " + 100);
+			Assert.IsTrue(hits.TotalHits == 100, "hits Size: " + hits.TotalHits + " is not: " + 100);
 			
 			//they should all have the exact same score, because they all contain seventy once, and we set
 			//all the other similarity factors to be 1
 			
 			Assert.IsTrue(hits.GetMaxScore() == 1, hits.GetMaxScore() + " does not equal: " + 1);
-			for (int i = 0; i < hits.scoreDocs.Length; i++)
+			for (int i = 0; i < hits.ScoreDocs.Length; i++)
 			{
-				ScoreDoc doc = hits.scoreDocs[i];
+				ScoreDoc doc = hits.ScoreDocs[i];
 				Assert.IsTrue(doc.score == 1, doc.score + " does not equal: " + 1);
 			}
 			CheckHits.CheckExplanations(query, PayloadHelper.FIELD, searcher, true);
@@ -231,7 +231,7 @@ namespace Lucene.Net.Search.Payloads
 			PayloadTermQuery query = new PayloadTermQuery(new Term(PayloadHelper.MULTI_FIELD, "seventy"), new MaxPayloadFunction());
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 100, "hits Size: " + hits.totalHits + " is not: " + 100);
+			Assert.IsTrue(hits.TotalHits == 100, "hits Size: " + hits.TotalHits + " is not: " + 100);
 			
 			//they should all have the exact same score, because they all contain seventy once, and we set
 			//all the other similarity factors to be 1
@@ -241,9 +241,9 @@ namespace Lucene.Net.Search.Payloads
 			//there should be exactly 10 items that score a 4, all the rest should score a 2
 			//The 10 items are: 70 + i*100 where i in [0-9]
 			int numTens = 0;
-			for (int i = 0; i < hits.scoreDocs.Length; i++)
+			for (int i = 0; i < hits.ScoreDocs.Length; i++)
 			{
-				ScoreDoc doc = hits.scoreDocs[i];
+				ScoreDoc doc = hits.ScoreDocs[i];
 				if (doc.doc % 10 == 0)
 				{
 					numTens++;
@@ -279,7 +279,7 @@ namespace Lucene.Net.Search.Payloads
 			theSearcher.SetSimilarity(new FullSimilarity());
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 100, "hits Size: " + hits.totalHits + " is not: " + 100);
+			Assert.IsTrue(hits.TotalHits == 100, "hits Size: " + hits.TotalHits + " is not: " + 100);
 			
 			//they should all have the exact same score, because they all contain seventy once, and we set
 			//all the other similarity factors to be 1
@@ -289,9 +289,9 @@ namespace Lucene.Net.Search.Payloads
 			//there should be exactly 10 items that score a 4, all the rest should score a 2
 			//The 10 items are: 70 + i*100 where i in [0-9]
 			int numTens = 0;
-			for (int i = 0; i < hits.scoreDocs.Length; i++)
+			for (int i = 0; i < hits.ScoreDocs.Length; i++)
 			{
-				ScoreDoc doc = hits.scoreDocs[i];
+				ScoreDoc doc = hits.ScoreDocs[i];
 				if (doc.doc % 10 == 0)
 				{
 					numTens++;
@@ -322,7 +322,7 @@ namespace Lucene.Net.Search.Payloads
 			PayloadTermQuery query = new PayloadTermQuery(new Term(PayloadHelper.FIELD, "junk"), new MaxPayloadFunction());
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 0, "hits Size: " + hits.totalHits + " is not: " + 0);
+			Assert.IsTrue(hits.TotalHits == 0, "hits Size: " + hits.TotalHits + " is not: " + 0);
 		}
 		
         [Test]
@@ -337,7 +337,7 @@ namespace Lucene.Net.Search.Payloads
 			query.Add(c2);
 			TopDocs hits = searcher.Search(query, null, 100);
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
-			Assert.IsTrue(hits.totalHits == 1, "hits Size: " + hits.totalHits + " is not: " + 1);
+			Assert.IsTrue(hits.TotalHits == 1, "hits Size: " + hits.TotalHits + " is not: " + 1);
 			int[] results = new int[1];
 			results[0] = 0; //hits.scoreDocs[0].doc;
 			CheckHits.CheckHitCollector(query, PayloadHelper.NO_PAYLOAD_FIELD, searcher, results);

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestPayloadSpans.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Spans/TestPayloadSpans.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestPayloadSpans.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestPayloadSpans.cs Tue Mar 22 09:31:10 2011
@@ -278,7 +278,7 @@ namespace Lucene.Net.Search.Spans
 			
 			TopDocs topDocs = is_Renamed.Search(snq, 1);
 			System.Collections.Hashtable payloadSet = new System.Collections.Hashtable();
-			for (int i = 0; i < topDocs.scoreDocs.Length; i++)
+			for (int i = 0; i < topDocs.ScoreDocs.Length; i++)
 			{
 				while (spans.Next())
 				{
@@ -315,7 +315,7 @@ namespace Lucene.Net.Search.Spans
 			
 			TopDocs topDocs = is_Renamed.Search(snq, 1);
 			System.Collections.Hashtable payloadSet = new System.Collections.Hashtable();
-			for (int i = 0; i < topDocs.scoreDocs.Length; i++)
+			for (int i = 0; i < topDocs.ScoreDocs.Length; i++)
 			{
 				while (spans.Next())
 				{
@@ -352,7 +352,7 @@ namespace Lucene.Net.Search.Spans
 			
 			TopDocs topDocs = is_Renamed.Search(snq, 1);
 			System.Collections.Hashtable payloadSet = new System.Collections.Hashtable();
-			for (int i = 0; i < topDocs.scoreDocs.Length; i++)
+			for (int i = 0; i < topDocs.ScoreDocs.Length; i++)
 			{
 				while (spans.Next())
 				{

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestSpans.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Spans/TestSpans.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestSpans.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestSpans.cs Tue Mar 22 09:31:10 2011
@@ -479,7 +479,7 @@ namespace Lucene.Net.Search.Spans
 		// LUCENE-1404
 		private int HitCount(Searcher searcher, System.String word)
 		{
-			return searcher.Search(new TermQuery(new Term("text", word)), 10).totalHits;
+			return searcher.Search(new TermQuery(new Term("text", word)), 10).TotalHits;
 		}
 		
 		// LUCENE-1404
@@ -525,7 +525,7 @@ namespace Lucene.Net.Search.Spans
 			Assert.AreEqual(0, HitCount(searcher, "rabbit"));
 			
 			// This throws exception (it shouldn't)
-			Assert.AreEqual(1, searcher.Search(CreateSpan(0, true, new SpanQuery[]{CreateSpan(4, false, "chased", "cat"), CreateSpan("ate")}), 10).totalHits);
+			Assert.AreEqual(1, searcher.Search(CreateSpan(0, true, new SpanQuery[]{CreateSpan(4, false, "chased", "cat"), CreateSpan("ate")}), 10).TotalHits);
 			reader.Close();
 			dir.Close();
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestSpansAdvanced.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/Spans/TestSpansAdvanced.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestSpansAdvanced.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/Spans/TestSpansAdvanced.cs Tue Mar 22 09:31:10 2011
@@ -156,14 +156,14 @@ namespace Lucene.Net.Search.Spans
 			*****/
 			
 			// did we get the hits we expected
-			Assert.AreEqual(expectedIds.Length, topdocs.totalHits);
-			for (int i = 0; i < topdocs.totalHits; i++)
+			Assert.AreEqual(expectedIds.Length, topdocs.TotalHits);
+			for (int i = 0; i < topdocs.TotalHits; i++)
 			{
 				//System.out.println(i + " exp: " + expectedIds[i]);
 				//System.out.println(i + " field: " + hits.doc(i).get(FIELD_ID));
 				
-				int id = topdocs.scoreDocs[i].doc;
-				float score = topdocs.scoreDocs[i].score;
+				int id = topdocs.ScoreDocs[i].doc;
+				float score = topdocs.ScoreDocs[i].score;
 				Document doc = s.Doc(id);
 				Assert.AreEqual(expectedIds[i], doc.Get(FIELD_ID));
 				bool scoreEq = System.Math.Abs(expectedScores[i] - score) < tolerance;

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestBoolean2.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestBoolean2.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestBoolean2.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestBoolean2.cs Tue Mar 22 09:31:10 2011
@@ -108,11 +108,11 @@ namespace Lucene.Net.Search
 			{
 				Query query1 = MakeQuery(queryText);
 				BooleanQuery.SetAllowDocsOutOfOrder(true);
-				ScoreDoc[] hits1 = searcher.Search(query1, null, 1000).scoreDocs;
+				ScoreDoc[] hits1 = searcher.Search(query1, null, 1000).ScoreDocs;
 				
 				Query query2 = MakeQuery(queryText); // there should be no need to parse again...
 				BooleanQuery.SetAllowDocsOutOfOrder(false);
-				ScoreDoc[] hits2 = searcher.Search(query2, null, 1000).scoreDocs;
+				ScoreDoc[] hits2 = searcher.Search(query2, null, 1000).ScoreDocs;
 				
 				CheckHits.CheckHitsQuery(query2, hits1, hits2, expDocNrs);
 			}
@@ -231,10 +231,10 @@ namespace Lucene.Net.Search
 					
 					QueryUtils.Check(q1, searcher);
 					
-					ScoreDoc[] hits1 = searcher.Search(q1, null, 1000, sort).scoreDocs;
+					ScoreDoc[] hits1 = searcher.Search(q1, null, 1000, sort).ScoreDocs;
 					
 					BooleanQuery.SetAllowDocsOutOfOrder(true);
-					ScoreDoc[] hits2 = searcher.Search(q1, null, 1000, sort).scoreDocs;
+					ScoreDoc[] hits2 = searcher.Search(q1, null, 1000, sort).ScoreDocs;
 					tot += hits2.Length;
 					CheckHits.CheckEqual(q1, hits1, hits2);
 				}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanMinShouldMatch.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestBooleanMinShouldMatch.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanMinShouldMatch.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanMinShouldMatch.cs Tue Mar 22 09:31:10 2011
@@ -109,7 +109,7 @@ namespace Lucene.Net.Search
 		
 		public virtual void  VerifyNrHits(Query q, int expected)
 		{
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			if (expected != h.Length)
 			{
 				PrintHits(Lucene.Net.TestCase.GetName(), h, s);  
@@ -388,24 +388,24 @@ namespace Lucene.Net.Search
 				
 				// The constrained query
 				// should be a superset to the unconstrained query.
-				if (top2.totalHits > top1.totalHits)
+				if (top2.TotalHits > top1.TotalHits)
 				{
 					//TestCase.fail("Constrained results not a subset:\n" + CheckHits.TopdocsString(top1, 0, 0) + CheckHits.TopdocsString(top2, 0, 0) + "for query:" + q2.ToString());
 					Assert.Fail("Constrained results not a subset:\n" + CheckHits.TopdocsString(top1, 0, 0) + CheckHits.TopdocsString(top2, 0, 0) + "for query:" + q2.ToString());
 				}
 				
-				for (int hit = 0; hit < top2.totalHits; hit++)
+				for (int hit = 0; hit < top2.TotalHits; hit++)
 				{
-					int id = top2.scoreDocs[hit].doc;
-					float score = top2.scoreDocs[hit].score;
+					int id = top2.ScoreDocs[hit].doc;
+					float score = top2.ScoreDocs[hit].score;
 					bool found = false;
 					// find this doc in other hits
-					for (int other = 0; other < top1.totalHits; other++)
+					for (int other = 0; other < top1.TotalHits; other++)
 					{
-						if (top1.scoreDocs[other].doc == id)
+						if (top1.ScoreDocs[other].doc == id)
 						{
 							found = true;
-							float otherScore = top1.scoreDocs[other].score;
+							float otherScore = top1.ScoreDocs[other].score;
 							// check if scores match
 							if (System.Math.Abs(otherScore - score) > 1.0e-6f)
 							{

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanOr.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestBooleanOr.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanOr.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanOr.cs Tue Mar 22 09:31:10 2011
@@ -47,7 +47,7 @@ namespace Lucene.Net.Search
 		private int Search(Query q)
 		{
 			QueryUtils.Check(q, searcher);
-			return searcher.Search(q, null, 1000).totalHits;
+			return searcher.Search(q, null, 1000).TotalHits;
 		}
 		
 		[Test]

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestBooleanQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanQuery.cs Tue Mar 22 09:31:10 2011
@@ -89,7 +89,7 @@ namespace Lucene.Net.Search
 			// PhraseQuery w/ no terms added returns a null scorer
 			PhraseQuery pq = new PhraseQuery();
 			q.Add(pq, BooleanClause.Occur.SHOULD);
-			Assert.AreEqual(1, s.Search(q, 10).totalHits);
+			Assert.AreEqual(1, s.Search(q, 10).TotalHits);
 			
 			// A required clause which returns null scorer should return null scorer to
 			// IndexSearcher.
@@ -97,12 +97,12 @@ namespace Lucene.Net.Search
 			pq = new PhraseQuery();
 			q.Add(new TermQuery(new Term("field", "a")), BooleanClause.Occur.SHOULD);
 			q.Add(pq, BooleanClause.Occur.MUST);
-			Assert.AreEqual(0, s.Search(q, 10).totalHits);
+			Assert.AreEqual(0, s.Search(q, 10).TotalHits);
 			
 			DisjunctionMaxQuery dmq = new DisjunctionMaxQuery(1.0f);
 			dmq.Add(new TermQuery(new Term("field", "a")));
 			dmq.Add(pq);
-			Assert.AreEqual(1, s.Search(dmq, 10).totalHits);
+			Assert.AreEqual(1, s.Search(dmq, 10).TotalHits);
 			
 			r.Close();
 			w.Close();

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestBooleanScorer.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestBooleanScorer.cs Tue Mar 22 09:31:10 2011
@@ -135,7 +135,7 @@ namespace Lucene.Net.Search
 				query.Add(new TermQuery(new Term(FIELD, "9")), BooleanClause.Occur.MUST_NOT);
 				
 				IndexSearcher indexSearcher = new IndexSearcher(directory);
-				ScoreDoc[] hits = indexSearcher.Search(query, null, 1000).scoreDocs;
+				ScoreDoc[] hits = indexSearcher.Search(query, null, 1000).ScoreDocs;
 				Assert.AreEqual(2, hits.Length, "Number of matched documents");
 			}
 			catch (System.IO.IOException e)

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestCachingSpanFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestCachingSpanFilter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestCachingSpanFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestCachingSpanFilter.cs Tue Mar 22 09:31:10 2011
@@ -51,7 +51,7 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             TopDocs docs = searcher.Search(new MatchAllDocsQuery(), 1);
-            Assert.AreEqual(1, docs.totalHits, "Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "Should find a hit...");
 
             SpanFilter startFilter = new SpanQueryFilter(new SpanTermQuery(new Term("id", "1")));
 
@@ -59,10 +59,10 @@ namespace Lucene.Net.Search
             CachingSpanFilter filter = new CachingSpanFilter(startFilter, CachingWrapperFilter.DeletesMode.IGNORE);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(1, docs.totalHits, "[query + filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
             ConstantScoreQuery constantScore = new ConstantScoreQuery(filter);
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
 
             // now delete the doc, refresh the reader, and see that it's not there
             writer.DeleteDocuments(new Term("id", "1"));
@@ -71,10 +71,10 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(0, docs.totalHits, "[query + filter] Should *not* find a hit...");
+            Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
 
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
 
 
             // force cache to regenerate:
@@ -85,11 +85,11 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(1, docs.totalHits, "[query + filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
 
             constantScore = new ConstantScoreQuery(filter);
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
 
             // make sure we get a cache hit when we reopen readers
             // that had no new deletions
@@ -99,7 +99,7 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
             int missCount = filter.missCount;
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
             Assert.AreEqual(missCount, filter.missCount);
 
             // now delete the doc, refresh the reader, and see that it's not there
@@ -109,10 +109,10 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(0, docs.totalHits, "[query + filter] Should *not* find a hit...");
+            Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
 
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(0, docs.totalHits, "[just filter] Should *not* find a hit...");
+            Assert.AreEqual(0, docs.TotalHits, "[just filter] Should *not* find a hit...");
         }
 
         private static IndexReader RefreshReader(IndexReader reader)

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestCachingWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestCachingWrapperFilter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestCachingWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestCachingWrapperFilter.cs Tue Mar 22 09:31:10 2011
@@ -221,7 +221,7 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             TopDocs docs = searcher.Search(new MatchAllDocsQuery(), 1);
-            Assert.AreEqual(1, docs.totalHits, "Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "Should find a hit...");
 
             Filter startFilter = new QueryWrapperFilter(new TermQuery(new Term("id", "1")));
 
@@ -229,10 +229,10 @@ namespace Lucene.Net.Search
             CachingWrapperFilter filter = new CachingWrapperFilter(startFilter, CachingWrapperFilter.DeletesMode.IGNORE);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(1, docs.totalHits, "[query + filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
             ConstantScoreQuery constantScore = new ConstantScoreQuery(filter);
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
 
             // now delete the doc, refresh the reader, and see that it's not there
             writer.DeleteDocuments(new Term("id", "1"));
@@ -241,10 +241,10 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(0, docs.totalHits, "[query + filter] Should *not* find a hit...");
+            Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
 
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
 
 
             // force cache to regenerate:
@@ -255,11 +255,11 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(1, docs.totalHits, "[query + filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
 
             constantScore = new ConstantScoreQuery(filter);
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
 
             // make sure we get a cache hit when we reopen reader
             // that had no change to deletions
@@ -269,7 +269,7 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
             int missCount = filter.missCount;
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
             Assert.AreEqual(missCount, filter.missCount);
 
             // now delete the doc, refresh the reader, and see that it's not there
@@ -281,9 +281,9 @@ namespace Lucene.Net.Search
             missCount = filter.missCount;
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
             Assert.AreEqual(missCount + 1, filter.missCount);
-            Assert.AreEqual(0, docs.totalHits, "[query + filter] Should *not* find a hit...");
+            Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(0, docs.totalHits, "[just filter] Should *not* find a hit...");
+            Assert.AreEqual(0, docs.TotalHits, "[just filter] Should *not* find a hit...");
 
 
             // apply deletions dynamically
@@ -294,10 +294,10 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(1, docs.totalHits, "[query + filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[query + filter] Should find a hit...");
             constantScore = new ConstantScoreQuery(filter);
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(1, docs.totalHits, "[just filter] Should find a hit...");
+            Assert.AreEqual(1, docs.TotalHits, "[just filter] Should find a hit...");
 
             // now delete the doc, refresh the reader, and see that it's not there
             writer.DeleteDocuments(new Term("id", "1"));
@@ -306,11 +306,11 @@ namespace Lucene.Net.Search
             searcher = new IndexSearcher(reader);
 
             docs = searcher.Search(new MatchAllDocsQuery(), filter, 1);
-            Assert.AreEqual(0, docs.totalHits, "[query + filter] Should *not* find a hit...");
+            Assert.AreEqual(0, docs.TotalHits, "[query + filter] Should *not* find a hit...");
 
             missCount = filter.missCount;
             docs = searcher.Search(constantScore, 1);
-            Assert.AreEqual(0, docs.totalHits, "[just filter] Should *not* find a hit...");
+            Assert.AreEqual(0, docs.TotalHits, "[just filter] Should *not* find a hit...");
 
             // doesn't count as a miss
             Assert.AreEqual(missCount, filter.missCount);

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestCustomSearcherSort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestCustomSearcherSort.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestCustomSearcherSort.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestCustomSearcherSort.cs Tue Mar 22 09:31:10 2011
@@ -140,7 +140,7 @@ namespace Lucene.Net.Search
 		private void  MatchHits(Searcher searcher, Sort sort)
 		{
 			// make a query without sorting first
-			ScoreDoc[] hitsByRank = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hitsByRank = searcher.Search(query, null, 1000).ScoreDocs;
 			CheckHits(hitsByRank, "Sort by rank: "); // check for duplicates
 			System.Collections.IDictionary resultMap = new System.Collections.SortedList();
 			// store hits in TreeMap - TreeMap does not allow duplicates; existing entries are silently overwritten
@@ -150,7 +150,7 @@ namespace Lucene.Net.Search
 			}
 			
 			// now make a query using the sort criteria
-			ScoreDoc[] resultSort = searcher.Search(query, null, 1000, sort).scoreDocs;
+			ScoreDoc[] resultSort = searcher.Search(query, null, 1000, sort).ScoreDocs;
 			CheckHits(resultSort, "Sort by custom criteria: "); // check for duplicates
 			
 			// besides the sorting both sets of hits must be identical



Mime
View raw message