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 [4/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/TestSort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestSort.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestSort.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestSort.cs Tue Mar 22 09:31:10 2011
@@ -226,7 +226,7 @@ namespace Lucene.Net.Search
 			{
 				System.Collections.BitArray bs = new System.Collections.BitArray((reader.MaxDoc() % 64 == 0?reader.MaxDoc() / 64:reader.MaxDoc() / 64 + 1) * 64);
                 for (int i = 0; i < reader.MaxDoc(); i++) bs.Set(i, true);
-				bs.Set(docs1.scoreDocs[0].doc, true);
+				bs.Set(docs1.ScoreDocs[0].doc, true);
 				return new DocIdBitSet(bs);
 			}
 		}
@@ -479,7 +479,7 @@ namespace Lucene.Net.Search
 			IndexSearcher searcher = GetFullStrings();
 			sort.SetSort(new SortField[]{new SortField("string", SortField.STRING), new SortField("string2", SortField.STRING, true), SortField.FIELD_DOC});
 			
-			result = searcher.Search(new MatchAllDocsQuery(), null, 500, sort).scoreDocs;
+			result = searcher.Search(new MatchAllDocsQuery(), null, 500, sort).ScoreDocs;
 			
 			System.Text.StringBuilder buff = new System.Text.StringBuilder();
 			int n = result.Length;
@@ -893,9 +893,9 @@ namespace Lucene.Net.Search
 		{
 			
 			// capture relevancy scores
-			System.Collections.Hashtable scoresX = GetScores(full.Search(queryX, null, 1000).scoreDocs, full);
-			System.Collections.Hashtable scoresY = GetScores(full.Search(queryY, null, 1000).scoreDocs, full);
-			System.Collections.Hashtable scoresA = GetScores(full.Search(queryA, null, 1000).scoreDocs, full);
+			System.Collections.Hashtable scoresX = GetScores(full.Search(queryX, null, 1000).ScoreDocs, full);
+			System.Collections.Hashtable scoresY = GetScores(full.Search(queryY, null, 1000).ScoreDocs, full);
+			System.Collections.Hashtable scoresA = GetScores(full.Search(queryA, null, 1000).ScoreDocs, full);
 			
 			// we'll test searching locally, remote and multi
 			
@@ -904,68 +904,68 @@ namespace Lucene.Net.Search
 			// change sorting and make sure relevancy stays the same
 			
 			sort = new Sort();
-			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).scoreDocs, multi));
+			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).ScoreDocs, multi));
 			
 			sort.SetSort(SortField.FIELD_DOC);
-			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).scoreDocs, multi));
+			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).ScoreDocs, multi));
 			
 			sort.SetSort("int");
-			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).scoreDocs, multi));
+			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).ScoreDocs, multi));
 			
 			sort.SetSort("float");
-			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).scoreDocs, multi));
+			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).ScoreDocs, multi));
 			
 			sort.SetSort("string");
-			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).scoreDocs, multi));
+			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).ScoreDocs, multi));
 			
 			sort.SetSort(new System.String[]{"int", "float"});
-			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).scoreDocs, multi));
+			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).ScoreDocs, multi));
 			
 			sort.SetSort(new SortField[]{new SortField("int", true), new SortField(null, SortField.DOC, true)});
-			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).scoreDocs, multi));
+			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).ScoreDocs, multi));
 			
 			sort.SetSort(new System.String[]{"float", "string"});
