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 [3/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
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiTermConstantScore.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMultiTermConstantScore.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiTermConstantScore.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiTermConstantScore.cs Tue Mar 22 09:31:10 2011
@@ -197,7 +197,7 @@ namespace Lucene.Net.Search
 			
 			// some hits match more terms then others, score should be the same
 			
-			result = search.Search(Csrq("data", "1", "6", T, T), null, 1000).scoreDocs;
+			result = search.Search(Csrq("data", "1", "6", T, T), null, 1000).ScoreDocs;
 			int numHits = result.Length;
 			AssertEquals("wrong number of results", 6, numHits);
 			float score = result[0].score;
@@ -206,7 +206,7 @@ namespace Lucene.Net.Search
 				AssertEquals("score for " + i + " was not the same", score, result[i].score);
 			}
 			
-			result = search.Search(Csrq("data", "1", "6", T, T, MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE), null, 1000).scoreDocs;
+			result = search.Search(Csrq("data", "1", "6", T, T, MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE), null, 1000).ScoreDocs;
 			numHits = result.Length;
 			AssertEquals("wrong number of results", 6, numHits);
 			for (int i = 0; i < numHits; i++)
@@ -240,7 +240,7 @@ namespace Lucene.Net.Search
 			bq.Add(q1, BooleanClause.Occur.SHOULD);
 			bq.Add(q2, BooleanClause.Occur.SHOULD);
 			
-			ScoreDoc[] hits = search.Search(bq, null, 1000).scoreDocs;
+			ScoreDoc[] hits = search.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits[0].doc);
 			Assert.AreEqual(0, hits[1].doc);
 			Assert.IsTrue(hits[0].score > hits[1].score);
@@ -252,7 +252,7 @@ namespace Lucene.Net.Search
 			bq.Add(q1, BooleanClause.Occur.SHOULD);
 			bq.Add(q2, BooleanClause.Occur.SHOULD);
 			
-			hits = search.Search(bq, null, 1000).scoreDocs;
+			hits = search.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits[0].doc);
 			Assert.AreEqual(0, hits[1].doc);
 			Assert.IsTrue(hits[0].score > hits[1].score);
@@ -264,7 +264,7 @@ namespace Lucene.Net.Search
 			bq.Add(q1, BooleanClause.Occur.SHOULD);
 			bq.Add(q2, BooleanClause.Occur.SHOULD);
 			
-			hits = search.Search(bq, null, 1000).scoreDocs;
+			hits = search.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits[0].doc);
 			Assert.AreEqual(1, hits[1].doc);
 			Assert.IsTrue(hits[0].score > hits[1].score);
@@ -283,7 +283,7 @@ namespace Lucene.Net.Search
 			
 			Query rq = new TermRangeQuery("data", "1", "4", T, T);
 			
-			ScoreDoc[] expected = search.Search(rq, null, 1000).scoreDocs;
+			ScoreDoc[] expected = search.Search(rq, null, 1000).ScoreDocs;
 			int numHits = expected.Length;
 			
 			// now do a boolean where which also contains a
@@ -293,7 +293,7 @@ namespace Lucene.Net.Search
 			q.Add(rq, BooleanClause.Occur.MUST); // T, F);
 			q.Add(Csrq("data", "1", "6", T, T), BooleanClause.Occur.MUST); // T, F);
 			
-			ScoreDoc[] actual = search.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] actual = search.Search(q, null, 1000).ScoreDocs;
 			
 			AssertEquals("wrong numebr of hits", numHits, actual.Length);
 			for (int i = 0; i < numHits; i++)
@@ -324,110 +324,110 @@ namespace Lucene.Net.Search
 			
 			// test id, bounded on both ends
 			
