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 2009/12/14 08:25:40 UTC
svn commit: r890203 [2/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/
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFieldCacheRangeFilter.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheRangeFilter.cs Mon Dec 14 07:25:37 2009
@@ -71,67 +71,67 @@
// test id, bounded on both ends
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but last");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but first");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, maxIP, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, maxIP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, maxIP, T, T), numDocs).scoreDocs;
Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, medIP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, medIP, T, T), numDocs).scoreDocs;
Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
// unbounded id
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, null, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, null, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "min and up");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, maxIP, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, maxIP, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "max and down");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, maxIP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, maxIP, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, maxIP, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, maxIP, T, F), numDocs).scoreDocs;
Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, medIP, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, medIP, F, T), numDocs).scoreDocs;
Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
// very small sets
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, minIP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, minIP, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, medIP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, medIP, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "med,med,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, maxIP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, maxIP, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, minIP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", minIP, minIP, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, minIP, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", null, minIP, F, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, maxIP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, maxIP, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", maxIP, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, medIP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("id", medIP, medIP, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
}
@@ -154,47 +154,47 @@
// test extremes, bounded on both ends
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but biggest");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but smallest");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, maxRP, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but extremes");
// unbounded
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "smallest and up");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, maxRP, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, maxRP, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "biggest and down");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not smallest, but up");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, maxRP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, maxRP, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not biggest, but down");
// very small sets
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, minRP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, minRP, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, maxRP, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, maxRP, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, minRP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", minRP, minRP, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, minRP, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", null, minRP, F, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, maxRP, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, maxRP, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewStringRange("rand", maxRP, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
}
@@ -220,77 +220,77 @@
// test id, bounded on both ends
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but last");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but first");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
// unbounded id
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, null, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, null, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "min and up");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, maxIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, maxIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "max and down");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, maxIdO, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, maxIdO, T, F), numDocs).scoreDocs;
Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, medIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, medIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
// very small sets
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, minIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, minIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, medIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, medIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "med,med,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, minIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, minIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, minIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, minIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", medIdO, medIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
// special cases
System.Int16 tempAux = (short) System.Int16.MaxValue;
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", tempAux, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
System.Int16 tempAux2 = (short) System.Int16.MinValue;
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", maxIdO, minIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "inverse range");
}
@@ -314,77 +314,77 @@
// test id, bounded on both ends
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but last");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but first");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
// unbounded id
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, null, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, null, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "min and up");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, maxIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, maxIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "max and down");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, maxIdO, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, maxIdO, T, F), numDocs).scoreDocs;
Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, medIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, medIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
// very small sets
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, minIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, minIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, medIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, medIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "med,med,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, minIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, minIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, minIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, minIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", medIdO, medIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
// special cases
System.Int32 tempAux = (System.Int32) System.Int32.MaxValue;
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", tempAux, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
System.Int32 tempAux2 = (System.Int32) System.Int32.MinValue;
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", maxIdO, minIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "inverse range");
}
@@ -408,77 +408,77 @@
// test id, bounded on both ends
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but last");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "all but first");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 2, result.Length, "all but ends");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1 + maxId - medId, result.Length, "med and up");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1 + medId - minId, result.Length, "up to med");
// unbounded id
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, null, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, null, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "min and up");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "max and down");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not min, but up");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(numDocs - 1, result.Length, "not max, but down");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, maxIdO, T, F), numDocs).scoreDocs;
Assert.AreEqual(maxId - medId, result.Length, "med and up, not max");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, medIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(medId - minId, result.Length, "not min, up to med");
// very small sets
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "min,min,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "med,med,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "max,max,F,F");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, minIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "min,min,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, minIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, minIdO, F, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "nul,min,F,T");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, maxIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,max,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, null, T, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, null, T, F), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "max,nul,T,T");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", medIdO, medIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
// special cases
System.Int64 tempAux = (long) System.Int64.MaxValue;
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", tempAux, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
System.Int64 tempAux2 = (long) System.Int64.MinValue;
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", maxIdO, minIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "inverse range");
}
@@ -498,21 +498,21 @@
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs / 2, result.Length, "find all");
int count = 0;
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, medIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, medIdO, F, T), numDocs).scoreDocs;
count += result.Length;
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", medIdO, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", medIdO, null, F, F), numDocs).scoreDocs;
count += result.Length;
Assert.AreEqual(numDocs, count, "sum of two concenatted ranges");
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, null, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, null, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
System.Single tempAux = (float) System.Single.PositiveInfinity;
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", tempAux, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "infinity special case");
System.Single tempAux2 = (float) System.Single.NegativeInfinity;
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "infinity special case");
}
@@ -530,21 +530,21 @@
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
- result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", minIdO, medIdO, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs / 2, result.Length, "find all");
int count = 0;
- result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, medIdO, F, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, medIdO, F, T), numDocs).scoreDocs;
count += result.Length;
- result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", medIdO, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", medIdO, null, F, F), numDocs).scoreDocs;
count += result.Length;
Assert.AreEqual(numDocs, count, "sum of two concenatted ranges");
- result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, null, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, null, T, T), numDocs).scoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
System.Double tempAux = (double) System.Double.PositiveInfinity;
- result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", tempAux, null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", tempAux, null, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "infinity special case");
System.Double tempAux2 = (double) System.Double.NegativeInfinity;
- result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, tempAux2, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewDoubleRange("id", null, tempAux2, F, F), numDocs).scoreDocs;
Assert.AreEqual(0, result.Length, "infinity special case");
}
}
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheTermsFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFieldCacheTermsFilter.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheTermsFilter.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFieldCacheTermsFilter.cs Mon Dec 14 07:25:37 2009
@@ -62,18 +62,18 @@
System.Collections.ArrayList terms = new System.Collections.ArrayList();
terms.Add("5");
- results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[]) terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
+ results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[]) terms.ToArray(typeof(System.String))), numDocs).scoreDocs;
Assert.AreEqual(0, results.Length, "Must match nothing");
terms = new System.Collections.ArrayList();
terms.Add("10");
- results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[])terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
+ results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[])terms.ToArray(typeof(System.String))), numDocs).scoreDocs;
Assert.AreEqual(1, results.Length, "Must match 1");
terms = new System.Collections.ArrayList();
terms.Add("10");
terms.Add("20");
- results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[]) terms.ToArray(typeof(System.String))), numDocs).ScoreDocs;
+ results = searcher.Search(q, new FieldCacheTermsFilter(fieldName, (System.String[]) terms.ToArray(typeof(System.String))), numDocs).scoreDocs;
Assert.AreEqual(2, results.Length, "Must match 2");
reader.Close();
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFilteredQuery.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredQuery.cs Mon Dec 14 07:25:37 2009
@@ -126,28 +126,28 @@
public virtual void TestFilteredQuery_Renamed()
{
Query filteredquery = new FilteredQuery(query, filter);
- ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(1, hits[0].doc);
QueryUtils.Check(filteredquery, searcher);
- hits = searcher.Search(filteredquery, null, 1000, new Sort("sorter")).ScoreDocs;
+ hits = searcher.Search(filteredquery, null, 1000, new Sort("sorter")).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(1, hits[0].doc);
filteredquery = new FilteredQuery(new TermQuery(new Term("field", "one")), filter);
- hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
+ hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length);
QueryUtils.Check(filteredquery, searcher);
filteredquery = new FilteredQuery(new TermQuery(new Term("field", "x")), filter);
- hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
+ hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(3, hits[0].doc);
QueryUtils.Check(filteredquery, searcher);
filteredquery = new FilteredQuery(new TermQuery(new Term("field", "y")), filter);
- hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
+ hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
QueryUtils.Check(filteredquery, searcher);
@@ -182,8 +182,8 @@
/// <summary> Tests whether the scores of the two queries are the same.</summary>
public virtual void AssertScoreEquals(Query q1, Query q2)
{
- ScoreDoc[] hits1 = searcher.Search(q1, null, 1000).ScoreDocs;
- ScoreDoc[] hits2 = searcher.Search(q2, null, 1000).ScoreDocs;
+ ScoreDoc[] hits1 = searcher.Search(q1, null, 1000).scoreDocs;
+ ScoreDoc[] hits2 = searcher.Search(q2, null, 1000).scoreDocs;
Assert.AreEqual(hits1.Length, hits2.Length);
@@ -200,7 +200,7 @@
TermRangeQuery rq = new TermRangeQuery("sorter", "b", "d", true, true);
Query filteredquery = new FilteredQuery(rq, filter);
- ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(filteredquery, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length);
QueryUtils.Check(filteredquery, searcher);
}
@@ -213,7 +213,7 @@
bq.Add(query, BooleanClause.Occur.MUST);
query = new FilteredQuery(new MatchAllDocsQuery(), new SingleDocTestFilter(1));
bq.Add(query, BooleanClause.Occur.MUST);
- ScoreDoc[] hits = searcher.Search(bq, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(bq, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
QueryUtils.Check(query, searcher);
}
@@ -227,7 +227,7 @@
Query query = new FilteredQuery(bq, new SingleDocTestFilter(0));
bq.Add(new TermQuery(new Term("field", "one")), BooleanClause.Occur.SHOULD);
bq.Add(new TermQuery(new Term("field", "two")), BooleanClause.Occur.SHOULD);
- ScoreDoc[] hits = searcher.Search(query, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(query, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
QueryUtils.Check(query, searcher);
}
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredSearch.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFilteredSearch.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredSearch.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFilteredSearch.cs Mon Dec 14 07:25:37 2009
@@ -65,7 +65,7 @@
IndexSearcher indexSearcher = new IndexSearcher(directory);
- ScoreDoc[] hits = indexSearcher.Search(booleanQuery, filter, 1000).ScoreDocs;
+ ScoreDoc[] hits = indexSearcher.Search(booleanQuery, filter, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length, "Number of matched documents");
}
catch (System.IO.IOException e)
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestFuzzyQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestFuzzyQuery.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestFuzzyQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestFuzzyQuery.cs Mon Dec 14 07:25:37 2009
@@ -59,40 +59,40 @@
IndexSearcher searcher = new IndexSearcher(directory);
FuzzyQuery query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 0);
- ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
// same with prefix
query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 1);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 2);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 3);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 4);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length);
query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 5);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 6);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
// not similar enough:
query = new FuzzyQuery(new Term("field", "xxxxx"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
query = new FuzzyQuery(new Term("field", "aaccc"), FuzzyQuery.defaultMinSimilarity, 0); // edit distance to "aaaaa" = 3
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// query identical to a word in the index:
query = new FuzzyQuery(new Term("field", "aaaaa"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
// default allows for up to two edits:
@@ -101,7 +101,7 @@
// query similar to a word in the index:
query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
@@ -109,63 +109,63 @@
// now with prefix
query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 1);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
Assert.AreEqual(searcher.Doc(hits[2].doc).Get("field"), ("aaabb"));
query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 2);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
Assert.AreEqual(searcher.Doc(hits[2].doc).Get("field"), ("aaabb"));
query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 3);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
Assert.AreEqual(searcher.Doc(hits[2].doc).Get("field"), ("aaabb"));
query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 4);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaa"));
Assert.AreEqual(searcher.Doc(hits[1].doc).Get("field"), ("aaaab"));
query = new FuzzyQuery(new Term("field", "aaaac"), FuzzyQuery.defaultMinSimilarity, 5);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
// now with prefix
query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 1);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 2);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 3);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 4);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("ddddd"));
query = new FuzzyQuery(new Term("field", "ddddX"), FuzzyQuery.defaultMinSimilarity, 5);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// different field = no match:
query = new FuzzyQuery(new Term("anotherfield", "ddddX"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
searcher.Close();
@@ -186,63 +186,63 @@
FuzzyQuery query;
// not similar enough:
query = new FuzzyQuery(new Term("field", "xxxxx"), FuzzyQuery.defaultMinSimilarity, 0);
- ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// edit distance to "aaaaaaa" = 3, this matches because the string is longer than
// in testDefaultFuzziness so a bigger difference is allowed:
query = new FuzzyQuery(new Term("field", "aaaaccc"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaaaa"));
// now with prefix
query = new FuzzyQuery(new Term("field", "aaaaccc"), FuzzyQuery.defaultMinSimilarity, 1);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaaaa"));
query = new FuzzyQuery(new Term("field", "aaaaccc"), FuzzyQuery.defaultMinSimilarity, 4);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), ("aaaaaaa"));
query = new FuzzyQuery(new Term("field", "aaaaccc"), FuzzyQuery.defaultMinSimilarity, 5);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// no match, more than half of the characters is wrong:
query = new FuzzyQuery(new Term("field", "aaacccc"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// now with prefix
query = new FuzzyQuery(new Term("field", "aaacccc"), FuzzyQuery.defaultMinSimilarity, 2);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// "student" and "stellent" are indeed similar to "segment" by default:
query = new FuzzyQuery(new Term("field", "student"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
query = new FuzzyQuery(new Term("field", "stellent"), FuzzyQuery.defaultMinSimilarity, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
// now with prefix
query = new FuzzyQuery(new Term("field", "student"), FuzzyQuery.defaultMinSimilarity, 1);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
query = new FuzzyQuery(new Term("field", "stellent"), FuzzyQuery.defaultMinSimilarity, 1);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
query = new FuzzyQuery(new Term("field", "student"), FuzzyQuery.defaultMinSimilarity, 2);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
query = new FuzzyQuery(new Term("field", "stellent"), FuzzyQuery.defaultMinSimilarity, 2);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// "student" doesn't match anymore thanks to increased minimum similarity:
query = new FuzzyQuery(new Term("field", "student"), 0.6f, 0);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
try
@@ -282,22 +282,22 @@
Query query;
// term not over 10 chars, so optimization shortcuts
query = new FuzzyQuery(new Term("field", "1234569"), 0.9f);
- ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// 10 chars, so no optimization
query = new FuzzyQuery(new Term("field", "1234567891"), 0.9f);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
// over 10 chars, so no optimization
query = new FuzzyQuery(new Term("field", "12345678911"), 0.9f);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
// over 10 chars, no match
query = new FuzzyQuery(new Term("field", "sdfsdfsdfsdf"), 0.9f);
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length);
}
@@ -334,7 +334,7 @@
// 3. search
IndexSearcher searcher = new IndexSearcher(r);
- ScoreDoc[] hits = searcher.Search(q, 10).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(q, 10).scoreDocs;
Assert.AreEqual(1, hits.Length);
Assert.AreEqual(searcher.Doc(hits[0].doc).Get("field"), "Giga byte");
r.Close();
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMatchAllDocsQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMatchAllDocsQuery.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMatchAllDocsQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMatchAllDocsQuery.cs Mon Dec 14 07:25:37 2009
@@ -68,7 +68,7 @@
// assert with norms scoring turned off
- hits = is_Renamed.Search(new MatchAllDocsQuery(), null, 1000).ScoreDocs;
+ hits = is_Renamed.Search(new MatchAllDocsQuery(), null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
Assert.AreEqual(ir.Document(hits[0].doc).Get("key"), "one");
Assert.AreEqual(ir.Document(hits[1].doc).Get("key"), "two");
@@ -77,7 +77,7 @@
// assert with norms scoring turned on
MatchAllDocsQuery normsQuery = new MatchAllDocsQuery("key");
- hits = is_Renamed.Search(normsQuery, null, 1000).ScoreDocs;
+ hits = is_Renamed.Search(normsQuery, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
Assert.AreEqual(ir.Document(hits[0].doc).Get("key"), "three four");
@@ -87,7 +87,7 @@
// change norm & retest
ir.SetNorm(0, "key", 400f);
normsQuery = new MatchAllDocsQuery("key");
- hits = is_Renamed.Search(normsQuery, null, 1000).ScoreDocs;
+ hits = is_Renamed.Search(normsQuery, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
Assert.AreEqual(ir.Document(hits[0].doc).Get("key"), "one");
@@ -99,30 +99,30 @@
BooleanQuery bq = new BooleanQuery();
bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
- hits = is_Renamed.Search(bq, null, 1000).ScoreDocs;
+ hits = is_Renamed.Search(bq, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
bq = new BooleanQuery();
bq.Add(new MatchAllDocsQuery(), BooleanClause.Occur.MUST);
bq.Add(new TermQuery(new Term("key", "three")), BooleanClause.Occur.MUST);
- hits = is_Renamed.Search(bq, null, 1000).ScoreDocs;
+ hits = is_Renamed.Search(bq, null, 1000).scoreDocs;
Assert.AreEqual(1, hits.Length);
// delete a document:
is_Renamed.GetIndexReader().DeleteDocument(0);
- hits = is_Renamed.Search(new MatchAllDocsQuery(), null, 1000).ScoreDocs;
+ hits = is_Renamed.Search(new MatchAllDocsQuery(), null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length);
// test parsable toString()
QueryParser qp = new QueryParser("key", analyzer);
- hits = is_Renamed.Search(qp.Parse(new MatchAllDocsQuery().ToString()), null, 1000).ScoreDocs;
+ hits = is_Renamed.Search(qp.Parse(new MatchAllDocsQuery().ToString()), null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length);
// test parsable toString() with non default boost
Query maq = new MatchAllDocsQuery();
maq.SetBoost(2.3f);
Query pq = qp.Parse(maq.ToString());
- hits = is_Renamed.Search(pq, null, 1000).ScoreDocs;
+ hits = is_Renamed.Search(pq, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length);
is_Renamed.Close();
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiPhraseQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMultiPhraseQuery.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiPhraseQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiPhraseQuery.cs Mon Dec 14 07:25:37 2009
@@ -88,9 +88,9 @@
Assert.AreEqual("body:\"strawberry (piccadilly pie pizza)\"", query2.ToString());
ScoreDoc[] result;
- result = searcher.Search(query1, null, 1000).ScoreDocs;
+ result = searcher.Search(query1, null, 1000).scoreDocs;
Assert.AreEqual(2, result.Length);
- result = searcher.Search(query2, null, 1000).ScoreDocs;
+ result = searcher.Search(query2, null, 1000).scoreDocs;
Assert.AreEqual(0, result.Length);
// search for "blue* pizza":
@@ -109,13 +109,13 @@
query3.Add((Term[]) termsWithPrefix.ToArray(typeof(Term)));
query3.Add(new Term("body", "pizza"));
- result = searcher.Search(query3, null, 1000).ScoreDocs;
+ result = searcher.Search(query3, null, 1000).scoreDocs;
Assert.AreEqual(2, result.Length); // blueberry pizza, bluebird pizza
Assert.AreEqual("body:\"(blueberry bluebird) pizza\"", query3.ToString());
// test slop:
query3.SetSlop(1);
- result = searcher.Search(query3, null, 1000).ScoreDocs;
+ result = searcher.Search(query3, null, 1000).scoreDocs;
Assert.AreEqual(3, result.Length); // blueberry pizza, bluebird pizza, bluebird foobar pizza
MultiPhraseQuery query4 = new MultiPhraseQuery();
@@ -167,7 +167,7 @@
q.Add(trouble, BooleanClause.Occur.MUST);
// exception will be thrown here without fix
- ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(q, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length, "Wrong number of hits");
searcher.Close();
@@ -194,7 +194,7 @@
q.Add(trouble, BooleanClause.Occur.MUST);
// exception will be thrown here without fix for #35626:
- ScoreDoc[] hits = searcher.Search(q, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(q, null, 1000).scoreDocs;
Assert.AreEqual(0, hits.Length, "Wrong number of hits");
searcher.Close();
}
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMultiSearcher.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcher.cs Mon Dec 14 07:25:37 2009
@@ -155,7 +155,7 @@
// creating the multiSearcher
Searcher mSearcher = GetMultiSearcherInstance(searchers);
// performing the search
- ScoreDoc[] hits = mSearcher.Search(query, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = mSearcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits.Length);
@@ -185,7 +185,7 @@
// creating the mulitSearcher
MultiSearcher mSearcher2 = GetMultiSearcherInstance(searchers2);
// performing the same search
- ScoreDoc[] hits2 = mSearcher2.Search(query, null, 1000).ScoreDocs;
+ ScoreDoc[] hits2 = mSearcher2.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(4, hits2.Length);
@@ -198,12 +198,12 @@
// test the subSearcher() method:
Query subSearcherQuery = parser.Parse("id:doc1");
- hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).ScoreDocs;
+ hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).scoreDocs;
Assert.AreEqual(2, hits2.Length);
Assert.AreEqual(0, mSearcher2.SubSearcher(hits2[0].doc)); // hit from searchers2[0]
Assert.AreEqual(1, mSearcher2.SubSearcher(hits2[1].doc)); // hit from searchers2[1]
subSearcherQuery = parser.Parse("id:doc2");
- hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).ScoreDocs;
+ hits2 = mSearcher2.Search(subSearcherQuery, null, 1000).scoreDocs;
Assert.AreEqual(1, hits2.Length);
Assert.AreEqual(1, mSearcher2.SubSearcher(hits2[0].doc)); // hit from searchers2[1]
mSearcher2.Close();
@@ -231,7 +231,7 @@
// creating the mulitSearcher
Searcher mSearcher3 = GetMultiSearcherInstance(searchers3);
// performing the same search
- ScoreDoc[] hits3 = mSearcher3.Search(query, null, 1000).ScoreDocs;
+ ScoreDoc[] hits3 = mSearcher3.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(3, hits3.Length);
@@ -300,7 +300,7 @@
MultiSearcher searcher = GetMultiSearcherInstance(new Searcher[]{indexSearcher1, indexSearcher2});
Assert.IsTrue(searcher != null, "searcher is null and it shouldn't be");
- ScoreDoc[] hits = searcher.Search(query, null, 1000).ScoreDocs;
+ ScoreDoc[] hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.IsTrue(hits != null, "hits is null and it shouldn't be");
Assert.IsTrue(hits.Length == 2, hits.Length + " does not equal: " + 2);
Document document = searcher.Doc(hits[0].doc);
@@ -357,7 +357,7 @@
indexSearcher1 = new IndexSearcher(ramDirectory1);
indexSearcher1.SetDefaultFieldSortScoring(true, true);
- hits = indexSearcher1.Search(query, null, 1000).ScoreDocs;
+ hits = indexSearcher1.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length, message);
@@ -389,7 +389,7 @@
Searcher searcher = GetMultiSearcherInstance(new Searcher[]{indexSearcher1, indexSearcher2});
- hits = searcher.Search(query, null, 1000).ScoreDocs;
+ hits = searcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(2, hits.Length, message);
@@ -400,7 +400,7 @@
// Adding a Sort.RELEVANCE object should not change anything
- hits = searcher.Search(query, null, 1000, Sort.RELEVANCE).ScoreDocs;
+ hits = searcher.Search(query, null, 1000, Sort.RELEVANCE).scoreDocs;
Assert.AreEqual(2, hits.Length, message);
Modified: incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcherRanking.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Test/Search/TestMultiSearcherRanking.cs?rev=890203&r1=890202&r2=890203&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcherRanking.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Test/Search/TestMultiSearcherRanking.cs Mon Dec 14 07:25:37 2009
@@ -111,8 +111,8 @@
System.Console.Out.WriteLine("Query: " + queryStr);
QueryParser queryParser = new QueryParser(FIELD_NAME, new StandardAnalyzer());
Query query = queryParser.Parse(queryStr);
- ScoreDoc[] multiSearcherHits = multiSearcher.Search(query, null, 1000).ScoreDocs;
- ScoreDoc[] singleSearcherHits = singleSearcher.Search(query, null, 1000).ScoreDocs;
+ ScoreDoc[] multiSearcherHits = multiSearcher.Search(query, null, 1000).scoreDocs;
+ ScoreDoc[] singleSearcherHits = singleSearcher.Search(query, null, 1000).scoreDocs;
Assert.AreEqual(multiSearcherHits.Length, singleSearcherHits.Length);
for (int i = 0; i < multiSearcherHits.Length; i++)
{