You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by di...@apache.org on 2011/03/22 10:31:12 UTC
[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/...
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)