lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject svn commit: r890061 [4/4] - in /incubator/lucene.net/trunk/C#/src: Lucene.Net/Search/ Test/ Test/Analysis/ Test/Document/ Test/Index/ Test/QueryParser/ Test/Search/ Test/Search/Function/ Test/Search/Payloads/ Test/Search/Spans/ Test/Store/
Date Sun, 13 Dec 2009 13:48:03 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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestSort.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestSort.cs Sun Dec 13 13:47:57 2009
@@ -226,7 +226,7 @@
 			{
 				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);
 			}
 		}
@@ -477,7 +477,7 @@
 			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;
@@ -891,9 +891,9 @@
 		{
 			
 			// 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
 			
@@ -902,68 +902,68 @@
 			// 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]
@@ -984,7 +984,7 @@
 			
 			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]
@@ -1004,7 +1004,7 @@
 				
 				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);
@@ -1026,7 +1026,7 @@
 				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));
@@ -1049,7 +1049,7 @@
 				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));
@@ -1072,7 +1072,7 @@
 				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));
@@ -1115,7 +1115,7 @@
 						full.Search(bq, tdc);
 						
 						TopDocs td = tdc.TopDocs();
-						ScoreDoc[] sd = td.scoreDocs;
+						ScoreDoc[] sd = td.ScoreDocs;
 						Assert.AreEqual(10, sd.Length);
 					}
 				}
@@ -1139,7 +1139,7 @@
 			{
 				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()));
 			}
 		}
@@ -1227,8 +1227,8 @@
 		{
 			//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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestStressSort.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestStressSort.cs Sun Dec 13 13:47:57 2009
@@ -441,10 +441,10 @@
 		
 		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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeFilter.cs Sun Dec 13 13:47:57
2009
@@ -71,64 +71,64 @@
 			
 			// 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 @@
 			
 			// 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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTermRangeQuery.cs Sun Dec 13 13:47:57
2009
@@ -55,19 +55,19 @@
 			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 @@
 			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 @@
 			
 			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 @@
 			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 @@
 			
 			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 @@
 			// 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 @@
 			// 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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTermVectors.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTermVectors.cs Sun Dec 13 13:47:57 2009
@@ -85,7 +85,7 @@
 			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 @@
 			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 @@
 			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 @@
 					//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 @@
 			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 @@
 			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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTopDocsCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTopDocsCollector.cs Sun Dec 13 13:47:57
2009
@@ -140,33 +140,33 @@
 			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 @@
 		{
 			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 @@
 		{
 			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 @@
 		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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestTopScoreDocCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestTopScoreDocCollector.cs Sun Dec 13 13:47:57
2009
@@ -81,7 +81,7 @@
 					
 					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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestWildcard.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestWildcard.cs Sun Dec 13 13:47:57 2009
@@ -158,7 +158,7 @@
 		
 		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);
 		}
 		
@@ -207,7 +207,7 @@
 				{
 					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);
 			}
 			
@@ -220,7 +220,7 @@
 				{
 					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);
 			}
 			
@@ -236,7 +236,7 @@
 						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);
 				}
@@ -254,7 +254,7 @@
 						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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Store/TestBufferedIndexInput.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Store/TestBufferedIndexInput.cs Sun Dec 13 13:47:57
2009
@@ -314,14 +314,14 @@
 				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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Store/TestLockFactory.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Store/TestLockFactory.cs Sun Dec 13 13:47:57 2009
@@ -592,7 +592,7 @@
 						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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/TestDemo.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/TestDemo.cs Sun Dec 13 13:47:57 2009
@@ -69,7 +69,7 @@
 			// 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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/TestSearch.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/TestSearch.cs Sun Dec 13 13:47:57 2009
@@ -111,7 +111,7 @@
 				//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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/TestSearchForDuplicates.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/TestSearchForDuplicates.cs Sun Dec 13 13:47:57
2009
@@ -113,7 +113,7 @@
 			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 @@
 			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=890061&r1=890060&r2=890061&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/TestSupportClass.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/TestSupportClass.cs Sun Dec 13 13:47:57 2009
@@ -808,7 +808,7 @@
             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");
         }
 
 



Mime
View raw message