lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [42/53] [abbrv] lucenenet git commit: SWEEP: Renamed constant and enum value names from Short, Int, Long, and Float to match CLR types Int16, Int32, Int64, and Single, respectively.
Date Wed, 08 Feb 2017 14:32:21 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs b/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs
index 1ce3b7f..7412746 100644
--- a/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs
+++ b/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs
@@ -166,7 +166,7 @@ namespace Lucene.Net.Util.Automaton
             {
                 if (map.Count > values.Length)
                 {
-                    int size = ArrayUtil.Oversize(map.Count, RamUsageEstimator.NUM_BYTES_INT);
+                    int size = ArrayUtil.Oversize(map.Count, RamUsageEstimator.NUM_BYTES_INT32);
                     values = new int[size];
                     counts = new int[size];
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/BytesRefArray.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/BytesRefArray.cs b/src/Lucene.Net.Core/Util/BytesRefArray.cs
index cc5147d..dd650ff 100644
--- a/src/Lucene.Net.Core/Util/BytesRefArray.cs
+++ b/src/Lucene.Net.Core/Util/BytesRefArray.cs
@@ -46,7 +46,7 @@ namespace Lucene.Net.Util
         {
             this.pool = new ByteBlockPool(new ByteBlockPool.DirectTrackingAllocator(bytesUsed));
             pool.NextBuffer();
-            bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + RamUsageEstimator.NUM_BYTES_INT);
+            bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + RamUsageEstimator.NUM_BYTES_INT32);
             this.bytesUsed = bytesUsed;
         }
 
@@ -71,7 +71,7 @@ namespace Lucene.Net.Util
             {
                 int oldLen = offsets.Length;
                 offsets = ArrayUtil.Grow(offsets, offsets.Length + 1);
-                bytesUsed.AddAndGet((offsets.Length - oldLen) * RamUsageEstimator.NUM_BYTES_INT);
+                bytesUsed.AddAndGet((offsets.Length - oldLen) * RamUsageEstimator.NUM_BYTES_INT32);
             }
             pool.Append(bytes);
             offsets[lastElement++] = currentOffset;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/BytesRefHash.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/BytesRefHash.cs b/src/Lucene.Net.Core/Util/BytesRefHash.cs
index b134712..a4934f7 100644
--- a/src/Lucene.Net.Core/Util/BytesRefHash.cs
+++ b/src/Lucene.Net.Core/Util/BytesRefHash.cs
@@ -91,7 +91,7 @@ namespace Lucene.Net.Util
             this.bytesStartArray = bytesStartArray;
             bytesStart = bytesStartArray.Init();
             bytesUsed = bytesStartArray.BytesUsed() == null ? Counter.NewCounter() : bytesStartArray.BytesUsed();
-            bytesUsed.AddAndGet(hashSize * RamUsageEstimator.NUM_BYTES_INT);
+            bytesUsed.AddAndGet(hashSize * RamUsageEstimator.NUM_BYTES_INT32);
         }
 
         /// <summary>
@@ -236,7 +236,7 @@ namespace Lucene.Net.Util
             }
             if (newSize != hashSize)
             {
-                bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT * -(hashSize - newSize));
+                bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT32 * -(hashSize - newSize));
                 hashSize = newSize;
                 ids = new int[hashSize];
                 Arrays.Fill(ids, -1);
@@ -282,7 +282,7 @@ namespace Lucene.Net.Util
         {
             Clear(true);
             ids = null;
-            bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT * -hashSize);
+            bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT32 * -hashSize);
         }
 
         /// <summary>
@@ -453,7 +453,7 @@ namespace Lucene.Net.Util
         private void Rehash(int newSize, bool hashOnData)
         {
             int newMask = newSize - 1;
-            bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT * (newSize));
+            bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT32 * (newSize));
             int[] newHash = new int[newSize];
             Arrays.Fill(newHash, -1);
             for (int i = 0; i < hashSize; i++)
@@ -504,7 +504,7 @@ namespace Lucene.Net.Util
             }
 
             hashMask = newMask;
-            bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT * (-ids.Length));
+            bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT32 * (-ids.Length));
             ids = newHash;
             hashSize = newSize;
             hashHalfSize = newSize / 2;
@@ -531,7 +531,7 @@ namespace Lucene.Net.Util
             if (ids == null)
             {
                 ids = new int[hashSize];
-                bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT * hashSize);
+                bytesUsed.AddAndGet(RamUsageEstimator.NUM_BYTES_INT32 * hashSize);
             }
         }
 
@@ -637,7 +637,7 @@ namespace Lucene.Net.Util
 
             public override int[] Init()
             {
-                return bytesStart = new int[ArrayUtil.Oversize(m_initSize, RamUsageEstimator.NUM_BYTES_INT)];
+                return bytesStart = new int[ArrayUtil.Oversize(m_initSize, RamUsageEstimator.NUM_BYTES_INT32)];
             }
 
             public override Counter BytesUsed()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/FieldCacheSanityChecker.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/FieldCacheSanityChecker.cs b/src/Lucene.Net.Core/Util/FieldCacheSanityChecker.cs
index cbb93ef..2641ee4 100644
--- a/src/Lucene.Net.Core/Util/FieldCacheSanityChecker.cs
+++ b/src/Lucene.Net.Core/Util/FieldCacheSanityChecker.cs
@@ -482,7 +482,7 @@ namespace Lucene.Net.Util
             /// tested -- if two cache entries have different parsers or datatypes but
             /// the cached values are the same Object (== not just equal()) this method
             /// does not consider that a red flag.  this allows for subtle variations
-            /// in the way a Parser is specified (null vs DEFAULT_LONG_PARSER, etc...)
+            /// in the way a Parser is specified (null vs DEFAULT_INT64_PARSER, etc...)
             /// </p>
             /// </summary>
             public static readonly InsanityType VALUEMISMATCH = new InsanityType("VALUEMISMATCH");

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Fst/FST.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Fst/FST.cs b/src/Lucene.Net.Core/Util/Fst/FST.cs
index 0c53847..8e187a0 100644
--- a/src/Lucene.Net.Core/Util/Fst/FST.cs
+++ b/src/Lucene.Net.Core/Util/Fst/FST.cs
@@ -244,7 +244,7 @@ namespace Lucene.Net.Util.Fst
 
             // NOTE: only reads most recent format; we don't have
             // back-compat promise for FSTs (they are experimental):