-			result = search.Search(Csrq("id", minIP, maxIP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("find all", numDocs, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("find all", numDocs, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, T, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, T, F), null, numDocs).ScoreDocs;
 			AssertEquals("all but last", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, T, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, T, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("all but last", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, F, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, F, T), null, numDocs).ScoreDocs;
 			AssertEquals("all but first", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, F, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, F, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("all but first", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("all but ends", numDocs - 2, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("all but ends", numDocs - 2, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, maxIP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, maxIP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("med and up", 1 + maxId - medId, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("med and up", 1 + maxId - medId, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, medIP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, medIP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("up to med", 1 + medId - minId, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, medIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, medIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("up to med", 1 + medId - minId, result.Length);
 			
 			// unbounded id
 			
-			result = search.Search(Csrq("id", minIP, null, T, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, null, T, F), null, numDocs).ScoreDocs;
 			AssertEquals("min and up", numDocs, result.Length);
 			
-			result = search.Search(Csrq("id", null, maxIP, F, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", null, maxIP, F, T), null, numDocs).ScoreDocs;
 			AssertEquals("max and down", numDocs, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, null, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, null, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("not min, but up", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", null, maxIP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", null, maxIP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("not max, but down", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, maxIP, T, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, maxIP, T, F), null, numDocs).ScoreDocs;
 			AssertEquals("med and up, not max", maxId - medId, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, medIP, F, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, medIP, F, T), null, numDocs).ScoreDocs;
 			AssertEquals("not min, up to med", medId - minId, result.Length);
 			
 			// very small sets
 			
-			result = search.Search(Csrq("id", minIP, minIP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, minIP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,F,F", 0, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, minIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, minIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,F,F", 0, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, medIP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, medIP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("med,med,F,F", 0, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, medIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, medIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("med,med,F,F", 0, result.Length);
 			
-			result = search.Search(Csrq("id", maxIP, maxIP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, maxIP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,F,F", 0, result.Length);
 			
-			result = search.Search(Csrq("id", maxIP, maxIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, maxIP, F, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,F,F", 0, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, minIP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, minIP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,T,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, minIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, minIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,T,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", null, minIP, F, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", null, minIP, F, T), null, numDocs).ScoreDocs;
 			AssertEquals("nul,min,F,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", null, minIP, F, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", null, minIP, F, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("nul,min,F,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", maxIP, maxIP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, maxIP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,T,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", maxIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, maxIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,T,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", maxIP, null, T, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, null, T, F), null, numDocs).ScoreDocs;
 			AssertEquals("max,nul,T,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", maxIP, null, T, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, null, T, F, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("max,nul,T,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, medIP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, medIP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("med,med,T,T", 1, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, medIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, medIP, T, T, MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT), null, numDocs).ScoreDocs;
 			AssertEquals("med,med,T,T", 1, result.Length);
 		}
 		
@@ -455,64 +455,64 @@ namespace Lucene.Net.Search
 			
 			// test id, bounded on both ends
 			
-			result = search.Search(Csrq("id", minIP, maxIP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("find all", numDocs, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, T, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, T, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("all but last", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, F, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, F, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("all but first", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, maxIP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, maxIP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("all but ends", numDocs - 2, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, maxIP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, maxIP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("med and up", 1 + maxId - medId, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, medIP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, medIP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("up to med", 1 + medId - minId, result.Length);
 			
 			// unbounded id
 			
-			result = search.Search(Csrq("id", minIP, null, T, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, null, T, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("min and up", numDocs, result.Length);
 			
-			result = search.Search(Csrq("id", null, maxIP, F, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", null, maxIP, F, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("max and down", numDocs, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, null, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, null, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("not min, but up", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", null, maxIP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", null, maxIP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("not max, but down", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, maxIP, T, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, maxIP, T, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("med and up, not max", maxId - medId, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, medIP, F, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, medIP, F, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("not min, up to med", medId - minId, result.Length);
 			
 			// very small sets
 			
-			result = search.Search(Csrq("id", minIP, minIP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, minIP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,F,F,c", 0, result.Length);
-			result = search.Search(Csrq("id", medIP, medIP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, medIP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("med,med,F,F,c", 0, result.Length);
-			result = search.Search(Csrq("id", maxIP, maxIP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, maxIP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,F,F,c", 0, result.Length);
 			
-			result = search.Search(Csrq("id", minIP, minIP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", minIP, minIP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,T,T,c", 1, result.Length);
-			result = search.Search(Csrq("id", null, minIP, F, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", null, minIP, F, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("nul,min,F,T,c", 1, result.Length);
 			
-			result = search.Search(Csrq("id", maxIP, maxIP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, maxIP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,T,T,c", 1, result.Length);
-			result = search.Search(Csrq("id", maxIP, null, T, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", maxIP, null, T, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("max,nul,T,T,c", 1, result.Length);
 			
-			result = search.Search(Csrq("id", medIP, medIP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("id", medIP, medIP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("med,med,T,T,c", 1, result.Length);
 		}
 		
@@ -535,47 +535,47 @@ namespace Lucene.Net.Search
 			
 			// test extremes, bounded on both ends
 			
-			result = search.Search(Csrq("rand", minRP, maxRP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, maxRP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("find all", numDocs, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, maxRP, T, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, maxRP, T, F), null, numDocs).ScoreDocs;
 			AssertEquals("all but biggest", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, maxRP, F, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, maxRP, F, T), null, numDocs).ScoreDocs;
 			AssertEquals("all but smallest", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, maxRP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, maxRP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("all but extremes", numDocs - 2, result.Length);
 			
 			// unbounded
 			
-			result = search.Search(Csrq("rand", minRP, null, T, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, null, T, F), null, numDocs).ScoreDocs;
 			AssertEquals("smallest and up", numDocs, result.Length);
 			
-			result = search.Search(Csrq("rand", null, maxRP, F, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", null, maxRP, F, T), null, numDocs).ScoreDocs;
 			AssertEquals("biggest and down", numDocs, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, null, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, null, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("not smallest, but up", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("rand", null, maxRP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", null, maxRP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("not biggest, but down", numDocs - 1, result.Length);
 			
 			// very small sets
 			
-			result = search.Search(Csrq("rand", minRP, minRP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, minRP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,F,F", 0, result.Length);
-			result = search.Search(Csrq("rand", maxRP, maxRP, F, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", maxRP, maxRP, F, F), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,F,F", 0, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, minRP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, minRP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,T,T", 1, result.Length);
-			result = search.Search(Csrq("rand", null, minRP, F, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", null, minRP, F, T), null, numDocs).ScoreDocs;
 			AssertEquals("nul,min,F,T", 1, result.Length);
 			
-			result = search.Search(Csrq("rand", maxRP, maxRP, T, T), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", maxRP, maxRP, T, T), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,T,T", 1, result.Length);
-			result = search.Search(Csrq("rand", maxRP, null, T, F), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", maxRP, null, T, F), null, numDocs).ScoreDocs;
 			AssertEquals("max,nul,T,T", 1, result.Length);
 		}
 		
@@ -601,47 +601,47 @@ namespace Lucene.Net.Search
 			
 			// test extremes, bounded on both ends
 			
-			result = search.Search(Csrq("rand", minRP, maxRP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, maxRP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("find all", numDocs, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, maxRP, T, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, maxRP, T, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("all but biggest", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, maxRP, F, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, maxRP, F, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("all but smallest", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, maxRP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, maxRP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("all but extremes", numDocs - 2, result.Length);
 			
 			// unbounded
 			
-			result = search.Search(Csrq("rand", minRP, null, T, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, null, T, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("smallest and up", numDocs, result.Length);
 			
-			result = search.Search(Csrq("rand", null, maxRP, F, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", null, maxRP, F, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("biggest and down", numDocs, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, null, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, null, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("not smallest, but up", numDocs - 1, result.Length);
 			
-			result = search.Search(Csrq("rand", null, maxRP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", null, maxRP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("not biggest, but down", numDocs - 1, result.Length);
 			
 			// very small sets
 			
-			result = search.Search(Csrq("rand", minRP, minRP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, minRP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,F,F,c", 0, result.Length);
-			result = search.Search(Csrq("rand", maxRP, maxRP, F, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", maxRP, maxRP, F, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,F,F,c", 0, result.Length);
 			
-			result = search.Search(Csrq("rand", minRP, minRP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", minRP, minRP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("min,min,T,T,c", 1, result.Length);
-			result = search.Search(Csrq("rand", null, minRP, F, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", null, minRP, F, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("nul,min,F,T,c", 1, result.Length);
 			
-			result = search.Search(Csrq("rand", maxRP, maxRP, T, T, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", maxRP, maxRP, T, T, c), null, numDocs).ScoreDocs;
 			AssertEquals("max,max,T,T,c", 1, result.Length);
-			result = search.Search(Csrq("rand", maxRP, null, T, F, c), null, numDocs).scoreDocs;
+			result = search.Search(Csrq("rand", maxRP, null, T, F, c), null, numDocs).ScoreDocs;
 			AssertEquals("max,nul,T,T,c", 1, result.Length);
 		}
 		
@@ -673,10 +673,10 @@ namespace Lucene.Net.Search
 			// index Term below should NOT be returned by a ConstantScoreRangeQuery
 			// with a Farsi Collator (or an Arabic one for the case when Farsi is
 			// not supported).
-			ScoreDoc[] result = search.Search(Csrq("content", "\u062F", "\u0698", T, T, c), null, 1000).scoreDocs;
+			ScoreDoc[] result = search.Search(Csrq("content", "\u062F", "\u0698", T, T, c), null, 1000).ScoreDocs;
 			AssertEquals("The index Term should not be included.", 0, result.Length);
 			
-			result = search.Search(Csrq("content", "\u0633", "\u0638", T, T, c), null, 1000).scoreDocs;
+			result = search.Search(Csrq("content", "\u0633", "\u0638", T, T, c), null, 1000).ScoreDocs;
 			AssertEquals("The index Term should be included.", 1, result.Length);
 			search.Close();
 		}
@@ -709,10 +709,10 @@ namespace Lucene.Net.Search
 			
 			// Unicode order would not include "H\u00C5T" in [ "H\u00D8T", "MAND" ],
 			// but Danish collation does.
-			ScoreDoc[] result = search.Search(Csrq("content", "H\u00D8T", "MAND", F, F, c), null, 1000).scoreDocs;
+			ScoreDoc[] result = search.Search(Csrq("content", "H\u00D8T", "MAND", F, F, c), null, 1000).ScoreDocs;
 			AssertEquals("The index Term should be included.", 1, result.Length);
 			
-			result = search.Search(Csrq("content", "H\u00C5T", "MAND", F, F, c), null, 1000).scoreDocs;
+			result = search.Search(Csrq("content", "H\u00C5T", "MAND", F, F, c), null, 1000).ScoreDocs;
 			AssertEquals("The index Term should not be included.", 0, result.Length);
 			search.Close();
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiValuedNumericRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMultiValuedNumericRangeQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiValuedNumericRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiValuedNumericRangeQuery.cs Tue Mar 22 09:31:10 2011
@@ -79,7 +79,7 @@ namespace Lucene.Net.Search
 				NumericRangeQuery tq = NumericRangeQuery.NewIntRange("trie", tempAux, tempAux2, true, true);
 				TopDocs trTopDocs = searcher.Search(cq, 1);
 				TopDocs nrTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(trTopDocs.totalHits, nrTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(trTopDocs.TotalHits, nrTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 			}
 			searcher.Close();
 			

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestNot.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestNot.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestNot.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestNot.cs Tue Mar 22 09:31:10 2011
@@ -56,7 +56,7 @@ namespace Lucene.Net.Search
 			QueryParser parser = new QueryParser("field", new SimpleAnalyzer());
 			Query query = parser.Parse("a NOT b");
 			//System.out.println(query);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 		}
 	}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestNumericRangeQuery32.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestNumericRangeQuery32.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestNumericRangeQuery32.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestNumericRangeQuery32.cs Tue Mar 22 09:31:10 2011
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search
 					
 				}
 				System.Console.Out.WriteLine("Found " + terms + " distinct terms in range for field '" + field + "'" + type + ".");
-				ScoreDoc[] sd = topDocs.scoreDocs;
+				ScoreDoc[] sd = topDocs.ScoreDocs;
 				Assert.IsNotNull(sd);
 				Assert.AreEqual(count, sd.Length, "Score doc count" + type);
 				Document doc = searcher.Doc(sd[0].doc);
@@ -151,7 +151,7 @@ namespace Lucene.Net.Search
 			NumericRangeQuery q = NumericRangeQuery.NewIntRange("ascfield8", 8, tempAux, tempAux2, true, true);
 			Assert.AreSame(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE, q.GetRewriteMethod());
 			TopDocs topDocs = searcher.Search(q, noDocs);
-			ScoreDoc[] sd = topDocs.scoreDocs;
+			ScoreDoc[] sd = topDocs.ScoreDocs;
 			Assert.IsNotNull(sd);
 			Assert.AreEqual(1, sd.Length, "Score doc count");
 		}
@@ -166,7 +166,7 @@ namespace Lucene.Net.Search
 			NumericRangeQuery q = NumericRangeQuery.NewIntRange(field, precisionStep, null, tempAux, true, true);
 			TopDocs topDocs = searcher.Search(q, null, noDocs, Sort.INDEXORDER);
 			System.Console.Out.WriteLine("Found " + q.GetTotalNumberOfTerms() + " distinct terms in left open range for field '" + field + "'.");
-			ScoreDoc[] sd = topDocs.scoreDocs;
+			ScoreDoc[] sd = topDocs.ScoreDocs;
 			Assert.IsNotNull(sd);
 			Assert.AreEqual(count, sd.Length, "Score doc count");
 			Document doc = searcher.Doc(sd[0].doc);
@@ -203,7 +203,7 @@ namespace Lucene.Net.Search
 			NumericRangeQuery q = NumericRangeQuery.NewIntRange(field, precisionStep, tempAux, null, true, true);
 			TopDocs topDocs = searcher.Search(q, null, noDocs, Sort.INDEXORDER);
 			System.Console.Out.WriteLine("Found " + q.GetTotalNumberOfTerms() + " distinct terms in right open range for field '" + field + "'.");
-			ScoreDoc[] sd = topDocs.scoreDocs;
+			ScoreDoc[] sd = topDocs.ScoreDocs;
 			Assert.IsNotNull(sd);
 			Assert.AreEqual(noDocs - count, sd.Length, "Score doc count");
 			Document doc = searcher.Doc(sd[0].doc);
@@ -250,7 +250,7 @@ namespace Lucene.Net.Search
 				TermRangeQuery cq = new TermRangeQuery(field, NumericUtils.IntToPrefixCoded(lower), NumericUtils.IntToPrefixCoded(upper), true, true);
 				TopDocs tTopDocs = searcher.Search(tq, 1);
 				TopDocs cTopDocs = searcher.Search(cq, 1);
-				Assert.AreEqual(cTopDocs.totalHits, tTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 				termCountT += tq.GetTotalNumberOfTerms();
 				termCountC += cq.GetTotalNumberOfTerms();
 				// test exclusive range
@@ -260,7 +260,7 @@ namespace Lucene.Net.Search
 				cq = new TermRangeQuery(field, NumericUtils.IntToPrefixCoded(lower), NumericUtils.IntToPrefixCoded(upper), false, false);
 				tTopDocs = searcher.Search(tq, 1);
 				cTopDocs = searcher.Search(cq, 1);
-				Assert.AreEqual(cTopDocs.totalHits, tTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 				termCountT += tq.GetTotalNumberOfTerms();
 				termCountC += cq.GetTotalNumberOfTerms();
 				// test left exclusive range
@@ -270,7 +270,7 @@ namespace Lucene.Net.Search
 				cq = new TermRangeQuery(field, NumericUtils.IntToPrefixCoded(lower), NumericUtils.IntToPrefixCoded(upper), false, true);
 				tTopDocs = searcher.Search(tq, 1);
 				cTopDocs = searcher.Search(cq, 1);
-				Assert.AreEqual(cTopDocs.totalHits, tTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 				termCountT += tq.GetTotalNumberOfTerms();
 				termCountC += cq.GetTotalNumberOfTerms();
 				// test right exclusive range
@@ -280,7 +280,7 @@ namespace Lucene.Net.Search
 				cq = new TermRangeQuery(field, NumericUtils.IntToPrefixCoded(lower), NumericUtils.IntToPrefixCoded(upper), true, false);
 				tTopDocs = searcher.Search(tq, 1);
 				cTopDocs = searcher.Search(cq, 1);
-				Assert.AreEqual(cTopDocs.totalHits, tTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 				termCountT += tq.GetTotalNumberOfTerms();
 				termCountC += cq.GetTotalNumberOfTerms();
 			}
@@ -338,25 +338,25 @@ namespace Lucene.Net.Search
 				System.Int32 tempAux2 = (System.Int32) upper;
 				Query tq = NumericRangeQuery.NewIntRange(field, precisionStep, tempAux, tempAux2, true, true);
 				TopDocs tTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(upper - lower + 1, tTopDocs.totalHits, "Returned count of range query must be equal to inclusive range length");
+				Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range query must be equal to inclusive range length");
 				// test exclusive range
 				System.Int32 tempAux3 = (System.Int32) lower;
 				System.Int32 tempAux4 = (System.Int32) upper;
 				tq = NumericRangeQuery.NewIntRange(field, precisionStep, tempAux3, tempAux4, false, false);
 				tTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(System.Math.Max(upper - lower - 1, 0), tTopDocs.totalHits, "Returned count of range query must be equal to exclusive range length");
+				Assert.AreEqual(System.Math.Max(upper - lower - 1, 0), tTopDocs.TotalHits, "Returned count of range query must be equal to exclusive range length");
 				// test left exclusive range
 				System.Int32 tempAux5 = (System.Int32) lower;
 				System.Int32 tempAux6 = (System.Int32) upper;
 				tq = NumericRangeQuery.NewIntRange(field, precisionStep, tempAux5, tempAux6, false, true);
 				tTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(upper - lower, tTopDocs.totalHits, "Returned count of range query must be equal to half exclusive range length");
+				Assert.AreEqual(upper - lower, tTopDocs.TotalHits, "Returned count of range query must be equal to half exclusive range length");
 				// test right exclusive range
 				System.Int32 tempAux7 = (System.Int32) lower;
 				System.Int32 tempAux8 = (System.Int32) upper;
 				tq = NumericRangeQuery.NewIntRange(field, precisionStep, tempAux7, tempAux8, true, false);
 				tTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(upper - lower, tTopDocs.totalHits, "Returned count of range query must be equal to half exclusive range length");
+				Assert.AreEqual(upper - lower, tTopDocs.TotalHits, "Returned count of range query must be equal to half exclusive range length");
 			}
 		}
 		
@@ -389,13 +389,13 @@ namespace Lucene.Net.Search
 			System.Single tempAux2 = (float) NumericUtils.SortableIntToFloat(upper);
 			Query tq = NumericRangeQuery.NewFloatRange(field, precisionStep, tempAux, tempAux2, true, true);
 			TopDocs tTopDocs = searcher.Search(tq, 1);
-			Assert.AreEqual(upper - lower + 1, tTopDocs.totalHits, "Returned count of range query must be equal to inclusive range length");
+			Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range query must be equal to inclusive range length");
 			
 			System.Single tempAux3 = (float) NumericUtils.SortableIntToFloat(lower);
 			System.Single tempAux4 = (float) NumericUtils.SortableIntToFloat(upper);
 			Filter tf = NumericRangeFilter.NewFloatRange(field, precisionStep, tempAux3, tempAux4, true, true);
 			tTopDocs = searcher.Search(new MatchAllDocsQuery(), tf, 1);
-			Assert.AreEqual(upper - lower + 1, tTopDocs.totalHits, "Returned count of range filter must be equal to inclusive range length");
+			Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range filter must be equal to inclusive range length");
 		}
 		
         [Test]
@@ -434,9 +434,9 @@ namespace Lucene.Net.Search
 				System.Int32 tempAux2 = (System.Int32) upper;
 				Query tq = NumericRangeQuery.NewIntRange(field, precisionStep, tempAux, tempAux2, true, true);
 				TopDocs topDocs = searcher.Search(tq, null, noDocs, new Sort(new SortField(field, SortField.INT, true)));
-				if (topDocs.totalHits == 0)
+				if (topDocs.TotalHits == 0)
 					continue;
-				ScoreDoc[] sd = topDocs.scoreDocs;
+				ScoreDoc[] sd = topDocs.ScoreDocs;
 				Assert.IsNotNull(sd);
 				int last = System.Int32.Parse(searcher.Doc(sd[0].doc).Get(field));
 				for (int j = 1; j < sd.Length; j++)

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestNumericRangeQuery64.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestNumericRangeQuery64.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestNumericRangeQuery64.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestNumericRangeQuery64.cs Tue Mar 22 09:31:10 2011
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search
 					
 				}
 				System.Console.Out.WriteLine("Found " + terms + " distinct terms in range for field '" + field + "'" + type + ".");
-				ScoreDoc[] sd = topDocs.scoreDocs;
+				ScoreDoc[] sd = topDocs.ScoreDocs;
 				Assert.IsNotNull(sd);
 				Assert.AreEqual(count, sd.Length, "Score doc count" + type);
 				Document doc = searcher.Doc(sd[0].doc);
@@ -158,7 +158,7 @@ namespace Lucene.Net.Search
 			NumericRangeQuery q = NumericRangeQuery.NewLongRange("ascfield8", 8, tempAux, tempAux2, true, true);
 			Assert.AreSame(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE, q.GetRewriteMethod());
 			TopDocs topDocs = searcher.Search(q, noDocs);
-			ScoreDoc[] sd = topDocs.scoreDocs;
+			ScoreDoc[] sd = topDocs.ScoreDocs;
 			Assert.IsNotNull(sd);
 			Assert.AreEqual(1, sd.Length, "Score doc count");
 		}
@@ -173,7 +173,7 @@ namespace Lucene.Net.Search
 			NumericRangeQuery q = NumericRangeQuery.NewLongRange(field, precisionStep, null, tempAux, true, true);
 			TopDocs topDocs = searcher.Search(q, null, noDocs, Sort.INDEXORDER);
 			System.Console.Out.WriteLine("Found " + q.GetTotalNumberOfTerms() + " distinct terms in left open range for field '" + field + "'.");
-			ScoreDoc[] sd = topDocs.scoreDocs;
+			ScoreDoc[] sd = topDocs.ScoreDocs;
 			Assert.IsNotNull(sd);
 			Assert.AreEqual(count, sd.Length, "Score doc count");
 			Document doc = searcher.Doc(sd[0].doc);
@@ -216,7 +216,7 @@ namespace Lucene.Net.Search
 			NumericRangeQuery q = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux, null, true, true);
 			TopDocs topDocs = searcher.Search(q, null, noDocs, Sort.INDEXORDER);
 			System.Console.Out.WriteLine("Found " + q.GetTotalNumberOfTerms() + " distinct terms in right open range for field '" + field + "'.");
-			ScoreDoc[] sd = topDocs.scoreDocs;
+			ScoreDoc[] sd = topDocs.ScoreDocs;
 			Assert.IsNotNull(sd);
 			Assert.AreEqual(noDocs - count, sd.Length, "Score doc count");
 			Document doc = searcher.Doc(sd[0].doc);
@@ -269,7 +269,7 @@ namespace Lucene.Net.Search
 				TermRangeQuery cq = new TermRangeQuery(field, NumericUtils.LongToPrefixCoded(lower), NumericUtils.LongToPrefixCoded(upper), true, true);
 				TopDocs tTopDocs = searcher.Search(tq, 1);
 				TopDocs cTopDocs = searcher.Search(cq, 1);
-				Assert.AreEqual(cTopDocs.totalHits, tTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 				termCountT += tq.GetTotalNumberOfTerms();
 				termCountC += cq.GetTotalNumberOfTerms();
 				// test exclusive range
@@ -279,7 +279,7 @@ namespace Lucene.Net.Search
 				cq = new TermRangeQuery(field, NumericUtils.LongToPrefixCoded(lower), NumericUtils.LongToPrefixCoded(upper), false, false);
 				tTopDocs = searcher.Search(tq, 1);
 				cTopDocs = searcher.Search(cq, 1);
-				Assert.AreEqual(cTopDocs.totalHits, tTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 				termCountT += tq.GetTotalNumberOfTerms();
 				termCountC += cq.GetTotalNumberOfTerms();
 				// test left exclusive range
@@ -289,7 +289,7 @@ namespace Lucene.Net.Search
 				cq = new TermRangeQuery(field, NumericUtils.LongToPrefixCoded(lower), NumericUtils.LongToPrefixCoded(upper), false, true);
 				tTopDocs = searcher.Search(tq, 1);
 				cTopDocs = searcher.Search(cq, 1);
-				Assert.AreEqual(cTopDocs.totalHits, tTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 				termCountT += tq.GetTotalNumberOfTerms();
 				termCountC += cq.GetTotalNumberOfTerms();
 				// test right exclusive range
@@ -299,7 +299,7 @@ namespace Lucene.Net.Search
 				cq = new TermRangeQuery(field, NumericUtils.LongToPrefixCoded(lower), NumericUtils.LongToPrefixCoded(upper), true, false);
 				tTopDocs = searcher.Search(tq, 1);
 				cTopDocs = searcher.Search(cq, 1);
-				Assert.AreEqual(cTopDocs.totalHits, tTopDocs.totalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
+				Assert.AreEqual(cTopDocs.TotalHits, tTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
 				termCountT += tq.GetTotalNumberOfTerms();
 				termCountC += cq.GetTotalNumberOfTerms();
 			}
@@ -363,25 +363,25 @@ namespace Lucene.Net.Search
 				System.Int64 tempAux2 = (long) upper;
 				Query tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux, tempAux2, true, true);
 				TopDocs tTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(upper - lower + 1, tTopDocs.totalHits, "Returned count of range query must be equal to inclusive range length");
+				Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range query must be equal to inclusive range length");
 				// test exclusive range
 				System.Int64 tempAux3 = (long) lower;
 				System.Int64 tempAux4 = (long) upper;
 				tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux3, tempAux4, false, false);
 				tTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(System.Math.Max(upper - lower - 1, 0), tTopDocs.totalHits, "Returned count of range query must be equal to exclusive range length");
+				Assert.AreEqual(System.Math.Max(upper - lower - 1, 0), tTopDocs.TotalHits, "Returned count of range query must be equal to exclusive range length");
 				// test left exclusive range
 				System.Int64 tempAux5 = (long) lower;
 				System.Int64 tempAux6 = (long) upper;
 				tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux5, tempAux6, false, true);
 				tTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(upper - lower, tTopDocs.totalHits, "Returned count of range query must be equal to half exclusive range length");
+				Assert.AreEqual(upper - lower, tTopDocs.TotalHits, "Returned count of range query must be equal to half exclusive range length");
 				// test right exclusive range
 				System.Int64 tempAux7 = (long) lower;
 				System.Int64 tempAux8 = (long) upper;
 				tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux7, tempAux8, true, false);
 				tTopDocs = searcher.Search(tq, 1);
-				Assert.AreEqual(upper - lower, tTopDocs.totalHits, "Returned count of range query must be equal to half exclusive range length");
+				Assert.AreEqual(upper - lower, tTopDocs.TotalHits, "Returned count of range query must be equal to half exclusive range length");
 			}
 		}
 		
@@ -420,13 +420,13 @@ namespace Lucene.Net.Search
 			System.Double tempAux2 = (double) NumericUtils.SortableLongToDouble(upper);
 			Query tq = NumericRangeQuery.NewDoubleRange(field, precisionStep, tempAux, tempAux2, true, true);
 			TopDocs tTopDocs = searcher.Search(tq, 1);
-			Assert.AreEqual(upper - lower + 1, tTopDocs.totalHits, "Returned count of range query must be equal to inclusive range length");
+			Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range query must be equal to inclusive range length");
 			
 			System.Double tempAux3 = (double) NumericUtils.SortableLongToDouble(lower);
 			System.Double tempAux4 = (double) NumericUtils.SortableLongToDouble(upper);
 			Filter tf = NumericRangeFilter.NewDoubleRange(field, precisionStep, tempAux3, tempAux4, true, true);
 			tTopDocs = searcher.Search(new MatchAllDocsQuery(), tf, 1);
-			Assert.AreEqual(upper - lower + 1, tTopDocs.totalHits, "Returned count of range filter must be equal to inclusive range length");
+			Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range filter must be equal to inclusive range length");
 		}
 		
         [Test]
@@ -471,9 +471,9 @@ namespace Lucene.Net.Search
 				System.Int64 tempAux2 = (long) upper;
 				Query tq = NumericRangeQuery.NewLongRange(field, precisionStep, tempAux, tempAux2, true, true);
 				TopDocs topDocs = searcher.Search(tq, null, noDocs, new Sort(new SortField(field, SortField.LONG, true)));
-				if (topDocs.totalHits == 0)
+				if (topDocs.TotalHits == 0)
 					continue;
-				ScoreDoc[] sd = topDocs.scoreDocs;
+				ScoreDoc[] sd = topDocs.ScoreDocs;
 				Assert.IsNotNull(sd);
 				long last = System.Int64.Parse(searcher.Doc(sd[0].doc).Get(field));
 				for (int j = 1; j < sd.Length; j++)

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestPhrasePrefixQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestPhrasePrefixQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestPhrasePrefixQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestPhrasePrefixQuery.cs Tue Mar 22 09:31:10 2011
@@ -97,10 +97,10 @@ namespace Lucene.Net.Search
 			query2.Add((Term[]) termsWithPrefix.ToArray(typeof(Term)));
 			
 			ScoreDoc[] result;
-			result = searcher.Search(query1, null, 1000).scoreDocs;
+			result = searcher.Search(query1, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, result.Length);
 			
-			result = searcher.Search(query2, null, 1000).scoreDocs;
+			result = searcher.Search(query2, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 		}
 	}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestPhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestPhraseQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestPhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestPhraseQuery.cs Tue Mar 22 09:31:10 2011
@@ -121,7 +121,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(2);
 			query.Add(new Term("field", "one"));
 			query.Add(new Term("field", "five"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			QueryUtils.Check(query, searcher);
 		}
@@ -132,7 +132,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(3);
 			query.Add(new Term("field", "one"));
 			query.Add(new Term("field", "five"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			QueryUtils.Check(query, searcher);
 		}
@@ -144,7 +144,7 @@ namespace Lucene.Net.Search
 			// slop is zero by default
 			query.Add(new Term("field", "four"));
 			query.Add(new Term("field", "five"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "exact match");
 			QueryUtils.Check(query, searcher);
 			
@@ -152,7 +152,7 @@ namespace Lucene.Net.Search
 			query = new PhraseQuery();
 			query.Add(new Term("field", "two"));
 			query.Add(new Term("field", "one"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "reverse not exact");
 			QueryUtils.Check(query, searcher);
 		}
@@ -164,7 +164,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(1);
 			query.Add(new Term("field", "one"));
 			query.Add(new Term("field", "two"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "in order");
 			QueryUtils.Check(query, searcher);
 			
@@ -175,7 +175,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(1);
 			query.Add(new Term("field", "two"));
 			query.Add(new Term("field", "one"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "reversed, slop not 2 or more");
 			QueryUtils.Check(query, searcher);
 		}
@@ -187,7 +187,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(2); // must be at least two for reverse order match
 			query.Add(new Term("field", "two"));
 			query.Add(new Term("field", "one"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "just sloppy enough");
 			QueryUtils.Check(query, searcher);
 			
@@ -196,7 +196,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(2);
 			query.Add(new Term("field", "three"));
 			query.Add(new Term("field", "one"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "not sloppy enough");
 			QueryUtils.Check(query, searcher);
 		}
@@ -211,7 +211,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("field", "one"));
 			query.Add(new Term("field", "three"));
 			query.Add(new Term("field", "five"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "two total moves");
 			QueryUtils.Check(query, searcher);
 			
@@ -221,13 +221,13 @@ namespace Lucene.Net.Search
 			query.Add(new Term("field", "five"));
 			query.Add(new Term("field", "three"));
 			query.Add(new Term("field", "one"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "slop of 5 not close enough");
 			QueryUtils.Check(query, searcher);
 			
 			
 			query.SetSlop(6);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "slop of 6 just right");
 			QueryUtils.Check(query, searcher);
 		}
@@ -249,7 +249,7 @@ namespace Lucene.Net.Search
 			PhraseQuery query = new PhraseQuery();
 			query.Add(new Term("field", "stop"));
 			query.Add(new Term("field", "words"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			QueryUtils.Check(query, searcher);
 			
@@ -258,7 +258,7 @@ namespace Lucene.Net.Search
 			query = new PhraseQuery();
 			query.Add(new Term("field", "words"));
 			query.Add(new Term("field", "here"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			QueryUtils.Check(query, searcher);
 			
@@ -289,7 +289,7 @@ namespace Lucene.Net.Search
 			PhraseQuery phraseQuery = new PhraseQuery();
 			phraseQuery.Add(new Term("source", "marketing"));
 			phraseQuery.Add(new Term("source", "info"));
-			ScoreDoc[] hits = searcher.Search(phraseQuery, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(phraseQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			QueryUtils.Check(phraseQuery, searcher);
 			
@@ -298,7 +298,7 @@ namespace Lucene.Net.Search
 			BooleanQuery booleanQuery = new BooleanQuery();
 			booleanQuery.Add(termQuery, BooleanClause.Occur.MUST);
 			booleanQuery.Add(phraseQuery, BooleanClause.Occur.MUST);
-			hits = searcher.Search(booleanQuery, null, 1000).scoreDocs;
+			hits = searcher.Search(booleanQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			QueryUtils.Check(termQuery, searcher);
 			
@@ -328,22 +328,22 @@ namespace Lucene.Net.Search
 			phraseQuery.Add(new Term("contents", "map"));
 			phraseQuery.Add(new Term("contents", "entry"));
 			
-			hits = searcher.Search(termQuery, null, 1000).scoreDocs;
+			hits = searcher.Search(termQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
-			hits = searcher.Search(phraseQuery, null, 1000).scoreDocs;
+			hits = searcher.Search(phraseQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			
 			
 			booleanQuery = new BooleanQuery();
 			booleanQuery.Add(termQuery, BooleanClause.Occur.MUST);
 			booleanQuery.Add(phraseQuery, BooleanClause.Occur.MUST);
-			hits = searcher.Search(booleanQuery, null, 1000).scoreDocs;
+			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);
-			hits = searcher.Search(booleanQuery, null, 1000).scoreDocs;
+			hits = searcher.Search(booleanQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			QueryUtils.Check(booleanQuery, searcher);
 			
@@ -378,7 +378,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("field", "firstname"));
 			query.Add(new Term("field", "lastname"));
 			query.SetSlop(System.Int32.MaxValue);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			// Make sure that those matches where the terms appear closer to
 			// each other get a higher score:
@@ -413,13 +413,13 @@ namespace Lucene.Net.Search
 			query.Add(new Term("repeated", "part"));
 			query.SetSlop(100);
 			
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "slop of 100 just right");
 			QueryUtils.Check(query, searcher);
 			
 			query.SetSlop(99);
 			
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "slop of 99 not enough");
 			QueryUtils.Check(query, searcher);
 		}
@@ -434,7 +434,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("nonexist", "found"));
 			query.SetSlop(2); // would be found this way
 			
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length, "phrase without repetitions exists in 2 docs");
 			QueryUtils.Check(query, searcher);
 			
@@ -445,7 +445,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("nonexist", "exist"));
 			query.SetSlop(1); // would be found 
 			
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length, "phrase with repetitions exists in two docs");
 			QueryUtils.Check(query, searcher);
 			
@@ -456,7 +456,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("nonexist", "phrase"));
 			query.SetSlop(1000); // would not be found no matter how high the slop is
 			
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "nonexisting phrase with repetitions does not exist in any doc");
 			QueryUtils.Check(query, searcher);
 			
@@ -468,7 +468,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("nonexist", "exist"));
 			query.SetSlop(1000); // would not be found no matter how high the slop is
 			
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "nonexisting phrase with repetitions does not exist in any doc");
 			QueryUtils.Check(query, searcher);
 		}
@@ -489,7 +489,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(0); // to use exact phrase scorer
 			query.Add(new Term("field", "two"));
 			query.Add(new Term("field", "three"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "phrase found with exact phrase scorer");
 			float score0 = hits[0].score;
 			//System.out.println("(exact) field: two three: "+score0);
@@ -497,7 +497,7 @@ namespace Lucene.Net.Search
 			
 			// search on non palyndrome, find phrase with slop 2, though no slop required here.
 			query.SetSlop(2); // to use sloppy scorer 
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "just sloppy enough");
 			float score1 = hits[0].score;
 			//System.out.println("(sloppy) field: two three: "+score1);
@@ -509,7 +509,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(2); // must be at least two for both ordered and reversed to match
 			query.Add(new Term("palindrome", "two"));
 			query.Add(new Term("palindrome", "three"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "just sloppy enough");
 			float score2 = hits[0].score;
 			//System.out.println("palindrome: two three: "+score2);
@@ -523,7 +523,7 @@ namespace Lucene.Net.Search
 			query.SetSlop(2); // must be at least two for both ordered and reversed to match
 			query.Add(new Term("palindrome", "three"));
 			query.Add(new Term("palindrome", "two"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "just sloppy enough");
 			float score3 = hits[0].score;
 			//System.out.println("palindrome: three two: "+score3);
@@ -551,7 +551,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("field", "one"));
 			query.Add(new Term("field", "two"));
 			query.Add(new Term("field", "three"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "phrase found with exact phrase scorer");
 			float score0 = hits[0].score;
 			//System.out.println("(exact) field: one two three: "+score0);
@@ -559,7 +559,7 @@ namespace Lucene.Net.Search
 			
 			// search on non palyndrome, find phrase with slop 3, though no slop required here.
 			query.SetSlop(4); // to use sloppy scorer 
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "just sloppy enough");
 			float score1 = hits[0].score;
 			//System.out.println("(sloppy) field: one two three: "+score1);
@@ -572,7 +572,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("palindrome", "one"));
 			query.Add(new Term("palindrome", "two"));
 			query.Add(new Term("palindrome", "three"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "just sloppy enough");
 			float score2 = hits[0].score;
 			//System.out.println("palindrome: one two three: "+score2);
@@ -587,7 +587,7 @@ namespace Lucene.Net.Search
 			query.Add(new Term("palindrome", "three"));
 			query.Add(new Term("palindrome", "two"));
 			query.Add(new Term("palindrome", "one"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "just sloppy enough");
 			float score3 = hits[0].score;
 			//System.out.println("palindrome: three two one: "+score3);

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestPositionIncrement.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestPositionIncrement.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestPositionIncrement.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestPositionIncrement.cs Tue Mar 22 09:31:10 2011
@@ -154,40 +154,40 @@ namespace Lucene.Net.Search
 			q = new PhraseQuery();
 			q.Add(new Term("field", "1"));
 			q.Add(new Term("field", "2"));
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// same as previous, just specify positions explicitely.
 			q = new PhraseQuery();
 			q.Add(new Term("field", "1"), 0);
 			q.Add(new Term("field", "2"), 1);
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// specifying correct positions should find the phrase.
 			q = new PhraseQuery();
 			q.Add(new Term("field", "1"), 0);
 			q.Add(new Term("field", "2"), 2);
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			q = new PhraseQuery();
 			q.Add(new Term("field", "2"));
 			q.Add(new Term("field", "3"));
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			q = new PhraseQuery();
 			q.Add(new Term("field", "3"));
 			q.Add(new Term("field", "4"));
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// phrase query would find it when correct positions are specified. 
 			q = new PhraseQuery();
 			q.Add(new Term("field", "3"), 0);
 			q.Add(new Term("field", "4"), 0);
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			// phrase query should fail for non existing searched term 
@@ -195,68 +195,68 @@ namespace Lucene.Net.Search
 			q = new PhraseQuery();
 			q.Add(new Term("field", "3"), 0);
 			q.Add(new Term("field", "9"), 0);
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// multi-phrase query should succed for non existing searched term
 			// because there exist another searched terms in the same searched position. 
 			MultiPhraseQuery mq = new MultiPhraseQuery();
 			mq.Add(new Term[]{new Term("field", "3"), new Term("field", "9")}, 0);
-			hits = searcher.Search(mq, null, 1000).scoreDocs;
+			hits = searcher.Search(mq, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			q = new PhraseQuery();
 			q.Add(new Term("field", "2"));
 			q.Add(new Term("field", "4"));
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			q = new PhraseQuery();
 			q.Add(new Term("field", "3"));
 			q.Add(new Term("field", "5"));
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			q = new PhraseQuery();
 			q.Add(new Term("field", "4"));
 			q.Add(new Term("field", "5"));
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			q = new PhraseQuery();
 			q.Add(new Term("field", "2"));
 			q.Add(new Term("field", "5"));
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// should not find "1 2" because there is a gap of 1 in the index
 			QueryParser qp = new QueryParser("field", new StopWhitespaceAnalyzer(false));
 			q = (PhraseQuery) qp.Parse("\"1 2\"");
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// omitted stop word cannot help because stop filter swallows the increments. 
 			q = (PhraseQuery) qp.Parse("\"1 stop 2\"");
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// query parser alone won't help, because stop filter swallows the increments. 
 			qp.SetEnablePositionIncrements(true);
 			q = (PhraseQuery) qp.Parse("\"1 stop 2\"");
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// stop filter alone won't help, because query parser swallows the increments. 
 			qp.SetEnablePositionIncrements(false);
 			q = (PhraseQuery) qp.Parse("\"1 stop 2\"");
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// when both qp qnd stopFilter propagate increments, we should find the doc.
 			qp = new QueryParser("field", new StopWhitespaceAnalyzer(true));
 			qp.SetEnablePositionIncrements(true);
 			q = (PhraseQuery) qp.Parse("\"1 stop 2\"");
-			hits = searcher.Search(q, null, 1000).scoreDocs;
+			hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 		}
 		

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestPositiveScoresOnlyCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestPositiveScoresOnlyCollector.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestPositiveScoresOnlyCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestPositiveScoresOnlyCollector.cs Tue Mar 22 09:31:10 2011
@@ -117,8 +117,8 @@ namespace Lucene.Net.Search
 				c.Collect(0);
 			}
 			TopDocs td = tdc.TopDocs();
-			ScoreDoc[] sd = td.scoreDocs;
-			Assert.AreEqual(numPositiveScores, td.totalHits);
+			ScoreDoc[] sd = td.ScoreDocs;
+			Assert.AreEqual(numPositiveScores, td.TotalHits);
 			for (int i = 0; i < sd.Length; i++)
 			{
 				Assert.IsTrue(sd[i].score > 0, "only positive scores should return: " + sd[i].score);

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestPrefixFilter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixFilter.cs Tue Mar 22 09:31:10 2011
@@ -55,55 +55,55 @@ namespace Lucene.Net.Search
 			PrefixFilter filter = new PrefixFilter(new Term("category", "/Computers"));
 			Query query = new ConstantScoreQuery(filter);
 			IndexSearcher searcher = new IndexSearcher(directory);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(4, hits.Length);
 			
 			// test middle of values
 			filter = new PrefixFilter(new Term("category", "/Computers/Mac"));
 			query = new ConstantScoreQuery(filter);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			
 			// test start of values
 			filter = new PrefixFilter(new Term("category", "/Computers/Linux"));
 			query = new ConstantScoreQuery(filter);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			// test end of values
 			filter = new PrefixFilter(new Term("category", "/Computers/Windows"));
 			query = new ConstantScoreQuery(filter);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			// test non-existant
 			filter = new PrefixFilter(new Term("category", "/Computers/ObsoleteOS"));
 			query = new ConstantScoreQuery(filter);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// test non-existant, before values
 			filter = new PrefixFilter(new Term("category", "/Computers/AAA"));
 			query = new ConstantScoreQuery(filter);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// test non-existant, after values
 			filter = new PrefixFilter(new Term("category", "/Computers/ZZZ"));
 			query = new ConstantScoreQuery(filter);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// test zero length prefix
 			filter = new PrefixFilter(new Term("category", ""));
 			query = new ConstantScoreQuery(filter);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(4, hits.Length);
 			
 			// test non existent field
 			filter = new PrefixFilter(new Term("nonexistantfield", "/Computers"));
 			query = new ConstantScoreQuery(filter);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 		}
 	}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixInBooleanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestPrefixInBooleanQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixInBooleanQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixInBooleanQuery.cs Tue Mar 22 09:31:10 2011
@@ -85,7 +85,7 @@ namespace Lucene.Net.Search
 		{
 			IndexSearcher indexSearcher = new IndexSearcher(directory, true);
 			Query query = new PrefixQuery(new Term(FIELD, "tang"));
-			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).totalHits, "Number of matched documents");
+			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).TotalHits, "Number of matched documents");
 		}
 		
 		[Test]
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search
 		{
 			IndexSearcher indexSearcher = new IndexSearcher(directory, true);
 			Query query = new TermQuery(new Term(FIELD, "tangfulin"));
-			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).totalHits, "Number of matched documents");
+			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).TotalHits, "Number of matched documents");
 		}
 		
 		[Test]
@@ -103,7 +103,7 @@ namespace Lucene.Net.Search
 			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);
-			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).totalHits, "Number of matched documents");
+			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).TotalHits, "Number of matched documents");
 		}
 		
 		[Test]
@@ -113,7 +113,7 @@ namespace Lucene.Net.Search
 			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);
-			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).totalHits, "Number of matched documents");
+			Assert.AreEqual(2, indexSearcher.Search(query, null, 1000).TotalHits, "Number of matched documents");
 		}
 	}
 }
\ No newline at end of file

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestPrefixQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestPrefixQuery.cs Tue Mar 22 09:31:10 2011
@@ -53,11 +53,11 @@ namespace Lucene.Net.Search
 			
 			PrefixQuery query = new PrefixQuery(new Term("category", "/Computers"));
 			IndexSearcher searcher = new IndexSearcher(directory);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length, "All documents in /Computers category and below");
 			
 			query = new PrefixQuery(new Term("category", "/Computers/Mac"));
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "One in /Computers/Mac");
 		}
 	}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestQueryWrapperFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestQueryWrapperFilter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestQueryWrapperFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestQueryWrapperFilter.cs Tue Mar 22 09:31:10 2011
@@ -55,7 +55,7 @@ namespace Lucene.Net.Search
 			
 			IndexSearcher searcher = new IndexSearcher(dir, true);
 			TopDocs hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
-			Assert.AreEqual(1, hits.totalHits);
+			Assert.AreEqual(1, hits.TotalHits);
 			
 			// should not throw exception with complex primitive query
 			BooleanQuery booleanQuery = new BooleanQuery();
@@ -64,14 +64,14 @@ namespace Lucene.Net.Search
 			qwf = new QueryWrapperFilter(termQuery);
 			
 			hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
-			Assert.AreEqual(1, hits.totalHits);
+			Assert.AreEqual(1, hits.TotalHits);
 			
 			// should not throw exception with non primitive Query (doesn't implement
 			// Query#createWeight)
 			qwf = new QueryWrapperFilter(new FuzzyQuery(new Term("field", "valu")));
 			
 			hits = searcher.Search(new MatchAllDocsQuery(), qwf, 10);
-			Assert.AreEqual(1, hits.totalHits);
+			Assert.AreEqual(1, hits.TotalHits);
 		}
 	}
 }
\ No newline at end of file

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestSimpleExplanations.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestSimpleExplanations.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestSimpleExplanations.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestSimpleExplanations.cs Tue Mar 22 09:31:10 2011
@@ -433,7 +433,7 @@ namespace Lucene.Net.Search
 			searchers[0] = new IndexSearcher(indexStoreB);
 			searchers[1] = new IndexSearcher(indexStoreA);
 			Searcher mSearcher = new MultiSearcher(searchers);
-			ScoreDoc[] hits = mSearcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = mSearcher.Search(query, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(3, hits.Length);
 			
@@ -443,7 +443,7 @@ namespace Lucene.Net.Search
 			Assert.IsTrue(exp.IndexOf("docFreq=3") > - 1, exp);
 			
 			query = parser.Parse("handle:\"1 2\"");
-			hits = mSearcher.Search(query, null, 1000).scoreDocs;
+			hits = mSearcher.Search(query, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(3, hits.Length);
 			
@@ -453,7 +453,7 @@ namespace Lucene.Net.Search
 			Assert.IsTrue(exp.IndexOf("2=3") > - 1, exp);
 			
 			query = new SpanNearQuery(new SpanQuery[]{new SpanTermQuery(new Term("handle", "1")), new SpanTermQuery(new Term("handle", "2"))}, 0, true);
-			hits = mSearcher.Search(query, null, 1000).scoreDocs;
+			hits = mSearcher.Search(query, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(3, hits.Length);
 			

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestSloppyPhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestSloppyPhraseQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestSloppyPhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestSloppyPhraseQuery.cs Tue Mar 22 09:31:10 2011
@@ -141,7 +141,7 @@ namespace Lucene.Net.Search
 			IndexSearcher searcher = new IndexSearcher(ramDir);
 			TopDocs td = searcher.Search(query, null, 10);
 			//System.out.println("slop: "+slop+"  query: "+query+"  doc: "+doc+"  Expecting number of hits: "+expectedNumResults+" maxScore="+td.getMaxScore());
-			Assert.AreEqual(expectedNumResults, td.totalHits, "slop: " + slop + "  query: " + query + "  doc: " + doc + "  Wrong number of hits");
+			Assert.AreEqual(expectedNumResults, td.TotalHits, "slop: " + slop + "  query: " + query + "  doc: " + doc + "  Wrong number of hits");
 			
 			//QueryUtils.check(query,searcher);
 			



Mime
View raw message