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 [2/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/TestDateFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestDateFilter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestDateFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestDateFilter.cs Tue Mar 22 09:31:10 2011
@@ -77,24 +77,24 @@ namespace Lucene.Net.Search
 			ScoreDoc[] result;
 			
 			// ensure that queries return expected results without DateFilter first
-			result = searcher.Search(query1, null, 1000).scoreDocs;
+			result = searcher.Search(query1, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 			
-			result = searcher.Search(query2, null, 1000).scoreDocs;
+			result = searcher.Search(query2, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, result.Length);
 			
 			
 			// run queries with DateFilter
-			result = searcher.Search(query1, df1, 1000).scoreDocs;
+			result = searcher.Search(query1, df1, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 			
-			result = searcher.Search(query1, df2, 1000).scoreDocs;
+			result = searcher.Search(query1, df2, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 			
-			result = searcher.Search(query2, df1, 1000).scoreDocs;
+			result = searcher.Search(query2, df1, 1000).ScoreDocs;
 			Assert.AreEqual(1, result.Length);
 			
-			result = searcher.Search(query2, df2, 1000).scoreDocs;
+			result = searcher.Search(query2, df2, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 		}
 		
@@ -134,24 +134,24 @@ namespace Lucene.Net.Search
 			ScoreDoc[] result;
 			
 			// ensure that queries return expected results without DateFilter first
-			result = searcher.Search(query1, null, 1000).scoreDocs;
+			result = searcher.Search(query1, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 			
-			result = searcher.Search(query2, null, 1000).scoreDocs;
+			result = searcher.Search(query2, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, result.Length);
 			
 			
 			// run queries with DateFilter
-			result = searcher.Search(query1, df1, 1000).scoreDocs;
+			result = searcher.Search(query1, df1, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 			
-			result = searcher.Search(query1, df2, 1000).scoreDocs;
+			result = searcher.Search(query1, df2, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 			
-			result = searcher.Search(query2, df1, 1000).scoreDocs;
+			result = searcher.Search(query2, df1, 1000).ScoreDocs;
 			Assert.AreEqual(1, result.Length);
 			
-			result = searcher.Search(query2, df2, 1000).scoreDocs;
+			result = searcher.Search(query2, df2, 1000).ScoreDocs;
 			Assert.AreEqual(0, result.Length);
 		}
 	}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestDateSort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestDateSort.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestDateSort.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestDateSort.cs Tue Mar 22 09:31:10 2011
@@ -83,7 +83,7 @@ namespace Lucene.Net.Search
 			
 			// Execute the search and process the search results.
 			System.String[] actualOrder = new System.String[5];
-			ScoreDoc[] hits = searcher.Search(query, null, 1000, sort).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000, sort).ScoreDocs;
 			for (int i = 0; i < hits.Length; i++)
 			{
 				Document document = searcher.Doc(hits[i].doc);

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestDisjunctionMaxQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestDisjunctionMaxQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestDisjunctionMaxQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestDisjunctionMaxQuery.cs Tue Mar 22 09:31:10 2011
@@ -184,7 +184,7 @@ namespace Lucene.Net.Search
 			q.Add(Tq("hed", "elephant"));
 			QueryUtils.Check(q, s);
 			
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			
 			try
 			{
@@ -213,7 +213,7 @@ namespace Lucene.Net.Search
 			QueryUtils.Check(q, s);
 			
 			
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			
 			try
 			{
@@ -243,7 +243,7 @@ namespace Lucene.Net.Search
 			QueryUtils.Check(q, s);
 			
 			
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			
 			try
 			{
@@ -271,7 +271,7 @@ namespace Lucene.Net.Search
 			QueryUtils.Check(q, s);
 			
 			
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			
 			try
 			{
@@ -312,7 +312,7 @@ namespace Lucene.Net.Search
 			
 			QueryUtils.Check(q, s);
 			
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			
 			try
 			{
@@ -351,7 +351,7 @@ namespace Lucene.Net.Search
 			QueryUtils.Check(q, s);
 			
 			
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			
 			try
 			{
@@ -394,7 +394,7 @@ namespace Lucene.Net.Search
 			QueryUtils.Check(q, s);
 			
 			
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			
 			try
 			{
@@ -448,7 +448,7 @@ namespace Lucene.Net.Search
 			QueryUtils.Check(q, s);
 			
 			
-			ScoreDoc[] h = s.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] h = s.Search(q, null, 1000).ScoreDocs;
 			
 			try
 			{

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestDocIdSet.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestDocIdSet.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestDocIdSet.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestDocIdSet.cs Tue Mar 22 09:31:10 2011
@@ -235,12 +235,12 @@ namespace Lucene.Net.Search
 			
 			// First verify the document is searchable.
 			IndexSearcher searcher = new IndexSearcher(dir, true);
-			Assert.AreEqual(1, searcher.Search(new MatchAllDocsQuery(), 10).totalHits);
+			Assert.AreEqual(1, searcher.Search(new MatchAllDocsQuery(), 10).TotalHits);
 			
 			// Now search w/ a Filter which returns a null DocIdSet
 			Filter f = new AnonymousClassFilter(this);
 			
-			Assert.AreEqual(0, searcher.Search(new MatchAllDocsQuery(), f, 10).totalHits);
+			Assert.AreEqual(0, searcher.Search(new MatchAllDocsQuery(), f, 10).TotalHits);
 			searcher.Close();
 		}
 	}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestElevationComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestElevationComparator.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestElevationComparator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestElevationComparator.cs Tue Mar 22 09:31:10 2011
@@ -78,23 +78,23 @@ namespace Lucene.Net.Search
 			searcher.Search(newq, null, topCollector);
 			
 			TopDocs topDocs = topCollector.TopDocs(0, 10);
-			int nDocsReturned = topDocs.scoreDocs.Length;
+			int nDocsReturned = topDocs.ScoreDocs.Length;
 			
 			Assert.AreEqual(4, nDocsReturned);
 			
 			// 0 & 3 were elevated
-			Assert.AreEqual(0, topDocs.scoreDocs[0].doc);
-			Assert.AreEqual(3, topDocs.scoreDocs[1].doc);
+			Assert.AreEqual(0, topDocs.ScoreDocs[0].doc);
+			Assert.AreEqual(3, topDocs.ScoreDocs[1].doc);
 			
 			if (reversed)
 			{
-				Assert.AreEqual(2, topDocs.scoreDocs[2].doc);
-				Assert.AreEqual(1, topDocs.scoreDocs[3].doc);
+				Assert.AreEqual(2, topDocs.ScoreDocs[2].doc);
+				Assert.AreEqual(1, topDocs.ScoreDocs[3].doc);
 			}
 			else
 			{
-				Assert.AreEqual(1, topDocs.scoreDocs[2].doc);
-				Assert.AreEqual(2, topDocs.scoreDocs[3].doc);
+				Assert.AreEqual(1, topDocs.ScoreDocs[2].doc);
+				Assert.AreEqual(2, topDocs.ScoreDocs[3].doc);
 			}
 			
 			/*

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFieldCacheRangeFilter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheRangeFilter.cs Tue Mar 22 09:31:10 2011
@@ -71,67 +71,67 @@ namespace Lucene.Net.Search
 			
 			// test id, bounded on both ends
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but last");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but first");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, maxIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, maxIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, medIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, medIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
 			
 			// unbounded id
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, null, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, null, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "min and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, maxIP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, maxIP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "max and down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, maxIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, maxIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, maxIP, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, maxIP, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, medIP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, medIP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
 			
 			// very small sets
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, minIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, minIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "min,min,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, medIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, medIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "med,med,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, maxIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, maxIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "max,max,F,F");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, minIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, minIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "min,min,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, minIP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, minIP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "nul,min,F,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, maxIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, maxIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,max,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,nul,T,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, medIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, medIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "med,med,T,T");
 		}
 		
@@ -154,47 +154,47 @@ namespace Lucene.Net.Search
 			
 			// test extremes, bounded on both ends
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but biggest");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but smallest");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 2, result.Length, "all but extremes");
 			
 			// unbounded
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "smallest and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, maxRP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, maxRP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "biggest and down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not smallest, but up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, maxRP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, maxRP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not biggest, but down");
 			
 			// very small sets
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, minRP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, minRP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "min,min,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, maxRP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, maxRP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "max,max,F,F");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, minRP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, minRP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "min,min,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, minRP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, minRP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "nul,min,F,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, maxRP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, maxRP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,max,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,nul,T,T");
 		}
 		
@@ -220,77 +220,77 @@ namespace Lucene.Net.Search
 			
 			// test id, bounded on both ends
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but last");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but first");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
 			
 			// unbounded id
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, null, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, null, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "min and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, maxIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, maxIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "max and down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, maxIdO, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, maxIdO, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, medIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, medIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
 			
 			// very small sets
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, minIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, minIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "min,min,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, medIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, medIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "med,med,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "max,max,F,F");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, minIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, minIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "min,min,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, minIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, minIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "nul,min,F,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,max,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,nul,T,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, medIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "med,med,T,T");
 			
 			// special cases
 			System.Int16 tempAux = (short) System.Int16.MaxValue;
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", tempAux, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "overflow special case");
 			System.Int16 tempAux2 = (short) System.Int16.MinValue;
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "overflow special case");
-			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, minIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "inverse range");
 		}
 		
@@ -314,77 +314,77 @@ namespace Lucene.Net.Search
 			
 			// test id, bounded on both ends
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but last");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but first");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
 			
 			// unbounded id
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, null, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, null, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "min and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, maxIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, maxIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "max and down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, maxIdO, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, maxIdO, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, medIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, medIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
 			
 			// very small sets
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, minIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, minIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "min,min,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, medIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, medIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "med,med,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "max,max,F,F");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, minIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, minIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "min,min,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, minIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, minIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "nul,min,F,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,max,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,nul,T,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, medIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "med,med,T,T");
 			
 			// special cases
 			System.Int32 tempAux = (System.Int32) System.Int32.MaxValue;
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", tempAux, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "overflow special case");
 			System.Int32 tempAux2 = (System.Int32) System.Int32.MinValue;
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "overflow special case");
-			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, minIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "inverse range");
 		}
 		
@@ -408,77 +408,77 @@ namespace Lucene.Net.Search
 			
 			// test id, bounded on both ends
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but last");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but first");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
 			
 			// unbounded id
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, null, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, null, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "min and up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "max and down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
 			
 			// very small sets
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "min,min,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "med,med,F,F");
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "max,max,F,F");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "min,min,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, minIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, minIdO, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "nul,min,F,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,max,T,T");
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,nul,T,T");
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "med,med,T,T");
 			
 			// special cases
 			System.Int64 tempAux = (long) System.Int64.MaxValue;
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", tempAux, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "overflow special case");
 			System.Int64 tempAux2 = (long) System.Int64.MinValue;
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "overflow special case");
-			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, minIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "inverse range");
 		}
 		
@@ -498,21 +498,21 @@ namespace Lucene.Net.Search
 			ScoreDoc[] result;
 			Query q = new TermQuery(new Term("body", "body"));
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs / 2, result.Length, "find all");
 			int count = 0;
-			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, medIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, medIdO, F, T), numDocs).ScoreDocs;
 			count += result.Length;
-			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", medIdO, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", medIdO, null, F, F), numDocs).ScoreDocs;
 			count += result.Length;
 			Assert.AreEqual(numDocs, count, "sum of two concenatted ranges");
-			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, null, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, null, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			System.Single tempAux = (float) System.Single.PositiveInfinity;
-			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", tempAux, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "infinity special case");
 			System.Single tempAux2 = (float) System.Single.NegativeInfinity;
-			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "infinity special case");
 		}
 		
@@ -530,21 +530,21 @@ namespace Lucene.Net.Search
 			ScoreDoc[] result;
 			Query q = new TermQuery(new Term("body", "body"));
 			
-			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs / 2, result.Length, "find all");
 			int count = 0;
-			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, medIdO, F, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, medIdO, F, T), numDocs).ScoreDocs;
 			count += result.Length;
-			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", medIdO, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", medIdO, null, F, F), numDocs).ScoreDocs;
 			count += result.Length;
 			Assert.AreEqual(numDocs, count, "sum of two concenatted ranges");
-			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, null, T, T), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, null, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			System.Double tempAux = (double) System.Double.PositiveInfinity;
-			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", tempAux, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "infinity special case");
 			System.Double tempAux2 = (double) System.Double.NegativeInfinity;
-			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
+			result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "infinity special case");
 		}
 	}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheTermsFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFieldCacheTermsFilter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheTermsFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheTermsFilter.cs Tue Mar 22 09:31:10 2011
@@ -62,18 +62,18 @@ namespace Lucene.Net.Search
 			
 			System.Collections.ArrayList terms = new System.Collections.ArrayList();
 			terms.Add("5");
-			results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[]) terms.ToArray(typeof(System.String))), numDocs).scoreDocs;
+			results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[]) terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
 			Assert.AreEqual(0, results.Length, "Must match nothing");
 			
 			terms = new System.Collections.ArrayList();
 			terms.Add("10");
-            results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[])terms.ToArray(typeof(System.String))), numDocs).scoreDocs;
+            results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[])terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
 			Assert.AreEqual(1, results.Length, "Must match 1");
 			
 			terms = new System.Collections.ArrayList();
 			terms.Add("10");
 			terms.Add("20");
-			results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[]) terms.ToArray(typeof(System.String))), numDocs).scoreDocs;
+			results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[]) terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
 			Assert.AreEqual(2, results.Length, "Must match 2");
 			
 			reader.Close();

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFilteredQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredQuery.cs Tue Mar 22 09:31:10 2011
@@ -126,28 +126,28 @@ namespace Lucene.Net.Search
 		public virtual void  TestFilteredQuery_Renamed()
 		{
 			Query filteredquery = new FilteredQuery(query, filter);
-			ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(1, hits[0].doc);
 			QueryUtils.Check(filteredquery, searcher);
 			
-			hits = searcher.Search(filteredquery, null, 1000, new Sort("sorter")).scoreDocs;
+			hits = searcher.Search(filteredquery, null, 1000, new Sort("sorter")).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(1, hits[0].doc);
 			
 			filteredquery = new FilteredQuery(new TermQuery(new Term("field", "one")), filter);
-			hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
+			hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			QueryUtils.Check(filteredquery, searcher);
 			
 			filteredquery = new FilteredQuery(new TermQuery(new Term("field", "x")), filter);
-			hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
+			hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(3, hits[0].doc);
 			QueryUtils.Check(filteredquery, searcher);
 			
 			filteredquery = new FilteredQuery(new TermQuery(new Term("field", "y")), filter);
-			hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
+			hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			QueryUtils.Check(filteredquery, searcher);
 			
@@ -182,8 +182,8 @@ namespace Lucene.Net.Search
 		/// <summary> Tests whether the scores of the two queries are the same.</summary>
 		public virtual void  AssertScoreEquals(Query q1, Query q2)
 		{
-			ScoreDoc[] hits1 = searcher.Search(q1, null, 1000).scoreDocs;
-			ScoreDoc[] hits2 = searcher.Search(q2, null, 1000).scoreDocs;
+			ScoreDoc[] hits1 = searcher.Search(q1, null, 1000).ScoreDocs;
+			ScoreDoc[] hits2 = searcher.Search(q2, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(hits1.Length, hits2.Length);
 			
@@ -200,7 +200,7 @@ namespace Lucene.Net.Search
 			TermRangeQuery rq = new TermRangeQuery("sorter", "b", "d", true, true);
 			
 			Query filteredquery = new FilteredQuery(rq, filter);
-			ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			QueryUtils.Check(filteredquery, searcher);
 		}
@@ -213,7 +213,7 @@ namespace Lucene.Net.Search
 			bq.Add(query, BooleanClause.Occur.MUST);
 			query = new FilteredQuery(new MatchAllDocsQuery(), new SingleDocTestFilter(1));
 			bq.Add(query, BooleanClause.Occur.MUST);
-			ScoreDoc[] hits = searcher.Search(bq, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			QueryUtils.Check(query, searcher);
 		}
@@ -227,7 +227,7 @@ namespace Lucene.Net.Search
 			Query query = new FilteredQuery(bq, new SingleDocTestFilter(0));
 			bq.Add(new TermQuery(new Term("field", "one")), BooleanClause.Occur.SHOULD);
 			bq.Add(new TermQuery(new Term("field", "two")), BooleanClause.Occur.SHOULD);
-			ScoreDoc[] hits = searcher.Search(query, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			QueryUtils.Check(query, searcher);
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredSearch.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFilteredSearch.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredSearch.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredSearch.cs Tue Mar 22 09:31:10 2011
@@ -84,7 +84,7 @@ namespace Lucene.Net.Search
 
 
                 IndexSearcher indexSearcher = new IndexSearcher(directory);
-                ScoreDoc[] hits = indexSearcher.Search(booleanQuery, filter, 1000).scoreDocs;
+                ScoreDoc[] hits = indexSearcher.Search(booleanQuery, filter, 1000).ScoreDocs;
                 Assert.AreEqual(1, hits.Length, "Number of matched documents");
 
             }

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFuzzyQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFuzzyQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFuzzyQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFuzzyQuery.cs Tue Mar 22 09:31:10 2011
@@ -59,40 +59,40 @@ namespace Lucene.Net.Search
 			IndexSearcher searcher = new IndexSearcher(directory);
 			
 			FuzzyQuery query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 0);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			
 			// same with prefix
 			query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 1);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 2);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 3);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 4);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 5);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 6);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			// not similar enough:
 			query = new FuzzyQuery(new Term("field", "xxxxx"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			query = new FuzzyQuery(new Term("field", "aaccc"), FuzzyQuery.defaultMinSimilarity, 0); // edit distance to "aaaaa" = 3
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// query identical to a word in the index:
 			query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
 			// default allows for up to two edits:
@@ -101,7 +101,7 @@ namespace Lucene.Net.Search
 			
 			// query similar to a word in the index:
 			query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
 			Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
@@ -109,63 +109,63 @@ namespace Lucene.Net.Search
 			
 			// now with prefix
 			query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 1);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
 			Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
 			Assert.AreEqual(searcher.Doc(hits[2].doc).Get("field"), ("aaabb"));
 			query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 2);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
 			Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
 			Assert.AreEqual(searcher.Doc(hits[2].doc).Get("field"), ("aaabb"));
 			query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 3);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
 			Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
 			Assert.AreEqual(searcher.Doc(hits[2].doc).Get("field"), ("aaabb"));
 			query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 4);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
 			Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
 			query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 5);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			
 			query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
 			
 			// now with prefix
 			query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 1);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
 			query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 2);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
 			query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 3);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
 			query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 4);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
 			query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 5);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			
 			// different field = no match:
 			query = new FuzzyQuery(new Term("anotherfield", "ddddX"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			searcher.Close();
@@ -186,63 +186,63 @@ namespace Lucene.Net.Search
 			FuzzyQuery query;
 			// not similar enough:
 			query = new FuzzyQuery(new Term("field", "xxxxx"), FuzzyQuery.defaultMinSimilarity, 0);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			// edit distance to "aaaaaaa" = 3, this matches because the string is longer than
 			// in testDefaultFuzziness so a bigger difference is allowed:
 			query = new FuzzyQuery(new Term("field", "aaaaccc"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaaaa"));
 			
 			// now with prefix
 			query = new FuzzyQuery(new Term("field", "aaaaccc"), FuzzyQuery.defaultMinSimilarity, 1);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaaaa"));
 			query = new FuzzyQuery(new Term("field", "aaaaccc"), FuzzyQuery.defaultMinSimilarity, 4);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaaaa"));
 			query = new FuzzyQuery(new Term("field", "aaaaccc"), FuzzyQuery.defaultMinSimilarity, 5);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// no match, more than half of the characters is wrong:
 			query = new FuzzyQuery(new Term("field", "aaacccc"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// now with prefix
 			query = new FuzzyQuery(new Term("field", "aaacccc"), FuzzyQuery.defaultMinSimilarity, 2);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// "student" and "stellent" are indeed similar to "segment" by default:
 			query = new FuzzyQuery(new Term("field", "student"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			query = new FuzzyQuery(new Term("field", "stellent"), FuzzyQuery.defaultMinSimilarity, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			// now with prefix
 			query = new FuzzyQuery(new Term("field", "student"), FuzzyQuery.defaultMinSimilarity, 1);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			query = new FuzzyQuery(new Term("field", "stellent"), FuzzyQuery.defaultMinSimilarity, 1);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			query = new FuzzyQuery(new Term("field", "student"), FuzzyQuery.defaultMinSimilarity, 2);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			query = new FuzzyQuery(new Term("field", "stellent"), FuzzyQuery.defaultMinSimilarity, 2);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// "student" doesn't match anymore thanks to increased minimum similarity:
 			query = new FuzzyQuery(new Term("field", "student"), 0.6f, 0);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			try
@@ -282,22 +282,22 @@ namespace Lucene.Net.Search
 			Query query;
 			// term not over 10 chars, so optimization shortcuts
 			query = new FuzzyQuery(new Term("field", "1234569"), 0.9f);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// 10 chars, so no optimization
 			query = new FuzzyQuery(new Term("field", "1234567891"), 0.9f);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 			
 			// over 10 chars, so no optimization
 			query = new FuzzyQuery(new Term("field", "12345678911"), 0.9f);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			// over 10 chars, no match
 			query = new FuzzyQuery(new Term("field", "sdfsdfsdfsdf"), 0.9f);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length);
 		}
 		
@@ -334,7 +334,7 @@ namespace Lucene.Net.Search
 			
 			// 3. search
 			IndexSearcher searcher = new IndexSearcher(r);
-			ScoreDoc[] hits = searcher.Search(q, 10).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(q, 10).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), "Giga byte");
 			r.Close();

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMatchAllDocsQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMatchAllDocsQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMatchAllDocsQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMatchAllDocsQuery.cs Tue Mar 22 09:31:10 2011
@@ -68,7 +68,7 @@ namespace Lucene.Net.Search
 			
 			// assert with norms scoring turned off
 			
-			hits = is_Renamed.Search(new MatchAllDocsQuery(), null, 1000).scoreDocs;
+			hits = is_Renamed.Search(new MatchAllDocsQuery(), null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			Assert.AreEqual(ir.Document(hits[0].doc).Get("key"), "one");
 			Assert.AreEqual(ir.Document(hits[1].doc).Get("key"), "two");
@@ -77,7 +77,7 @@ namespace Lucene.Net.Search
 			// assert with norms scoring turned on
 			
 			MatchAllDocsQuery normsQuery = new MatchAllDocsQuery("key");
-			hits = is_Renamed.Search(normsQuery, null, 1000).scoreDocs;
+			hits = is_Renamed.Search(normsQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			
 			Assert.AreEqual(ir.Document(hits[0].doc).Get("key"), "three four");
@@ -87,7 +87,7 @@ namespace Lucene.Net.Search
 			// change norm & retest
 			ir.SetNorm(0, "key", 400f);
 			normsQuery = new MatchAllDocsQuery("key");
-			hits = is_Renamed.Search(normsQuery, null, 1000).scoreDocs;
+			hits = is_Renamed.Search(normsQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			
 			Assert.AreEqual(ir.Document(hits[0].doc).Get("key"), "one");
@@ -99,30 +99,30 @@ namespace Lucene.Net.Search
 			BooleanQuery bq = new BooleanQuery();
 			bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
 			bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
-			hits = is_Renamed.Search(bq, null, 1000).scoreDocs;
+			hits = is_Renamed.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length);
 			
 			bq = new BooleanQuery();
 			bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
 			bq.Add(new TermQuery(new Term("key", "three")), BooleanClause.Occur.MUST);
-			hits = is_Renamed.Search(bq, null, 1000).scoreDocs;
+			hits = is_Renamed.Search(bq, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			
 			// delete a document:
 			is_Renamed.GetIndexReader().DeleteDocument(0);
-			hits = is_Renamed.Search(new MatchAllDocsQuery(), null, 1000).scoreDocs;
+			hits = is_Renamed.Search(new MatchAllDocsQuery(), null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			
 			// test parsable toString()
 			QueryParser qp = new QueryParser("key", analyzer);
-			hits = is_Renamed.Search(qp.Parse(new MatchAllDocsQuery().ToString()), null, 1000).scoreDocs;
+			hits = is_Renamed.Search(qp.Parse(new MatchAllDocsQuery().ToString()), null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			
 			// test parsable toString() with non default boost
 			Query maq = new MatchAllDocsQuery();
 			maq.SetBoost(2.3f);
 			Query pq = qp.Parse(maq.ToString());
-			hits = is_Renamed.Search(pq, null, 1000).scoreDocs;
+			hits = is_Renamed.Search(pq, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length);
 			
 			is_Renamed.Close();

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiPhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMultiPhraseQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiPhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiPhraseQuery.cs Tue Mar 22 09:31:10 2011
@@ -88,9 +88,9 @@ namespace Lucene.Net.Search
 			Assert.AreEqual("body:\"strawberry (piccadilly pie pizza)\"", query2.ToString());
 			
 			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);
 			
 			// search for "blue* pizza":
@@ -109,13 +109,13 @@ namespace Lucene.Net.Search
 			query3.Add((Term[]) termsWithPrefix.ToArray(typeof(Term)));
 			query3.Add(new Term("body", "pizza"));
 			
-			result = searcher.Search(query3, null, 1000).scoreDocs;
+			result = searcher.Search(query3, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, result.Length); // blueberry pizza, bluebird pizza
 			Assert.AreEqual("body:\"(blueberry bluebird) pizza\"", query3.ToString());
 			
 			// test slop:
 			query3.SetSlop(1);
-			result = searcher.Search(query3, null, 1000).scoreDocs;
+			result = searcher.Search(query3, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, result.Length); // blueberry pizza, bluebird pizza, bluebird foobar pizza
 			
 			MultiPhraseQuery query4 = new MultiPhraseQuery();
@@ -167,7 +167,7 @@ namespace Lucene.Net.Search
 			q.Add(trouble, BooleanClause.Occur.MUST);
 			
 			// exception will be thrown here without fix
-			ScoreDoc[] hits = searcher.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(2, hits.Length, "Wrong number of hits");
 			searcher.Close();
@@ -194,7 +194,7 @@ namespace Lucene.Net.Search
 			q.Add(trouble, BooleanClause.Occur.MUST);
 			
 			// exception will be thrown here without fix for #35626:
-			ScoreDoc[] hits = searcher.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "Wrong number of hits");
 			searcher.Close();
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMultiSearcher.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcher.cs Tue Mar 22 09:31:10 2011
@@ -155,7 +155,7 @@ namespace Lucene.Net.Search
 			// creating the multiSearcher
 			Searcher mSearcher = GetMultiSearcherInstance(searchers);
 			// performing the search
-			ScoreDoc[] hits = mSearcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = mSearcher.Search(query, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(3, hits.Length);
 			
@@ -185,7 +185,7 @@ namespace Lucene.Net.Search
 			// creating the mulitSearcher
 			MultiSearcher mSearcher2 = GetMultiSearcherInstance(searchers2);
 			// performing the same search
-			ScoreDoc[] hits2 = mSearcher2.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits2 = mSearcher2.Search(query, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(4, hits2.Length);
 			
@@ -198,12 +198,12 @@ namespace Lucene.Net.Search
 			
 			// test the subSearcher() method:
 			Query subSearcherQuery = parser.Parse("id:doc1");
-			hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).scoreDocs;
+			hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits2.Length);
 			Assert.AreEqual(0, mSearcher2.SubSearcher(hits2[0].doc)); // hit from searchers2[0]
 			Assert.AreEqual(1, mSearcher2.SubSearcher(hits2[1].doc)); // hit from searchers2[1]
 			subSearcherQuery = parser.Parse("id:doc2");
-			hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).scoreDocs;
+			hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits2.Length);
 			Assert.AreEqual(1, mSearcher2.SubSearcher(hits2[0].doc)); // hit from searchers2[1]
 			mSearcher2.Close();
@@ -231,7 +231,7 @@ namespace Lucene.Net.Search
 			// creating the mulitSearcher
 			Searcher mSearcher3 = GetMultiSearcherInstance(searchers3);
 			// performing the same search
-			ScoreDoc[] hits3 = mSearcher3.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits3 = mSearcher3.Search(query, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(3, hits3.Length);
 			
@@ -300,7 +300,7 @@ namespace Lucene.Net.Search
 			
 			MultiSearcher searcher = GetMultiSearcherInstance(new Searcher[]{indexSearcher1, indexSearcher2});
 			Assert.IsTrue(searcher != null, "searcher is null and it shouldn't be");
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
 			Assert.IsTrue(hits.Length == 2, hits.Length + " does not equal: " + 2);
 			Document document = searcher.Doc(hits[0].doc);
@@ -357,7 +357,7 @@ namespace Lucene.Net.Search
 			indexSearcher1 = new IndexSearcher(ramDirectory1);
 			indexSearcher1.SetDefaultFieldSortScoring(true, true);
 			
-			hits = indexSearcher1.Search(query, null, 1000).scoreDocs;
+			hits = indexSearcher1.Search(query, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(2, hits.Length, message);
 			
@@ -389,7 +389,7 @@ namespace Lucene.Net.Search
 			
 			Searcher searcher = GetMultiSearcherInstance(new Searcher[]{indexSearcher1, indexSearcher2});
 			
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			
 			Assert.AreEqual(2, hits.Length, message);
 			
@@ -400,7 +400,7 @@ namespace Lucene.Net.Search
 			
 			
 			// Adding a Sort.RELEVANCE object should not change anything
-			hits = searcher.Search(query, null, 1000, Sort.RELEVANCE).scoreDocs;
+			hits = searcher.Search(query, null, 1000, Sort.RELEVANCE).ScoreDocs;
 			
 			Assert.AreEqual(2, hits.Length, message);
 			

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcherRanking.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMultiSearcherRanking.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcherRanking.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcherRanking.cs Tue Mar 22 09:31:10 2011
@@ -111,8 +111,8 @@ namespace Lucene.Net.Search
 				System.Console.Out.WriteLine("Query: " + queryStr);
 			QueryParser queryParser = new QueryParser(FIELD_NAME, new StandardAnalyzer());
 			Query query = queryParser.Parse(queryStr);
-			ScoreDoc[] multiSearcherHits = multiSearcher.Search(query, null, 1000).scoreDocs;
-			ScoreDoc[] singleSearcherHits = singleSearcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] multiSearcherHits = multiSearcher.Search(query, null, 1000).ScoreDocs;
+			ScoreDoc[] singleSearcherHits = singleSearcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(multiSearcherHits.Length, singleSearcherHits.Length);
 			for (int i = 0; i < multiSearcherHits.Length; i++)
 			{



Mime
View raw message