lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [03/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:42 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
index e602ed8..14060c2 100644
--- a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
+++ b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
@@ -274,7 +274,7 @@ namespace Lucene.Net.Facet.Range
 
             // Third search, drill down on "less than or equal to 10":
             ddq = new DrillDownQuery(config);
-            ddq.Add("field", NumericRangeQuery.NewLongRange("field", 0L, 10L, true, true));
+            ddq.Add("field", NumericRangeQuery.NewInt64Range("field", 0L, 10L, true, true));
             dsr = ds.Search(null, ddq, 10);
 
             Assert.AreEqual(11, dsr.Hits.TotalHits);
@@ -522,11 +522,11 @@ namespace Lucene.Net.Facet.Range
                 {
                     if (Random().NextBoolean())
                     {
-                        fastMatchFilter = NumericRangeFilter.NewLongRange("field", minValue, maxValue, true, true);
+                        fastMatchFilter = NumericRangeFilter.NewInt64Range("field", minValue, maxValue, true, true);
                     }
                     else
                     {
-                        fastMatchFilter = NumericRangeFilter.NewLongRange("field", minAcceptedValue, maxAcceptedValue, true, true);
+                        fastMatchFilter = NumericRangeFilter.NewInt64Range("field", minAcceptedValue, maxAcceptedValue, true, true);
                     }
                 }
                 else
@@ -555,11 +555,11 @@ namespace Lucene.Net.Facet.Range
                     {
                         if (Random().NextBoolean())
                         {
-                            ddq.Add("field", NumericRangeFilter.NewLongRange("field", range.Min, range.Max, range.MinInclusive, range.MaxInclusive));
+                            ddq.Add("field", NumericRangeFilter.NewInt64Range("field", range.Min, range.Max, range.MinInclusive, range.MaxInclusive));
                         }
                         else
                         {
-                            ddq.Add("field", NumericRangeQuery.NewLongRange("field", range.Min, range.Max, range.MinInclusive, range.MaxInclusive));
+                            ddq.Add("field", NumericRangeQuery.NewInt64Range("field", range.Min, range.Max, range.MinInclusive, range.MaxInclusive));
                         }
                     }
                     else
@@ -727,11 +727,11 @@ namespace Lucene.Net.Facet.Range
                 {
                     if (Random().NextBoolean())
                     {
-                        fastMatchFilter = NumericRangeFilter.NewFloatRange("field", minValue, maxValue, true, true);
+                        fastMatchFilter = NumericRangeFilter.NewSingleRange("field", minValue, maxValue, true, true);
                     }
                     else
                     {
-                        fastMatchFilter = NumericRangeFilter.NewFloatRange("field", minAcceptedValue, maxAcceptedValue, true, true);
+                        fastMatchFilter = NumericRangeFilter.NewSingleRange("field", minAcceptedValue, maxAcceptedValue, true, true);
                     }
                 }
                 else
@@ -760,11 +760,11 @@ namespace Lucene.Net.Facet.Range
                     {
                         if (Random().NextBoolean())
                         {
-                            ddq.Add("field", NumericRangeFilter.NewFloatRange("field", (float)range.Min, (float)range.Max, range.MinInclusive, range.MaxInclusive));
+                            ddq.Add("field", NumericRangeFilter.NewSingleRange("field", (float)range.Min, (float)range.Max, range.MinInclusive, range.MaxInclusive));
                         }
                         else
                         {
-                            ddq.Add("field", NumericRangeQuery.NewFloatRange("field", (float)range.Min, (float)range.Max, range.MinInclusive, range.MaxInclusive));
+                            ddq.Add("field", NumericRangeQuery.NewSingleRange("field", (float)range.Min, (float)range.Max, range.MinInclusive, range.MaxInclusive));
                         }
                     }
                     else

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/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 1b7bc7a..1835309 100644
--- a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs
@@ -312,7 +312,7 @@ namespace Lucene.Net.Search.Grouping
                 w.Dispose();
 
                 // NOTE: intentional but temporary field cache insanity!
-                FieldCache.Ints docIdToFieldId = FieldCache.DEFAULT.GetInts(SlowCompositeReaderWrapper.Wrap(r), "id", false);
+                FieldCache.Ints docIdToFieldId = FieldCache.DEFAULT.GetInt32s(SlowCompositeReaderWrapper.Wrap(r), "id", false);
                 int[] fieldIdToDocID = new int[numDocs];
                 for (int i = 0; i < numDocs; i++)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/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 8a77f2e..b22e46d 100644
--- a/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
+++ b/src/Lucene.Net.Tests.Grouping/TestGrouping.cs
@@ -900,7 +900,7 @@ namespace Lucene.Net.Search.Grouping
                 w.Dispose();
 
                 // NOTE: intentional but temporary field cache insanity!
-                FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInts(SlowCompositeReaderWrapper.Wrap(r), "id", false);
+                FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInt32s(SlowCompositeReaderWrapper.Wrap(r), "id", false);
                 DirectoryReader rBlocks = null;
                 Directory dirBlocks = null;
 
@@ -944,7 +944,7 @@ namespace Lucene.Net.Search.Grouping
                     dirBlocks = NewDirectory();
                     rBlocks = GetDocBlockReader(dirBlocks, groupDocs);
                     Filter lastDocInBlock = new CachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("groupend", "x"))));
-                    FieldCache.Ints docIDToIDBlocks = FieldCache.DEFAULT.GetInts(SlowCompositeReaderWrapper.Wrap(rBlocks), "id", false);
+                    FieldCache.Ints docIDToIDBlocks = FieldCache.DEFAULT.GetInt32s(SlowCompositeReaderWrapper.Wrap(rBlocks), "id", false);
 
                     IndexSearcher sBlocks = NewSearcher(rBlocks);
                     ShardState shardsBlocks = new ShardState(sBlocks);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs b/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs
index d9e7347..84d00a8 100644
--- a/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs
+++ b/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs
@@ -502,7 +502,7 @@ namespace Lucene.Net.Search.Highlight
         public void TestNumericRangeQuery()
         {
             // doesn't currently highlight, but make sure it doesn't cause exception either
-            query = NumericRangeQuery.NewIntRange(NUMERIC_FIELD_NAME, 2, 6, true, true);
+            query = NumericRangeQuery.NewInt32Range(NUMERIC_FIELD_NAME, 2, 6, true, true);
             searcher = NewSearcher(reader);
             hits = searcher.Search(query, 100);
             int maxNumFragmentsRequired = 2;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/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 ba0dfd2..a5f3ce2 100644
--- a/src/Lucene.Net.Tests.Join/TestBlockJoin.cs
+++ b/src/Lucene.Net.Tests.Join/TestBlockJoin.cs
@@ -103,7 +103,7 @@ namespace Lucene.Net.Tests.Join
 
             BooleanQuery childQuery = new BooleanQuery();
             childQuery.Add(new BooleanClause(new TermQuery(new Term("skill", "java")), Occur.MUST));
-            childQuery.Add(new BooleanClause(NumericRangeQuery.NewIntRange("year", 2006, 2011, true, true), Occur.MUST));
+            childQuery.Add(new BooleanClause(NumericRangeQuery.NewInt32Range("year", 2006, 2011, true, true), Occur.MUST));
 
             ToParentBlockJoinQuery childJoinQuery = new ToParentBlockJoinQuery(childQuery, parentsFilter, ScoreMode.Avg);
 
@@ -156,7 +156,7 @@ namespace Lucene.Net.Tests.Join
             // Define child document criteria (finds an example of relevant work experience)
             BooleanQuery childQuery = new BooleanQuery();
             childQuery.Add(new BooleanClause(new TermQuery(new Term("skill", "java")), Occur.MUST));
-            childQuery.Add(new BooleanClause(NumericRangeQuery.NewIntRange("year", 2006, 2011, true, true), Occur.MUST));
+            childQuery.Add(new BooleanClause(NumericRangeQuery.NewInt32Range("year", 2006, 2011, true, true), Occur.MUST));
 
             // Define parent document criteria (find a resident in the UK)
             Query parentQuery = new TermQuery(new Term("country", "United Kingdom"));
@@ -238,7 +238,7 @@ namespace Lucene.Net.Tests.Join
             w.Dispose();
             IndexSearcher s = NewSearcher(r);
 
-            MultiTermQuery qc = NumericRangeQuery.NewIntRange("year", 2007, 2007, true, true);
+            MultiTermQuery qc = NumericRangeQuery.NewInt32Range("year", 2007, 2007, true, true);
             // Hacky: this causes the query to need 2 rewrite
             // iterations: 
             qc.MultiTermRewriteMethod = MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE;
@@ -312,7 +312,7 @@ namespace Lucene.Net.Tests.Join
             // Define child document criteria (finds an example of relevant work experience)
             BooleanQuery childQuery = new BooleanQuery();
             childQuery.Add(new BooleanClause(new TermQuery(new Term("skill", "java")), Occur.MUST));
-            childQuery.Add(new BooleanClause(NumericRangeQuery.NewIntRange("year", 2006, 2011, true, true), Occur.MUST));
+            childQuery.Add(new BooleanClause(NumericRangeQuery.NewInt32Range("year", 2006, 2011, true, true), Occur.MUST));
 
             // Define parent document criteria (find a resident in the UK)
             Query parentQuery = new TermQuery(new Term("country", "United Kingdom"));
@@ -417,7 +417,7 @@ namespace Lucene.Net.Tests.Join
             w.Commit();
             IndexSearcher s = NewSearcher(DirectoryReader.Open(dir));
 
-            ToParentBlockJoinQuery q = new ToParentBlockJoinQuery(NumericRangeQuery.NewIntRange("year", 1990, 2010, true, true), new FixedBitSetCachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("docType", "resume")))), ScoreMode.Total);
+            ToParentBlockJoinQuery q = new ToParentBlockJoinQuery(NumericRangeQuery.NewInt32Range("year", 1990, 2010, true, true), new FixedBitSetCachingWrapperFilter(new QueryWrapperFilter(new TermQuery(new Term("docType", "resume")))), ScoreMode.Total);
 
             TopDocs topDocs = s.Search(q, 10);
             assertEquals(2, topDocs.TotalHits);
