You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2017/02/08 14:31:41 UTC
[02/53] [abbrv] lucenenet git commit: Lucene.Net.Core: Renamed all
type-derived properties and methods from Short, Int, Long,
and Float to match CLR types Int16, Int32, Int64, and Single, respectively.
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs b/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs
index a1d1e50..63f77d9 100644
--- a/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestFieldCacheRangeFilter.cs
@@ -234,75 +234,75 @@ namespace Lucene.Net.Search
#pragma warning disable 612, 618
// test id, bounded on both ends
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("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.NewInt16Range("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
// special cases
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", Convert.ToInt16(short.MaxValue), null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt16Range("id", Convert.ToInt16(short.MaxValue), null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
- result = search.Search(q, FieldCacheRangeFilter.NewShortRange("id", null, Convert.ToInt16(short.MinValue), F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt16Range("id", null, Convert.ToInt16(short.MinValue), 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.NewInt16Range("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "inverse range");
#pragma warning restore 612, 618
}
@@ -326,75 +326,75 @@ namespace Lucene.Net.Search
// test id, bounded on both ends
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("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.NewInt32Range("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
// special cases
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", Convert.ToInt32(int.MaxValue), null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt32Range("id", Convert.ToInt32(int.MaxValue), null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
- result = search.Search(q, FieldCacheRangeFilter.NewIntRange("id", null, Convert.ToInt32(int.MinValue), F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt32Range("id", null, Convert.ToInt32(int.MinValue), 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.NewInt32Range("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "inverse range");
}
@@ -417,75 +417,75 @@ namespace Lucene.Net.Search
// test id, bounded on both ends
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", minIdO, maxIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("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.NewInt64Range("id", medIdO, medIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(1, result.Length, "med,med,T,T");
// special cases
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", Convert.ToInt64(long.MaxValue), null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt64Range("id", Convert.ToInt64(long.MaxValue), null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "overflow special case");
- result = search.Search(q, FieldCacheRangeFilter.NewLongRange("id", null, Convert.ToInt64(long.MinValue), F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewInt64Range("id", null, Convert.ToInt64(long.MinValue), 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.NewInt64Range("id", maxIdO, minIdO, T, T), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "inverse range");
}
@@ -504,19 +504,19 @@ namespace Lucene.Net.Search
ScoreDoc[] result;
Query q = new TermQuery(new Term("body", "body"));
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", minIdO, medIdO, T, T), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewSingleRange("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.NewSingleRange("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.NewSingleRange("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.NewSingleRange("id", null, null, T, T), numDocs).ScoreDocs;
Assert.AreEqual(numDocs, result.Length, "find all");
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", Convert.ToSingle(float.PositiveInfinity), null, F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewSingleRange("id", Convert.ToSingle(float.PositiveInfinity), null, F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "infinity special case");
- result = search.Search(q, FieldCacheRangeFilter.NewFloatRange("id", null, Convert.ToSingle(float.NegativeInfinity), F, F), numDocs).ScoreDocs;
+ result = search.Search(q, FieldCacheRangeFilter.NewSingleRange("id", null, Convert.ToSingle(float.NegativeInfinity), F, F), numDocs).ScoreDocs;
Assert.AreEqual(0, result.Length, "infinity special case");
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs b/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs
index c473302..8c5b83a 100644
--- a/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs
@@ -76,7 +76,7 @@ namespace Lucene.Net.Search
upper = a;
}
TermRangeQuery cq = TermRangeQuery.NewStringRange("asc", lower.ToString(format), upper.ToString(format), true, true);
- NumericRangeQuery<int> tq = NumericRangeQuery.NewIntRange("trie", lower, upper, true, true);
+ NumericRangeQuery<int> tq = NumericRangeQuery.NewInt32Range("trie", lower, upper, true, true);
TopDocs trTopDocs = searcher.Search(cq, 1);
TopDocs nrTopDocs = searcher.Search(tq, 1);
Assert.AreEqual(trTopDocs.TotalHits, nrTopDocs.TotalHits, "Returned count for NumericRangeQuery and TermRangeQuery must be equal");
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs b/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs
index ce5741d..cc0da97 100644
--- a/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs
@@ -160,8 +160,8 @@ namespace Lucene.Net.Search
string field = "field" + precisionStep;
int count = 3000;
int lower = (Distance * 3 / 2) + StartOffset, upper = lower + count * Distance + (Distance / 3);
- NumericRangeQuery<int> q = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, true, true);
- NumericRangeFilter<int> f = NumericRangeFilter.NewIntRange(field, precisionStep, lower, upper, true, true);
+ NumericRangeQuery<int> q = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, true, true);
+ NumericRangeFilter<int> f = NumericRangeFilter.NewInt32Range(field, precisionStep, lower, upper, true, true);
for (sbyte i = 0; i < 3; i++)
{
TopDocs topDocs;
@@ -220,18 +220,18 @@ namespace Lucene.Net.Search
public virtual void TestInverseRange()
{
AtomicReaderContext context = (AtomicReaderContext)SlowCompositeReaderWrapper.Wrap(Reader).Context;
- NumericRangeFilter<int> f = NumericRangeFilter.NewIntRange("field8", 8, 1000, -1000, true, true);
+ NumericRangeFilter<int> f = NumericRangeFilter.NewInt32Range("field8", 8, 1000, -1000, true, true);
Assert.IsNull(f.GetDocIdSet(context, (context.AtomicReader).LiveDocs), "A inverse range should return the null instance");
- f = NumericRangeFilter.NewIntRange("field8", 8, int.MaxValue, null, false, false);
+ f = NumericRangeFilter.NewInt32Range("field8", 8, int.MaxValue, null, false, false);
Assert.IsNull(f.GetDocIdSet(context, (context.AtomicReader).LiveDocs), "A exclusive range starting with Integer.MAX_VALUE should return the null instance");
- f = NumericRangeFilter.NewIntRange("field8", 8, null, int.MinValue, false, false);
+ f = NumericRangeFilter.NewInt32Range("field8", 8, null, int.MinValue, false, false);
Assert.IsNull(f.GetDocIdSet(context, (context.AtomicReader).LiveDocs), "A exclusive range ending with Integer.MIN_VALUE should return the null instance");
}
[Test]
public virtual void TestOneMatchQuery()
{
- NumericRangeQuery<int> q = NumericRangeQuery.NewIntRange("ascfield8", 8, 1000, 1000, true, true);
+ NumericRangeQuery<int> q = NumericRangeQuery.NewInt32Range("ascfield8", 8, 1000, 1000, true, true);
TopDocs topDocs = Searcher.Search(q, NoDocs);
ScoreDoc[] sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -243,7 +243,7 @@ namespace Lucene.Net.Search
string field = "field" + precisionStep;
int count = 3000;
int upper = (count - 1) * Distance + (Distance / 3) + StartOffset;
- NumericRangeQuery<int> q = NumericRangeQuery.NewIntRange(field, precisionStep, null, upper, true, true);
+ NumericRangeQuery<int> q = NumericRangeQuery.NewInt32Range(field, precisionStep, null, upper, true, true);
TopDocs topDocs = Searcher.Search(q, null, NoDocs, Sort.INDEXORDER);
ScoreDoc[] sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -253,7 +253,7 @@ namespace Lucene.Net.Search
doc = Searcher.Doc(sd[sd.Length - 1].Doc);
Assert.AreEqual((count - 1) * Distance + StartOffset, (int)doc.GetField(field).GetNumericValue(), "Last doc");
- q = NumericRangeQuery.NewIntRange(field, precisionStep, null, upper, false, true);
+ q = NumericRangeQuery.NewInt32Range(field, precisionStep, null, upper, false, true);
topDocs = Searcher.Search(q, null, NoDocs, Sort.INDEXORDER);
sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -287,7 +287,7 @@ namespace Lucene.Net.Search
string field = "field" + precisionStep;
int count = 3000;
int lower = (count - 1) * Distance + (Distance / 3) + StartOffset;
- NumericRangeQuery<int> q = NumericRangeQuery.NewIntRange(field, precisionStep, lower, null, true, true);
+ NumericRangeQuery<int> q = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, null, true, true);
TopDocs topDocs = Searcher.Search(q, null, NoDocs, Sort.INDEXORDER);
ScoreDoc[] sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -297,7 +297,7 @@ namespace Lucene.Net.Search
doc = Searcher.Doc(sd[sd.Length - 1].Doc);
Assert.AreEqual((NoDocs - 1) * Distance + StartOffset, (int)doc.GetField(field).GetNumericValue(), "Last doc");
- q = NumericRangeQuery.NewIntRange(field, precisionStep, lower, null, true, false);
+ q = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, null, true, false);
topDocs = Searcher.Search(q, null, NoDocs, Sort.INDEXORDER);
sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -358,39 +358,39 @@ namespace Lucene.Net.Search
IndexReader r = DirectoryReader.Open(dir);
IndexSearcher s = NewSearcher(r);
- Query q = NumericRangeQuery.NewIntRange("int", null, null, true, true);
+ Query q = NumericRangeQuery.NewInt32Range("int", null, null, true, true);
TopDocs topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewIntRange("int", null, null, false, false);
+ q = NumericRangeQuery.NewInt32Range("int", null, null, false, false);
topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewIntRange("int", int.MinValue, int.MaxValue, true, true);
+ q = NumericRangeQuery.NewInt32Range("int", int.MinValue, int.MaxValue, true, true);
topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewIntRange("int", int.MinValue, int.MaxValue, false, false);
+ q = NumericRangeQuery.NewInt32Range("int", int.MinValue, int.MaxValue, false, false);
topDocs = s.Search(q, 10);
Assert.AreEqual(1, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewFloatRange("float", null, null, true, true);
+ q = NumericRangeQuery.NewSingleRange("float", null, null, true, true);
topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewFloatRange("float", null, null, false, false);
+ q = NumericRangeQuery.NewSingleRange("float", null, null, false, false);
topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewFloatRange("float", float.NegativeInfinity, float.PositiveInfinity, true, true);
+ q = NumericRangeQuery.NewSingleRange("float", float.NegativeInfinity, float.PositiveInfinity, true, true);
topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewFloatRange("float", float.NegativeInfinity, float.PositiveInfinity, false, false);
+ q = NumericRangeQuery.NewSingleRange("float", float.NegativeInfinity, float.PositiveInfinity, false, false);
topDocs = s.Search(q, 10);
Assert.AreEqual(1, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewFloatRange("float", float.NaN, float.NaN, true, true);
+ q = NumericRangeQuery.NewSingleRange("float", float.NaN, float.NaN, true, true);
topDocs = s.Search(q, 10);
Assert.AreEqual(TestNumericUtils.FLOAT_NANs.Length, topDocs.ScoreDocs.Length, "Score doc count");
@@ -414,11 +414,11 @@ namespace Lucene.Net.Search
upper = a;
}
BytesRef lowerBytes = new BytesRef(NumericUtils.BUF_SIZE_INT), upperBytes = new BytesRef(NumericUtils.BUF_SIZE_INT);
- NumericUtils.IntToPrefixCodedBytes(lower, 0, lowerBytes);
- NumericUtils.IntToPrefixCodedBytes(upper, 0, upperBytes);
+ NumericUtils.Int32ToPrefixCodedBytes(lower, 0, lowerBytes);
+ NumericUtils.Int32ToPrefixCodedBytes(upper, 0, upperBytes);
// test inclusive range
- NumericRangeQuery<int> tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, true, true);
+ NumericRangeQuery<int> tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, true, true);
TermRangeQuery cq = new TermRangeQuery(field, lowerBytes, upperBytes, true, true);
TopDocs tTopDocs = Searcher.Search(tq, 1);
TopDocs cTopDocs = Searcher.Search(cq, 1);
@@ -427,7 +427,7 @@ namespace Lucene.Net.Search
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test exclusive range
- tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, false, false);
+ tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, false, false);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, false, false);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
@@ -436,7 +436,7 @@ namespace Lucene.Net.Search
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test left exclusive range
- tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, false, true);
+ tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, false, true);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, false, true);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
@@ -445,7 +445,7 @@ namespace Lucene.Net.Search
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test right exclusive range
- tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, true, false);
+ tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, true, false);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, true, false);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
@@ -471,13 +471,13 @@ namespace Lucene.Net.Search
int lower = (Distance * 3 / 2) + StartOffset, upper = lower + count * Distance + (Distance / 3);
// test empty enum
Debug.Assert(lower < upper);
- Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewIntRange("field4", 4, lower, upper, true, true)));
- Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewIntRange("field4", 4, upper, lower, true, true)));
+ Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, lower, upper, true, true)));
+ Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, upper, lower, true, true)));
// test empty enum outside of bounds
lower = Distance * NoDocs + StartOffset;
upper = 2 * lower;
Debug.Assert(lower < upper);
- Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewIntRange("field4", 4, lower, upper, true, true)));
+ Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt32Range("field4", 4, lower, upper, true, true)));
}
private int CountTerms(MultiTermQuery q)
@@ -557,19 +557,19 @@ namespace Lucene.Net.Search
upper = a;
}
// test inclusive range
- Query tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, true, true);
+ Query tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, true, true);
TopDocs tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range query must be equal to inclusive range length");
// test exclusive range
- tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, false, false);
+ tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, false, false);
tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(Math.Max(upper - lower - 1, 0), tTopDocs.TotalHits, "Returned count of range query must be equal to exclusive range length");
// test left exclusive range
- tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, false, true);
+ tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, false, true);
tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(upper - lower, tTopDocs.TotalHits, "Returned count of range query must be equal to half exclusive range length");
// test right exclusive range
- tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, true, false);
+ tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, true, false);
tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(upper - lower, tTopDocs.TotalHits, "Returned count of range query must be equal to half exclusive range length");
}
@@ -600,11 +600,11 @@ namespace Lucene.Net.Search
string field = "ascfield" + precisionStep;
const int lower = -1000, upper = +2000;
- Query tq = NumericRangeQuery.NewFloatRange(field, precisionStep, NumericUtils.SortableIntToFloat(lower), NumericUtils.SortableIntToFloat(upper), true, true);
+ Query tq = NumericRangeQuery.NewSingleRange(field, precisionStep, NumericUtils.SortableInt32ToSingle(lower), NumericUtils.SortableInt32ToSingle(upper), true, true);
TopDocs tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range query must be equal to inclusive range length");
- Filter tf = NumericRangeFilter.NewFloatRange(field, precisionStep, NumericUtils.SortableIntToFloat(lower), NumericUtils.SortableIntToFloat(upper), true, true);
+ Filter tf = NumericRangeFilter.NewSingleRange(field, precisionStep, NumericUtils.SortableInt32ToSingle(lower), NumericUtils.SortableInt32ToSingle(upper), true, true);
tTopDocs = Searcher.Search(new MatchAllDocsQuery(), tf, 1);
Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range filter must be equal to inclusive range length");
}
@@ -643,7 +643,7 @@ namespace Lucene.Net.Search
lower = upper;
upper = a;
}
- Query tq = NumericRangeQuery.NewIntRange(field, precisionStep, lower, upper, true, true);
+ Query tq = NumericRangeQuery.NewInt32Range(field, precisionStep, lower, upper, true, true);
TopDocs topDocs = Searcher.Search(tq, null, NoDocs, new Sort(new SortField(field, SortFieldType.INT, true)));
if (topDocs.TotalHits == 0)
{
@@ -682,22 +682,22 @@ namespace Lucene.Net.Search
[Test]
public virtual void TestEqualsAndHash()
{
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewIntRange("test1", 4, 10, 20, true, true));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewIntRange("test2", 4, 10, 20, false, true));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewIntRange("test3", 4, 10, 20, true, false));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewIntRange("test4", 4, 10, 20, false, false));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewIntRange("test5", 4, 10, null, true, true));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewIntRange("test6", 4, null, 20, true, true));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewIntRange("test7", 4, null, null, true, true));
- QueryUtils.CheckEqual(NumericRangeQuery.NewIntRange("test8", 4, 10, 20, true, true), NumericRangeQuery.NewIntRange("test8", 4, 10, 20, true, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewIntRange("test9", 4, 10, 20, true, true), NumericRangeQuery.NewIntRange("test9", 8, 10, 20, true, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewIntRange("test10a", 4, 10, 20, true, true), NumericRangeQuery.NewIntRange("test10b", 4, 10, 20, true, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewIntRange("test11", 4, 10, 20, true, true), NumericRangeQuery.NewIntRange("test11", 4, 20, 10, true, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewIntRange("test12", 4, 10, 20, true, true), NumericRangeQuery.NewIntRange("test12", 4, 10, 20, false, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewIntRange("test13", 4, 10, 20, true, true), NumericRangeQuery.NewFloatRange("test13", 4, 10f, 20f, true, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt32Range("test1", 4, 10, 20, true, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt32Range("test2", 4, 10, 20, false, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt32Range("test3", 4, 10, 20, true, false));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt32Range("test4", 4, 10, 20, false, false));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt32Range("test5", 4, 10, null, true, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt32Range("test6", 4, null, 20, true, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt32Range("test7", 4, null, null, true, true));
+ QueryUtils.CheckEqual(NumericRangeQuery.NewInt32Range("test8", 4, 10, 20, true, true), NumericRangeQuery.NewInt32Range("test8", 4, 10, 20, true, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt32Range("test9", 4, 10, 20, true, true), NumericRangeQuery.NewInt32Range("test9", 8, 10, 20, true, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt32Range("test10a", 4, 10, 20, true, true), NumericRangeQuery.NewInt32Range("test10b", 4, 10, 20, true, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt32Range("test11", 4, 10, 20, true, true), NumericRangeQuery.NewInt32Range("test11", 4, 20, 10, true, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt32Range("test12", 4, 10, 20, true, true), NumericRangeQuery.NewInt32Range("test12", 4, 10, 20, false, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt32Range("test13", 4, 10, 20, true, true), NumericRangeQuery.NewSingleRange("test13", 4, 10f, 20f, true, true));
// the following produces a hash collision, because Long and Integer have the same hashcode, so only test equality:
- Query q1 = NumericRangeQuery.NewIntRange("test14", 4, 10, 20, true, true);
- Query q2 = NumericRangeQuery.NewLongRange("test14", 4, 10L, 20L, true, true);
+ Query q1 = NumericRangeQuery.NewInt32Range("test14", 4, 10, 20, true, true);
+ Query q2 = NumericRangeQuery.NewInt64Range("test14", 4, 10L, 20L, true, true);
Assert.IsFalse(q1.Equals(q2));
Assert.IsFalse(q2.Equals(q1));
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs b/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs
index 861f3cd..a1525f7 100644
--- a/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs
@@ -169,8 +169,8 @@ namespace Lucene.Net.Search
string field = "field" + precisionStep;
int count = 3000;
long lower = (Distance * 3 / 2) + StartOffset, upper = lower + count * Distance + (Distance / 3);
- NumericRangeQuery<long> q = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, true, true);
- NumericRangeFilter<long> f = NumericRangeFilter.NewLongRange(field, precisionStep, lower, upper, true, true);
+ NumericRangeQuery<long> q = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, true, true);
+ NumericRangeFilter<long> f = NumericRangeFilter.NewInt64Range(field, precisionStep, lower, upper, true, true);
for (sbyte i = 0; i < 3; i++)
{
TopDocs topDocs;
@@ -235,18 +235,18 @@ namespace Lucene.Net.Search
public virtual void TestInverseRange()
{
AtomicReaderContext context = (AtomicReaderContext)SlowCompositeReaderWrapper.Wrap(Searcher.IndexReader).Context;
- NumericRangeFilter<long> f = NumericRangeFilter.NewLongRange("field8", 8, 1000L, -1000L, true, true);
+ NumericRangeFilter<long> f = NumericRangeFilter.NewInt64Range("field8", 8, 1000L, -1000L, true, true);
Assert.IsNull(f.GetDocIdSet(context, (context.AtomicReader).LiveDocs), "A inverse range should return the null instance");
- f = NumericRangeFilter.NewLongRange("field8", 8, long.MaxValue, null, false, false);
+ f = NumericRangeFilter.NewInt64Range("field8", 8, long.MaxValue, null, false, false);
Assert.IsNull(f.GetDocIdSet(context, (context.AtomicReader).LiveDocs), "A exclusive range starting with Long.MAX_VALUE should return the null instance");
- f = NumericRangeFilter.NewLongRange("field8", 8, null, long.MinValue, false, false);
+ f = NumericRangeFilter.NewInt64Range("field8", 8, null, long.MinValue, false, false);
Assert.IsNull(f.GetDocIdSet(context, (context.AtomicReader).LiveDocs), "A exclusive range ending with Long.MIN_VALUE should return the null instance");
}
[Test]
public virtual void TestOneMatchQuery()
{
- NumericRangeQuery<long> q = NumericRangeQuery.NewLongRange("ascfield8", 8, 1000L, 1000L, true, true);
+ NumericRangeQuery<long> q = NumericRangeQuery.NewInt64Range("ascfield8", 8, 1000L, 1000L, true, true);
TopDocs topDocs = Searcher.Search(q, NoDocs);
ScoreDoc[] sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -258,7 +258,7 @@ namespace Lucene.Net.Search
string field = "field" + precisionStep;
int count = 3000;
long upper = (count - 1) * Distance + (Distance / 3) + StartOffset;
- NumericRangeQuery<long> q = NumericRangeQuery.NewLongRange(field, precisionStep, null, upper, true, true);
+ NumericRangeQuery<long> q = NumericRangeQuery.NewInt64Range(field, precisionStep, null, upper, true, true);
TopDocs topDocs = Searcher.Search(q, null, NoDocs, Sort.INDEXORDER);
ScoreDoc[] sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -268,7 +268,7 @@ namespace Lucene.Net.Search
doc = Searcher.Doc(sd[sd.Length - 1].Doc);
Assert.AreEqual((count - 1) * Distance + StartOffset, (long)doc.GetField(field).GetNumericValue(), "Last doc");
- q = NumericRangeQuery.NewLongRange(field, precisionStep, null, upper, false, true);
+ q = NumericRangeQuery.NewInt64Range(field, precisionStep, null, upper, false, true);
topDocs = Searcher.Search(q, null, NoDocs, Sort.INDEXORDER);
sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -308,7 +308,7 @@ namespace Lucene.Net.Search
string field = "field" + precisionStep;
int count = 3000;
long lower = (count - 1) * Distance + (Distance / 3) + StartOffset;
- NumericRangeQuery<long> q = NumericRangeQuery.NewLongRange(field, precisionStep, lower, null, true, true);
+ NumericRangeQuery<long> q = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, null, true, true);
TopDocs topDocs = Searcher.Search(q, null, NoDocs, Sort.INDEXORDER);
ScoreDoc[] sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -318,7 +318,7 @@ namespace Lucene.Net.Search
doc = Searcher.Doc(sd[sd.Length - 1].Doc);
Assert.AreEqual((NoDocs - 1) * Distance + StartOffset, (long)doc.GetField(field).GetNumericValue(), "Last doc");
- q = NumericRangeQuery.NewLongRange(field, precisionStep, lower, null, true, false);
+ q = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, null, true, false);
topDocs = Searcher.Search(q, null, NoDocs, Sort.INDEXORDER);
sd = topDocs.ScoreDocs;
Assert.IsNotNull(sd);
@@ -385,19 +385,19 @@ namespace Lucene.Net.Search
IndexReader r = DirectoryReader.Open(dir);
IndexSearcher s = NewSearcher(r);
- Query q = NumericRangeQuery.NewLongRange("long", null, null, true, true);
+ Query q = NumericRangeQuery.NewInt64Range("long", null, null, true, true);
TopDocs topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewLongRange("long", null, null, false, false);
+ q = NumericRangeQuery.NewInt64Range("long", null, null, false, false);
topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewLongRange("long", long.MinValue, long.MaxValue, true, true);
+ q = NumericRangeQuery.NewInt64Range("long", long.MinValue, long.MaxValue, true, true);
topDocs = s.Search(q, 10);
Assert.AreEqual(3, topDocs.ScoreDocs.Length, "Score doc count");
- q = NumericRangeQuery.NewLongRange("long", long.MinValue, long.MaxValue, false, false);
+ q = NumericRangeQuery.NewInt64Range("long", long.MinValue, long.MaxValue, false, false);
topDocs = s.Search(q, 10);
Assert.AreEqual(1, topDocs.ScoreDocs.Length, "Score doc count");
@@ -441,11 +441,11 @@ namespace Lucene.Net.Search
upper = a;
}
BytesRef lowerBytes = new BytesRef(NumericUtils.BUF_SIZE_LONG), upperBytes = new BytesRef(NumericUtils.BUF_SIZE_LONG);
- NumericUtils.LongToPrefixCodedBytes(lower, 0, lowerBytes);
- NumericUtils.LongToPrefixCodedBytes(upper, 0, upperBytes);
+ NumericUtils.Int64ToPrefixCodedBytes(lower, 0, lowerBytes);
+ NumericUtils.Int64ToPrefixCodedBytes(upper, 0, upperBytes);
// test inclusive range
- NumericRangeQuery<long> tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, true, true);
+ NumericRangeQuery<long> tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, true, true);
TermRangeQuery cq = new TermRangeQuery(field, lowerBytes, upperBytes, true, true);
TopDocs tTopDocs = Searcher.Search(tq, 1);
TopDocs cTopDocs = Searcher.Search(cq, 1);
@@ -454,7 +454,7 @@ namespace Lucene.Net.Search
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test exclusive range
- tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, false, false);
+ tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, false, false);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, false, false);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
@@ -463,7 +463,7 @@ namespace Lucene.Net.Search
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test left exclusive range
- tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, false, true);
+ tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, false, true);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, false, true);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
@@ -472,7 +472,7 @@ namespace Lucene.Net.Search
totalTermCountC += termCountC = CountTerms(cq);
CheckTermCounts(precisionStep, termCountT, termCountC);
// test right exclusive range
- tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, true, false);
+ tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, true, false);
cq = new TermRangeQuery(field, lowerBytes, upperBytes, true, false);
tTopDocs = Searcher.Search(tq, 1);
cTopDocs = Searcher.Search(cq, 1);
@@ -498,13 +498,13 @@ namespace Lucene.Net.Search
long lower = (Distance * 3 / 2) + StartOffset, upper = lower + count * Distance + (Distance / 3);
// test empty enum
Debug.Assert(lower < upper);
- Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewLongRange("field4", 4, lower, upper, true, true)));
- Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewLongRange("field4", 4, upper, lower, true, true)));
+ Assert.IsTrue(0 < CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, lower, upper, true, true)));
+ Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, upper, lower, true, true)));
// test empty enum outside of bounds
lower = Distance * NoDocs + StartOffset;
upper = 2L * lower;
Debug.Assert(lower < upper);
- Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewLongRange("field4", 4, lower, upper, true, true)));
+ Assert.AreEqual(0, CountTerms(NumericRangeQuery.NewInt64Range("field4", 4, lower, upper, true, true)));
}
private int CountTerms(MultiTermQuery q)
@@ -590,19 +590,19 @@ namespace Lucene.Net.Search
upper = a;
}
// test inclusive range
- Query tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, true, true);
+ Query tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, true, true);
TopDocs tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range query must be equal to inclusive range length");
// test exclusive range
- tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, false, false);
+ tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, false, false);
tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(Math.Max(upper - lower - 1, 0), tTopDocs.TotalHits, "Returned count of range query must be equal to exclusive range length");
// test left exclusive range
- tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, false, true);
+ tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, false, true);
tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(upper - lower, tTopDocs.TotalHits, "Returned count of range query must be equal to half exclusive range length");
// test right exclusive range
- tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, true, false);
+ tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, true, false);
tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(upper - lower, tTopDocs.TotalHits, "Returned count of range query must be equal to half exclusive range length");
}
@@ -639,11 +639,11 @@ namespace Lucene.Net.Search
string field = "ascfield" + precisionStep;
const long lower = -1000L, upper = +2000L;
- Query tq = NumericRangeQuery.NewDoubleRange(field, precisionStep, NumericUtils.SortableLongToDouble(lower), NumericUtils.SortableLongToDouble(upper), true, true);
+ Query tq = NumericRangeQuery.NewDoubleRange(field, precisionStep, NumericUtils.SortableInt64ToDouble(lower), NumericUtils.SortableInt64ToDouble(upper), true, true);
TopDocs tTopDocs = Searcher.Search(tq, 1);
Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range query must be equal to inclusive range length");
- Filter tf = NumericRangeFilter.NewDoubleRange(field, precisionStep, NumericUtils.SortableLongToDouble(lower), NumericUtils.SortableLongToDouble(upper), true, true);
+ Filter tf = NumericRangeFilter.NewDoubleRange(field, precisionStep, NumericUtils.SortableInt64ToDouble(lower), NumericUtils.SortableInt64ToDouble(upper), true, true);
tTopDocs = Searcher.Search(new MatchAllDocsQuery(), tf, 1);
Assert.AreEqual(upper - lower + 1, tTopDocs.TotalHits, "Returned count of range filter must be equal to inclusive range length");
}
@@ -688,7 +688,7 @@ namespace Lucene.Net.Search
lower = upper;
upper = a;
}
- Query tq = NumericRangeQuery.NewLongRange(field, precisionStep, lower, upper, true, true);
+ Query tq = NumericRangeQuery.NewInt64Range(field, precisionStep, lower, upper, true, true);
TopDocs topDocs = Searcher.Search(tq, null, NoDocs, new Sort(new SortField(field, SortFieldType.LONG, true)));
if (topDocs.TotalHits == 0)
{
@@ -733,19 +733,19 @@ namespace Lucene.Net.Search
[Test]
public virtual void TestEqualsAndHash()
{
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewLongRange("test1", 4, 10L, 20L, true, true));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewLongRange("test2", 4, 10L, 20L, false, true));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewLongRange("test3", 4, 10L, 20L, true, false));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewLongRange("test4", 4, 10L, 20L, false, false));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewLongRange("test5", 4, 10L, null, true, true));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewLongRange("test6", 4, null, 20L, true, true));
- QueryUtils.CheckHashEquals(NumericRangeQuery.NewLongRange("test7", 4, null, null, true, true));
- QueryUtils.CheckEqual(NumericRangeQuery.NewLongRange("test8", 4, 10L, 20L, true, true), NumericRangeQuery.NewLongRange("test8", 4, 10L, 20L, true, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewLongRange("test9", 4, 10L, 20L, true, true), NumericRangeQuery.NewLongRange("test9", 8, 10L, 20L, true, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewLongRange("test10a", 4, 10L, 20L, true, true), NumericRangeQuery.NewLongRange("test10b", 4, 10L, 20L, true, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewLongRange("test11", 4, 10L, 20L, true, true), NumericRangeQuery.NewLongRange("test11", 4, 20L, 10L, true, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewLongRange("test12", 4, 10L, 20L, true, true), NumericRangeQuery.NewLongRange("test12", 4, 10L, 20L, false, true));
- QueryUtils.CheckUnequal(NumericRangeQuery.NewLongRange("test13", 4, 10L, 20L, true, true), NumericRangeQuery.NewFloatRange("test13", 4, 10f, 20f, true, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt64Range("test1", 4, 10L, 20L, true, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt64Range("test2", 4, 10L, 20L, false, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt64Range("test3", 4, 10L, 20L, true, false));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt64Range("test4", 4, 10L, 20L, false, false));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt64Range("test5", 4, 10L, null, true, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt64Range("test6", 4, null, 20L, true, true));
+ QueryUtils.CheckHashEquals(NumericRangeQuery.NewInt64Range("test7", 4, null, null, true, true));
+ QueryUtils.CheckEqual(NumericRangeQuery.NewInt64Range("test8", 4, 10L, 20L, true, true), NumericRangeQuery.NewInt64Range("test8", 4, 10L, 20L, true, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt64Range("test9", 4, 10L, 20L, true, true), NumericRangeQuery.NewInt64Range("test9", 8, 10L, 20L, true, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt64Range("test10a", 4, 10L, 20L, true, true), NumericRangeQuery.NewInt64Range("test10b", 4, 10L, 20L, true, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt64Range("test11", 4, 10L, 20L, true, true), NumericRangeQuery.NewInt64Range("test11", 4, 20L, 10L, true, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt64Range("test12", 4, 10L, 20L, true, true), NumericRangeQuery.NewInt64Range("test12", 4, 10L, 20L, false, true));
+ QueryUtils.CheckUnequal(NumericRangeQuery.NewInt64Range("test13", 4, 10L, 20L, true, true), NumericRangeQuery.NewSingleRange("test13", 4, 10f, 20f, true, true));
// difference to int range is tested in TestNumericRangeQuery32
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestQueryRescorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestQueryRescorer.cs b/src/Lucene.Net.Tests/core/Search/TestQueryRescorer.cs
index 1d3cab5..aa585fc 100644
--- a/src/Lucene.Net.Tests/core/Search/TestQueryRescorer.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestQueryRescorer.cs
@@ -586,7 +586,7 @@ namespace Lucene.Net.Search
return false;
}
FixedScoreQuery other = (FixedScoreQuery)o;
- return Number.FloatToIntBits(Boost) == Number.FloatToIntBits(other.Boost) && Reverse == other.Reverse && Arrays.Equals(IdToNum, other.IdToNum);
+ return Number.SingleToInt32Bits(Boost) == Number.SingleToInt32Bits(other.Boost) && Reverse == other.Reverse && Arrays.Equals(IdToNum, other.IdToNum);
}
public override object Clone()
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestSort.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSort.cs b/src/Lucene.Net.Tests/core/Search/TestSort.cs
index 2a31834..92253c2 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSort.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSort.cs
@@ -1556,7 +1556,10 @@ namespace Lucene.Net.Search
this.OuterInstance = outerInstance;
}
- public int ParseInt(BytesRef term)
+ /// <summary>
+ /// NOTE: This was parseInt() in Lucene
+ /// </summary>
+ public int ParseInt32(BytesRef term)
{
return (term.Bytes[term.Offset] - 'A') * 123456;
}
@@ -1672,7 +1675,10 @@ namespace Lucene.Net.Search
this.OuterInstance = outerInstance;
}
- public short ParseShort(BytesRef term)
+ /// <summary>
+ /// NOTE: This was parseShort() in Lucene
+ /// </summary>
+ public short ParseInt16(BytesRef term)
{
return (short)(term.Bytes[term.Offset] - 'A');
}
@@ -1730,7 +1736,10 @@ namespace Lucene.Net.Search
this.OuterInstance = outerInstance;
}
- public long ParseLong(BytesRef term)
+ /// <summary>
+ /// NOTE: This was parseLong() in Lucene
+ /// </summary>
+ public long ParseInt64(BytesRef term)
{
return (term.Bytes[term.Offset] - 'A') * 1234567890L;
}
@@ -1788,7 +1797,10 @@ namespace Lucene.Net.Search
this.OuterInstance = outerInstance;
}
- public float ParseFloat(BytesRef term)
+ /// <summary>
+ /// NOTE: This was parseFloat() in Lucene
+ /// </summary>
+ public float ParseSingle(BytesRef term)
{
return (float)Math.Sqrt(term.Bytes[term.Offset]);
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs b/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs
index 7973806..5687659 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs
@@ -345,7 +345,7 @@ namespace Lucene.Net.Search
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
int maxDoc = context.Reader.MaxDoc;
- FieldCache.Ints idSource = FieldCache.DEFAULT.GetInts(context.AtomicReader, "id", false);
+ FieldCache.Ints idSource = FieldCache.DEFAULT.GetInt32s(context.AtomicReader, "id", false);
Assert.IsNotNull(idSource);
FixedBitSet bits = new FixedBitSet(maxDoc);
for (int docID = 0; docID < maxDoc; docID++)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Store/TestFileSwitchDirectory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Store/TestFileSwitchDirectory.cs b/src/Lucene.Net.Tests/core/Store/TestFileSwitchDirectory.cs
index 8228e10..3eb0de7 100644
--- a/src/Lucene.Net.Tests/core/Store/TestFileSwitchDirectory.cs
+++ b/src/Lucene.Net.Tests/core/Store/TestFileSwitchDirectory.cs
@@ -153,7 +153,7 @@ namespace Lucene.Net.Store
var csw = new CompoundFileDirectory(newDir, "d.cfs", NewIOContext(Random()), true);
CreateSequenceFile(newDir, "d1", (sbyte)0, 15);
IndexOutput @out = csw.CreateOutput("d.xyz", NewIOContext(Random()));
- @out.WriteInt(0);
+ @out.WriteInt32(0);
@out.Dispose();
Assert.AreEqual(1, csw.ListAll().Length);
Assert.AreEqual("d.xyz", csw.ListAll()[0]);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Store/TestMultiMMap.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Store/TestMultiMMap.cs b/src/Lucene.Net.Tests/core/Store/TestMultiMMap.cs
index 6e609c3..8341b1a 100644
--- a/src/Lucene.Net.Tests/core/Store/TestMultiMMap.cs
+++ b/src/Lucene.Net.Tests/core/Store/TestMultiMMap.cs
@@ -64,7 +64,7 @@ namespace Lucene.Net.Store
{
MMapDirectory mmapDir = new MMapDirectory(CreateTempDir("testCloneSafety"));
IndexOutput io = mmapDir.CreateOutput("bytes", NewIOContext(Random()));
- io.WriteVInt(5);
+ io.WriteVInt32(5);
io.Dispose();
IndexInput one = mmapDir.OpenInput("bytes", IOContext.DEFAULT);
IndexInput two = (IndexInput)one.Clone();
@@ -72,7 +72,7 @@ namespace Lucene.Net.Store
one.Dispose();
try
{
- one.ReadVInt();
+ one.ReadVInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -83,7 +83,7 @@ namespace Lucene.Net.Store
}
try
{
- two.ReadVInt();
+ two.ReadVInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -94,7 +94,7 @@ namespace Lucene.Net.Store
}
try
{
- three.ReadVInt();
+ three.ReadVInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -115,16 +115,16 @@ namespace Lucene.Net.Store
{
MMapDirectory mmapDir = new MMapDirectory(CreateTempDir("testCloneClose"));
IndexOutput io = mmapDir.CreateOutput("bytes", NewIOContext(Random()));
- io.WriteVInt(5);
+ io.WriteVInt32(5);
io.Dispose();
IndexInput one = mmapDir.OpenInput("bytes", IOContext.DEFAULT);
IndexInput two = (IndexInput)one.Clone();
IndexInput three = (IndexInput)two.Clone(); // clone of clone
two.Dispose();
- Assert.AreEqual(5, one.ReadVInt());
+ Assert.AreEqual(5, one.ReadVInt32());
try
{
- two.ReadVInt();
+ two.ReadVInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -133,7 +133,7 @@ namespace Lucene.Net.Store
{
// pass
}
- Assert.AreEqual(5, three.ReadVInt());
+ Assert.AreEqual(5, three.ReadVInt32());
one.Dispose();
three.Dispose();
mmapDir.Dispose();
@@ -144,8 +144,8 @@ namespace Lucene.Net.Store
{
MMapDirectory mmapDir = new MMapDirectory(CreateTempDir("testCloneSliceSafety"));
IndexOutput io = mmapDir.CreateOutput("bytes", NewIOContext(Random()));
- io.WriteInt(1);
- io.WriteInt(2);
+ io.WriteInt32(1);
+ io.WriteInt32(2);
io.Dispose();
IndexInputSlicer slicer = mmapDir.CreateSlicer("bytes", NewIOContext(Random()));
IndexInput one = slicer.OpenSlice("first int", 0, 4);
@@ -155,7 +155,7 @@ namespace Lucene.Net.Store
slicer.Dispose();
try
{
- one.ReadInt();
+ one.ReadInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -166,7 +166,7 @@ namespace Lucene.Net.Store
}
try
{
- two.ReadInt();
+ two.ReadInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -177,7 +177,7 @@ namespace Lucene.Net.Store
}
try
{
- three.ReadInt();
+ three.ReadInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -188,7 +188,7 @@ namespace Lucene.Net.Store
}
try
{
- four.ReadInt();
+ four.ReadInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -211,8 +211,8 @@ namespace Lucene.Net.Store
{
MMapDirectory mmapDir = new MMapDirectory(CreateTempDir("testCloneSliceClose"));
IndexOutput io = mmapDir.CreateOutput("bytes", NewIOContext(Random()));
- io.WriteInt(1);
- io.WriteInt(2);
+ io.WriteInt32(1);
+ io.WriteInt32(2);
io.Dispose();
IndexInputSlicer slicer = mmapDir.CreateSlicer("bytes", NewIOContext(Random()));
IndexInput one = slicer.OpenSlice("first int", 0, 4);
@@ -220,7 +220,7 @@ namespace Lucene.Net.Store
one.Dispose();
try
{
- one.ReadInt();
+ one.ReadInt32();
Assert.Fail("Must throw AlreadyClosedException");
}
#pragma warning disable 168
@@ -229,10 +229,10 @@ namespace Lucene.Net.Store
{
// pass
}
- Assert.AreEqual(2, two.ReadInt());
+ Assert.AreEqual(2, two.ReadInt32());
// reopen a new slice "one":
one = slicer.OpenSlice("first int", 0, 4);
- Assert.AreEqual(1, one.ReadInt());
+ Assert.AreEqual(1, one.ReadInt32());
one.Dispose();
two.Dispose();
slicer.Dispose();
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Store/TestNRTCachingDirectory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Store/TestNRTCachingDirectory.cs b/src/Lucene.Net.Tests/core/Store/TestNRTCachingDirectory.cs
index 0fa65e3..806295b 100644
--- a/src/Lucene.Net.Tests/core/Store/TestNRTCachingDirectory.cs
+++ b/src/Lucene.Net.Tests/core/Store/TestNRTCachingDirectory.cs
@@ -184,7 +184,7 @@ namespace Lucene.Net.Store
CompoundFileDirectory csw = new CompoundFileDirectory(newDir, "d.cfs", NewIOContext(Random()), true);
CreateSequenceFile(newDir, "d1", (sbyte)0, 15);
IndexOutput @out = csw.CreateOutput("d.xyz", NewIOContext(Random()));
- @out.WriteInt(0);
+ @out.WriteInt32(0);
@out.Dispose();
Assert.AreEqual(1, csw.ListAll().Length);
Assert.AreEqual("d.xyz", csw.ListAll()[0]);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs b/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs
index 322645a..b386f4d 100644
--- a/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs
+++ b/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs
@@ -181,7 +181,7 @@ namespace Lucene.Net.Support
//checkBytes(b, new byte[] { 0, 0, 0, (byte)ic(0) });
//checkInvalidMarkException(ib);
- LongBuffer lb = b.AsLongBuffer();
+ LongBuffer lb = b.AsInt64Buffer();
TestLongBuffer.test(level, lb, direct);
checkBytes(b, new byte[] { 0, 0, 0, 0, 0, 0, 0, (byte)Ic(0) });
checkInvalidMarkException(lb);
@@ -209,21 +209,21 @@ namespace Lucene.Net.Support
b.PutChar((char)char.MaxValue);
output.Write(" char");
- b.PutShort((short)1);
- b.PutShort((short)short.MaxValue);
+ b.PutInt16((short)1);
+ b.PutInt16((short)short.MaxValue);
output.Write(" short");
- b.PutInt(1);
- b.PutInt(int.MaxValue);
+ b.PutInt32(1);
+ b.PutInt32(int.MaxValue);
output.Write(" int");
- b.PutLong((long)1);
- b.PutLong((long)long.MaxValue);
+ b.PutInt64((long)1);
+ b.PutInt64((long)long.MaxValue);
output.Write(" long");
- b.PutFloat((float)1);
- b.PutFloat((float)float.MinValue);
- b.PutFloat((float)float.MaxValue);
+ b.PutSingle((float)1);
+ b.PutSingle((float)float.MinValue);
+ b.PutSingle((float)float.MaxValue);
output.Write(" float");
b.PutDouble((double)1);
@@ -241,21 +241,21 @@ namespace Lucene.Net.Support
ck(b, b.GetChar(), char.MaxValue);
output.Write(" char");
- ck(b, b.GetShort(), 1);
- ck(b, b.GetShort(), short.MaxValue);
+ ck(b, b.GetInt16(), 1);
+ ck(b, b.GetInt16(), short.MaxValue);
output.Write(" short");
- ck(b, b.GetInt(), 1);
- ck(b, b.GetInt(), int.MaxValue);
+ ck(b, b.GetInt32(), 1);
+ ck(b, b.GetInt32(), int.MaxValue);
output.Write(" int");
- ck(b, b.GetLong(), 1);
- ck(b, b.GetLong(), long.MaxValue);
+ ck(b, b.GetInt64(), 1);
+ ck(b, b.GetInt64(), long.MaxValue);
output.Write(" long");
- ck(b, (long)b.GetFloat(), 1);
- ck(b, (long)b.GetFloat(), unchecked((long)float.MinValue));
- ck(b, (long)b.GetFloat(), unchecked((long)float.MaxValue));
+ ck(b, (long)b.GetSingle(), 1);
+ ck(b, (long)b.GetSingle(), unchecked((long)float.MinValue));
+ ck(b, (long)b.GetSingle(), unchecked((long)float.MaxValue));
output.Write(" float");
ck(b, (long)b.GetDouble(), 1);
@@ -575,38 +575,38 @@ namespace Lucene.Net.Support
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
- rb.PutShort((short)1);
+ rb.PutInt16((short)1);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
- rb.PutShort(0, (short)1);
+ rb.PutInt16(0, (short)1);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
- rb.PutInt(1);
+ rb.PutInt32(1);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
- rb.PutInt(0, 1);
+ rb.PutInt32(0, 1);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
- rb.PutLong((long)1);
+ rb.PutInt64((long)1);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
- rb.PutLong(0, (long)1);
+ rb.PutInt64(0, (long)1);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
- rb.PutFloat((float)1);
+ rb.PutSingle((float)1);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
- rb.PutFloat(0, (float)1);
+ rb.PutSingle(0, (float)1);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Support/TestLongBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Support/TestLongBuffer.cs b/src/Lucene.Net.Tests/core/Support/TestLongBuffer.cs
index 7055211..c4f0947 100644
--- a/src/Lucene.Net.Tests/core/Support/TestLongBuffer.cs
+++ b/src/Lucene.Net.Tests/core/Support/TestLongBuffer.cs
@@ -122,19 +122,19 @@ namespace Lucene.Net.Support
// LUCENENET: AllocateDirect not implemented
//LongBuffer direct1 = ByteBuffer.AllocateDirect(cap).AsLongBuffer();
- LongBuffer nondirect1 = ByteBuffer.Allocate(cap).AsLongBuffer();
+ LongBuffer nondirect1 = ByteBuffer.Allocate(cap).AsInt64Buffer();
//direct1.Put(nondirect1);
//LongBuffer direct2 = ByteBuffer.AllocateDirect(cap).AsLongBuffer();
- LongBuffer nondirect2 = ByteBuffer.Allocate(cap).AsLongBuffer();
+ LongBuffer nondirect2 = ByteBuffer.Allocate(cap).AsInt64Buffer();
//nondirect2.Put(direct2);
//LongBuffer direct3 = ByteBuffer.AllocateDirect(cap).AsLongBuffer();
//LongBuffer direct4 = ByteBuffer.AllocateDirect(cap).AsLongBuffer();
//direct3.Put(direct4);
- LongBuffer nondirect3 = ByteBuffer.Allocate(cap).AsLongBuffer();
- LongBuffer nondirect4 = ByteBuffer.Allocate(cap).AsLongBuffer();
+ LongBuffer nondirect3 = ByteBuffer.Allocate(cap).AsInt64Buffer();
+ LongBuffer nondirect4 = ByteBuffer.Allocate(cap).AsInt64Buffer();
nondirect3.Put(nondirect4);
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Util/Automaton/TestSpecialOperations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Util/Automaton/TestSpecialOperations.cs b/src/Lucene.Net.Tests/core/Util/Automaton/TestSpecialOperations.cs
index 5f0dac7..5eb06cc 100644
--- a/src/Lucene.Net.Tests/core/Util/Automaton/TestSpecialOperations.cs
+++ b/src/Lucene.Net.Tests/core/Util/Automaton/TestSpecialOperations.cs
@@ -51,10 +51,10 @@ namespace Lucene.Net.Util.Automaton
ISet<IntsRef> strings = SpecialOperations.GetFiniteStrings(a, -1);
Assert.AreEqual(2, strings.Count);
IntsRef dog = new IntsRef();
- Util.ToIntsRef(new BytesRef("dog"), dog);
+ Util.ToInt32sRef(new BytesRef("dog"), dog);
Assert.IsTrue(strings.Contains(dog));
IntsRef duck = new IntsRef();
- Util.ToIntsRef(new BytesRef("duck"), duck);
+ Util.ToInt32sRef(new BytesRef("duck"), duck);
Assert.IsTrue(strings.Contains(duck));
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Util/Fst/TestBytesStore.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Util/Fst/TestBytesStore.cs b/src/Lucene.Net.Tests/core/Util/Fst/TestBytesStore.cs
index b2b6379..beb674d 100644
--- a/src/Lucene.Net.Tests/core/Util/Fst/TestBytesStore.cs
+++ b/src/Lucene.Net.Tests/core/Util/Fst/TestBytesStore.cs
@@ -104,7 +104,7 @@ namespace Lucene.Net.Util.Fst
{
Console.WriteLine(" abs writeInt pos=" + randomPos + " x=" + x);
}
- bytes.WriteInt(randomPos, x);
+ bytes.WriteInt32(randomPos, x);
expected[randomPos++] = (byte)(x >> 24);
expected[randomPos++] = (byte)(x >> 16);
expected[randomPos++] = (byte)(x >> 8);
@@ -424,7 +424,7 @@ namespace Lucene.Net.Util.Fst
}
r.SkipBytes(skipBytes);
- Assert.AreEqual(expectedInt, r.ReadInt());
+ Assert.AreEqual(expectedInt, r.ReadInt32());
}
}
}