-            version = CodecUtil.CheckHeader(@in, FST.FILE_FORMAT_NAME, FST.VERSION_PACKED, FST.VERSION_VINT_TARGET);
+            version = CodecUtil.CheckHeader(@in, FST.FILE_FORMAT_NAME, FST.VERSION_PACKED, FST.VERSION_VINT32_TARGET);
             packed = @in.ReadByte() == 1;
             if (@in.ReadByte() == 1)
             {
@@ -920,7 +920,7 @@ namespace Lucene.Net.Util.Fst
                 {
                     // array: jump straight to end
                     arc.NumArcs = @in.ReadVInt32();
-                    if (packed || version >= FST.VERSION_VINT_TARGET)
+                    if (packed || version >= FST.VERSION_VINT32_TARGET)
                     {
                         arc.BytesPerArc = @in.ReadVInt32();
                     }
@@ -979,7 +979,7 @@ namespace Lucene.Net.Util.Fst
         private long ReadUnpackedNodeTarget(FST.BytesReader @in)
         {
             long target;
-            if (version < FST.VERSION_VINT_TARGET)
+            if (version < FST.VERSION_VINT32_TARGET)
             {
                 target = @in.ReadInt32();
             }
@@ -1040,7 +1040,7 @@ namespace Lucene.Net.Util.Fst
                 //System.out.println("  fixedArray");
                 // this is first arc in a fixed-array
                 arc.NumArcs = @in.ReadVInt32();
-                if (packed || version >= FST.VERSION_VINT_TARGET)
+                if (packed || version >= FST.VERSION_VINT32_TARGET)
                 {
                     arc.BytesPerArc = @in.ReadVInt32();
                 }
@@ -1121,7 +1121,7 @@ namespace Lucene.Net.Util.Fst
                     @in.ReadVInt32();
 
                     // Skip bytesPerArc:
-                    if (packed || version >= FST.VERSION_VINT_TARGET)
+                    if (packed || version >= FST.VERSION_VINT32_TARGET)
                     {
                         @in.ReadVInt32();
                     }
@@ -1341,7 +1341,7 @@ namespace Lucene.Net.Util.Fst
             {
                 // Arcs are full array; do binary search:
                 arc.NumArcs = @in.ReadVInt32();
-                if (packed || version >= FST.VERSION_VINT_TARGET)
+                if (packed || version >= FST.VERSION_VINT32_TARGET)
                 {
                     arc.BytesPerArc = @in.ReadVInt32();
                 }
@@ -2117,14 +2117,18 @@ namespace Lucene.Net.Util.Fst
         internal const int VERSION_START = 0;
 
         /// <summary>
-        /// Changed numBytesPerArc for array'd case from byte to int.
+        /// Changed numBytesPerArc for array'd case from byte to <see cref="int"/>.
+        /// <para/>
+        /// NOTE: This was VERSION_INT_NUM_BYTES_PER_ARC in Lucene
         /// </summary>
-        internal const int VERSION_INT_NUM_BYTES_PER_ARC = 1;
+        internal const int VERSION_INT32_NUM_BYTES_PER_ARC = 1;
 
         /// <summary>
-        /// Write BYTE2 labels as 2-byte short, not vInt.
+        /// Write BYTE2 labels as 2-byte <see cref="short"/>, not v<see cref="int"/>.
+        /// <para/>
+        /// NOTE: This was VERSION_SHORT_BYTE2_LABELS in Lucene
         /// </summary>
-        internal const int VERSION_SHORT_BYTE2_LABELS = 2;
+        internal const int VERSION_INT16_BYTE2_LABELS = 2;
 
         /// <summary>
         /// Added optional packed format.
@@ -2132,12 +2136,14 @@ namespace Lucene.Net.Util.Fst
         internal const int VERSION_PACKED = 3;
 
         /// <summary>
-        /// Changed from int to vInt for encoding arc targets.
-        /// Also changed maxBytesPerArc from int to vInt in the array case.
+        /// Changed from <see cref="int"/> to v<see cref="int"/> for encoding arc targets.
+        /// Also changed maxBytesPerArc from int to v<see cref="int"/> in the array case.
+        /// <para/>
+        /// NOTE: This was VERSION_VINT_TARGET in Lucene
         /// </summary>
-        internal const int VERSION_VINT_TARGET = 4;
+        internal const int VERSION_VINT32_TARGET = 4;
 
-        internal const int VERSION_CURRENT = VERSION_VINT_TARGET;
+        internal const int VERSION_CURRENT = VERSION_VINT32_TARGET;
 
         // Never serialized; just used to represent the virtual
         // final node w/ no arcs:

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/IntBlockPool.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/IntBlockPool.cs b/src/Lucene.Net.Core/Util/IntBlockPool.cs
index 300a5f6..ec6c3de 100644
--- a/src/Lucene.Net.Core/Util/IntBlockPool.cs
+++ b/src/Lucene.Net.Core/Util/IntBlockPool.cs
@@ -30,13 +30,24 @@ namespace Lucene.Net.Util
     /// </summary>
     public sealed class Int32BlockPool
     {
-        public static readonly int INT_BLOCK_SHIFT = 13;
-        public static readonly int INT_BLOCK_SIZE = 1 << INT_BLOCK_SHIFT;
-        public static readonly int INT_BLOCK_MASK = INT_BLOCK_SIZE - 1;
+        /// <summary>
+        /// NOTE: This was INT_BLOCK_SHIFT in Lucene
+        /// </summary>
+        public static readonly int INT32_BLOCK_SHIFT = 13;
+
+        /// <summary>
+        /// NOTE: This was INT_BLOCK_SIZE in Lucene
+        /// </summary>
+        public static readonly int INT32_BLOCK_SIZE = 1 << INT32_BLOCK_SHIFT;
+
+        /// <summary>
+        /// NOTE: This was INT_BLOCK_MASK in Lucene
+        /// </summary>
+        public static readonly int INT32_BLOCK_MASK = INT32_BLOCK_SIZE - 1;
 
         /// <summary>
         /// Abstract class for allocating and freeing int
-        ///  blocks.
+        /// blocks.
         /// </summary>
         public abstract class Allocator
         {
@@ -69,7 +80,7 @@ namespace Lucene.Net.Util
             /// Creates a new <seealso cref="DirectAllocator"/> with a default block size
             /// </summary>
             public DirectAllocator()
-                : base(INT_BLOCK_SIZE)
+                : base(INT32_BLOCK_SIZE)
             {
             }
 
@@ -137,8 +148,8 @@ namespace Lucene.Net.Util
         public Int32BlockPool(Allocator allocator)
         {
             // set defaults
-            Int32Upto = INT_BLOCK_SIZE;
-            Int32Offset = -INT_BLOCK_SIZE;
+            Int32Upto = INT32_BLOCK_SIZE;
+            Int32Offset = -INT32_BLOCK_SIZE;
 
             this.allocator = allocator;
         }
@@ -195,8 +206,8 @@ namespace Lucene.Net.Util
                 else
                 {
                     bufferUpto = -1;
-                    Int32Upto = INT_BLOCK_SIZE;
-                    Int32Offset = -INT_BLOCK_SIZE;
+                    Int32Upto = INT32_BLOCK_SIZE;
+                    Int32Offset = -INT32_BLOCK_SIZE;
                     buffer = null;
                 }
             }
@@ -220,7 +231,7 @@ namespace Lucene.Net.Util
             bufferUpto++;
 
             Int32Upto = 0;
-            Int32Offset += INT_BLOCK_SIZE;
+            Int32Offset += INT32_BLOCK_SIZE;
         }
 
         /// <summary>
@@ -228,7 +239,7 @@ namespace Lucene.Net.Util
         /// <seealso cref= SliceReader </seealso>
         private int NewSlice(int size)
         {
-            if (Int32Upto > INT_BLOCK_SIZE - size)
+            if (Int32Upto > INT32_BLOCK_SIZE - size)
             {
                 NextBuffer();
                 Debug.Assert(AssertSliceBuffer(buffer));
@@ -277,7 +288,7 @@ namespace Lucene.Net.Util
             int newLevel = NEXT_LEVEL_ARRAY[level - 1];
             int newSize = LEVEL_SIZE_ARRAY[newLevel];
             // Maybe allocate another block
-            if (Int32Upto > INT_BLOCK_SIZE - newSize)
+            if (Int32Upto > INT32_BLOCK_SIZE - newSize)
             {
                 NextBuffer();
                 Debug.Assert(AssertSliceBuffer(buffer));
@@ -323,9 +334,9 @@ namespace Lucene.Net.Util
             /// </summary>
             public virtual void WriteInt32(int value)
             {
-                int[] ints = pool.buffers[offset >> INT_BLOCK_SHIFT];
+                int[] ints = pool.buffers[offset >> INT32_BLOCK_SHIFT];
                 Debug.Assert(ints != null);
-                int relativeOffset = offset & INT_BLOCK_MASK;
+                int relativeOffset = offset & INT32_BLOCK_MASK;
                 if (ints[relativeOffset] != 0)
                 {
                     // End of slice; allocate a new one
@@ -389,20 +400,20 @@ namespace Lucene.Net.Util
             /// </summary>
             public void Reset(int startOffset, int endOffset)
             {
-                bufferUpto = startOffset / INT_BLOCK_SIZE;
-                bufferOffset = bufferUpto * INT_BLOCK_SIZE;
+                bufferUpto = startOffset / INT32_BLOCK_SIZE;
+                bufferOffset = bufferUpto * INT32_BLOCK_SIZE;
                 this.end = endOffset;
                 upto = startOffset;
                 level = 1;
 
                 buffer = pool.buffers[bufferUpto];
-                upto = startOffset & INT_BLOCK_MASK;
+                upto = startOffset & INT32_BLOCK_MASK;
 
                 int firstSize = Int32BlockPool.LEVEL_SIZE_ARRAY[0];
                 if (startOffset + firstSize >= endOffset)
                 {
                     // There is only this one slice to read
-                    limit = endOffset & INT_BLOCK_MASK;
+                    limit = endOffset & INT32_BLOCK_MASK;
                 }
                 else
                 {
@@ -445,11 +456,11 @@ namespace Lucene.Net.Util
                 level = NEXT_LEVEL_ARRAY[level - 1];
                 int newSize = LEVEL_SIZE_ARRAY[level];
 
-                bufferUpto = nextIndex / INT_BLOCK_SIZE;
-                bufferOffset = bufferUpto * INT_BLOCK_SIZE;
+                bufferUpto = nextIndex / INT32_BLOCK_SIZE;
+                bufferOffset = bufferUpto * INT32_BLOCK_SIZE;
 
                 buffer = pool.Buffers[bufferUpto];
-                upto = nextIndex & INT_BLOCK_MASK;
+                upto = nextIndex & INT32_BLOCK_MASK;
 
                 if (nextIndex + newSize >= end)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/IntsRef.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/IntsRef.cs b/src/Lucene.Net.Core/Util/IntsRef.cs
index c39aceb..c32f62f 100644
--- a/src/Lucene.Net.Core/Util/IntsRef.cs
+++ b/src/Lucene.Net.Core/Util/IntsRef.cs
@@ -24,9 +24,9 @@ namespace Lucene.Net.Util
      */
 
     /// <summary>
-    /// Represents int[], as a slice (offset + length) into an
-    /// existing int[].  The <seealso cref="#ints"/> member should never be null; use
-    /// <seealso cref="#EMPTY_INTS"/> if necessary.
+    /// Represents <see cref="T:int[]"/>, as a slice (offset + length) into an
+    /// existing <see cref="T:int[]"/>.  The <see cref="Int32s"/> member should never be null; use
+    /// <see cref="EMPTY_INT32S"/> if necessary.
     /// <para/>
     /// NOTE: This was IntsRef in Lucene
     /// 
@@ -35,8 +35,11 @@ namespace Lucene.Net.Util
     public sealed class Int32sRef : IComparable<Int32sRef>
     {
         /// <summary>
-        /// An empty integer array for convenience </summary>
-        public static readonly int[] EMPTY_INTS = new int[0];
+        /// An empty integer array for convenience
+        /// <para/>
+        /// NOTE: This was EMPTY_INTS in Lucene
+        /// </summary>
+        public static readonly int[] EMPTY_INT32S = new int[0];
 
         /// <summary>
         /// The contents of the IntsRef. Should never be {@code null}. 
@@ -68,10 +71,10 @@ namespace Lucene.Net.Util
         public int Length { get; set; }
 
         /// <summary>
-        /// Create a IntsRef with <seealso cref="#EMPTY_INTS"/> </summary>
+        /// Create a IntsRef with <see cref="EMPTY_INT32S"/> </summary>
         public Int32sRef()
         {
-            ints = EMPTY_INTS;
+            ints = EMPTY_INT32S;
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/LongsRef.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/LongsRef.cs b/src/Lucene.Net.Core/Util/LongsRef.cs
index 4274922..fe27e80 100644
--- a/src/Lucene.Net.Core/Util/LongsRef.cs
+++ b/src/Lucene.Net.Core/Util/LongsRef.cs
@@ -24,10 +24,10 @@ namespace Lucene.Net.Util
      */
 
     /// <summary>
-    /// Represents long[], as a slice (offset + length) into an
-    ///  existing long[].  The <seealso cref="#longs"/> member should never be null; use
-    ///  <seealso cref="#EMPTY_LONGS"/> if necessary.
-    ///  <para/>
+    /// Represents <see cref="T:long[]"/>, as a slice (offset + length) into an
+    /// existing <see cref="T:long[]"/>.  The <see cref="Int64s"/> member should never be null; use
+    /// <see cref="EMPTY_INT64S"/> if necessary.
+    /// <para/>
     /// NOTE: This was LongsRef in Lucene
     ///
     ///  @lucene.internal
@@ -35,8 +35,11 @@ namespace Lucene.Net.Util
     public sealed class Int64sRef : IComparable<Int64sRef>
     {
         /// <summary>
-        /// An empty long array for convenience </summary>
-        public static readonly long[] EMPTY_LONGS = new long[0];
+        /// An empty long array for convenience
+        /// <para/>
+        /// NOTE: This was EMPTY_LONGS in Lucene
+        /// </summary>
+        public static readonly long[] EMPTY_INT64S = new long[0];
 
         /// <summary>
         /// The contents of the LongsRef. Should never be {@code null}. 
@@ -68,10 +71,10 @@ namespace Lucene.Net.Util
         public int Length { get; set; }
 
         /// <summary>
-        /// Create a LongsRef with <seealso cref="#EMPTY_LONGS"/> </summary>
+        /// Create a LongsRef with <see cref="EMPTY_INT64S"/> </summary>
         public Int64sRef()
         {
-            longs = EMPTY_LONGS;
+            longs = EMPTY_INT64S;
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/NumericUtils.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/NumericUtils.cs b/src/Lucene.Net.Core/Util/NumericUtils.cs
index 4478e44..8f1bb66 100644
--- a/src/Lucene.Net.Core/Util/NumericUtils.cs
+++ b/src/Lucene.Net.Core/Util/NumericUtils.cs
@@ -75,27 +75,37 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// Longs are stored at lower precision by shifting off lower bits. The shift count is
-        /// stored as <code>SHIFT_START_LONG+shift</code> in the first byte
+        /// stored as <c>SHIFT_START_INT64+shift</c> in the first byte
+        /// <para/>
+        /// NOTE: This was SHIFT_START_LONG in Lucene
         /// </summary>
-        public const char SHIFT_START_LONG = (char)0x20;
+        public const char SHIFT_START_INT64 = (char)0x20;
 
         /// <summary>
         /// The maximum term length (used for <code>byte[]</code> buffer size)
-        /// for encoding <code>long</code> values. </summary>
-        /// <seealso cref= #longToPrefixCodedBytes </seealso>
-        public const int BUF_SIZE_LONG = 63 / 7 + 2;
+        /// for encoding <see cref="long"/> values.
+        /// <para/>
+        /// NOTE: This was BUF_SIZE_LONG in Lucene
+        /// </summary>
+        /// <seealso cref="Int64ToPrefixCodedBytes(long, int, BytesRef)"/>
+        public const int BUF_SIZE_INT64 = 63 / 7 + 2;
 
         /// <summary>
         /// Integers are stored at lower precision by shifting off lower bits. The shift count is
-        /// stored as <code>SHIFT_START_INT+shift</code> in the first byte
+        /// stored as <code>SHIFT_START_INT32+shift</code> in the first byte
+        /// <para/>
+        /// NOTE: This was SHIFT_START_INT in Lucene
         /// </summary>
-        public const byte SHIFT_START_INT = 0x60;
+        public const byte SHIFT_START_INT32 = 0x60;
 
         /// <summary>
-        /// The maximum term length (used for <code>byte[]</code> buffer size)
-        /// for encoding <code>int</code> values. </summary>
-        /// <seealso cref= #intToPrefixCodedBytes </seealso>
-        public const int BUF_SIZE_INT = 31 / 7 + 2;
+        /// The maximum term length (used for <see cref="T:byte[]"/> buffer size)
+        /// for encoding <see cref="int"/> values.
+        /// <para/>
+        /// NOTE: This was BUF_SIZE_INT in Lucene
+        /// </summary>
+        /// <seealso cref="Int32ToPrefixCodedBytes(int, int, BytesRef)"/>
+        public const int BUF_SIZE_INT32 = 31 / 7 + 2;
 
         /// <summary>
         /// Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
@@ -148,9 +158,9 @@ namespace Lucene.Net.Util
             bytes.Length = nChars + 1; // one extra for the byte that contains the shift info
             if (bytes.Bytes.Length < bytes.Length)
             {
-                bytes.Bytes = new byte[NumericUtils.BUF_SIZE_LONG]; // use the max
+                bytes.Bytes = new byte[NumericUtils.BUF_SIZE_INT64]; // use the max
             }
-            bytes.Bytes[0] = (byte)(SHIFT_START_LONG + shift);
+            bytes.Bytes[0] = (byte)(SHIFT_START_INT64 + shift);
             ulong sortableBits = BitConverter.ToUInt64(BitConverter.GetBytes(val), 0) ^ 0x8000000000000000L;
             sortableBits = sortableBits >> shift;
             while (nChars > 0)
@@ -183,9 +193,9 @@ namespace Lucene.Net.Util
             bytes.Length = nChars + 1; // one extra for the byte that contains the shift info
             if (bytes.Bytes.Length < bytes.Length)
             {
-                bytes.Bytes = new byte[NumericUtils.BUF_SIZE_LONG]; // use the max
+                bytes.Bytes = new byte[NumericUtils.BUF_SIZE_INT64]; // use the max
             }
-            bytes.Bytes[0] = (byte)(SHIFT_START_INT + shift);
+            bytes.Bytes[0] = (byte)(SHIFT_START_INT32 + shift);
             int sortableBits = val ^ unchecked((int)0x80000000);
             sortableBits = Number.URShift(sortableBits, shift);
             while (nChars > 0)
@@ -206,7 +216,7 @@ namespace Lucene.Net.Util
         /// not correctly prefix encoded. </exception>
         public static int GetPrefixCodedInt64Shift(BytesRef val)
         {
-            int shift = val.Bytes[val.Offset] - SHIFT_START_LONG;
+            int shift = val.Bytes[val.Offset] - SHIFT_START_INT64;
             if (shift > 63 || shift < 0)
             {
                 throw new System.FormatException("Invalid shift value (" + shift + ") in prefixCoded bytes (is encoded value really an INT?)");
@@ -223,7 +233,7 @@ namespace Lucene.Net.Util
         /// not correctly prefix encoded. </exception>
         public static int GetPrefixCodedInt32Shift(BytesRef val)
         {
-            int shift = val.Bytes[val.Offset] - SHIFT_START_INT;
+            int shift = val.Bytes[val.Offset] - SHIFT_START_INT32;
             if (shift > 31 || shift < 0)
             {
                 throw new System.FormatException("Invalid shift value in prefixCoded bytes (is encoded value really an INT?)");
@@ -482,7 +492,7 @@ namespace Lucene.Net.Util
             /// </summary>
             public virtual void AddRange(long min, long max, int shift)
             {
-                BytesRef minBytes = new BytesRef(BUF_SIZE_LONG), maxBytes = new BytesRef(BUF_SIZE_LONG);
+                BytesRef minBytes = new BytesRef(BUF_SIZE_INT64), maxBytes = new BytesRef(BUF_SIZE_INT64);
                 Int64ToPrefixCodedBytes(min, shift, minBytes);
                 Int64ToPrefixCodedBytes(max, shift, maxBytes);
                 AddRange(minBytes, maxBytes);
@@ -515,7 +525,7 @@ namespace Lucene.Net.Util
             /// </summary>
             public virtual void AddRange(int min, int max, int shift)
             {
-                BytesRef minBytes = new BytesRef(BUF_SIZE_INT), maxBytes = new BytesRef(BUF_SIZE_INT);
+                BytesRef minBytes = new BytesRef(BUF_SIZE_INT32), maxBytes = new BytesRef(BUF_SIZE_INT32);
                 Int32ToPrefixCodedBytes(min, shift, minBytes);
                 Int32ToPrefixCodedBytes(max, shift, maxBytes);
                 AddRange(minBytes, maxBytes);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs b/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs
index 1916751..eb650c6 100644
--- a/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs
+++ b/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs
@@ -221,10 +221,10 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
                 + 2 * RamUsageEstimator.NUM_BYTES_OBJECT_REF 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT 
-                + RamUsageEstimator.NUM_BYTES_FLOAT 
-                + RamUsageEstimator.NUM_BYTES_LONG; // valuesBytes -  acceptable overhead -  pageShift, pageMask -  the 2 offsets -  the 2 arrays
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 
+                + RamUsageEstimator.NUM_BYTES_SINGLE 
+                + RamUsageEstimator.NUM_BYTES_INT64; // valuesBytes -  acceptable overhead -  pageShift, pageMask -  the 2 offsets -  the 2 arrays
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs b/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs
index f3c88a0..82bd3ee 100644
--- a/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs
+++ b/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs
@@ -108,7 +108,7 @@ namespace Lucene.Net.Util.Packed
 
         protected virtual long BaseRamBytesUsed()
         {
-            return RamUsageEstimator.NUM_BYTES_OBJECT_HEADER + RamUsageEstimator.NUM_BYTES_OBJECT_REF + RamUsageEstimator.NUM_BYTES_LONG + 3 * RamUsageEstimator.NUM_BYTES_INT;
+            return RamUsageEstimator.NUM_BYTES_OBJECT_HEADER + RamUsageEstimator.NUM_BYTES_OBJECT_REF + RamUsageEstimator.NUM_BYTES_INT64 + 3 * RamUsageEstimator.NUM_BYTES_INT32;
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/Direct16.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/Direct16.cs b/src/Lucene.Net.Core/Util/Packed/Direct16.cs
index 75e2d37..a6088ac 100644
--- a/src/Lucene.Net.Core/Util/Packed/Direct16.cs
+++ b/src/Lucene.Net.Core/Util/Packed/Direct16.cs
@@ -68,7 +68,7 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT // valueCount,bitsPerValue
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 // valueCount,bitsPerValue
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // values ref
                 + RamUsageEstimator.SizeOf(values);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/Direct32.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/Direct32.cs b/src/Lucene.Net.Core/Util/Packed/Direct32.cs
index 575f2bf..6ecb585 100644
--- a/src/Lucene.Net.Core/Util/Packed/Direct32.cs
+++ b/src/Lucene.Net.Core/Util/Packed/Direct32.cs
@@ -68,7 +68,7 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT // valueCount,bitsPerValue
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 // valueCount,bitsPerValue
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // values ref  
                 + RamUsageEstimator.SizeOf(values);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/Direct64.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/Direct64.cs b/src/Lucene.Net.Core/Util/Packed/Direct64.cs
index 9a56944..b48c8d7 100644
--- a/src/Lucene.Net.Core/Util/Packed/Direct64.cs
+++ b/src/Lucene.Net.Core/Util/Packed/Direct64.cs
@@ -62,7 +62,7 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT // valueCount,bitsPerValue
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 // valueCount,bitsPerValue
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // values ref 
                 + RamUsageEstimator.SizeOf(values); 
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/Direct8.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/Direct8.cs b/src/Lucene.Net.Core/Util/Packed/Direct8.cs
index 40ba1c5..d2345dc 100644
--- a/src/Lucene.Net.Core/Util/Packed/Direct8.cs
+++ b/src/Lucene.Net.Core/Util/Packed/Direct8.cs
@@ -65,7 +65,7 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT // valueCount,bitsPerValue
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 // valueCount,bitsPerValue
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // values ref 
                 + RamUsageEstimator.SizeOf(values);  
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/EliasFanoDecoder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/EliasFanoDecoder.cs b/src/Lucene.Net.Core/Util/Packed/EliasFanoDecoder.cs
index 7e4c1d6..0e62206 100644
--- a/src/Lucene.Net.Core/Util/Packed/EliasFanoDecoder.cs
+++ b/src/Lucene.Net.Core/Util/Packed/EliasFanoDecoder.cs
@@ -27,7 +27,10 @@ namespace Lucene.Net.Util.Packed
     /// </summary>
     public class EliasFanoDecoder
     {
-        private static readonly int LOG2_LONG_SIZE = Number.NumberOfTrailingZeros((sizeof(long) * 8));
+        /// <summary>
+        /// NOTE: This was LOG2_LONG_SIZE in Lucene
+        /// </summary>
+        private static readonly int LOG2_INT64_SIZE = Number.NumberOfTrailingZeros((sizeof(long) * 8));
 
         private readonly EliasFanoEncoder efEncoder;
         private readonly long numEncoded;
@@ -115,7 +118,7 @@ namespace Lucene.Net.Util.Packed
                 return 0;
             }
             long bitPos = packIndex * numBits;
-            int index = (int)((long)((ulong)bitPos >> LOG2_LONG_SIZE));
+            int index = (int)((long)((ulong)bitPos >> LOG2_INT64_SIZE));
             int bitPosAtIndex = (int)(bitPos & ((sizeof(long) * 8) - 1));
             long value = (long)((ulong)longArray[index] >> bitPosAtIndex);
             if ((bitPosAtIndex + numBits) > (sizeof(long) * 8))
@@ -187,7 +190,7 @@ namespace Lucene.Net.Util.Packed
                 return false;
             }
             setBitForIndex += 1;
-            int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_LONG_SIZE));
+            int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
             curHighLong = (long)((ulong)efEncoder.upperLongs[highIndex] >> CurrentRightShift);
             return true;
         }
@@ -202,7 +205,7 @@ namespace Lucene.Net.Util.Packed
         {
             setBitForIndex += (sizeof(long) * 8) - (setBitForIndex & ((sizeof(long) * 8) - 1));
             //assert getCurrentRightShift() == 0;
-            int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_LONG_SIZE));
+            int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
             curHighLong = efEncoder.upperLongs[highIndex];
         }
 
@@ -299,7 +302,7 @@ namespace Lucene.Net.Util.Packed
             }
             setBitForIndex += 1; // the high bit at setBitForIndex belongs to the unary code for efIndex
 
-            int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_LONG_SIZE));
+            int highIndex = (int)((long)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
             long upperLong = efEncoder.upperLongs[highIndex];
             curHighLong = (long)((ulong)upperLong >> ((int)(setBitForIndex & ((sizeof(long) * 8) - 1)))); // may contain the unary 1 bit for efIndex
 
@@ -319,7 +322,7 @@ namespace Lucene.Net.Util.Packed
                 {
                     setBitForIndex = UnPackValue(efEncoder.upperZeroBitPositionIndex, efEncoder.nIndexEntryBits, indexEntryIndex, indexMask);
                     efIndex = setBitForIndex - indexHighValue; // the high bit at setBitForIndex belongs to the unary code for efIndex
-                    highIndex = (int)(((ulong)setBitForIndex >> LOG2_LONG_SIZE));
+                    highIndex = (int)(((ulong)setBitForIndex >> LOG2_INT64_SIZE));
                     upperLong = efEncoder.upperLongs[highIndex];
                     curHighLong = (long)((ulong)upperLong >> ((int)(setBitForIndex & ((sizeof(long) * 8) - 1)))); // may contain the unary 1 bit for efIndex
                 }
@@ -339,7 +342,7 @@ namespace Lucene.Net.Util.Packed
                 }
                 setBitForIndex += (sizeof(long) * 8) - (setBitForIndex & ((sizeof(long) * 8) - 1));
                 // highIndex = (int)(setBitForIndex >>> LOG2_LONG_SIZE);
-                Debug.Assert((highIndex + 1) == (int)((long)((ulong)setBitForIndex >> LOG2_LONG_SIZE)));
+                Debug.Assert((highIndex + 1) == (int)((long)((ulong)setBitForIndex >> LOG2_INT64_SIZE)));
                 highIndex += 1;
                 upperLong = efEncoder.upperLongs[highIndex];
                 curHighLong = upperLong;
@@ -350,7 +353,7 @@ namespace Lucene.Net.Util.Packed
             while (curHighLong == 0L)
             {
                 setBitForIndex += (sizeof(long) * 8) - (setBitForIndex & ((sizeof(long) * 8) - 1));
-                Debug.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_LONG_SIZE));
+                Debug.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
                 highIndex += 1;
                 upperLong = efEncoder.upperLongs[highIndex];
                 curHighLong = upperLong;
@@ -374,14 +377,14 @@ namespace Lucene.Net.Util.Packed
 
                 if ((setBitForIndex & ((sizeof(long) * 8) - 1)) == 0L) // exhausted curHighLong
                 {
-                    Debug.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_LONG_SIZE));
+                    Debug.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
                     highIndex += 1;
                     upperLong = efEncoder.upperLongs[highIndex];
                     curHighLong = upperLong;
                 }
                 else
                 {
-                    Debug.Assert(highIndex == (int)((ulong)setBitForIndex >> LOG2_LONG_SIZE));
+                    Debug.Assert(highIndex == (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
                     curHighLong = (long)((ulong)upperLong >> ((int)(setBitForIndex & ((sizeof(long) * 8) - 1))));
                 }
                 // curHighLong has enough clear bits to reach highTarget, and may not have enough set bits.
@@ -389,7 +392,7 @@ namespace Lucene.Net.Util.Packed
                 while (curHighLong == 0L)
                 {
                     setBitForIndex += (sizeof(long) * 8) - (setBitForIndex & ((sizeof(long) * 8) - 1));
-                    Debug.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_LONG_SIZE));
+                    Debug.Assert((highIndex + 1) == (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE));
                     highIndex += 1;
                     upperLong = efEncoder.upperLongs[highIndex];
                     curHighLong = upperLong;
@@ -444,7 +447,7 @@ namespace Lucene.Net.Util.Packed
                 return false;
             }
             setBitForIndex -= 1;
-            int highIndex = (int)((ulong)setBitForIndex >> LOG2_LONG_SIZE);
+            int highIndex = (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE);
             curHighLong = efEncoder.upperLongs[highIndex] << CurrentLeftShift;
             return true;
         }
@@ -459,7 +462,7 @@ namespace Lucene.Net.Util.Packed
         {
             setBitForIndex -= (setBitForIndex & ((sizeof(long) * 8) - 1)) + 1;
             //assert getCurrentLeftShift() == 0;
-            int highIndex = (int)((ulong)setBitForIndex >> LOG2_LONG_SIZE);
+            int highIndex = (int)((ulong)setBitForIndex >> LOG2_INT64_SIZE);
             curHighLong = efEncoder.upperLongs[highIndex];
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/EliasFanoEncoder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/EliasFanoEncoder.cs b/src/Lucene.Net.Core/Util/Packed/EliasFanoEncoder.cs
index 2e09188..6963115 100644
--- a/src/Lucene.Net.Core/Util/Packed/EliasFanoEncoder.cs
+++ b/src/Lucene.Net.Core/Util/Packed/EliasFanoEncoder.cs
@@ -91,7 +91,11 @@ namespace Lucene.Net.Util.Packed
         internal readonly long lowerBitsMask;
         internal readonly long[] upperLongs;
         internal readonly long[] lowerLongs;
-        private static readonly int LOG2_LONG_SIZE = Number.NumberOfTrailingZeros(sizeof(long) * 8);
+
+        /// <summary>
+        /// NOTE: This was LOG2_LONG_SIZE in Lucene
+        /// </summary>
+        private static readonly int LOG2_INT64_SIZE = Number.NumberOfTrailingZeros(sizeof(long) * 8);
 
         internal long numEncoded = 0L;
         internal long lastEncoded = 0L;
@@ -213,7 +217,7 @@ namespace Lucene.Net.Util.Packed
         private static long NumInt64sForBits(long numBits) // Note: int version in FixedBitSet.bits2words()
         {
             Debug.Assert(numBits >= 0, numBits.ToString());
-            return (long)((ulong)(numBits + (sizeof(long) * 8 - 1)) >> LOG2_LONG_SIZE);
+            return (long)((ulong)(numBits + (sizeof(long) * 8 - 1)) >> LOG2_INT64_SIZE);
         }
 
         /// <summary>
@@ -258,7 +262,7 @@ namespace Lucene.Net.Util.Packed
         private void EncodeUpperBits(long highValue)
         {
             long nextHighBitNum = numEncoded + highValue; // sequence of unary gaps
-            upperLongs[(int)((long)((ulong)nextHighBitNum >> LOG2_LONG_SIZE))] |= (1L << (int)(nextHighBitNum & ((sizeof(long) * 8) - 1)));
+            upperLongs[(int)((long)((ulong)nextHighBitNum >> LOG2_INT64_SIZE))] |= (1L << (int)(nextHighBitNum & ((sizeof(long) * 8) - 1)));
         }
 
         private void EncodeLowerBits(long lowValue)
@@ -271,7 +275,7 @@ namespace Lucene.Net.Util.Packed
             if (numBits != 0)
             {
                 long bitPos = numBits * packIndex;
-                int index = (int)((long)((ulong)bitPos >> LOG2_LONG_SIZE));
+                int index = (int)((long)((ulong)bitPos >> LOG2_INT64_SIZE));
                 int bitPosAtIndex = (int)(bitPos & ((sizeof(long) * 8) - 1));
                 longArray[index] |= (value << bitPosAtIndex);
                 if ((bitPosAtIndex + numBits) > (sizeof(long) * 8))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs b/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs
index 590746a..34da357 100644
--- a/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs
+++ b/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs
@@ -152,8 +152,8 @@ namespace Lucene.Net.Util.Packed
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF 
-                + RamUsageEstimator.NUM_BYTES_LONG 
-                + RamUsageEstimator.NUM_BYTES_FLOAT) 
+                + RamUsageEstimator.NUM_BYTES_INT64 
+                + RamUsageEstimator.NUM_BYTES_SINGLE) 
                 + current.RamBytesUsed();
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs b/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs
index 2323d1d..af0d9e9 100644
--- a/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs
+++ b/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs
@@ -127,7 +127,7 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT // valueCount,bitsPerValue
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 // valueCount,bitsPerValue
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // blocks ref 
                 + RamUsageEstimator.SizeOf(blocks);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/Packed64.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/Packed64.cs b/src/Lucene.Net.Core/Util/Packed/Packed64.cs
index f6f56bd..301d26e 100644
--- a/src/Lucene.Net.Core/Util/Packed/Packed64.cs
+++ b/src/Lucene.Net.Core/Util/Packed/Packed64.cs
@@ -298,8 +298,8 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
-                + 3 * RamUsageEstimator.NUM_BYTES_INT // bpvMinusBlockSize,valueCount,bitsPerValue
-                + RamUsageEstimator.NUM_BYTES_LONG // maskRight
+                + 3 * RamUsageEstimator.NUM_BYTES_INT32 // bpvMinusBlockSize,valueCount,bitsPerValue
+                + RamUsageEstimator.NUM_BYTES_INT64 // maskRight
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // blocks ref
                 + RamUsageEstimator.SizeOf(blocks);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs b/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs
index 4119a4b..3b98323 100644
--- a/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs
+++ b/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs
@@ -65,7 +65,7 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT // valueCount,bitsPerValue
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 // valueCount,bitsPerValue
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // blocks ref 
                 + RamUsageEstimator.SizeOf(blocks);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs b/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs
index eac8677..9643a60 100644
--- a/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs
+++ b/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs
@@ -124,7 +124,7 @@ namespace Lucene.Net.Util.Packed
         {
             return RamUsageEstimator.AlignObjectSize(
                 RamUsageEstimator.NUM_BYTES_OBJECT_HEADER 
-                + 2 * RamUsageEstimator.NUM_BYTES_INT // valueCount,bitsPerValue
+                + 2 * RamUsageEstimator.NUM_BYTES_INT32 // valueCount,bitsPerValue
                 + RamUsageEstimator.NUM_BYTES_OBJECT_REF) // blocks ref
                 + RamUsageEstimator.SizeOf(blocks);
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/PackedInts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/PackedInts.cs b/src/Lucene.Net.Core/Util/Packed/PackedInts.cs
index a440651..1a5649a 100644
--- a/src/Lucene.Net.Core/Util/Packed/PackedInts.cs
+++ b/src/Lucene.Net.Core/Util/Packed/PackedInts.cs
@@ -932,7 +932,7 @@ namespace Lucene.Net.Util.Packed
 
             public override long RamBytesUsed()
             {
-                return RamUsageEstimator.AlignObjectSize(RamUsageEstimator.NUM_BYTES_OBJECT_HEADER + RamUsageEstimator.NUM_BYTES_INT);
+                return RamUsageEstimator.AlignObjectSize(RamUsageEstimator.NUM_BYTES_OBJECT_HEADER + RamUsageEstimator.NUM_BYTES_INT32);
             }
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs b/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs
index 3de2bb8..f05202b 100644
--- a/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs
+++ b/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs
@@ -65,7 +65,7 @@ namespace Lucene.Net.Util.Packed
 
         protected override long BaseRamBytesUsed()
         {
-            return base.BaseRamBytesUsed() + RamUsageEstimator.NUM_BYTES_FLOAT;
+            return base.BaseRamBytesUsed() + RamUsageEstimator.NUM_BYTES_SINGLE;
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/RamUsageEstimator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/RamUsageEstimator.cs b/src/Lucene.Net.Core/Util/RamUsageEstimator.cs
index 6450ee8..1f5aaf5 100644
--- a/src/Lucene.Net.Core/Util/RamUsageEstimator.cs
+++ b/src/Lucene.Net.Core/Util/RamUsageEstimator.cs
@@ -61,10 +61,26 @@ namespace Lucene.Net.Util
         public const int NUM_BYTES_BOOLEAN = 1;
         public const int NUM_BYTES_BYTE = 1;
         public const int NUM_BYTES_CHAR = 2;
-        public const int NUM_BYTES_SHORT = 2;
-        public const int NUM_BYTES_INT = 4;
-        public const int NUM_BYTES_FLOAT = 4;
-        public const int NUM_BYTES_LONG = 8;
+
+        /// <summary>
+        /// NOTE: This was NUM_BYTES_SHORT in Lucene
+        /// </summary>
+        public const int NUM_BYTES_INT16 = 2;
+
+        /// <summary>
+        /// NOTE: This was NUM_BYTES_INT in Lucene
+        /// </summary>
+        public const int NUM_BYTES_INT32 = 4;
+
+        /// <summary>
+        /// NOTE: This was NUM_BYTES_FLOAT in Lucene
+        /// </summary>
+        public const int NUM_BYTES_SINGLE = 4;
+
+        /// <summary>
+        /// NOTE: This was NUM_BYTES_LONG in Lucene
+        /// </summary>
+        public const int NUM_BYTES_INT64 = 8;
         public const int NUM_BYTES_DOUBLE = 8;
 
         /// <summary>
@@ -100,17 +116,17 @@ namespace Lucene.Net.Util
             primitiveSizes[typeof(bool)] = Convert.ToInt32(NUM_BYTES_BOOLEAN);
             primitiveSizes[typeof(sbyte)] = Convert.ToInt32(NUM_BYTES_BYTE);
             primitiveSizes[typeof(char)] = Convert.ToInt32(NUM_BYTES_CHAR);
-            primitiveSizes[typeof(short)] = Convert.ToInt32(NUM_BYTES_SHORT);
-            primitiveSizes[typeof(int)] = Convert.ToInt32(NUM_BYTES_INT);
-            primitiveSizes[typeof(float)] = Convert.ToInt32(NUM_BYTES_FLOAT);
+            primitiveSizes[typeof(short)] = Convert.ToInt32(NUM_BYTES_INT16);
+            primitiveSizes[typeof(int)] = Convert.ToInt32(NUM_BYTES_INT32);
+            primitiveSizes[typeof(float)] = Convert.ToInt32(NUM_BYTES_SINGLE);
             primitiveSizes[typeof(double)] = Convert.ToInt32(NUM_BYTES_DOUBLE);
-            primitiveSizes[typeof(long)] = Convert.ToInt32(NUM_BYTES_LONG);
+            primitiveSizes[typeof(long)] = Convert.ToInt32(NUM_BYTES_INT64);
 
             // Initialize empirically measured defaults. We'll modify them to the current
             // JVM settings later on if possible.
             int referenceSize = Constants.JRE_IS_64BIT ? 8 : 4;
             int objectHeader = Constants.JRE_IS_64BIT ? 16 : 8;
-            // The following is objectHeader + NUM_BYTES_INT, but aligned (object alignment)
+            // The following is objectHeader + NUM_BYTES_INT32, but aligned (object alignment)
             // so on 64 bit JVMs it'll be align(16 + 4, @8) = 24.
             int arrayHeader = Constants.JRE_IS_64BIT ? 24 : 12;
             int objectAlignment = Constants.JRE_IS_64BIT ? 8 : 4;
@@ -305,28 +321,28 @@ namespace Lucene.Net.Util
         /// Returns the size in bytes of the short[] object. </summary>
         public static long SizeOf(short[] arr)
         {
-            return AlignObjectSize((long)NUM_BYTES_ARRAY_HEADER + (long)NUM_BYTES_SHORT * arr.Length);
+            return AlignObjectSize((long)NUM_BYTES_ARRAY_HEADER + (long)NUM_BYTES_INT16 * arr.Length);
         }
 
         /// <summary>
         /// Returns the size in bytes of the int[] object. </summary>
         public static long SizeOf(int[] arr)
         {
-            return AlignObjectSize((long)NUM_BYTES_ARRAY_HEADER + (long)NUM_BYTES_INT * arr.Length);
+            return AlignObjectSize((long)NUM_BYTES_ARRAY_HEADER + (long)NUM_BYTES_INT32 * arr.Length);
         }
 
         /// <summary>
         /// Returns the size in bytes of the float[] object. </summary>
         public static long SizeOf(float[] arr)
         {
-            return AlignObjectSize((long)NUM_BYTES_ARRAY_HEADER + (long)NUM_BYTES_FLOAT * arr.Length);
+            return AlignObjectSize((long)NUM_BYTES_ARRAY_HEADER + (long)NUM_BYTES_SINGLE * arr.Length);
         }
 
         /// <summary>
         /// Returns the size in bytes of the long[] object. </summary>
         public static long SizeOf(long[] arr)
         {
-            return AlignObjectSize((long)NUM_BYTES_ARRAY_HEADER + (long)NUM_BYTES_LONG * arr.Length);
+            return AlignObjectSize((long)NUM_BYTES_ARRAY_HEADER + (long)NUM_BYTES_INT64 * arr.Length);
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs b/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs
index 271515e..073ea2d 100644
--- a/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs
+++ b/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs
@@ -72,13 +72,13 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// Creates a new <seealso cref="RecyclingInt32BlockAllocator"/> with a block size of
-        /// <seealso cref="Int32BlockPool#INT_BLOCK_SIZE"/>, upper buffered docs limit of
-        /// <seealso cref="#DEFAULT_BUFFERED_BLOCKS"/> ({@value #DEFAULT_BUFFERED_BLOCKS}).
+        /// Creates a new <see cref="RecyclingInt32BlockAllocator"/> with a block size of
+        /// <see cref="Int32BlockPool.INT32_BLOCK_SIZE"/>, upper buffered docs limit of
+        /// <see cref="DEFAULT_BUFFERED_BLOCKS"/>.
         ///
         /// </summary>
         public RecyclingInt32BlockAllocator()
-            : this(Int32BlockPool.INT_BLOCK_SIZE, 64, Counter.NewCounter(false))
+            : this(Int32BlockPool.INT32_BLOCK_SIZE, 64, Counter.NewCounter(false))
         {
         }
 
@@ -89,7 +89,7 @@ namespace Lucene.Net.Util
         {
             if (freeBlocks == 0)
             {
-                bytesUsed.AddAndGet(m_blockSize * RamUsageEstimator.NUM_BYTES_INT);
+                bytesUsed.AddAndGet(m_blockSize * RamUsageEstimator.NUM_BYTES_INT32);
                 return new int[m_blockSize];
             }
             int[] b = freeByteBlocks[--freeBlocks];
@@ -120,7 +120,7 @@ namespace Lucene.Net.Util
             {
                 blocks[i] = null;
             }
-            bytesUsed.AddAndGet(-(end - stop) * (m_blockSize * RamUsageEstimator.NUM_BYTES_INT));
+            bytesUsed.AddAndGet(-(end - stop) * (m_blockSize * RamUsageEstimator.NUM_BYTES_INT32));
             Debug.Assert(bytesUsed.Get() >= 0);
         }
 
@@ -167,7 +167,7 @@ namespace Lucene.Net.Util
             {
                 freeByteBlocks[--freeBlocks] = null;
             }
-            bytesUsed.AddAndGet(-count * m_blockSize * RamUsageEstimator.NUM_BYTES_INT);
+            bytesUsed.AddAndGet(-count * m_blockSize * RamUsageEstimator.NUM_BYTES_INT32);
             Debug.Assert(bytesUsed.Get() >= 0);
             return count;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs b/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
index 46fca06..dad410c 100644
--- a/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
+++ b/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
@@ -903,7 +903,7 @@ namespace Lucene.Net.Util
         /// Return the memory usage of this class in bytes. </summary>
         public long RamBytesUsed()
         {
-            return RamUsageEstimator.AlignObjectSize(3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF + 2 * RamUsageEstimator.NUM_BYTES_INT) 
+            return RamUsageEstimator.AlignObjectSize(3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF + 2 * RamUsageEstimator.NUM_BYTES_INT32) 
                 + RamUsageEstimator.SizeOf(data) 
                 + positions.RamBytesUsed() 
                 + wordNums.RamBytesUsed();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Expressions/SimpleBindings.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Expressions/SimpleBindings.cs b/src/Lucene.Net.Expressions/SimpleBindings.cs
index 89c121b..2c638b6 100644
--- a/src/Lucene.Net.Expressions/SimpleBindings.cs
+++ b/src/Lucene.Net.Expressions/SimpleBindings.cs
@@ -90,17 +90,17 @@ namespace Lucene.Net.Expressions
             SortField field = (SortField)o;
             switch (field.Type)
             {
-                case SortFieldType.INT:
+                case SortFieldType.INT32:
                     {
                         return new Int32FieldSource(field.Field, (FieldCache.IInt32Parser)field.Parser);
                     }
 
-                case SortFieldType.LONG:
+                case SortFieldType.INT64:
                     {
                         return new Int64FieldSource(field.Field, (FieldCache.IInt64Parser)field.Parser);
                     }
 
-                case SortFieldType.FLOAT:
+                case SortFieldType.SINGLE:
                     {
                         return new SingleFieldSource(field.Field, (FieldCache.ISingleParser)field.Parser);
                     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Memory/MemoryIndex.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Memory/MemoryIndex.cs b/src/Lucene.Net.Memory/MemoryIndex.cs
index 1d46b1b..2152d43 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.cs
@@ -215,10 +215,10 @@ namespace Lucene.Net.Index.Memory
             this.storeOffsets = storeOffsets;
             this.bytesUsed = Counter.NewCounter();
             int maxBufferedByteBlocks = (int)((maxReusedBytes / 2) / ByteBlockPool.BYTE_BLOCK_SIZE);
-            int maxBufferedIntBlocks = (int)((maxReusedBytes - (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE)) / (Int32BlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT));
-            Debug.Assert((maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT) <= maxReusedBytes);
+            int maxBufferedIntBlocks = (int)((maxReusedBytes - (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE)) / (Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32));
+            Debug.Assert((maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT32_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT32) <= maxReusedBytes);
             byteBlockPool = new ByteBlockPool(new RecyclingByteBlockAllocator(ByteBlockPool.BYTE_BLOCK_SIZE, maxBufferedByteBlocks, bytesUsed));
-            intBlockPool = new Int32BlockPool(new RecyclingInt32BlockAllocator(Int32BlockPool.INT_BLOCK_SIZE, maxBufferedIntBlocks, bytesUsed));
+            intBlockPool = new Int32BlockPool(new RecyclingInt32BlockAllocator(Int32BlockPool.INT32_BLOCK_SIZE, maxBufferedIntBlocks, bytesUsed));
             postingsWriter = new Int32BlockPool.SliceWriter(intBlockPool);
         }
 
@@ -730,9 +730,9 @@ namespace Lucene.Net.Index.Memory
             public override int[] Init()
             {
                 int[] ord = base.Init();
-                start = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT)];
-                end = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT)];
-                freq = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT)];
+                start = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
+                end = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
+                freq = new int[ArrayUtil.Oversize(ord.Length, RamUsageEstimator.NUM_BYTES_INT32)];
                 Debug.Assert(start.Length >= ord.Length);
                 Debug.Assert(end.Length >= ord.Length);
                 Debug.Assert(freq.Length >= ord.Length);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
index dffcd8b..ae8197a 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Builders/NumericRangeQueryNodeBuilder.cs
@@ -63,16 +63,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Builders
 
             switch (numberType)
             {
-                case NumericType.LONG:
+                case NumericType.INT64:
                     return NumericRangeQuery.NewInt64Range(field, precisionStep,
                         (long?)lowerNumber, (long?)upperNumber, minInclusive, maxInclusive);
 
-                case NumericType.INT:
+                case NumericType.INT32:
                     return NumericRangeQuery.NewInt32Range(field, precisionStep,
                         (int?)lowerNumber, (int?)upperNumber, minInclusive,
                         maxInclusive);
 
-                case NumericType.FLOAT:
+                case NumericType.SINGLE:
                     return NumericRangeQuery.NewSingleRange(field, precisionStep,
                         (float?)lowerNumber, (float?)upperNumber, minInclusive,
                         maxInclusive);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs
index a6f161c..8c2d2bb 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Nodes/NumericRangeQueryNode.cs
@@ -55,11 +55,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
         {
             if (number is long)
             {
-                return NumericType.LONG;
+                return NumericType.INT64;
             }
             else if (number is int)
             {
-                return NumericType.INT;
+                return NumericType.INT32;
             }
             else if (number is double)
             {
@@ -67,7 +67,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Nodes
             }
             else if (number is float)
             {
-                return NumericType.FLOAT;
+                return NumericType.SINGLE;
             }
             else
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
index 4ab43a3..cb71fac 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
@@ -100,16 +100,16 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                                 switch (numericConfig.Type)
                                 {
-                                    case NumericType.LONG:
+                                    case NumericType.INT64:
                                         number = Convert.ToInt64(number);
                                         break;
-                                    case NumericType.INT:
+                                    case NumericType.INT32:
                                         number = Convert.ToInt32(number);
                                         break;
                                     case NumericType.DOUBLE:
                                         number = Convert.ToDouble(number);
                                         break;
-                                    case NumericType.FLOAT:
+                                    case NumericType.SINGLE:
                                         number = Convert.ToSingle(number);
                                         break;
                                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
index 1dcbe51..89dc1ba 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
@@ -114,11 +114,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
                             switch (numericConfig.Type)
                             {
-                                case NumericType.LONG:
+                                case NumericType.INT64:
                                     if (upperNumber != null) upperNumber = Convert.ToInt64(upperNumber);
                                     if (lowerNumber != null) lowerNumber = Convert.ToInt64(lowerNumber);
                                     break;
-                                case NumericType.INT:
+                                case NumericType.INT32:
                                     if (upperNumber != null) upperNumber = Convert.ToInt32(upperNumber);
                                     if (lowerNumber != null) lowerNumber = Convert.ToInt32(lowerNumber);
                                     break;
@@ -126,7 +126,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
                                     if (upperNumber != null) upperNumber = Convert.ToDouble(upperNumber);
                                     if (lowerNumber != null) lowerNumber = Convert.ToDouble(lowerNumber);
                                     break;
-                                case NumericType.FLOAT:
+                                case NumericType.SINGLE:
                                     if (upperNumber != null) upperNumber = Convert.ToSingle(upperNumber);
                                     if (lowerNumber != null) lowerNumber = Convert.ToSingle(lowerNumber);
                                     break;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
index fce571d..27cb7b5 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
@@ -106,7 +106,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
         /// <summary>
         /// How we sort the postings and search results. </summary>
-        private static readonly Sort SORT = new Sort(new SortField("weight", SortFieldType.LONG, true));
+        private static readonly Sort SORT = new Sort(new SortField("weight", SortFieldType.INT64, true));
 
         /// <summary>
         /// Create a new instance, loading from a previously built

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs
index 30ee047..4b831fb 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs
@@ -286,7 +286,7 @@ namespace Lucene.Net.Index
                         answer = Convert.ToSingle(f);
                         nf = new SingleField("nf", f, Field.Store.NO);
                         sf = new StoredField("nf", f);
-                        typeAnswer = NumericType.FLOAT;
+                        typeAnswer = NumericType.SINGLE;
                     }
                     else
                     {
@@ -306,7 +306,7 @@ namespace Lucene.Net.Index
                         answer = Convert.ToInt32(i);
                         nf = new Int32Field("nf", i, Field.Store.NO);
                         sf = new StoredField("nf", i);
-                        typeAnswer = NumericType.INT;
+                        typeAnswer = NumericType.INT32;
                     }
                     else
                     {
@@ -314,7 +314,7 @@ namespace Lucene.Net.Index
                         answer = Convert.ToInt64(l);
                         nf = new Int64Field("nf", l, Field.Store.NO);
                         sf = new StoredField("nf", l);
-                        typeAnswer = NumericType.LONG;
+                        typeAnswer = NumericType.INT64;
                     }
                 }
                 doc.Add(nf);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.TestFramework/Util/ApiScanTestBase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Util/ApiScanTestBase.cs b/src/Lucene.Net.TestFramework/Util/ApiScanTestBase.cs
index 2889000..3eac4f1 100644
--- a/src/Lucene.Net.TestFramework/Util/ApiScanTestBase.cs
+++ b/src/Lucene.Net.TestFramework/Util/ApiScanTestBase.cs
@@ -58,6 +58,11 @@ namespace Lucene.Net.Util
         private static Regex ContainsNonNetNumeric = new Regex("(?<![Pp]o|[Pp]r|[Jj]o)[Ii]nt(?!16|32|64|er|eg|ro)|[Ll]ong(?!est|er)|[Ss]hort(?!est|er)|[Ff]loat", RegexOptions.Compiled);
 
         /// <summary>
+        /// Constants should not contain the word INT that is not followed by 16, 32, or 64, LONG, SHORT, or FLOAT
+        /// </summary>
+        private static Regex ConstContainsNonNetNumeric = new Regex("(?<!PO|PR|JO)INT(?!16|32|64|ER|EG|RO)|LONG(?!EST|ER)|SHORT(?!EST|ER)|FLOAT", RegexOptions.Compiled);
+
+        /// <summary>
         /// Matches IL code pattern for a method body with only a return statement for a local variable.
         /// In this case, the array is writable by the consumer.
         /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.TestFramework/Util/TestUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Util/TestUtil.cs b/src/Lucene.Net.TestFramework/Util/TestUtil.cs
index 7fee1f9..ee6cf6f 100644
--- a/src/Lucene.Net.TestFramework/Util/TestUtil.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestUtil.cs
@@ -1058,15 +1058,15 @@ namespace Lucene.Net.Util
                 {
                     switch (numType)
                     {
-                        case NumericType.INT:
+                        case NumericType.INT32:
                             field2 = new Int32Field(field1.Name, (int)field1.GetNumericValue(), (FieldType)field1.FieldType);
                             break;
 
-                        case NumericType.FLOAT:
+                        case NumericType.SINGLE:
                             field2 = new SingleField(field1.Name, (int)field1.GetNumericValue(), (FieldType)field1.FieldType);
                             break;
 
-                        case NumericType.LONG:
+                        case NumericType.INT64:
                             field2 = new Int64Field(field1.Name, (int)field1.GetNumericValue(), (FieldType)field1.FieldType);
                             break;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Expressions/TestDemoExpressions.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/TestDemoExpressions.cs b/src/Lucene.Net.Tests.Expressions/TestDemoExpressions.cs
index a1864e6..4d6a51a 100644
--- a/src/Lucene.Net.Tests.Expressions/TestDemoExpressions.cs
+++ b/src/Lucene.Net.Tests.Expressions/TestDemoExpressions.cs
@@ -76,7 +76,7 @@ namespace Lucene.Net.Tests.Expressions
 			// we use SimpleBindings: which just maps variables to SortField instances
 			SimpleBindings bindings = new SimpleBindings();
 			bindings.Add(new SortField("_score", SortFieldType.SCORE));
-			bindings.Add(new SortField("popularity", SortFieldType.INT));
+			bindings.Add(new SortField("popularity", SortFieldType.INT32));
 			// create a sort field and sort by it (reverse order)
 			Sort sort = new Sort(expr.GetSortField(bindings, true));
 			Query query = new TermQuery(new Term("body", "contents"));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Expressions/TestExpressionRescorer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/TestExpressionRescorer.cs b/src/Lucene.Net.Tests.Expressions/TestExpressionRescorer.cs
index 91b046a..1899640 100644
--- a/src/Lucene.Net.Tests.Expressions/TestExpressionRescorer.cs
+++ b/src/Lucene.Net.Tests.Expressions/TestExpressionRescorer.cs
@@ -72,7 +72,7 @@ namespace Lucene.Net.Tests.Expressions
 			// Now, rescore:
 			Expression e = JavascriptCompiler.Compile("sqrt(_score) + ln(popularity)");
 			SimpleBindings bindings = new SimpleBindings();
-			bindings.Add(new SortField("popularity", SortFieldType.INT));
+			bindings.Add(new SortField("popularity", SortFieldType.INT32));
 			bindings.Add(new SortField("_score", SortFieldType.SCORE));
 			Rescorer rescorer = e.GetRescorer(bindings);
 			hits = rescorer.Rescore(searcher, hits, 10);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Expressions/TestExpressionSortField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/TestExpressionSortField.cs b/src/Lucene.Net.Tests.Expressions/TestExpressionSortField.cs
index 062047e..985e843 100644
--- a/src/Lucene.Net.Tests.Expressions/TestExpressionSortField.cs
+++ b/src/Lucene.Net.Tests.Expressions/TestExpressionSortField.cs
@@ -13,7 +13,7 @@ namespace Lucene.Net.Tests.Expressions
 			Expression expr = JavascriptCompiler.Compile("sqrt(_score) + ln(popularity)");
 			SimpleBindings bindings = new SimpleBindings();
 			bindings.Add(new SortField("_score", SortFieldType.SCORE));
-			bindings.Add(new SortField("popularity", SortFieldType.INT));
+			bindings.Add(new SortField("popularity", SortFieldType.INT32));
 			SortField sf = expr.GetSortField(bindings, true);
 			AreEqual("<expr \"sqrt(_score) + ln(popularity)\">!", sf.ToString());
 		}
@@ -24,10 +24,10 @@ namespace Lucene.Net.Tests.Expressions
 			Expression expr = JavascriptCompiler.Compile("sqrt(_score) + ln(popularity)");
 			SimpleBindings bindings = new SimpleBindings();
 			bindings.Add(new SortField("_score", SortFieldType.SCORE));
-			bindings.Add(new SortField("popularity", SortFieldType.INT));
+			bindings.Add(new SortField("popularity", SortFieldType.INT32));
 			SimpleBindings otherBindings = new SimpleBindings();
-			otherBindings.Add(new SortField("_score", SortFieldType.LONG));
-			otherBindings.Add(new SortField("popularity", SortFieldType.INT));
+			otherBindings.Add(new SortField("_score", SortFieldType.INT64));
+			otherBindings.Add(new SortField("popularity", SortFieldType.INT32));
 			SortField sf1 = expr.GetSortField(bindings, true);
 			// different order
 			SortField sf2 = expr.GetSortField(bindings, false);
@@ -68,7 +68,7 @@ namespace Lucene.Net.Tests.Expressions
 			// several variables
 			Expression exprI = JavascriptCompiler.Compile("b / c + e * g");
 			bindings.Add(new SortField("_score", SortFieldType.SCORE));
-			bindings.Add(new SortField("intfield", SortFieldType.INT));
+			bindings.Add(new SortField("intfield", SortFieldType.INT32));
 			bindings.Add("a", exprA);
 			bindings.Add("b", exprB);
 			bindings.Add("c", exprC);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Expressions/TestExpressionSorts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/TestExpressionSorts.cs b/src/Lucene.Net.Tests.Expressions/TestExpressionSorts.cs
index dcf6cd6..4852778 100644
--- a/src/Lucene.Net.Tests.Expressions/TestExpressionSorts.cs
+++ b/src/Lucene.Net.Tests.Expressions/TestExpressionSorts.cs
@@ -96,11 +96,11 @@ namespace Lucene.Net.Tests.Expressions
             {
                 bool reversed = Random().NextBoolean();
                 SortField[] fields =
-				{ new SortField("int", SortFieldType.INT, reversed
-				    ), new SortField("long", SortFieldType.LONG, reversed), new SortField("float", 
-				        SortFieldType.FLOAT, reversed), new SortField("double", SortFieldType.DOUBLE, 
-				            reversed), new SortField("intdocvalues", SortFieldType.INT, reversed), new SortField
-				                ("floatdocvalues", SortFieldType.FLOAT, reversed), new SortField("score", SortFieldType.SCORE) };
+				{ new SortField("int", SortFieldType.INT32, reversed
+				    ), new SortField("long", SortFieldType.INT64, reversed), new SortField("float", 
+				        SortFieldType.SINGLE, reversed), new SortField("double", SortFieldType.DOUBLE, 
+				            reversed), new SortField("intdocvalues", SortFieldType.INT32, reversed), new SortField
+				                ("floatdocvalues", SortFieldType.SINGLE, reversed), new SortField("score", SortFieldType.SCORE) };
                 //TODO: Add Shuffle extension
                 //Collections.Shuffle(Arrays.AsList(fields), Random());
                 int numSorts = TestUtil.NextInt(Random(), 1, fields.Length);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs b/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs
index 14d0539..9912128 100644
--- a/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs
+++ b/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs
@@ -13,9 +13,9 @@ namespace Lucene.Net.Tests.Expressions
 		public virtual void TestValidExternals()
 		{
 			SimpleBindings bindings = new SimpleBindings();
-			bindings.Add(new SortField("valid0", SortFieldType.INT));
-			bindings.Add(new SortField("valid1", SortFieldType.INT));
-			bindings.Add(new SortField("valid2", SortFieldType.INT));
+			bindings.Add(new SortField("valid0", SortFieldType.INT32));
+			bindings.Add(new SortField("valid1", SortFieldType.INT32));
+			bindings.Add(new SortField("valid2", SortFieldType.INT32));
 			bindings.Add(new SortField("_score", SortFieldType.SCORE));
 			bindings.Add("valide0", JavascriptCompiler.Compile("valid0 - valid1 + valid2 + _score"
 				));
@@ -30,7 +30,7 @@ namespace Lucene.Net.Tests.Expressions
 		public virtual void TestInvalidExternal()
 		{
 			SimpleBindings bindings = new SimpleBindings();
-			bindings.Add(new SortField("valid", SortFieldType.INT));
+			bindings.Add(new SortField("valid", SortFieldType.INT32));
 			bindings.Add("invalid", JavascriptCompiler.Compile("badreference"));
 			try
 			{
@@ -47,7 +47,7 @@ namespace Lucene.Net.Tests.Expressions
 		public virtual void TestInvalidExternal2()
 		{
 			SimpleBindings bindings = new SimpleBindings();
-			bindings.Add(new SortField("valid", SortFieldType.INT));
+			bindings.Add(new SortField("valid", SortFieldType.INT32));
 			bindings.Add("invalid", JavascriptCompiler.Compile("valid + badreference"));
 			try
 			{

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Expressions/TestExpressionValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/TestExpressionValueSource.cs b/src/Lucene.Net.Tests.Expressions/TestExpressionValueSource.cs
index a088eae..cc1b9b4 100644
--- a/src/Lucene.Net.Tests.Expressions/TestExpressionValueSource.cs
+++ b/src/Lucene.Net.Tests.Expressions/TestExpressionValueSource.cs
@@ -66,7 +66,7 @@ namespace Lucene.Net.Tests.Expressions
 		{
 			Expression expr = JavascriptCompiler.Compile("2*popularity");
 			SimpleBindings bindings = new SimpleBindings();
-			bindings.Add(new SortField("popularity", SortFieldType.LONG));
+			bindings.Add(new SortField("popularity", SortFieldType.INT64));
 			ValueSource vs = expr.GetValueSource(bindings);
 			AreEqual(1, reader.Leaves.Count);
 			AtomicReaderContext leaf = reader.Leaves[0];
@@ -102,7 +102,7 @@ namespace Lucene.Net.Tests.Expressions
 		{
 			Expression expr = JavascriptCompiler.Compile("2*popularity");
 			SimpleBindings bindings = new SimpleBindings();
-			bindings.Add(new SortField("popularity", SortFieldType.LONG));
+			bindings.Add(new SortField("popularity", SortFieldType.INT64));
 			ValueSource vs = expr.GetValueSource(bindings);
 			AreEqual(1, reader.Leaves.Count);
 			AtomicReaderContext leaf = reader.Leaves[0];
@@ -127,8 +127,8 @@ namespace Lucene.Net.Tests.Expressions
 		{
 			Expression expr = JavascriptCompiler.Compile("sqrt(a) + ln(b)");
 			SimpleBindings bindings = new SimpleBindings();
-			bindings.Add(new SortField("a", SortFieldType.INT));
-			bindings.Add(new SortField("b", SortFieldType.INT));
+			bindings.Add(new SortField("a", SortFieldType.INT32));
+			bindings.Add(new SortField("b", SortFieldType.INT32));
 			ValueSource vs1 = expr.GetValueSource(bindings);
 			// same instance
 			AreEqual(vs1, vs1);
@@ -142,14 +142,14 @@ namespace Lucene.Net.Tests.Expressions
 			AreEqual(vs1, vs2);
 			// equiv bindings (different instance)
 			SimpleBindings bindings2 = new SimpleBindings();
-			bindings2.Add(new SortField("a", SortFieldType.INT));
-			bindings2.Add(new SortField("b", SortFieldType.INT));
+			bindings2.Add(new SortField("a", SortFieldType.INT32));
+			bindings2.Add(new SortField("b", SortFieldType.INT32));
 			ValueSource vs3 = expr.GetValueSource(bindings2);
 			AreEqual(vs1, vs3);
 			// different bindings (same names, different types)
 			SimpleBindings bindings3 = new SimpleBindings();
-			bindings3.Add(new SortField("a", SortFieldType.LONG));
-			bindings3.Add(new SortField("b", SortFieldType.INT));
+			bindings3.Add(new SortField("a", SortFieldType.INT64));
+			bindings3.Add(new SortField("b", SortFieldType.INT32));
 			ValueSource vs4 = expr.GetValueSource(bindings3);
 			IsFalse(vs1.Equals(vs4));
 		}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
index f090be7..0d3d0ab 100644
--- a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
+++ b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
@@ -1315,7 +1315,7 @@ namespace Lucene.Net.Facet
             DrillSidewaysResult r = ds.Search(ddq, 10); // this used to fail on IllegalArgEx
             Assert.AreEqual(0, r.Hits.TotalHits);
 
-            r = ds.Search(ddq, null, null, 10, new Sort(new SortField("foo", SortFieldType.INT)), false, false); // this used to fail on IllegalArgEx
+            r = ds.Search(ddq, null, null, 10, new Sort(new SortField("foo", SortFieldType.INT32)), false, false); // this used to fail on IllegalArgEx
             Assert.AreEqual(0, r.Hits.TotalHits);
 
             IOUtils.Close(writer, taxoWriter, searcher.IndexReader, taxoReader, dir, taxoDir);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
index 4008b34..5daab0c 100644
--- a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
@@ -123,7 +123,7 @@ namespace Lucene.Net.Search.Grouping
             w.Dispose();
             int maxDoc = reader.MaxDoc;
 
-            Sort sortWithinGroup = new Sort(new SortField("id_1", SortFieldType.INT, true));
+            Sort sortWithinGroup = new Sort(new SortField("id_1", SortFieldType.INT32, true));
             var allGroupHeadsCollector = CreateRandomCollector(groupField, sortWithinGroup, canUseIDV, valueType);
             indexSearcher.Search(new TermQuery(new Term("content", "random")), allGroupHeadsCollector);
             assertTrue(ArrayContains(new int[] { 2, 3, 5, 7 }, allGroupHeadsCollector.RetrieveGroupHeads()));
@@ -549,7 +549,7 @@ namespace Lucene.Net.Search.Grouping
             }
             else if (!scoreOnly)
             {
-                sortFields.Add(new SortField("id", SortFieldType.INT));
+                sortFields.Add(new SortField("id", SortFieldType.INT32));
             }
             return new Sort(sortFields.ToArray(/*new SortField[sortFields.size()]*/));
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/TestGrouping.cs b/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
index 6345b13..7be434f 100644
--- a/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
+++ b/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
@@ -406,7 +406,7 @@ namespace Lucene.Net.Search.Grouping
                 }
             }
             // Break ties:
-            sortFields.Add(new SortField("id", SortFieldType.INT));
+            sortFields.Add(new SortField("id", SortFieldType.INT32));
             return new Sort(sortFields.ToArray(/*new SortField[sortFields.size()]*/));
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73cb5b22/src/Lucene.Net.Tests.Join/TestBlockJoin.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Join/TestBlockJoin.cs b/src/Lucene.Net.Tests.Join/TestBlockJoin.cs
index 24c00b9..c28b350 100644
--- a/src/Lucene.Net.Tests.Join/TestBlockJoin.cs
+++ b/src/Lucene.Net.Tests.Join/TestBlockJoin.cs
@@ -495,7 +495,7 @@ namespace Lucene.Net.Tests.Join
                 sortFields.Add(new SortField(prefix + Random().Next(numFields), SortFieldType.STRING, Random().NextBoolean()));
             }
             // Break ties:
-            sortFields.Add(new SortField(prefix + "ID", SortFieldType.INT));
+            sortFields.Add(new SortField(prefix + "ID", SortFieldType.INT32));
             return new Sort(sortFields.ToArray());
         }
 


Mime
View raw message