-			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).scoreDocs, multi));
-			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).scoreDocs, full));
-			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).scoreDocs, multi));
+			AssertSameValues(scoresX, GetScores(full.Search(queryX, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresX, GetScores(multi.Search(queryX, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresY, GetScores(full.Search(queryY, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresY, GetScores(multi.Search(queryY, null, 1000, sort).ScoreDocs, multi));
+			AssertSameValues(scoresA, GetScores(full.Search(queryA, null, 1000, sort).ScoreDocs, full));
+			AssertSameValues(scoresA, GetScores(multi.Search(queryA, null, 1000, sort).ScoreDocs, multi));
 		}
 		
 		[Test]
@@ -986,7 +986,7 @@ namespace Lucene.Net.Search
 			
 			TopDocs docs2 = full.Search(queryE, filt, nDocs, sort);
 			
-			Assert.AreEqual(docs1.scoreDocs[0].score, docs2.scoreDocs[0].score, 1e-6);
+			Assert.AreEqual(docs1.ScoreDocs[0].score, docs2.ScoreDocs[0].score, 1e-6);
 		}
 		
 		[Test]
@@ -1006,7 +1006,7 @@ namespace Lucene.Net.Search
 				
 				full.Search(q, tdc);
 				
-				ScoreDoc[] sd = tdc.TopDocs().scoreDocs;
+				ScoreDoc[] sd = tdc.TopDocs().ScoreDocs;
 				for (int j = 1; j < sd.Length; j++)
 				{
 					Assert.IsTrue(sd[j].doc != sd[j - 1].doc);
@@ -1028,7 +1028,7 @@ namespace Lucene.Net.Search
 				full.Search(q, tdc);
 				
 				TopDocs td = tdc.TopDocs();
-				ScoreDoc[] sd = td.scoreDocs;
+				ScoreDoc[] sd = td.ScoreDocs;
 				for (int j = 0; j < sd.Length; j++)
 				{
 					Assert.IsTrue(System.Single.IsNaN(sd[j].score));
@@ -1051,7 +1051,7 @@ namespace Lucene.Net.Search
 				full.Search(q, tdc);
 				
 				TopDocs td = tdc.TopDocs();
-				ScoreDoc[] sd = td.scoreDocs;
+				ScoreDoc[] sd = td.ScoreDocs;
 				for (int j = 0; j < sd.Length; j++)
 				{
 					Assert.IsTrue(!System.Single.IsNaN(sd[j].score));
@@ -1074,7 +1074,7 @@ namespace Lucene.Net.Search
 				full.Search(q, tdc);
 				
 				TopDocs td = tdc.TopDocs();
-				ScoreDoc[] sd = td.scoreDocs;
+				ScoreDoc[] sd = td.ScoreDocs;
 				for (int j = 0; j < sd.Length; j++)
 				{
 					Assert.IsTrue(!System.Single.IsNaN(sd[j].score));
@@ -1117,7 +1117,7 @@ namespace Lucene.Net.Search
 						full.Search(bq, tdc);
 						
 						TopDocs td = tdc.TopDocs();
-						ScoreDoc[] sd = td.scoreDocs;
+						ScoreDoc[] sd = td.ScoreDocs;
 						Assert.AreEqual(10, sd.Length);
 					}
 				}
@@ -1141,7 +1141,7 @@ namespace Lucene.Net.Search
 			{
 				TopDocsCollector tdc = TopFieldCollector.create(sort[i], 10, true, true, true, true);
 				TopDocs td = tdc.TopDocs();
-				Assert.AreEqual(0, td.totalHits);
+				Assert.AreEqual(0, td.TotalHits);
 				Assert.IsTrue(System.Single.IsNaN(td.GetMaxScore()));
 			}
 		}
@@ -1229,8 +1229,8 @@ namespace Lucene.Net.Search
 		{
 			//ScoreDoc[] result = searcher.search (query, null, 1000, sort).scoreDocs;
 			TopDocs hits = searcher.Search(query, null, expectedResult.Length, sort);
-			ScoreDoc[] result = hits.scoreDocs;
-			Assert.AreEqual(hits.totalHits, expectedResult.Length);
+			ScoreDoc[] result = hits.ScoreDocs;
+			Assert.AreEqual(hits.TotalHits, expectedResult.Length);
 			System.Text.StringBuilder buff = new System.Text.StringBuilder(10);
 			int n = result.Length;
 			for (int i = 0; i < n; ++i)

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestStressSort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestStressSort.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestStressSort.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestStressSort.cs Tue Mar 22 09:31:10 2011
@@ -441,10 +441,10 @@ namespace Lucene.Net.Search
 		
 		private void  Compare(TopDocs oldHits, TopDocs newHits)
 		{
-			Assert.AreEqual(oldHits.totalHits, newHits.totalHits);
-			Assert.AreEqual(oldHits.scoreDocs.Length, newHits.scoreDocs.Length);
-			ScoreDoc[] oldDocs = oldHits.scoreDocs;
-			ScoreDoc[] newDocs = newHits.scoreDocs;
+			Assert.AreEqual(oldHits.TotalHits, newHits.TotalHits);
+			Assert.AreEqual(oldHits.ScoreDocs.Length, newHits.ScoreDocs.Length);
+			ScoreDoc[] oldDocs = oldHits.ScoreDocs;
+			ScoreDoc[] newDocs = newHits.ScoreDocs;
 			
 			for (int i = 0; i < oldDocs.Length; i++)
 			{

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestTermRangeFilter.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeFilter.cs Tue Mar 22 09:31:10 2011
@@ -71,64 +71,64 @@ namespace Lucene.Net.Search
 			
 			// test id, bounded on both ends
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but last");
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but first");
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, maxIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
 			
-			result = search.Search(q, new TermRangeFilter("id", medIP, maxIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", medIP, maxIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, medIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, medIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
 			
 			// unbounded id
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "min and up");
 			
-			result = search.Search(q, new TermRangeFilter("id", null, maxIP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", null, maxIP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "max and down");
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
 			
-			result = search.Search(q, new TermRangeFilter("id", null, maxIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", null, maxIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
 			
-			result = search.Search(q, new TermRangeFilter("id", medIP, maxIP, T, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", medIP, maxIP, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, medIP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("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, new TermRangeFilter("id", minIP, minIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, minIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "min,min,F,F");
-			result = search.Search(q, new TermRangeFilter("id", medIP, medIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", medIP, medIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "med,med,F,F");
-			result = search.Search(q, new TermRangeFilter("id", maxIP, maxIP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", maxIP, maxIP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "max,max,F,F");
 			
-			result = search.Search(q, new TermRangeFilter("id", minIP, minIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", minIP, minIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "min,min,T,T");
-			result = search.Search(q, new TermRangeFilter("id", null, minIP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", null, minIP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "nul,min,F,T");
 			
-			result = search.Search(q, new TermRangeFilter("id", maxIP, maxIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", maxIP, maxIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,max,T,T");
-			result = search.Search(q, new TermRangeFilter("id", maxIP, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", maxIP, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,nul,T,T");
 			
-			result = search.Search(q, new TermRangeFilter("id", medIP, medIP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("id", medIP, medIP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "med,med,T,T");
 		}
 		
@@ -236,47 +236,47 @@ namespace Lucene.Net.Search
 			
 			// test extremes, bounded on both ends
 			
-			result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "find all");
 			
-			result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, T, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but biggest");
 			
-			result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "all but smallest");
 			
-			result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", minRP, maxRP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 2, result.Length, "all but extremes");
 			
 			// unbounded
 			
-			result = search.Search(q, new TermRangeFilter("rand", minRP, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", minRP, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "smallest and up");
 			
-			result = search.Search(q, new TermRangeFilter("rand", null, maxRP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", null, maxRP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs, result.Length, "biggest and down");
 			
-			result = search.Search(q, new TermRangeFilter("rand", minRP, null, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", minRP, null, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not smallest, but up");
 			
-			result = search.Search(q, new TermRangeFilter("rand", null, maxRP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", null, maxRP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(numDocs - 1, result.Length, "not biggest, but down");
 			
 			// very small sets
 			
-			result = search.Search(q, new TermRangeFilter("rand", minRP, minRP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", minRP, minRP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "min,min,F,F");
-			result = search.Search(q, new TermRangeFilter("rand", maxRP, maxRP, F, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", maxRP, maxRP, F, F), numDocs).ScoreDocs;
 			Assert.AreEqual(0, result.Length, "max,max,F,F");
 			
-			result = search.Search(q, new TermRangeFilter("rand", minRP, minRP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", minRP, minRP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "min,min,T,T");
-			result = search.Search(q, new TermRangeFilter("rand", null, minRP, F, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", null, minRP, F, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "nul,min,F,T");
 			
-			result = search.Search(q, new TermRangeFilter("rand", maxRP, maxRP, T, T), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", maxRP, maxRP, T, T), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,max,T,T");
-			result = search.Search(q, new TermRangeFilter("rand", maxRP, null, T, F), numDocs).scoreDocs;
+			result = search.Search(q, new TermRangeFilter("rand", maxRP, null, T, F), numDocs).ScoreDocs;
 			Assert.AreEqual(1, result.Length, "max,nul,T,T");
 		}
 		

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestTermRangeQuery.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeQuery.cs Tue Mar 22 09:31:10 2011
@@ -55,19 +55,19 @@ namespace Lucene.Net.Search
 			Query query = new TermRangeQuery("content", "A", "C", false, false);
 			InitializeIndex(new System.String[]{"A", "B", "C", "D"});
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "A,B,C,D, only B in range");
 			searcher.Close();
 			
 			InitializeIndex(new System.String[]{"A", "B", "D"});
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "A,B,D, only B in range");
 			searcher.Close();
 			
 			AddDoc("C");
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "C added, still only B in range");
 			searcher.Close();
 		}
@@ -79,14 +79,14 @@ namespace Lucene.Net.Search
 			Query query = new RangeQuery(null, new Term("content", "C"), false);
 			InitializeIndex(new System.String[]{"A", "B", "C", "D"});
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length, "A,B,C,D, only B in range");
 			searcher.Close();
 			
 			query = new RangeQuery(new Term("content", "C"), null, false);
 			InitializeIndex(new System.String[]{"A", "B", "C", "D"});
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "A,B,C,D, only B in range");
 			searcher.Close();
 		}
@@ -98,19 +98,19 @@ namespace Lucene.Net.Search
 			
 			InitializeIndex(new System.String[]{"A", "B", "C", "D"});
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length, "A,B,C,D - A,B,C in range");
 			searcher.Close();
 			
 			InitializeIndex(new System.String[]{"A", "B", "D"});
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length, "A,B,D - A and B in range");
 			searcher.Close();
 			
 			AddDoc("C");
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length, "C added - A, B, C in range");
 			searcher.Close();
 		}
@@ -169,19 +169,19 @@ namespace Lucene.Net.Search
 			Query query = new TermRangeQuery("content", "A", "C", false, false, new System.Globalization.CultureInfo("en").CompareInfo);
 			InitializeIndex(new System.String[]{"A", "B", "C", "D"});
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "A,B,C,D, only B in range");
 			searcher.Close();
 			
 			InitializeIndex(new System.String[]{"A", "B", "D"});
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "A,B,D, only B in range");
 			searcher.Close();
 			
 			AddDoc("C");
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "C added, still only B in range");
 			searcher.Close();
 		}
@@ -193,19 +193,19 @@ namespace Lucene.Net.Search
 			
 			InitializeIndex(new System.String[]{"A", "B", "C", "D"});
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length, "A,B,C,D - A,B,C in range");
 			searcher.Close();
 			
 			InitializeIndex(new System.String[]{"A", "B", "D"});
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(2, hits.Length, "A,B,D - A and B in range");
 			searcher.Close();
 			
 			AddDoc("C");
 			searcher = new IndexSearcher(dir);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(3, hits.Length, "C added - A, B, C in range");
 			searcher.Close();
 		}
@@ -224,11 +224,11 @@ namespace Lucene.Net.Search
 			// Collator (or an Arabic one for the case when Farsi is not supported).
 			InitializeIndex(new System.String[]{"\u0633\u0627\u0628"});
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "The index Term should not be included.");
 			
 			query = new TermRangeQuery("content", "\u0633", "\u0638", true, true, collator);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "The index Term should be included.");
 			searcher.Close();
 		}
@@ -246,11 +246,11 @@ namespace Lucene.Net.Search
 			// but Danish collation does.
 			InitializeIndex(words);
 			IndexSearcher searcher = new IndexSearcher(dir);
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length, "The index Term should be included.");
 			
 			query = new TermRangeQuery("content", "H\u00C5T", "MAND", false, false, collator);
-			hits = searcher.Search(query, null, 1000).scoreDocs;
+			hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(0, hits.Length, "The index Term should not be included.");
 			searcher.Close();
 		}

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestTermVectors.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestTermVectors.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTermVectors.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTermVectors.cs Tue Mar 22 09:31:10 2011
@@ -85,7 +85,7 @@ namespace Lucene.Net.Search
 			Query query = new TermQuery(new Term("field", "seventy"));
 			try
 			{
-				ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+				ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 				Assert.AreEqual(100, hits.Length);
 				
 				for (int i = 0; i < hits.Length; i++)
@@ -142,7 +142,7 @@ namespace Lucene.Net.Search
 			Query query = new TermQuery(new Term("field", "zero"));
 			try
 			{
-				ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+				ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 				Assert.AreEqual(1, hits.Length);
 				
 				for (int i = 0; i < hits.Length; i++)
@@ -213,7 +213,7 @@ namespace Lucene.Net.Search
 			Query query = new TermQuery(new Term("field", "fifty"));
 			try
 			{
-				ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+				ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 				Assert.AreEqual(100, hits.Length);
 				
 				for (int i = 0; i < hits.Length; i++)
@@ -309,7 +309,7 @@ namespace Lucene.Net.Search
 					//System.out.println("--------");
 				}
 				Query query = new TermQuery(new Term("field", "chocolate"));
-				ScoreDoc[] hits = knownSearcher.Search(query, null, 1000).scoreDocs;
+				ScoreDoc[] hits = knownSearcher.Search(query, null, 1000).ScoreDocs;
 				//doc 3 should be the first hit b/c it is the shortest match
 				Assert.IsTrue(hits.Length == 3);
 				float score = hits[0].score;
@@ -407,7 +407,7 @@ namespace Lucene.Net.Search
 			searcher = new IndexSearcher(directory);
 			
 			Query query = new TermQuery(new Term("field", "hundred"));
-			ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(10, hits.Length);
 			for (int i = 0; i < hits.Length; i++)
 			{
@@ -436,7 +436,7 @@ namespace Lucene.Net.Search
 			searcher = new IndexSearcher(directory);
 			
 			Query query = new TermQuery(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);
 			
 			TermFreqVector[] vector = searcher.reader_ForNUnit.GetTermFreqVectors(hits[0].doc);

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestTopDocsCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestTopDocsCollector.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTopDocsCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTopDocsCollector.cs Tue Mar 22 09:31:10 2011
@@ -140,33 +140,33 @@ namespace Lucene.Net.Search
 			TopDocsCollector tdc = doSearch(numResults);
 			
 			// start < 0
-			Assert.AreEqual(0, tdc.TopDocs(- 1).scoreDocs.Length);
+			Assert.AreEqual(0, tdc.TopDocs(- 1).ScoreDocs.Length);
 			
 			// start > pq.size()
-			Assert.AreEqual(0, tdc.TopDocs(numResults + 1).scoreDocs.Length);
+			Assert.AreEqual(0, tdc.TopDocs(numResults + 1).ScoreDocs.Length);
 			
 			// start == pq.size()
-			Assert.AreEqual(0, tdc.TopDocs(numResults).scoreDocs.Length);
+			Assert.AreEqual(0, tdc.TopDocs(numResults).ScoreDocs.Length);
 			
 			// howMany < 0
-			Assert.AreEqual(0, tdc.TopDocs(0, - 1).scoreDocs.Length);
+			Assert.AreEqual(0, tdc.TopDocs(0, - 1).ScoreDocs.Length);
 			
 			// howMany == 0
-			Assert.AreEqual(0, tdc.TopDocs(0, 0).scoreDocs.Length);
+			Assert.AreEqual(0, tdc.TopDocs(0, 0).ScoreDocs.Length);
 		}
 		
         [Test]
 		public virtual void  TestZeroResults()
 		{
 			TopDocsCollector tdc = new MyTopsDocCollector(5);
-			Assert.AreEqual(0, tdc.TopDocs(0, 1).scoreDocs.Length);
+			Assert.AreEqual(0, tdc.TopDocs(0, 1).ScoreDocs.Length);
 		}
 		
         [Test]
 		public virtual void  TestFirstResultsPage()
 		{
 			TopDocsCollector tdc = doSearch(15);
-			Assert.AreEqual(10, tdc.TopDocs(0, 10).scoreDocs.Length);
+			Assert.AreEqual(10, tdc.TopDocs(0, 10).ScoreDocs.Length);
 		}
 		
         [Test]
@@ -174,22 +174,22 @@ namespace Lucene.Net.Search
 		{
 			TopDocsCollector tdc = doSearch(15);
 			// ask for more results than are available
-			Assert.AreEqual(5, tdc.TopDocs(10, 10).scoreDocs.Length);
+			Assert.AreEqual(5, tdc.TopDocs(10, 10).ScoreDocs.Length);
 			
 			// ask for 5 results (exactly what there should be
 			tdc = doSearch(15);
-			Assert.AreEqual(5, tdc.TopDocs(10, 5).scoreDocs.Length);
+			Assert.AreEqual(5, tdc.TopDocs(10, 5).ScoreDocs.Length);
 			
 			// ask for less results than there are
 			tdc = doSearch(15);
-			Assert.AreEqual(4, tdc.TopDocs(10, 4).scoreDocs.Length);
+			Assert.AreEqual(4, tdc.TopDocs(10, 4).ScoreDocs.Length);
 		}
 		
         [Test]
 		public virtual void  TestGetAllResults()
 		{
 			TopDocsCollector tdc = doSearch(15);
-			Assert.AreEqual(15, tdc.TopDocs().scoreDocs.Length);
+			Assert.AreEqual(15, tdc.TopDocs().ScoreDocs.Length);
 		}
 		
         [Test]
@@ -197,11 +197,11 @@ namespace Lucene.Net.Search
 		{
 			TopDocsCollector tdc = doSearch(15);
 			// should bring all results
-			Assert.AreEqual(15, tdc.TopDocs(0).scoreDocs.Length);
+			Assert.AreEqual(15, tdc.TopDocs(0).ScoreDocs.Length);
 			
 			tdc = doSearch(15);
 			// get the last 5 only.
-			Assert.AreEqual(5, tdc.TopDocs(10).scoreDocs.Length);
+			Assert.AreEqual(5, tdc.TopDocs(10).ScoreDocs.Length);
 		}
 		
         [Test]
@@ -224,7 +224,7 @@ namespace Lucene.Net.Search
 		public virtual void  TestResultsOrder()
 		{
 			TopDocsCollector tdc = doSearch(15);
-			ScoreDoc[] sd = tdc.TopDocs().scoreDocs;
+			ScoreDoc[] sd = tdc.TopDocs().ScoreDocs;
 			
 			Assert.AreEqual(MAX_SCORE, sd[0].score, 0f);
 			for (int i = 1; i < sd.Length; i++)

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestTopScoreDocCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestTopScoreDocCollector.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTopScoreDocCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTopScoreDocCollector.cs Tue Mar 22 09:31:10 2011
@@ -81,7 +81,7 @@ namespace Lucene.Net.Search
 					
 					searcher.Search(new MatchAllDocsQuery(), tdc);
 					
-					ScoreDoc[] sd = tdc.TopDocs().scoreDocs;
+					ScoreDoc[] sd = tdc.TopDocs().ScoreDocs;
 					Assert.AreEqual(3, sd.Length);
 					for (int j = 0; j < sd.Length; j++)
 					{

Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestWildcard.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestWildcard.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestWildcard.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestWildcard.cs Tue Mar 22 09:31:10 2011
@@ -179,7 +179,7 @@ namespace Lucene.Net.Search
 		
 		private void  AssertMatches(IndexSearcher searcher, Query q, int expectedMatches)
 		{
-			ScoreDoc[] result = searcher.Search(q, null, 1000).scoreDocs;
+			ScoreDoc[] result = searcher.Search(q, null, 1000).ScoreDocs;
 			Assert.AreEqual(expectedMatches, result.Length);
 		}
 		
@@ -228,7 +228,7 @@ namespace Lucene.Net.Search
 				{
 					System.Console.Out.WriteLine("matchAll: qtxt=" + qtxt + " q=" + q + " " + q.GetType().FullName);
 				}
-				ScoreDoc[] hits = searcher.Search(q, null, 1000).scoreDocs;
+				ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
 				Assert.AreEqual(docs.Length, hits.Length);
 			}
 			
@@ -241,7 +241,7 @@ namespace Lucene.Net.Search
 				{
 					System.Console.Out.WriteLine("matchNone: qtxt=" + qtxt + " q=" + q + " " + q.GetType().FullName);
 				}
-				ScoreDoc[] hits = searcher.Search(q, null, 1000).scoreDocs;
+				ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
 				Assert.AreEqual(0, hits.Length);
 			}
 			
@@ -257,7 +257,7 @@ namespace Lucene.Net.Search
 						System.Console.Out.WriteLine("match 1 prefix: doc=" + docs[i] + " qtxt=" + qtxt + " q=" + q + " " + q.GetType().FullName);
 					}
 					Assert.AreEqual(typeof(PrefixQuery), q.GetType());
-					ScoreDoc[] hits = searcher.Search(q, null, 1000).scoreDocs;
+					ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
 					Assert.AreEqual(1, hits.Length);
 					Assert.AreEqual(i, hits[0].doc);
 				}
@@ -275,7 +275,7 @@ namespace Lucene.Net.Search
 						System.Console.Out.WriteLine("match 1 wild: doc=" + docs[i] + " qtxt=" + qtxt + " q=" + q + " " + q.GetType().FullName);
 					}
 					Assert.AreEqual(typeof(WildcardQuery), q.GetType());
-					ScoreDoc[] hits = searcher.Search(q, null, 1000).scoreDocs;
+					ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
 					Assert.AreEqual(1, hits.Length);
 					Assert.AreEqual(i, hits[0].doc);
 				}

Modified: incubator/lucene.net/trunk/C#/src/Test/Store/TestBufferedIndexInput.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Store/TestBufferedIndexInput.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Store/TestBufferedIndexInput.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Store/TestBufferedIndexInput.cs Tue Mar 22 09:31:10 2011
@@ -314,14 +314,14 @@ namespace Lucene.Net.Store
 				dir.tweakBufferSizes();
 				
 				IndexSearcher searcher = new IndexSearcher(reader);
-				ScoreDoc[] hits = searcher.Search(new TermQuery(bbb), null, 1000).scoreDocs;
+				ScoreDoc[] hits = searcher.Search(new TermQuery(bbb), null, 1000).ScoreDocs;
 				dir.tweakBufferSizes();
 				Assert.AreEqual(35, hits.Length);
 				dir.tweakBufferSizes();
-				hits = searcher.Search(new TermQuery(new Term("id", "33")), null, 1000).scoreDocs;
+				hits = searcher.Search(new TermQuery(new Term("id", "33")), null, 1000).ScoreDocs;
 				dir.tweakBufferSizes();
 				Assert.AreEqual(1, hits.Length);
-				hits = searcher.Search(new TermQuery(aaa), null, 1000).scoreDocs;
+				hits = searcher.Search(new TermQuery(aaa), null, 1000).ScoreDocs;
 				dir.tweakBufferSizes();
 				Assert.AreEqual(35, hits.Length);
 				searcher.Close();

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

Modified: incubator/lucene.net/trunk/C#/src/Test/TestDemo.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/TestDemo.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/TestDemo.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/TestDemo.cs Tue Mar 22 09:31:10 2011
@@ -69,7 +69,7 @@ namespace Lucene.Net
 			// Parse a simple query that searches for "text":
 			QueryParser parser = new QueryParser("fieldname", analyzer);
 			Query query = parser.Parse("text");
-			ScoreDoc[] hits = isearcher.Search(query, null, 1000).scoreDocs;
+			ScoreDoc[] hits = isearcher.Search(query, null, 1000).ScoreDocs;
 			Assert.AreEqual(1, hits.Length);
 			// Iterate through the results:
 			for (int i = 0; i < hits.Length; i++)

Modified: incubator/lucene.net/trunk/C#/src/Test/TestSearch.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/TestSearch.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/TestSearch.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/TestSearch.cs Tue Mar 22 09:31:10 2011
@@ -111,7 +111,7 @@ namespace Lucene.Net
 				//DateFilter filter = DateFilter.Before("modified", Time(1997,00,01));
 				//System.out.println(filter);
 				
-				hits = searcher.Search(query, null, 1000).scoreDocs;
+				hits = searcher.Search(query, null, 1000).ScoreDocs;
 				
 				out_Renamed.WriteLine(hits.Length + " total results");
 				for (int i = 0; i < hits.Length && i < 10; i++)

Modified: incubator/lucene.net/trunk/C#/src/Test/TestSearchForDuplicates.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/TestSearchForDuplicates.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/TestSearchForDuplicates.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/TestSearchForDuplicates.cs Tue Mar 22 09:31:10 2011
@@ -113,7 +113,7 @@ namespace Lucene.Net
 			Query query = parser.Parse(HIGH_PRIORITY);
 			out_Renamed.WriteLine("Query: " + query.ToString(PRIORITY_FIELD));
 			
-			ScoreDoc[] hits = searcher.Search(query, null, MAX_DOCS).scoreDocs;
+			ScoreDoc[] hits = searcher.Search(query, null, MAX_DOCS).ScoreDocs;
 			PrintHits(out_Renamed, hits, searcher);
 			CheckHits(hits, MAX_DOCS, searcher);
 			
@@ -128,7 +128,7 @@ namespace Lucene.Net
 			query = parser.Parse(HIGH_PRIORITY + " OR " + MED_PRIORITY);
 			out_Renamed.WriteLine("Query: " + query.ToString(PRIORITY_FIELD));
 			
-			hits = searcher.Search(query, null, MAX_DOCS).scoreDocs;
+			hits = searcher.Search(query, null, MAX_DOCS).ScoreDocs;
 			PrintHits(out_Renamed, hits, searcher);
 			CheckHits(hits, MAX_DOCS, searcher);
 			

Modified: incubator/lucene.net/trunk/C#/src/Test/TestSupportClass.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/TestSupportClass.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/TestSupportClass.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/TestSupportClass.cs Tue Mar 22 09:31:10 2011
@@ -907,7 +907,7 @@ namespace Lucene.Net._SupportClass
             Lucene.Net.Search.TopDocs topDocs = s.Search(q, 100);
             s.Close();
 
-            Assert.AreEqual(topDocs.totalHits, 2, "See the issue: LUCENENET-174");
+            Assert.AreEqual(topDocs.TotalHits, 2, "See the issue: LUCENENET-174");
         }
 
 
@@ -1097,12 +1097,12 @@ namespace Lucene.Net._SupportClass
 
             Lucene.Net.Search.IndexSearcher searcher = new Lucene.Net.Search.IndexSearcher(dir, true);
 
-            int hitCount = searcher.Search(lucQuery, 20).totalHits;
+            int hitCount = searcher.Search(lucQuery, 20).TotalHits;
             
             searcher.Close();
             searcher = new Lucene.Net.Search.IndexSearcher(dir, true);
 
-            int hitCount2 = searcher.Search(lucQuery2, 20).totalHits;
+            int hitCount2 = searcher.Search(lucQuery2, 20).TotalHits;
 
             Assert.AreEqual(hitCount, hitCount2,"Error in serialization - different hit counts");
         }

Modified: incubator/lucene.net/trunk/C#/src/Test/Util/TestNumericUtils.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Util/TestNumericUtils.cs?rev=1084113&r1=1084112&r2=1084113&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Util/TestNumericUtils.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Util/TestNumericUtils.cs Tue Mar 22 09:31:10 2011
@@ -75,11 +75,26 @@ namespace Lucene.Net.Util
                 neededShifts.MoveNext();
                 Assert.AreEqual(((Int32)neededShifts.Current), shift, "shift");
                 neededBounds.MoveNext();
-				Assert.AreEqual((long) neededBounds.Current, SupportClass.Number.URShift(min, shift), "inner min bound");
+                try
+                {
+                    Assert.AreEqual(neededBounds.Current, (ulong)SupportClass.Number.URShift(min, shift), "inner min bound");
+                }
+                catch (OverflowException)
+                {
+                    Assert.AreEqual((long)neededBounds.Current, SupportClass.Number.URShift(min, shift), "inner min bound");
+                }
                 neededBounds.MoveNext();
-				Assert.AreEqual((long) neededBounds.Current, SupportClass.Number.URShift(max, shift), "inner max bound");
+                try
+                {
+                    Assert.AreEqual(neededBounds.Current, (ulong)SupportClass.Number.URShift(max, shift), "inner max bound");
+                }
+                catch (OverflowException)
+                {
+                    Assert.AreEqual((long)neededBounds.Current, SupportClass.Number.URShift(max, shift), "inner max bound");
+                }
             }
 		}
+
 		private class AnonymousClassIntRangeBuilder:NumericUtils.IntRangeBuilder
 		{
 			public AnonymousClassIntRangeBuilder(int lower, int upper, bool useBitSet, Lucene.Net.Util.OpenBitSet bits, System.Collections.IEnumerator neededBounds, System.Collections.IEnumerator neededShifts,TestNumericUtils enclosingInstance)



Mime
View raw message