@@ -1145,11 +1145,11 @@ namespace Lucene.Net.Tests.Join
             // Define child document criteria (finds an example of relevant work experience)
             BooleanQuery childJobQuery = new BooleanQuery();
             childJobQuery.Add(new BooleanClause(new TermQuery(new Term("skill", "java")), Occur.MUST));
-            childJobQuery.Add(new BooleanClause(NumericRangeQuery.NewIntRange("year", 2006, 2011, true, true), Occur.MUST));
+            childJobQuery.Add(new BooleanClause(NumericRangeQuery.NewInt32Range("year", 2006, 2011, true, true), Occur.MUST));
 
             BooleanQuery childQualificationQuery = new BooleanQuery();
             childQualificationQuery.Add(new BooleanClause(new TermQuery(new Term("qualification", "maths")), Occur.MUST));
-            childQualificationQuery.Add(new BooleanClause(NumericRangeQuery.NewIntRange("year", 1980, 2000, true, true), Occur.MUST));
+            childQualificationQuery.Add(new BooleanClause(NumericRangeQuery.NewInt32Range("year", 1980, 2000, true, true), Occur.MUST));
 
 
             // Define parent document criteria (find a resident in the UK)
@@ -1295,7 +1295,7 @@ namespace Lucene.Net.Tests.Join
             // Define child document criteria (finds an example of relevant work experience)
             BooleanQuery childQuery = new BooleanQuery();
             childQuery.Add(new BooleanClause(new TermQuery(new Term("skill", "java")), Occur.MUST));
