lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [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.
Date Wed, 08 Feb 2017 14:31:41 GMT
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());
                     }
                 }
             }


Mime
View raw message