-            childQuery.Add(new BooleanClause(NumericRangeQuery.NewIntRange("year", 2006, 2011, true, true), Occur.MUST));
+            childQuery.Add(new BooleanClause(NumericRangeQuery.NewInt32Range("year", 2006, 2011, true, true), Occur.MUST));
 
             // Wrap the child document query to 'join' any matches
             // up to corresponding parent:

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs b/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs
index e1cbe65..a364e45 100644
--- a/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs
+++ b/src/Lucene.Net.Tests.Misc/Index/Sorter/SorterTestBase.cs
@@ -49,7 +49,7 @@ namespace Lucene.Net.Index.Sorter
             {
                 if (state.Name.Equals(NORMS_FIELD))
                 {
-                    return Number.FloatToIntBits(state.Boost);
+                    return Number.SingleToInt32Bits(state.Boost);
                 }
                 else
                 {
@@ -156,7 +156,7 @@ namespace Lucene.Net.Index.Sorter
             }
             doc.Add(new NumericDocValuesField(NUMERIC_DV_FIELD, id));
             TextField norms = new TextField(NORMS_FIELD, id.ToString(), Field.Store.NO);
-            norms.Boost = (Number.IntBitsToFloat(id));
+            norms.Boost = (Number.Int32BitsToSingle(id));
             doc.Add(norms);
             doc.Add(new BinaryDocValuesField(BINARY_DV_FIELD, new BytesRef(id.ToString())));
             doc.Add(new SortedDocValuesField(SORTED_DV_FIELD, new BytesRef(id.ToString())));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs b/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs
index 41752e0..228b91f 100644
--- a/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs
+++ b/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs
@@ -181,10 +181,10 @@ namespace Lucene.Net.Util.Fst
             IntsRef scratch = new IntsRef();
             // Add the same input more than once and the outputs
             // are merged:
-            builder.Add(Util.ToIntsRef(new BytesRef("a"), scratch), 1L);
-            builder.Add(Util.ToIntsRef(new BytesRef("a"), scratch), 3L);
-            builder.Add(Util.ToIntsRef(new BytesRef("a"), scratch), 0L);
-            builder.Add(Util.ToIntsRef(new BytesRef("b"), scratch), 17L);
+            builder.Add(Util.ToInt32sRef(new BytesRef("a"), scratch), 1L);
+            builder.Add(Util.ToInt32sRef(new BytesRef("a"), scratch), 3L);
+            builder.Add(Util.ToInt32sRef(new BytesRef("a"), scratch), 0L);
+            builder.Add(Util.ToInt32sRef(new BytesRef("b"), scratch), 17L);
             FST<object> fst = builder.Finish();
 
             object output = Util.Get(fst, new BytesRef("a"));
@@ -215,10 +215,10 @@ namespace Lucene.Net.Util.Fst
             builder.Add(scratch, 17L);
             builder.Add(scratch, 1L);
 
-            builder.Add(Util.ToIntsRef(new BytesRef("a"), scratch), 1L);
-            builder.Add(Util.ToIntsRef(new BytesRef("a"), scratch), 3L);
-            builder.Add(Util.ToIntsRef(new BytesRef("a"), scratch), 0L);
-            builder.Add(Util.ToIntsRef(new BytesRef("b"), scratch), 0L);
+            builder.Add(Util.ToInt32sRef(new BytesRef("a"), scratch), 1L);
+            builder.Add(Util.ToInt32sRef(new BytesRef("a"), scratch), 3L);
+            builder.Add(Util.ToInt32sRef(new BytesRef("a"), scratch), 0L);
+            builder.Add(Util.ToInt32sRef(new BytesRef("b"), scratch), 0L);
 
             FST<object> fst = builder.Finish();
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs b/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs
index b1d6b82..b188246 100644
--- a/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs
+++ b/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs
@@ -184,7 +184,7 @@ namespace Lucene.Net.Tests.Queries
 
             protected override CustomScoreProvider GetCustomScoreProvider(AtomicReaderContext context)
             {
-                FieldCache.Ints values = FieldCache.DEFAULT.GetInts(context.AtomicReader, INT_FIELD, false);
+                FieldCache.Ints values = FieldCache.DEFAULT.GetInt32s(context.AtomicReader, INT_FIELD, false);
                 return new CustomScoreProviderAnonymousInnerClassHelper(this, context, values);
             }
             

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
index 9690713..d0796d8 100644
--- a/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
+++ b/src/Lucene.Net.Tests.Suggest/Suggest/Analyzing/FuzzySuggesterTest.cs
@@ -1375,15 +1375,15 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
             for (j = 1; j <= m; j++)
             {
-                t_j = otherPoints.Ints[j - 1];
+                t_j = otherPoints.Int32s[j - 1];
 
                 for (i = 1; i <= n; i++)
                 {
-                    cost = targetPoints.Ints[i - 1] == t_j ? 0 : 1;
+                    cost = targetPoints.Int32s[i - 1] == t_j ? 0 : 1;
                     // minimum of cell to the left+1, to the top+1, diagonally left and up +cost
                     d[i][j] = Math.Min(Math.Min(d[i - 1][j] + 1, d[i][j - 1] + 1), d[i - 1][j - 1] + cost);
                     // transposition
-                    if (allowTransposition && i > 1 && j > 1 && targetPoints.Ints[i - 1] == otherPoints.Ints[j - 2] && targetPoints.Ints[i - 2] == otherPoints.Ints[j - 1])
+                    if (allowTransposition && i > 1 && j > 1 && targetPoints.Int32s[i - 1] == otherPoints.Int32s[j - 2] && targetPoints.Int32s[i - 2] == otherPoints.Int32s[j - 1])
                     {
                         d[i][j] = Math.Min(d[i][j], d[i - 2][j - 2] + cost);
                     }
@@ -1419,7 +1419,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             int utf16Len = s.Length;
             for (int i = 0, cp = 0; i < utf16Len; i += Character.CharCount(cp))
             {
-                cp = @ref.Ints[@ref.Length++] = Character.CodePointAt(s, i);
+                cp = @ref.Int32s[@ref.Length++] = Character.CodePointAt(s, i);
             }
             return @ref;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Analysis/TestNumericTokenStream.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Analysis/TestNumericTokenStream.cs b/src/Lucene.Net.Tests/core/Analysis/TestNumericTokenStream.cs
index 2e655e7..8c020e4 100644
--- a/src/Lucene.Net.Tests/core/Analysis/TestNumericTokenStream.cs
+++ b/src/Lucene.Net.Tests/core/Analysis/TestNumericTokenStream.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Analysis
         [NUnit.Framework.Test]
         public virtual void TestLongStream()
         {
-            using (NumericTokenStream stream = (new NumericTokenStream()).SetLongValue(Lvalue)) {
+            using (NumericTokenStream stream = (new NumericTokenStream()).SetInt64Value(Lvalue)) {
                 // use getAttribute to test if attributes really exist, if not an IAE will be throwed
                 ITermToBytesRefAttribute bytesAtt = stream.GetAttribute<ITermToBytesRefAttribute>();
                 ITypeAttribute typeAtt = stream.GetAttribute<ITypeAttribute>();
@@ -49,7 +49,7 @@ namespace Lucene.Net.Analysis
                     Assert.IsTrue(stream.IncrementToken(), "New token is available");
                     Assert.AreEqual(shift, numericAtt.Shift, "Shift value wrong");
                     bytesAtt.FillBytesRef();
-                    Assert.AreEqual(Lvalue & ~((1L << shift) - 1L), NumericUtils.PrefixCodedToLong(bytes), "Term is incorrectly encoded");
+                    Assert.AreEqual(Lvalue & ~((1L << shift) - 1L), NumericUtils.PrefixCodedToInt64(bytes), "Term is incorrectly encoded");
                     Assert.AreEqual(Lvalue & ~((1L << shift) - 1L), numericAtt.RawValue, "Term raw value is incorrectly encoded");
                     Assert.AreEqual((shift == 0) ? NumericTokenStream.TOKEN_TYPE_FULL_PREC : NumericTokenStream.TOKEN_TYPE_LOWER_PREC, typeAtt.Type, "Type incorrect");
                 }
@@ -61,7 +61,7 @@ namespace Lucene.Net.Analysis
         [NUnit.Framework.Test]
         public virtual void TestIntStream()
         {
-            NumericTokenStream stream = (new NumericTokenStream()).SetIntValue(Ivalue);
+            NumericTokenStream stream = (new NumericTokenStream()).SetInt32Value(Ivalue);
             // use getAttribute to test if attributes really exist, if not an IAE will be throwed
             ITermToBytesRefAttribute bytesAtt = stream.GetAttribute<ITermToBytesRefAttribute>();
             ITypeAttribute typeAtt = stream.GetAttribute<ITypeAttribute>();
@@ -74,7 +74,7 @@ namespace Lucene.Net.Analysis
                 Assert.IsTrue(stream.IncrementToken(), "New token is available");
                 Assert.AreEqual(shift, numericAtt.Shift, "Shift value wrong");
                 bytesAtt.FillBytesRef();
-                Assert.AreEqual(Ivalue & ~((1 << shift) - 1), NumericUtils.PrefixCodedToInt(bytes), "Term is incorrectly encoded");
+                Assert.AreEqual(Ivalue & ~((1 << shift) - 1), NumericUtils.PrefixCodedToInt32(bytes), "Term is incorrectly encoded");
                 Assert.AreEqual(((long)Ivalue) & ~((1L << shift) - 1L), numericAtt.RawValue, "Term raw value is incorrectly encoded");
                 Assert.AreEqual((shift == 0) ? NumericTokenStream.TOKEN_TYPE_FULL_PREC : NumericTokenStream.TOKEN_TYPE_LOWER_PREC, typeAtt.Type, "Type incorrect");
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Document/TestField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Document/TestField.cs b/src/Lucene.Net.Tests/core/Document/TestField.cs
index 105384c..c278fbf 100644
--- a/src/Lucene.Net.Tests/core/Document/TestField.cs
+++ b/src/Lucene.Net.Tests/core/Document/TestField.cs
@@ -95,7 +95,7 @@ namespace Lucene.Net.Documents
             TrySetStringValue(field);
             TrySetTokenStreamValue(field);
 
-            Assert.AreEqual(6f, Number.IntBitsToFloat(Convert.ToInt32(field.GetNumericValue())), 0.0f);
+            Assert.AreEqual(6f, Number.Int32BitsToSingle(Convert.ToInt32(field.GetNumericValue())), 0.0f);
         }
 
         [Test]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/Test2BBinaryDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/Test2BBinaryDocValues.cs b/src/Lucene.Net.Tests/core/Index/Test2BBinaryDocValues.cs
index 10c1dd4..e7bc021 100644
--- a/src/Lucene.Net.Tests/core/Index/Test2BBinaryDocValues.cs
+++ b/src/Lucene.Net.Tests/core/Index/Test2BBinaryDocValues.cs
@@ -130,7 +130,7 @@ namespace Lucene.Net.Index
             for (int i = 0; i < int.MaxValue; i++)
             {
                 encoder.Reset(bytes);
-                encoder.WriteVInt(i % 65535); // 1, 2, or 3 bytes
+                encoder.WriteVInt32(i % 65535); // 1, 2, or 3 bytes
                 data.Length = encoder.Position;
                 w.AddDocument(doc);
                 if (i % 100000 == 0)
@@ -158,7 +158,7 @@ namespace Lucene.Net.Index
                 {
                     dv.Get(i, scratch);
                     input.Reset((byte[])(Array)scratch.Bytes, scratch.Offset, scratch.Length);
-                    Assert.AreEqual(expectedValue % 65535, input.ReadVInt());
+                    Assert.AreEqual(expectedValue % 65535, input.ReadVInt32());
                     Assert.IsTrue(input.Eof);
                     expectedValue++;
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestAllFilesHaveCodecHeader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestAllFilesHaveCodecHeader.cs b/src/Lucene.Net.Tests/core/Index/TestAllFilesHaveCodecHeader.cs
index 9e52d00..2fbaa40 100644
--- a/src/Lucene.Net.Tests/core/Index/TestAllFilesHaveCodecHeader.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestAllFilesHaveCodecHeader.cs
@@ -98,7 +98,7 @@ namespace Lucene.Net.Index
                 try
                 {
                     @in = dir.OpenInput(file, NewIOContext(Random()));
-                    int val = @in.ReadInt();
+                    int val = @in.ReadInt32();
                     Assert.AreEqual(CodecUtil.CODEC_MAGIC, val, file + " has no codec header, instead found: " + val);
                     success = true;
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs b/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs
index 598782f..5183860 100644
--- a/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility.cs
@@ -531,7 +531,7 @@ namespace Lucene.Net.Index
                     Assert.AreEqual(expectedRef, scratch);
 
                     Assert.AreEqual((double)id, BitConverter.Int64BitsToDouble(dvDouble.Get(i)), 0D);
-                    Assert.AreEqual((float)id, Number.IntBitsToFloat((int)dvFloat.Get(i)), 0F);
+                    Assert.AreEqual((float)id, Number.Int32BitsToSingle((int)dvFloat.Get(i)), 0F);
                     Assert.AreEqual(id, dvInt.Get(i));
                     Assert.AreEqual(id, dvLong.Get(i));
                     Assert.AreEqual(id, dvPacked.Get(i));
@@ -869,26 +869,26 @@ namespace Lucene.Net.Index
 
                 for (int id = 10; id < 15; id++)
                 {
-                    ScoreDoc[] hits = searcher.Search(NumericRangeQuery.NewIntRange("trieInt", 4, Convert.ToInt32(id), Convert.ToInt32(id), true, true), 100).ScoreDocs;
+                    ScoreDoc[] hits = searcher.Search(NumericRangeQuery.NewInt32Range("trieInt", 4, Convert.ToInt32(id), Convert.ToInt32(id), true, true), 100).ScoreDocs;
                     Assert.AreEqual(1, hits.Length, "wrong number of hits");
                     Document d = searcher.Doc(hits[0].Doc);
                     Assert.AreEqual(Convert.ToString(id), d.Get("id"));
 
-                    hits = searcher.Search(NumericRangeQuery.NewLongRange("trieLong", 4, Convert.ToInt64(id), Convert.ToInt64(id), true, true), 100).ScoreDocs;
+                    hits = searcher.Search(NumericRangeQuery.NewInt64Range("trieLong", 4, Convert.ToInt64(id), Convert.ToInt64(id), true, true), 100).ScoreDocs;
                     Assert.AreEqual(1, hits.Length, "wrong number of hits");
                     d = searcher.Doc(hits[0].Doc);
                     Assert.AreEqual(Convert.ToString(id), d.Get("id"));
                 }
 
                 // check that also lower-precision fields are ok
-                ScoreDoc[] hits_ = searcher.Search(NumericRangeQuery.NewIntRange("trieInt", 4, int.MinValue, int.MaxValue, false, false), 100).ScoreDocs;
+                ScoreDoc[] hits_ = searcher.Search(NumericRangeQuery.NewInt32Range("trieInt", 4, int.MinValue, int.MaxValue, false, false), 100).ScoreDocs;
                 Assert.AreEqual(34, hits_.Length, "wrong number of hits");
 
-                hits_ = searcher.Search(NumericRangeQuery.NewLongRange("trieLong", 4, long.MinValue, long.MaxValue, false, false), 100).ScoreDocs;
+                hits_ = searcher.Search(NumericRangeQuery.NewInt64Range("trieLong", 4, long.MinValue, long.MaxValue, false, false), 100).ScoreDocs;
                 Assert.AreEqual(34, hits_.Length, "wrong number of hits");
 
                 // check decoding into field cache
-                FieldCache.Ints fci = FieldCache.DEFAULT.GetInts(SlowCompositeReaderWrapper.Wrap(searcher.IndexReader), "trieInt", false);
+                FieldCache.Ints fci = FieldCache.DEFAULT.GetInt32s(SlowCompositeReaderWrapper.Wrap(searcher.IndexReader), "trieInt", false);
                 int maxDoc = searcher.IndexReader.MaxDoc;
                 for (int doc = 0; doc < maxDoc; doc++)
                 {
@@ -896,7 +896,7 @@ namespace Lucene.Net.Index
                     Assert.IsTrue(val >= 0 && val < 35, "value in id bounds");
                 }
 
-                FieldCache.Longs fcl = FieldCache.DEFAULT.GetLongs(SlowCompositeReaderWrapper.Wrap(searcher.IndexReader), "trieLong", false);
+                FieldCache.Longs fcl = FieldCache.DEFAULT.GetInt64s(SlowCompositeReaderWrapper.Wrap(searcher.IndexReader), "trieLong", false);
                 for (int doc = 0; doc < maxDoc; doc++)
                 {
                     long val = fcl.Get(doc);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs b/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs
index 711ea4d..ba5cd08 100644
--- a/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestBackwardsCompatibility3x.cs
@@ -497,7 +497,7 @@ namespace Lucene.Net.Index
                     Assert.AreEqual(expectedRef, scratch);
 
                     Assert.AreEqual((double)id, BitConverter.Int64BitsToDouble(dvDouble.Get(i)), 0D);
-                    Assert.AreEqual((float)id, Number.IntBitsToFloat((int)dvFloat.Get(i)), 0F);
+                    Assert.AreEqual((float)id, Number.Int32BitsToSingle((int)dvFloat.Get(i)), 0F);
                     Assert.AreEqual(id, dvInt.Get(i));
                     Assert.AreEqual(id, dvLong.Get(i));
                     Assert.AreEqual(id, dvPacked.Get(i));
@@ -827,26 +827,26 @@ namespace Lucene.Net.Index
 
                 for (int id = 10; id < 15; id++)
                 {
-                    ScoreDoc[] hits = searcher.Search(NumericRangeQuery.NewIntRange("trieInt", 4, Convert.ToInt32(id), Convert.ToInt32(id), true, true), 100).ScoreDocs;
+                    ScoreDoc[] hits = searcher.Search(NumericRangeQuery.NewInt32Range("trieInt", 4, Convert.ToInt32(id), Convert.ToInt32(id), true, true), 100).ScoreDocs;
                     Assert.AreEqual(1, hits.Length, "wrong number of hits");
                     Document d = searcher.Doc(hits[0].Doc);
                     Assert.AreEqual(Convert.ToString(id), d.Get("id"));
 
-                    hits = searcher.Search(NumericRangeQuery.NewLongRange("trieLong", 4, Convert.ToInt64(id), Convert.ToInt64(id), true, true), 100).ScoreDocs;
+                    hits = searcher.Search(NumericRangeQuery.NewInt64Range("trieLong", 4, Convert.ToInt64(id), Convert.ToInt64(id), true, true), 100).ScoreDocs;
                     Assert.AreEqual(1, hits.Length, "wrong number of hits");
                     d = searcher.Doc(hits[0].Doc);
                     Assert.AreEqual(Convert.ToString(id), d.Get("id"));
                 }
 
                 // check that also lower-precision fields are ok
-                ScoreDoc[] hits_ = searcher.Search(NumericRangeQuery.NewIntRange("trieInt", 4, int.MinValue, int.MaxValue, false, false), 100).ScoreDocs;
+                ScoreDoc[] hits_ = searcher.Search(NumericRangeQuery.NewInt32Range("trieInt", 4, int.MinValue, int.MaxValue, false, false), 100).ScoreDocs;
                 Assert.AreEqual(34, hits_.Length, "wrong number of hits");
 
-                hits_ = searcher.Search(NumericRangeQuery.NewLongRange("trieLong", 4, long.MinValue, long.MaxValue, false, false), 100).ScoreDocs;
+                hits_ = searcher.Search(NumericRangeQuery.NewInt64Range("trieLong", 4, long.MinValue, long.MaxValue, false, false), 100).ScoreDocs;
                 Assert.AreEqual(34, hits_.Length, "wrong number of hits");
 
                 // check decoding into field cache
-                FieldCache.Ints fci = FieldCache.DEFAULT.GetInts(SlowCompositeReaderWrapper.Wrap(searcher.IndexReader), "trieInt", false);
+                FieldCache.Ints fci = FieldCache.DEFAULT.GetInt32s(SlowCompositeReaderWrapper.Wrap(searcher.IndexReader), "trieInt", false);
                 int maxDoc = searcher.IndexReader.MaxDoc;
                 for (int doc = 0; doc < maxDoc; doc++)
                 {
@@ -854,7 +854,7 @@ namespace Lucene.Net.Index
                     Assert.IsTrue(val >= 0 && val < 35, "value in id bounds");
                 }
 
-                FieldCache.Longs fcl = FieldCache.DEFAULT.GetLongs(SlowCompositeReaderWrapper.Wrap(searcher.IndexReader), "trieLong", false);
+                FieldCache.Longs fcl = FieldCache.DEFAULT.GetInt64s(SlowCompositeReaderWrapper.Wrap(searcher.IndexReader), "trieLong", false);
                 for (int doc = 0; doc < maxDoc; doc++)
                 {
                     long val = fcl.Get(doc);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestByteSlices.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestByteSlices.cs b/src/Lucene.Net.Tests/core/Index/TestByteSlices.cs
index db4c9e0..9869364 100644
--- a/src/Lucene.Net.Tests/core/Index/TestByteSlices.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestByteSlices.cs
@@ -105,8 +105,8 @@ namespace Lucene.Net.Index
                             Console.WriteLine("    write " + (counters[stream] + j));
                         }
                         // write some large (incl. negative) ints:
-                        writer.WriteVInt(Random().Next());
-                        writer.WriteVInt(counters[stream] + j);
+                        writer.WriteVInt32(Random().Next());
+                        writer.WriteVInt32(counters[stream] + j);
                     }
                     counters[stream] += numValue;
                     uptos[stream] = writer.Address;
@@ -128,8 +128,8 @@ namespace Lucene.Net.Index
                         reader.Init(pool, starts[stream], uptos[stream]);
                         for (int j = 0; j < counters[stream]; j++)
                         {
-                            reader.ReadVInt();
-                            Assert.AreEqual(j, reader.ReadVInt());
+                            reader.ReadVInt32();
+                            Assert.AreEqual(j, reader.ReadVInt32());
                         }
                     }
                 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestCompoundFile.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestCompoundFile.cs b/src/Lucene.Net.Tests/core/Index/TestCompoundFile.cs
index c291379..8452701 100644
--- a/src/Lucene.Net.Tests/core/Index/TestCompoundFile.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestCompoundFile.cs
@@ -681,7 +681,7 @@ namespace Lucene.Net.Index
                 IndexOutput os = csw.CreateOutput("seg_" + j + "_foo.txt", NewIOContext(Random()));
                 for (int i = 0; i < size; i++)
                 {
-                    os.WriteInt(i * j);
+                    os.WriteInt32(i * j);
                 }
                 os.Dispose();
                 string[] listAll = newDir.ListAll();
@@ -701,7 +701,7 @@ namespace Lucene.Net.Index
                 Assert.AreEqual(size * 4, openInput.Length);
                 for (int i = 0; i < size; i++)
                 {
-                    Assert.AreEqual(i * j, openInput.ReadInt());
+                    Assert.AreEqual(i * j, openInput.ReadInt32());
                 }
 
                 openInput.Dispose();
@@ -723,7 +723,7 @@ namespace Lucene.Net.Index
             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]);
@@ -759,8 +759,8 @@ namespace Lucene.Net.Index
             CompoundFileDirectory nested = new CompoundFileDirectory(newDir, "b.cfs", NewIOContext(Random()), true);
             IndexOutput @out = nested.CreateOutput("b.xyz", NewIOContext(Random()));
             IndexOutput out1 = nested.CreateOutput("b_1.xyz", NewIOContext(Random()));
-            @out.WriteInt(0);
-            out1.WriteInt(1);
+            @out.WriteInt32(0);
+            out1.WriteInt32(1);
             @out.Dispose();
             out1.Dispose();
             nested.Dispose();
@@ -778,10 +778,10 @@ namespace Lucene.Net.Index
 
             Assert.AreEqual(2, nested.ListAll().Length);
             IndexInput openInput = nested.OpenInput("b.xyz", NewIOContext(Random()));
-            Assert.AreEqual(0, openInput.ReadInt());
+            Assert.AreEqual(0, openInput.ReadInt32());
             openInput.Dispose();
             openInput = nested.OpenInput("b_1.xyz", NewIOContext(Random()));
-            Assert.AreEqual(1, openInput.ReadInt());
+            Assert.AreEqual(1, openInput.ReadInt32());
             openInput.Dispose();
             nested.Dispose();
             csw.Dispose();
@@ -794,7 +794,7 @@ namespace Lucene.Net.Index
             Directory newDir = NewDirectory();
             CompoundFileDirectory csw = new CompoundFileDirectory(newDir, "d.cfs", NewIOContext(Random()), true);
             IndexOutput @out = csw.CreateOutput("d.xyz", NewIOContext(Random()));
-            @out.WriteInt(0);
+            @out.WriteInt32(0);
             @out.Dispose();
 
             csw.Dispose();
@@ -803,7 +803,7 @@ namespace Lucene.Net.Index
 
             csw = new CompoundFileDirectory(newDir, "d.cfs", NewIOContext(Random()), false);
             IndexInput openInput = csw.OpenInput("d.xyz", NewIOContext(Random()));
-            Assert.AreEqual(0, openInput.ReadInt());
+            Assert.AreEqual(0, openInput.ReadInt32());
             openInput.Dispose();
             csw.Dispose();
             // close a second time - must have no effect according to IDisposable

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestCustomNorms.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestCustomNorms.cs b/src/Lucene.Net.Tests/core/Index/TestCustomNorms.cs
index 6865cdb..0db78f9 100644
--- a/src/Lucene.Net.Tests/core/Index/TestCustomNorms.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestCustomNorms.cs
@@ -82,7 +82,7 @@ namespace Lucene.Net.Index
             {
                 Document document = open.Document(i);
                 float expected = Convert.ToSingle(document.Get(FloatTestField));
-                Assert.AreEqual(expected, Number.IntBitsToFloat((int)norms.Get(i)), 0.0f);
+                Assert.AreEqual(expected, Number.Int32BitsToSingle((int)norms.Get(i)), 0.0f);
             }
             open.Dispose();
             dir.Dispose();
@@ -127,7 +127,7 @@ namespace Lucene.Net.Index
         {
             public override long ComputeNorm(FieldInvertState state)
             {
-                return Number.FloatToIntBits(state.Boost);
+                return Number.SingleToInt32Bits(state.Boost);
             }
 
             public override SimWeight ComputeWeight(float queryBoost, CollectionStatistics collectionStats, params TermStatistics[] termStats)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs b/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs
index ee4a8b6..a0ccdce 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDirectoryReader.cs
@@ -822,7 +822,7 @@ namespace Lucene.Net.Index
             // Open reader1
             DirectoryReader r = DirectoryReader.Open(dir);
             AtomicReader r1 = GetOnlySegmentReader(r);
-            FieldCache.Ints ints = FieldCache.DEFAULT.GetInts(r1, "number", false);
+            FieldCache.Ints ints = FieldCache.DEFAULT.GetInt32s(r1, "number", false);
             Assert.AreEqual(17, ints.Get(0));
 
             // Add new segment
@@ -834,7 +834,7 @@ namespace Lucene.Net.Index
             Assert.IsNotNull(r2);
             r.Dispose();
             AtomicReader sub0 = (AtomicReader)r2.Leaves[0].Reader;
-            FieldCache.Ints ints2 = FieldCache.DEFAULT.GetInts(sub0, "number", false);
+            FieldCache.Ints ints2 = FieldCache.DEFAULT.GetInt32s(sub0, "number", false);
             r2.Dispose();
             Assert.IsTrue(ints == ints2);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs b/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
index 599402b..337c152 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
@@ -342,7 +342,7 @@ namespace Lucene.Net.Index
         {
             DocTermOrds dto = new DocTermOrds(r, r.LiveDocs, "field", prefixRef, int.MaxValue, TestUtil.NextInt(Random(), 2, 10));
 
-            FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInts(r, "id", false);
+            FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInt32s(r, "id", false);
             /*
               for(int docID=0;docID<subR.MaxDoc;docID++) {
               System.out.println("  docID=" + docID + " id=" + docIDToID[docID]);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestDocValuesIndexing.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDocValuesIndexing.cs b/src/Lucene.Net.Tests/core/Index/TestDocValuesIndexing.cs
index 063aad9..f46110b 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDocValuesIndexing.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDocValuesIndexing.cs
@@ -123,7 +123,7 @@ namespace Lucene.Net.Index
             w.ForceMerge(1);
             DirectoryReader r = w.Reader;
             w.Dispose();
-            Assert.AreEqual(17, FieldCache.DEFAULT.GetInts(GetOnlySegmentReader(r), "field", false).Get(0));
+            Assert.AreEqual(17, FieldCache.DEFAULT.GetInt32s(GetOnlySegmentReader(r), "field", false).Get(0));
             r.Dispose();
             d.Dispose();
         }
@@ -157,7 +157,7 @@ namespace Lucene.Net.Index
             w.ForceMerge(1);
             DirectoryReader r = w.Reader;
             w.Dispose();
-            Assert.AreEqual(17, FieldCache.DEFAULT.GetInts(GetOnlySegmentReader(r), "field", false).Get(0));
+            Assert.AreEqual(17, FieldCache.DEFAULT.GetInt32s(GetOnlySegmentReader(r), "field", false).Get(0));
             r.Dispose();
             d.Dispose();
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestDocValuesWithThreads.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDocValuesWithThreads.cs b/src/Lucene.Net.Tests/core/Index/TestDocValuesWithThreads.cs
index 8d0ea97..11fa190 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDocValuesWithThreads.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDocValuesWithThreads.cs
@@ -126,7 +126,7 @@ namespace Lucene.Net.Index
                 try
                 {
                     //NumericDocValues ndv = ar.GetNumericDocValues("number");
-                    FieldCache.Longs ndv = FieldCache.DEFAULT.GetLongs(Ar, "number", false);
+                    FieldCache.Longs ndv = FieldCache.DEFAULT.GetInt64s(Ar, "number", false);
                     //BinaryDocValues bdv = ar.GetBinaryDocValues("bytes");
                     BinaryDocValues bdv = FieldCache.DEFAULT.GetTerms(Ar, "bytes", false);
                     SortedDocValues sdv = FieldCache.DEFAULT.GetTermsIndex(Ar, "sorted");
@@ -145,20 +145,20 @@ namespace Lucene.Net.Index
                                 break;
 
                             case 1:
-                                Assert.AreEqual((long)(short)Numbers[docID], FieldCache.DEFAULT.GetShorts(Ar, "number", false).Get(docID));
+                                Assert.AreEqual((long)(short)Numbers[docID], FieldCache.DEFAULT.GetInt16s(Ar, "number", false).Get(docID));
                                 break;
 #pragma warning restore 612, 618
 
                             case 2:
-                                Assert.AreEqual((long)(int)Numbers[docID], FieldCache.DEFAULT.GetInts(Ar, "number", false).Get(docID));
+                                Assert.AreEqual((long)(int)Numbers[docID], FieldCache.DEFAULT.GetInt32s(Ar, "number", false).Get(docID));
                                 break;
 
                             case 3:
-                                Assert.AreEqual((long)Numbers[docID], FieldCache.DEFAULT.GetLongs(Ar, "number", false).Get(docID));
+                                Assert.AreEqual((long)Numbers[docID], FieldCache.DEFAULT.GetInt64s(Ar, "number", false).Get(docID));
                                 break;
 
                             case 4:
-                                Assert.AreEqual(Number.IntBitsToFloat((int)Numbers[docID]), FieldCache.DEFAULT.GetFloats(Ar, "number", false).Get(docID), 0.0f);
+                                Assert.AreEqual(Number.Int32BitsToSingle((int)Numbers[docID]), FieldCache.DEFAULT.GetSingles(Ar, "number", false).Get(docID), 0.0f);
                                 break;
 
                             case 5:

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestIndexInput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIndexInput.cs b/src/Lucene.Net.Tests/core/Index/TestIndexInput.cs
index 71357ac..32cd6a5 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIndexInput.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIndexInput.cs
@@ -53,8 +53,8 @@ namespace Lucene.Net.Index
             for (int i = 0; i < COUNT; i++)
             {
                 int i1 = INTS[i] = random.Next();
-                bdo.WriteVInt(i1);
-                bdo.WriteInt(i1);
+                bdo.WriteVInt32(i1);
+                bdo.WriteInt32(i1);
 
                 long l1;
                 if (Rarely())
@@ -66,8 +66,8 @@ namespace Lucene.Net.Index
                 {
                     l1 = LONGS[i] = TestUtil.NextLong(random, 0, long.MaxValue);
                 }
-                bdo.WriteVLong(l1);
-                bdo.WriteLong(l1);
+                bdo.WriteVInt64(l1);
+                bdo.WriteInt64(l1);
             }
         }
 
@@ -81,14 +81,14 @@ namespace Lucene.Net.Index
 
         private void CheckReads(DataInput @is, Type expectedEx)
         {
-            Assert.AreEqual(128, @is.ReadVInt());
-            Assert.AreEqual(16383, @is.ReadVInt());
-            Assert.AreEqual(16384, @is.ReadVInt());
-            Assert.AreEqual(16385, @is.ReadVInt());
-            Assert.AreEqual(int.MaxValue, @is.ReadVInt());
-            Assert.AreEqual(-1, @is.ReadVInt());
-            Assert.AreEqual((long)int.MaxValue, @is.ReadVLong());
-            Assert.AreEqual(long.MaxValue, @is.ReadVLong());
+            Assert.AreEqual(128, @is.ReadVInt32());
+            Assert.AreEqual(16383, @is.ReadVInt32());
+            Assert.AreEqual(16384, @is.ReadVInt32());
+            Assert.AreEqual(16385, @is.ReadVInt32());
+            Assert.AreEqual(int.MaxValue, @is.ReadVInt32());
+            Assert.AreEqual(-1, @is.ReadVInt32());
+            Assert.AreEqual((long)int.MaxValue, @is.ReadVInt64());
+            Assert.AreEqual(long.MaxValue, @is.ReadVInt64());
             Assert.AreEqual("Lucene", @is.ReadString());
 
             Assert.AreEqual("\u00BF", @is.ReadString());
@@ -106,7 +106,7 @@ namespace Lucene.Net.Index
 
             try
             {
-                @is.ReadVInt();
+                @is.ReadVInt32();
                 Assert.Fail("Should throw " + expectedEx.Name);
             }
             catch (Exception e)
@@ -114,11 +114,11 @@ namespace Lucene.Net.Index
                 Assert.IsTrue(e.Message.StartsWith("Invalid vInt"));
                 Assert.IsTrue(expectedEx.IsInstanceOfType(e));
             }
-            Assert.AreEqual(1, @is.ReadVInt()); // guard value
+            Assert.AreEqual(1, @is.ReadVInt32()); // guard value
 
             try
             {
-                @is.ReadVLong();
+                @is.ReadVInt64();
                 Assert.Fail("Should throw " + expectedEx.Name);
             }
             catch (Exception e)
@@ -126,17 +126,17 @@ namespace Lucene.Net.Index
                 Assert.IsTrue(e.Message.StartsWith("Invalid vLong"));
                 Assert.IsTrue(expectedEx.IsInstanceOfType(e));
             }
-            Assert.AreEqual(1L, @is.ReadVLong()); // guard value
+            Assert.AreEqual(1L, @is.ReadVInt64()); // guard value
         }
 
         private void CheckRandomReads(DataInput @is)
         {
             for (int i = 0; i < COUNT; i++)
             {
-                Assert.AreEqual(INTS[i], @is.ReadVInt());
-                Assert.AreEqual(INTS[i], @is.ReadInt());
-                Assert.AreEqual(LONGS[i], @is.ReadVLong());
-                Assert.AreEqual(LONGS[i], @is.ReadLong());
+                Assert.AreEqual(INTS[i], @is.ReadVInt32());
+                Assert.AreEqual(INTS[i], @is.ReadInt32());
+                Assert.AreEqual(LONGS[i], @is.ReadVInt64());
+                Assert.AreEqual(LONGS[i], @is.ReadInt64());
             }
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestIntBlockPool.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIntBlockPool.cs b/src/Lucene.Net.Tests/core/Index/TestIntBlockPool.cs
index 7a996ca..f81bfa2 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIntBlockPool.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIntBlockPool.cs
@@ -46,7 +46,7 @@ namespace Lucene.Net.Index
                 int num = AtLeast(100);
                 for (int i = 0; i < num; i++)
                 {
-                    writer.WriteInt(i);
+                    writer.WriteInt32(i);
                 }
 
                 int upto = writer.CurrentOffset;
@@ -54,7 +54,7 @@ namespace Lucene.Net.Index
                 reader.Reset(start, upto);
                 for (int i = 0; i < num; i++)
                 {
-                    Assert.AreEqual(i, reader.ReadInt());
+                    Assert.AreEqual(i, reader.ReadInt32());
                 }
                 Assert.IsTrue(reader.EndOfSlice());
                 if (Random().NextBoolean())
@@ -98,7 +98,7 @@ namespace Lucene.Net.Index
                     {
                         writer.Reset(values.End);
                     }
-                    writer.WriteInt(values.NextValue());
+                    writer.WriteInt32(values.NextValue());
                     values.End = writer.CurrentOffset;
                     if (Random().Next(5) == 0)
                     {
@@ -142,13 +142,13 @@ namespace Lucene.Net.Index
                 this.BytesUsed = bytesUsed;
             }
 
-            public override int[] GetIntBlock()
+            public override int[] GetInt32Block()
             {
                 BytesUsed.AddAndGet(m_blockSize * RamUsageEstimator.NUM_BYTES_INT);
                 return new int[m_blockSize];
             }
 
-            public override void RecycleIntBlocks(int[][] blocks, int start, int end)
+            public override void RecycleInt32Blocks(int[][] blocks, int start, int end)
             {
                 BytesUsed.AddAndGet(-((end - start) * m_blockSize * RamUsageEstimator.NUM_BYTES_INT));
             }
@@ -159,7 +159,7 @@ namespace Lucene.Net.Index
             reader.Reset(values.Start, values.End);
             for (int i = 0; i < values.ValueCount; i++)
             {
-                Assert.AreEqual(values.ValueOffset + i, reader.ReadInt());
+                Assert.AreEqual(values.ValueOffset + i, reader.ReadInt32());
             }
             Assert.IsTrue(reader.EndOfSlice());
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs b/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs
index a665696..b52811b 100644
--- a/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestPerSegmentDeletes.cs
@@ -263,7 +263,7 @@ namespace Lucene.Net.Index
                 int docID = docsEnum.DocID;
                 docs.Add(docID);
             }
-            return ArrayUtil.ToIntArray(docs);
+            return ArrayUtil.ToInt32Array(docs);
         }
 
         public class RangeMergePolicy : MergePolicy

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs b/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
index bcb30f3..ddbb79e 100644
--- a/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
@@ -331,7 +331,7 @@ namespace Lucene.Net.Index
                 DocsEnum docs = null;
                 DocsAndPositionsEnum docsAndPositions = null;
                 DocsAndPositionsEnum docsAndPositionsAndOffsets = null;
-                FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInts(sub, "id", false);
+                FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInt32s(sub, "id", false);
                 foreach (string term in terms)
                 {
                     //System.out.println("  term=" + term);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs b/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
index 608fee0..edb37d0 100644
--- a/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
@@ -285,7 +285,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             // NOTE: intentional insanity!!
-            FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInts(SlowCompositeReaderWrapper.Wrap(r), "id", false);
+            FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInt32s(SlowCompositeReaderWrapper.Wrap(r), "id", false);
 
             for (int iter = 0; iter < 10 * RANDOM_MULTIPLIER; iter++)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/JustCompileSearch.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/JustCompileSearch.cs b/src/Lucene.Net.Tests/core/Search/JustCompileSearch.cs
index c610709..d157b3e 100644
--- a/src/Lucene.Net.Tests/core/Search/JustCompileSearch.cs
+++ b/src/Lucene.Net.Tests/core/Search/JustCompileSearch.cs
@@ -96,7 +96,10 @@ namespace Lucene.Net.Search
 
         internal sealed class JustCompileExtendedFieldCacheLongParser : FieldCache.ILongParser
         {
-            public long ParseLong(BytesRef @string)
+            /// <summary>
+            /// NOTE: This was parseLong() in Lucene
+            /// </summary>
+            public long ParseInt64(BytesRef @string)
             {
                 throw new System.NotSupportedException(UNSUPPORTED_MSG);
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestCachingWrapperFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestCachingWrapperFilter.cs b/src/Lucene.Net.Tests/core/Search/TestCachingWrapperFilter.cs
index dc46ed9..2bbb21c 100644
--- a/src/Lucene.Net.Tests/core/Search/TestCachingWrapperFilter.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestCachingWrapperFilter.cs
@@ -333,9 +333,9 @@ namespace Lucene.Net.Search
             // not cacheable:
             AssertDocIdSetCacheable(reader, new QueryWrapperFilter(new TermQuery(new Term("test", "value"))), false);
             // returns default empty docidset, always cacheable:
-            AssertDocIdSetCacheable(reader, NumericRangeFilter.NewIntRange("test", Convert.ToInt32(10000), Convert.ToInt32(-10000), true, true), true);
+            AssertDocIdSetCacheable(reader, NumericRangeFilter.NewInt32Range("test", Convert.ToInt32(10000), Convert.ToInt32(-10000), true, true), true);
             // is cacheable:
-            AssertDocIdSetCacheable(reader, FieldCacheRangeFilter.NewIntRange("test", Convert.ToInt32(10), Convert.ToInt32(20), true, true), true);
+            AssertDocIdSetCacheable(reader, FieldCacheRangeFilter.NewInt32Range("test", Convert.ToInt32(10), Convert.ToInt32(20), true, true), true);
             // a fixedbitset filter is always cacheable
             AssertDocIdSetCacheable(reader, new FilterAnonymousInnerClassHelper3(this), true);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestDocValuesScoring.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestDocValuesScoring.cs b/src/Lucene.Net.Tests/core/Search/TestDocValuesScoring.cs
index c8e9499..ab4dfcb 100644
--- a/src/Lucene.Net.Tests/core/Search/TestDocValuesScoring.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestDocValuesScoring.cs
@@ -184,7 +184,7 @@ namespace Lucene.Net.Search
             public override SimScorer GetSimScorer(SimWeight stats, AtomicReaderContext context)
             {
                 SimScorer sub = Sim.GetSimScorer(stats, context);
-                FieldCache.Floats values = FieldCache.DEFAULT.GetFloats(context.AtomicReader, BoostField, false);
+                FieldCache.Floats values = FieldCache.DEFAULT.GetSingles(context.AtomicReader, BoostField, false);
 
                 return new SimScorerAnonymousInnerClassHelper(this, sub, values);
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f7432173/src/Lucene.Net.Tests/core/Search/TestFieldCache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestFieldCache.cs b/src/Lucene.Net.Tests/core/Search/TestFieldCache.cs
index ba63742..a161aff 100644
--- a/src/Lucene.Net.Tests/core/Search/TestFieldCache.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestFieldCache.cs
@@ -187,7 +187,7 @@ namespace Lucene.Net.Search
                 {
                     cache.InfoStream = bos;
                     cache.GetDoubles(Reader, "theDouble", false);
-                    cache.GetFloats(Reader, "theDouble", false);
+                    cache.GetSingles(Reader, "theDouble", false);
                 }
                 Assert.IsTrue(sb.ToString(/*IOUtils.UTF_8*/).IndexOf("WARNING") != -1);
             }
@@ -209,9 +209,9 @@ namespace Lucene.Net.Search
                 Assert.IsTrue(doubles.Get(i) == (double.MaxValue - i), doubles.Get(i) + " does not equal: " + (double.MaxValue - i));
             }
 
-            FieldCache.Longs longs = cache.GetLongs(Reader, "theLong", Random().NextBoolean());
-            Assert.AreSame(longs, cache.GetLongs(Reader, "theLong", Random().NextBoolean()), "Second request to cache return same array");
-            Assert.AreSame(longs, cache.GetLongs(Reader, "theLong", FieldCache.DEFAULT_LONG_PARSER, Random().NextBoolean()), "Second request with explicit parser return same array");
+            FieldCache.Longs longs = cache.GetInt64s(Reader, "theLong", Random().NextBoolean());
+            Assert.AreSame(longs, cache.GetInt64s(Reader, "theLong", Random().NextBoolean()), "Second request to cache return same array");
+            Assert.AreSame(longs, cache.GetInt64s(Reader, "theLong", FieldCache.DEFAULT_LONG_PARSER, Random().NextBoolean()), "Second request with explicit parser return same array");
             for (int i = 0; i < NUM_DOCS; i++)
             {
                 Assert.IsTrue(longs.Get(i) == (long.MaxValue - i), longs.Get(i) + " does not equal: " + (long.MaxValue - i) + " i=" + i);
@@ -226,26 +226,26 @@ namespace Lucene.Net.Search
                 Assert.IsTrue(bytes.Get(i) == (sbyte)(sbyte.MaxValue - i), bytes.Get(i) + " does not equal: " + (sbyte.MaxValue - i));
             }
 
-            FieldCache.Shorts shorts = cache.GetShorts(Reader, "theShort", Random().NextBoolean());
-            Assert.AreSame(shorts, cache.GetShorts(Reader, "theShort", Random().NextBoolean()), "Second request to cache return same array");
-            Assert.AreSame(shorts, cache.GetShorts(Reader, "theShort", FieldCache.DEFAULT_SHORT_PARSER, Random().NextBoolean()), "Second request with explicit parser return same array");
+            FieldCache.Shorts shorts = cache.GetInt16s(Reader, "theShort", Random().NextBoolean());
+            Assert.AreSame(shorts, cache.GetInt16s(Reader, "theShort", Random().NextBoolean()), "Second request to cache return same array");
+            Assert.AreSame(shorts, cache.GetInt16s(Reader, "theShort", FieldCache.DEFAULT_SHORT_PARSER, Random().NextBoolean()), "Second request with explicit parser return same array");
             for (int i = 0; i < NUM_DOCS; i++)
             {
                 Assert.IsTrue(shorts.Get(i) == (short)(short.MaxValue - i), shorts.Get(i) + " does not equal: " + (short.MaxValue - i));
             }
 #pragma warning restore 612, 618
 
-            FieldCache.Ints ints = cache.GetInts(Reader, "theInt", Random().NextBoolean());
-            Assert.AreSame(ints, cache.GetInts(Reader, "theInt", Random().NextBoolean()), "Second request to cache return same array");
-            Assert.AreSame(ints, cache.GetInts(Reader, "theInt", FieldCache.DEFAULT_INT_PARSER, Random().NextBoolean()), "Second request with explicit parser return same array");
+            FieldCache.Ints ints = cache.GetInt32s(Reader, "theInt", Random().NextBoolean());
+            Assert.AreSame(ints, cache.GetInt32s(Reader, "theInt", Random().NextBoolean()), "Second request to cache return same array");
+            Assert.AreSame(ints, cache.GetInt32s(Reader, "theInt", FieldCache.DEFAULT_INT_PARSER, Random().NextBoolean()), "Second request with explicit parser return same array");
             for (int i = 0; i < NUM_DOCS; i++)
             {
                 Assert.IsTrue(ints.Get(i) == (int.MaxValue - i), ints.Get(i) + " does not equal: " + (int.MaxValue - i));
             }
 
-            FieldCache.Floats floats = cache.GetFloats(Reader, "theFloat", Random().NextBoolean());
-            Assert.AreSame(floats, cache.GetFloats(Reader, "theFloat", Random().NextBoolean()), "Second request to cache return same array");
-            Assert.AreSame(floats, cache.GetFloats(Reader, "theFloat", FieldCache.DEFAULT_FLOAT_PARSER, Random().NextBoolean()), "Second request with explicit parser return same array");
+            FieldCache.Floats floats = cache.GetSingles(Reader, "theFloat", Random().NextBoolean());
+            Assert.AreSame(floats, cache.GetSingles(Reader, "theFloat", Random().NextBoolean()), "Second request to cache return same array");
+            Assert.AreSame(floats, cache.GetSingles(Reader, "theFloat", FieldCache.DEFAULT_FLOAT_PARSER, Random().NextBoolean()), "Second request with explicit parser return same array");
             for (int i = 0; i < NUM_DOCS; i++)
             {
                 Assert.IsTrue(floats.Get(i) == (float.MaxValue - i), floats.Get(i) + " does not equal: " + (float.MaxValue - i));
@@ -435,7 +435,7 @@ namespace Lucene.Net.Search
             Assert.AreEqual(3, cache.GetCacheEntries().Length);
             Assert.IsTrue(bits is Bits.MatchAllBits);
 
-            Ints ints = cache.GetInts(Reader, "sparse", true);
+            Ints ints = cache.GetInt32s(Reader, "sparse", true);
             Assert.AreEqual(6, cache.GetCacheEntries().Length);
             IBits docsWithField = cache.GetDocsWithField(Reader, "sparse");
             Assert.AreEqual(6, cache.GetCacheEntries().Length);
@@ -452,7 +452,7 @@ namespace Lucene.Net.Search
                 }
             }
 
-            Ints numInts = cache.GetInts(Reader, "numInt", Random().NextBoolean());
+            Ints numInts = cache.GetInt32s(Reader, "numInt", Random().NextBoolean());
             docsWithField = cache.GetDocsWithField(Reader, "numInt");
             for (int i = 0; i < docsWithField.Length; i++)
             {
@@ -562,7 +562,7 @@ namespace Lucene.Net.Search
                         }
                         else
                         {
-                            Ints ints = Cache.GetInts(Reader, "sparse", true);
+                            Ints ints = Cache.GetInt32s(Reader, "sparse", true);
                             IBits docsWithField = Cache.GetDocsWithField(Reader, "sparse");
                             for (int i = 0; i < docsWithField.Length; i++)
                             {
@@ -613,7 +613,7 @@ namespace Lucene.Net.Search
             // Binary type: can be retrieved via getTerms()
             try
             {
-                FieldCache.DEFAULT.GetInts(ar, "binary", false);
+                FieldCache.DEFAULT.GetInt32s(ar, "binary", false);
                 Assert.Fail();
             }
 #pragma warning disable 168
@@ -665,7 +665,7 @@ namespace Lucene.Net.Search
             // Sorted type: can be retrieved via getTerms(), getTermsIndex(), getDocTermOrds()
             try
             {
-                FieldCache.DEFAULT.GetInts(ar, "sorted", false);
+                FieldCache.DEFAULT.GetInt32s(ar, "sorted", false);
                 Assert.Fail();
             }
 #pragma warning disable 168
@@ -705,7 +705,7 @@ namespace Lucene.Net.Search
             Assert.IsTrue(bits.Get(0));
 
             // Numeric type: can be retrieved via getInts() and so on
-            Ints numeric = FieldCache.DEFAULT.GetInts(ar, "numeric", false);
+            Ints numeric = FieldCache.DEFAULT.GetInt32s(ar, "numeric", false);
             Assert.AreEqual(42, numeric.Get(0));
 
             try
@@ -760,7 +760,7 @@ namespace Lucene.Net.Search
             {
                 try
                 {
-                    FieldCache.DEFAULT.GetInts(ar, "sortedset", false);
+                    FieldCache.DEFAULT.GetInt32s(ar, "sortedset", false);
                     Assert.Fail();
                 }
 #pragma warning disable 168
@@ -837,17 +837,17 @@ namespace Lucene.Net.Search
             Bytes bytes = cache.GetBytes(ar, "bogusbytes", true);
             Assert.AreEqual(0, bytes.Get(0));
 
-            Shorts shorts = cache.GetShorts(ar, "bogusshorts", true);
+            Shorts shorts = cache.GetInt16s(ar, "bogusshorts", true);
             Assert.AreEqual(0, shorts.Get(0));
 #pragma warning restore 612, 618
 
-            Ints ints = cache.GetInts(ar, "bogusints", true);
+            Ints ints = cache.GetInt32s(ar, "bogusints", true);
             Assert.AreEqual(0, ints.Get(0));
 
-            Longs longs = cache.GetLongs(ar, "boguslongs", true);
+            Longs longs = cache.GetInt64s(ar, "boguslongs", true);
             Assert.AreEqual(0, longs.Get(0));
 
-            Floats floats = cache.GetFloats(ar, "bogusfloats", true);
+            Floats floats = cache.GetSingles(ar, "bogusfloats", true);
             Assert.AreEqual(0, floats.Get(0), 0.0f);
 
             Doubles doubles = cache.GetDoubles(ar, "bogusdoubles", true);
@@ -906,17 +906,17 @@ namespace Lucene.Net.Search
             Bytes bytes = cache.GetBytes(ar, "bogusbytes", true);
             Assert.AreEqual(0, bytes.Get(0));
 
-            Shorts shorts = cache.GetShorts(ar, "bogusshorts", true);
+            Shorts shorts = cache.GetInt16s(ar, "bogusshorts", true);
             Assert.AreEqual(0, shorts.Get(0));
 #pragma warning restore 612, 618
 
-            Ints ints = cache.GetInts(ar, "bogusints", true);
+            Ints ints = cache.GetInt32s(ar, "bogusints", true);
             Assert.AreEqual(0, ints.Get(0));
 
-            Longs longs = cache.GetLongs(ar, "boguslongs", true);
+            Longs longs = cache.GetInt64s(ar, "boguslongs", true);
             Assert.AreEqual(0, longs.Get(0));
 
-            Floats floats = cache.GetFloats(ar, "bogusfloats", true);
+            Floats floats = cache.GetSingles(ar, "bogusfloats", true);
             Assert.AreEqual(0, floats.Get(0), 0.0f);
 
             Doubles doubles = cache.GetDoubles(ar, "bogusdoubles", true);
@@ -989,7 +989,7 @@ namespace Lucene.Net.Search
             }
             iw.ForceMerge(1);
             DirectoryReader reader = iw.Reader;
-            Longs longs = FieldCache.DEFAULT.GetLongs(GetOnlySegmentReader(reader), "f", false);
+            Longs longs = FieldCache.DEFAULT.GetInt64s(GetOnlySegmentReader(reader), "f", false);
             for (int i = 0; i < values.Length; ++i)
             {
                 Assert.AreEqual(values[i], longs.Get(i));
@@ -1043,7 +1043,7 @@ namespace Lucene.Net.Search
             }
             iw.ForceMerge(1);
             DirectoryReader reader = iw.Reader;
-            Ints ints = FieldCache.DEFAULT.GetInts(GetOnlySegmentReader(reader), "f", false);
+            Ints ints = FieldCache.DEFAULT.GetInt32s(GetOnlySegmentReader(reader), "f", false);
             for (int i = 0; i < values.Length; ++i)
             {
                 Assert.AreEqual(values[i], ints.Get(i));


Mime
View raw message