lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [22/53] [abbrv] lucenenet git commit: Lucene.Net.Core: Renamed all type-derived classes and interfaces from Short, Int, Long, and Float to match CLR types Int16, Int32, Int64, and Single, respectively.
Date Wed, 08 Feb 2017 14:32:01 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestBinaryDocValuesUpdates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestBinaryDocValuesUpdates.cs b/src/Lucene.Net.Tests/core/Index/TestBinaryDocValuesUpdates.cs
index 266b436..a9629fb 100644
--- a/src/Lucene.Net.Tests/core/Index/TestBinaryDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestBinaryDocValuesUpdates.cs
@@ -1230,7 +1230,7 @@ namespace Lucene.Net.Index
             }
 
             CountdownEvent done = new CountdownEvent(numThreads);
-            AtomicInteger numUpdates = new AtomicInteger(AtLeast(100));
+            AtomicInt32 numUpdates = new AtomicInt32(AtLeast(100));
 
             // same thread updates a field as well as reopens
             ThreadClass[] threads = new ThreadClass[numThreads];
@@ -1285,11 +1285,11 @@ namespace Lucene.Net.Index
             private IndexWriter Writer;
             private int NumDocs;
             private CountdownEvent Done;
-            private AtomicInteger NumUpdates;
+            private AtomicInt32 NumUpdates;
             private string f;
             private string Cf;
 
-            public ThreadAnonymousInnerClassHelper(TestBinaryDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInteger numUpdates, string f, string cf)
+            public ThreadAnonymousInnerClassHelper(TestBinaryDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
                 : base(str)
             {
                 this.OuterInstance = outerInstance;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestConcurrentMergeScheduler.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestConcurrentMergeScheduler.cs b/src/Lucene.Net.Tests/core/Index/TestConcurrentMergeScheduler.cs
index 1cde70b..da0395e 100644
--- a/src/Lucene.Net.Tests/core/Index/TestConcurrentMergeScheduler.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestConcurrentMergeScheduler.cs
@@ -291,7 +291,7 @@ namespace Lucene.Net.Index
             int maxMergeCount = TestUtil.NextInt(Random(), 1, 5);
             int maxMergeThreads = TestUtil.NextInt(Random(), 1, maxMergeCount);
             CountdownEvent enoughMergesWaiting = new CountdownEvent(maxMergeCount);
-            AtomicInteger runningMergeCount = new AtomicInteger(0);
+            AtomicInt32 runningMergeCount = new AtomicInt32(0);
             AtomicBoolean failed = new AtomicBoolean();
 
             if (VERBOSE)
@@ -329,10 +329,10 @@ namespace Lucene.Net.Index
 
             private int maxMergeCount;
             private CountdownEvent EnoughMergesWaiting;
-            private AtomicInteger RunningMergeCount;
+            private AtomicInt32 RunningMergeCount;
             private AtomicBoolean Failed;
 
-            public ConcurrentMergeSchedulerAnonymousInnerClassHelper(TestConcurrentMergeScheduler outerInstance, int maxMergeCount, CountdownEvent enoughMergesWaiting, AtomicInteger runningMergeCount, AtomicBoolean failed)
+            public ConcurrentMergeSchedulerAnonymousInnerClassHelper(TestConcurrentMergeScheduler outerInstance, int maxMergeCount, CountdownEvent enoughMergesWaiting, AtomicInt32 runningMergeCount, AtomicBoolean failed)
             {
                 this.OuterInstance = outerInstance;
                 this.maxMergeCount = maxMergeCount;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/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 a0ccdce..62fd676 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.GetInt32s(r1, "number", false);
+            FieldCache.Int32s 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.GetInt32s(sub0, "number", false);
+            FieldCache.Int32s ints2 = FieldCache.DEFAULT.GetInt32s(sub0, "number", false);
             r2.Dispose();
             Assert.IsTrue(ints == ints2);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/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 337c152..1ea4d2b 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDocTermOrds.cs
@@ -32,7 +32,7 @@ namespace Lucene.Net.Index
     using Directory = Lucene.Net.Store.Directory;
     using Document = Documents.Document;
     using Field = Field;
-    using IntField = IntField;
+    using Int32Field = Int32Field;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
     using MockAnalyzer = Lucene.Net.Analysis.MockAnalyzer;
     using PostingsFormat = Lucene.Net.Codecs.PostingsFormat;
@@ -134,7 +134,7 @@ namespace Lucene.Net.Index
             {
                 Document doc = new Document();
 
-                doc.Add(new IntField("id", id, Field.Store.NO));
+                doc.Add(new Int32Field("id", id, Field.Store.NO));
 
                 int termCount = TestUtil.NextInt(Random(), 0, 20 * RANDOM_MULTIPLIER);
                 while (ordsForDocSet.Count < termCount)
@@ -251,7 +251,7 @@ namespace Lucene.Net.Index
             {
                 Document doc = new Document();
 
-                doc.Add(new IntField("id", id, Field.Store.NO));
+                doc.Add(new Int32Field("id", id, Field.Store.NO));
 
                 int termCount = TestUtil.NextInt(Random(), 0, 20 * RANDOM_MULTIPLIER);
                 while (ordsForDocSet.Count < termCount)
@@ -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.GetInt32s(r, "id", false);
+            FieldCache.Int32s 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/8b7f4185/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 11fa190..40cc370 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.GetInt64s(Ar, "number", false);
+                    FieldCache.Int64s 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");

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestDocumentsWriterDeleteQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestDocumentsWriterDeleteQueue.cs b/src/Lucene.Net.Tests/core/Index/TestDocumentsWriterDeleteQueue.cs
index f1ba611..b238062 100644
--- a/src/Lucene.Net.Tests/core/Index/TestDocumentsWriterDeleteQueue.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestDocumentsWriterDeleteQueue.cs
@@ -219,7 +219,7 @@ namespace Lucene.Net.Index
                 uniqueValues.Add(new Term("id", ids[i].ToString()));
             }
             CountdownEvent latch = new CountdownEvent(1);
-            AtomicInteger index = new AtomicInteger(0);
+            AtomicInt32 index = new AtomicInt32(0);
             int numThreads = 2 + Random().Next(5);
             UpdateThread[] threads = new UpdateThread[numThreads];
             for (int i = 0; i < threads.Length; i++)
@@ -257,13 +257,13 @@ namespace Lucene.Net.Index
         private class UpdateThread : ThreadClass
         {
             internal readonly DocumentsWriterDeleteQueue Queue;
-            internal readonly AtomicInteger Index;
+            internal readonly AtomicInt32 Index;
             internal readonly int?[] Ids;
             internal readonly DeleteSlice Slice;
             internal readonly BufferedUpdates Deletes;
             internal readonly CountdownEvent Latch;
 
-            protected internal UpdateThread(DocumentsWriterDeleteQueue queue, AtomicInteger index, int?[] ids, CountdownEvent latch)
+            protected internal UpdateThread(DocumentsWriterDeleteQueue queue, AtomicInt32 index, int?[] ids, CountdownEvent latch)
             {
                 this.Queue = queue;
                 this.Index = index;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestFlushByRamOrCountsPolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestFlushByRamOrCountsPolicy.cs b/src/Lucene.Net.Tests/core/Index/TestFlushByRamOrCountsPolicy.cs
index 9450356..001f9e9 100644
--- a/src/Lucene.Net.Tests/core/Index/TestFlushByRamOrCountsPolicy.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestFlushByRamOrCountsPolicy.cs
@@ -69,7 +69,7 @@ namespace Lucene.Net.Index
         protected internal virtual void RunFlushByRam(int numThreads, double maxRamMB, bool ensureNotStalled)
         {
             int numDocumentsToIndex = 10 + AtLeast(30);
-            AtomicInteger numDocs = new AtomicInteger(numDocumentsToIndex);
+            AtomicInt32 numDocs = new AtomicInt32(numDocumentsToIndex);
             Directory dir = NewDirectory();
             MockDefaultFlushPolicy flushPolicy = new MockDefaultFlushPolicy();
             MockAnalyzer analyzer = new MockAnalyzer(Random());
@@ -130,7 +130,7 @@ namespace Lucene.Net.Index
             {
 
                 int numDocumentsToIndex = 50 + AtLeast(30);
-                AtomicInteger numDocs = new AtomicInteger(numDocumentsToIndex);
+                AtomicInt32 numDocs = new AtomicInt32(numDocumentsToIndex);
                 Directory dir = NewDirectory();
                 MockDefaultFlushPolicy flushPolicy = new MockDefaultFlushPolicy();
                 IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())).SetFlushPolicy(flushPolicy);
@@ -179,7 +179,7 @@ namespace Lucene.Net.Index
         {
             int numThreads = 1 + Random().Next(8);
             int numDocumentsToIndex = 50 + AtLeast(70);
-            AtomicInteger numDocs = new AtomicInteger(numDocumentsToIndex);
+            AtomicInt32 numDocs = new AtomicInt32(numDocumentsToIndex);
             Directory dir = NewDirectory();
             IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random()));
             MockDefaultFlushPolicy flushPolicy = new MockDefaultFlushPolicy();
@@ -244,7 +244,7 @@ namespace Lucene.Net.Index
             int numDocumentsToIndex = 50 + Random().Next(50);
             for (int i = 0; i < numThreads.Length; i++)
             {
-                AtomicInteger numDocs = new AtomicInteger(numDocumentsToIndex);
+                AtomicInt32 numDocs = new AtomicInt32(numDocumentsToIndex);
                 MockDirectoryWrapper dir = NewMockDirectory();
                 // mock a very slow harddisk sometimes here so that flushing is very slow
                 dir.Throttling = MockDirectoryWrapper.Throttling_e.SOMETIMES;
@@ -312,10 +312,10 @@ namespace Lucene.Net.Index
             internal IndexWriter Writer;
             internal LiveIndexWriterConfig Iwc;
             internal LineFileDocs Docs;
-            internal AtomicInteger PendingDocs;
+            internal AtomicInt32 PendingDocs;
             internal readonly bool DoRandomCommit;
 
-            public IndexThread(TestFlushByRamOrCountsPolicy outerInstance, AtomicInteger pendingDocs, int numThreads, IndexWriter writer, LineFileDocs docs, bool doRandomCommit)
+            public IndexThread(TestFlushByRamOrCountsPolicy outerInstance, AtomicInt32 pendingDocs, int numThreads, IndexWriter writer, LineFileDocs docs, bool doRandomCommit)
             {
                 this.OuterInstance = outerInstance;
                 this.PendingDocs = pendingDocs;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestForceMergeForever.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestForceMergeForever.cs b/src/Lucene.Net.Tests/core/Index/TestForceMergeForever.cs
index 720a6e1..12145b1 100644
--- a/src/Lucene.Net.Tests/core/Index/TestForceMergeForever.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestForceMergeForever.cs
@@ -34,7 +34,7 @@ namespace Lucene.Net.Index
         // Just counts how many merges are done
         private class MyIndexWriter : IndexWriter
         {
-            internal AtomicInteger MergeCount = new AtomicInteger();
+            internal AtomicInt32 MergeCount = new AtomicInt32();
             internal bool First;
 
             public MyIndexWriter(Directory dir, IndexWriterConfig conf)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestIndexReaderClose.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIndexReaderClose.cs b/src/Lucene.Net.Tests/core/Index/TestIndexReaderClose.cs
index 6767adf..9c96ced 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIndexReaderClose.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIndexReaderClose.cs
@@ -49,7 +49,7 @@ namespace Lucene.Net.Index
                 FilterAtomicReader reader = new FilterAtomicReaderAnonymousInnerClassHelper(this, wrap, throwOnClose);
                 IList<IndexReader.IReaderClosedListener> listeners = new List<IndexReader.IReaderClosedListener>();
                 int listenerCount = Random().Next(20);
-                AtomicInteger count = new AtomicInteger();
+                AtomicInt32 count = new AtomicInt32();
                 bool faultySet = false;
                 for (int i = 0; i < listenerCount; i++)
                 {
@@ -131,9 +131,9 @@ namespace Lucene.Net.Index
 
         private sealed class CountListener : IndexReader.IReaderClosedListener
         {
-            internal readonly AtomicInteger Count;
+            internal readonly AtomicInt32 Count;
 
-            public CountListener(AtomicInteger count)
+            public CountListener(AtomicInt32 count)
             {
                 this.Count = count;
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs b/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs
index b2d5535..de2d69c 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIndexWriter.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Index
     using MockDirectoryWrapper = Lucene.Net.Store.MockDirectoryWrapper;
     using NoLockFactory = Lucene.Net.Store.NoLockFactory;
     using NumericDocValuesField = NumericDocValuesField;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using PhraseQuery = Lucene.Net.Search.PhraseQuery;
     using RAMDirectory = Lucene.Net.Store.RAMDirectory;
     using ScoreDoc = Lucene.Net.Search.ScoreDoc;
@@ -2024,7 +2024,7 @@ namespace Lucene.Net.Index
             w.Dispose();
             Assert.AreEqual(1, reader.DocFreq(new Term("content", bigTerm)));
 
-            SortedDocValues dti = FieldCache.DEFAULT.GetTermsIndex(SlowCompositeReaderWrapper.Wrap(reader), "content", (float)Random().NextDouble() * PackedInts.FAST);
+            SortedDocValues dti = FieldCache.DEFAULT.GetTermsIndex(SlowCompositeReaderWrapper.Wrap(reader), "content", (float)Random().NextDouble() * PackedInt32s.FAST);
             Assert.AreEqual(4, dti.ValueCount);
             BytesRef br = new BytesRef();
             dti.LookupOrd(2, br);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestIndexWriterDelete.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIndexWriterDelete.cs b/src/Lucene.Net.Tests/core/Index/TestIndexWriterDelete.cs
index 1fb48ea..6ac040a 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIndexWriterDelete.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIndexWriterDelete.cs
@@ -1304,7 +1304,7 @@ namespace Lucene.Net.Index
             Directory dir = NewDirectory();
             // Cannot use RandomIndexWriter because we don't want to
             // ever call commit() for this test:
-            AtomicInteger docsInSegment = new AtomicInteger();
+            AtomicInt32 docsInSegment = new AtomicInt32();
             AtomicBoolean closing = new AtomicBoolean();
             AtomicBoolean sawAfterFlush = new AtomicBoolean();
             IndexWriter w = new IndexWriterAnonymousInnerClassHelper(this, dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())).SetRAMBufferSizeMB(0.5).SetMaxBufferedDocs(-1).SetMergePolicy(NoMergePolicy.NO_COMPOUND_FILES).SetReaderPooling(false), docsInSegment, closing, sawAfterFlush);
@@ -1346,11 +1346,11 @@ namespace Lucene.Net.Index
         {
             private readonly TestIndexWriterDelete OuterInstance;
 
-            private AtomicInteger DocsInSegment;
+            private AtomicInt32 DocsInSegment;
             private AtomicBoolean Closing;
             private AtomicBoolean SawAfterFlush;
 
-            public IndexWriterAnonymousInnerClassHelper(TestIndexWriterDelete outerInstance, Directory dir, IndexWriterConfig setReaderPooling, AtomicInteger docsInSegment, AtomicBoolean closing, AtomicBoolean sawAfterFlush)
+            public IndexWriterAnonymousInnerClassHelper(TestIndexWriterDelete outerInstance, Directory dir, IndexWriterConfig setReaderPooling, AtomicInt32 docsInSegment, AtomicBoolean closing, AtomicBoolean sawAfterFlush)
                 : base(dir, setReaderPooling)
             {
                 this.OuterInstance = outerInstance;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestIndexWriterReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestIndexWriterReader.cs b/src/Lucene.Net.Tests/core/Index/TestIndexWriterReader.cs
index 4748ea0..9207b98 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIndexWriterReader.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIndexWriterReader.cs
@@ -473,8 +473,8 @@ namespace Lucene.Net.Index
             internal readonly IList<Exception> Failures = new List<Exception>();
             internal IndexReader[] Readers;
             internal bool DidClose = false;
-            internal AtomicInteger Count = new AtomicInteger(0);
-            internal AtomicInteger NumaddIndexes = new AtomicInteger(0);
+            internal AtomicInt32 Count = new AtomicInt32(0);
+            internal AtomicInt32 NumaddIndexes = new AtomicInt32(0);
 
             public AddDirectoriesThreads(TestIndexWriterReader outerInstance, int numDirs, IndexWriter mainWriter)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/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 f81bfa2..b74d541 100644
--- a/src/Lucene.Net.Tests/core/Index/TestIntBlockPool.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestIntBlockPool.cs
@@ -23,12 +23,12 @@ namespace Lucene.Net.Index
              */
 
     using Counter = Lucene.Net.Util.Counter;
-    using IntBlockPool = Lucene.Net.Util.IntBlockPool;
+    using Int32BlockPool = Lucene.Net.Util.Int32BlockPool;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
     using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator;
 
     /// <summary>
-    /// tests basic <seealso cref="IntBlockPool"/> functionality
+    /// tests basic <seealso cref="Int32BlockPool"/> functionality
     /// </summary>
     [TestFixture]
     public class TestIntBlockPool : LuceneTestCase
@@ -37,11 +37,11 @@ namespace Lucene.Net.Index
         public virtual void TestSingleWriterReader()
         {
             Counter bytesUsed = Util.Counter.NewCounter();
-            IntBlockPool pool = new IntBlockPool(new ByteTrackingAllocator(bytesUsed));
+            Int32BlockPool pool = new Int32BlockPool(new ByteTrackingAllocator(bytesUsed));
 
             for (int j = 0; j < 2; j++)
             {
-                IntBlockPool.SliceWriter writer = new IntBlockPool.SliceWriter(pool);
+                Int32BlockPool.SliceWriter writer = new Int32BlockPool.SliceWriter(pool);
                 int start = writer.StartNewSlice();
                 int num = AtLeast(100);
                 for (int i = 0; i < num; i++)
@@ -50,7 +50,7 @@ namespace Lucene.Net.Index
                 }
 
                 int upto = writer.CurrentOffset;
-                IntBlockPool.SliceReader reader = new IntBlockPool.SliceReader(pool);
+                Int32BlockPool.SliceReader reader = new Int32BlockPool.SliceReader(pool);
                 reader.Reset(start, upto);
                 for (int i = 0; i < num; i++)
                 {
@@ -65,7 +65,7 @@ namespace Lucene.Net.Index
                 else
                 {
                     pool.Reset(true, true);
-                    Assert.AreEqual(IntBlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT, bytesUsed.Get());
+                    Assert.AreEqual(Int32BlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT, bytesUsed.Get());
                 }
             }
         }
@@ -74,7 +74,7 @@ namespace Lucene.Net.Index
         public virtual void TestMultipleWriterReader()
         {
             Counter bytesUsed = Util.Counter.NewCounter();
-            IntBlockPool pool = new IntBlockPool(new ByteTrackingAllocator(bytesUsed));
+            Int32BlockPool pool = new Int32BlockPool(new ByteTrackingAllocator(bytesUsed));
             for (int j = 0; j < 2; j++)
             {
                 IList<StartEndAndValues> holders = new List<StartEndAndValues>();
@@ -83,8 +83,8 @@ namespace Lucene.Net.Index
                 {
                     holders.Add(new StartEndAndValues(Random().Next(1000)));
                 }
-                IntBlockPool.SliceWriter writer = new IntBlockPool.SliceWriter(pool);
-                IntBlockPool.SliceReader reader = new IntBlockPool.SliceReader(pool);
+                Int32BlockPool.SliceWriter writer = new Int32BlockPool.SliceWriter(pool);
+                Int32BlockPool.SliceReader reader = new Int32BlockPool.SliceReader(pool);
 
                 int numValuesToWrite = AtLeast(10000);
                 for (int i = 0; i < numValuesToWrite; i++)
@@ -122,17 +122,17 @@ namespace Lucene.Net.Index
                 else
                 {
                     pool.Reset(true, true);
-                    Assert.AreEqual(IntBlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT, bytesUsed.Get());
+                    Assert.AreEqual(Int32BlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT, bytesUsed.Get());
                 }
             }
         }
 
-        private class ByteTrackingAllocator : IntBlockPool.Allocator
+        private class ByteTrackingAllocator : Int32BlockPool.Allocator
         {
             internal readonly Counter BytesUsed;
 
             public ByteTrackingAllocator(Counter bytesUsed)
-                : this(IntBlockPool.INT_BLOCK_SIZE, bytesUsed)
+                : this(Int32BlockPool.INT_BLOCK_SIZE, bytesUsed)
             {
             }
 
@@ -154,7 +154,7 @@ namespace Lucene.Net.Index
             }
         }
 
-        private void AssertReader(IntBlockPool.SliceReader reader, StartEndAndValues values)
+        private void AssertReader(Int32BlockPool.SliceReader reader, StartEndAndValues values)
         {
             reader.Reset(values.Start, values.End);
             for (int i = 0; i < values.ValueCount; i++)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestMixedDocValuesUpdates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestMixedDocValuesUpdates.cs b/src/Lucene.Net.Tests/core/Index/TestMixedDocValuesUpdates.cs
index b02aa25..4a3741d 100644
--- a/src/Lucene.Net.Tests/core/Index/TestMixedDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestMixedDocValuesUpdates.cs
@@ -266,7 +266,7 @@ namespace Lucene.Net.Index
             }
 
             CountdownEvent done = new CountdownEvent(numThreads);
-            AtomicInteger numUpdates = new AtomicInteger(AtLeast(100));
+            AtomicInt32 numUpdates = new AtomicInt32(AtLeast(100));
 
             // same thread updates a field as well as reopens
             ThreadClass[] threads = new ThreadClass[numThreads];
@@ -326,11 +326,11 @@ namespace Lucene.Net.Index
             private IndexWriter Writer;
             private int NumDocs;
             private CountdownEvent Done;
-            private AtomicInteger NumUpdates;
+            private AtomicInt32 NumUpdates;
             private string f;
             private string Cf;
 
-            public ThreadAnonymousInnerClassHelper(TestMixedDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInteger numUpdates, string f, string cf)
+            public ThreadAnonymousInnerClassHelper(TestMixedDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
                 : base(str)
             {
                 this.OuterInstance = outerInstance;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestMultiLevelSkipList.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestMultiLevelSkipList.cs b/src/Lucene.Net.Tests/core/Index/TestMultiLevelSkipList.cs
index 70a459e..49456ed 100644
--- a/src/Lucene.Net.Tests/core/Index/TestMultiLevelSkipList.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestMultiLevelSkipList.cs
@@ -125,7 +125,7 @@ namespace Lucene.Net.Index
 
         private class PayloadAnalyzer : Analyzer
         {
-            internal readonly AtomicInteger PayloadCount = new AtomicInteger(-1);
+            internal readonly AtomicInt32 PayloadCount = new AtomicInt32(-1);
 
             protected internal override TokenStreamComponents CreateComponents(string fieldName, TextReader reader)
             {
@@ -137,9 +137,9 @@ namespace Lucene.Net.Index
         private class PayloadFilter : TokenFilter
         {
             internal IPayloadAttribute PayloadAtt;
-            internal AtomicInteger PayloadCount;
+            internal AtomicInt32 PayloadCount;
 
-            protected internal PayloadFilter(AtomicInteger payloadCount, TokenStream input)
+            protected internal PayloadFilter(AtomicInt32 payloadCount, TokenStream input)
                 : base(input)
             {
                 this.PayloadCount = payloadCount;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestNRTReaderWithThreads.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestNRTReaderWithThreads.cs b/src/Lucene.Net.Tests/core/Index/TestNRTReaderWithThreads.cs
index bcf2260..918b5b5 100644
--- a/src/Lucene.Net.Tests/core/Index/TestNRTReaderWithThreads.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestNRTReaderWithThreads.cs
@@ -32,7 +32,7 @@ namespace Lucene.Net.Index
     [TestFixture]
     public class TestNRTReaderWithThreads : LuceneTestCase
     {
-        internal AtomicInteger Seq = new AtomicInteger(1);
+        internal AtomicInt32 Seq = new AtomicInt32(1);
         [Test]
         public virtual void TestIndexing()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs b/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs
index 4bff40a..cdef49a 100644
--- a/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestNumericDocValuesUpdates.cs
@@ -1149,7 +1149,7 @@ namespace Lucene.Net.Index
             }
 
             CountdownEvent done = new CountdownEvent(numThreads);
-            AtomicInteger numUpdates = new AtomicInteger(AtLeast(100));
+            AtomicInt32 numUpdates = new AtomicInt32(AtLeast(100));
 
             // same thread updates a field as well as reopens
             ThreadClass[] threads = new ThreadClass[numThreads];
@@ -1203,11 +1203,11 @@ namespace Lucene.Net.Index
             private IndexWriter Writer;
             private int NumDocs;
             private CountdownEvent Done;
-            private AtomicInteger NumUpdates;
+            private AtomicInt32 NumUpdates;
             private string f;
             private string Cf;
 
-            public ThreadAnonymousInnerClassHelper(TestNumericDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInteger numUpdates, string f, string cf)
+            public ThreadAnonymousInnerClassHelper(TestNumericDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
                 : base(str)
             {
                 this.OuterInstance = outerInstance;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/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 ddbb79e..3d05e9a 100644
--- a/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestPostingsOffsets.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Index
     using English = Lucene.Net.Util.English;
     using Field = Field;
     using FieldType = FieldType;
-    using IntField = IntField;
+    using Int32Field = Int32Field;
     using IOUtils = Lucene.Net.Util.IOUtils;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
     using MockAnalyzer = Lucene.Net.Analysis.MockAnalyzer;
@@ -262,7 +262,7 @@ namespace Lucene.Net.Index
             for (int docCount = 0; docCount < numDocs; docCount++)
             {
                 Document doc = new Document();
-                doc.Add(new IntField("id", docCount, Field.Store.NO));
+                doc.Add(new Int32Field("id", docCount, Field.Store.NO));
                 IList<Token> tokens = new List<Token>();
                 int numTokens = AtLeast(100);
                 //final int numTokens = AtLeast(20);
@@ -331,7 +331,7 @@ namespace Lucene.Net.Index
                 DocsEnum docs = null;
                 DocsAndPositionsEnum docsAndPositions = null;
                 DocsAndPositionsEnum docsAndPositionsAndOffsets = null;
-                FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInt32s(sub, "id", false);
+                FieldCache.Int32s 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/8b7f4185/src/Lucene.Net.Tests/core/Index/TestStressNRT.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Index/TestStressNRT.cs b/src/Lucene.Net.Tests/core/Index/TestStressNRT.cs
index e3d4d7b..b9d52cb 100644
--- a/src/Lucene.Net.Tests/core/Index/TestStressNRT.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestStressNRT.cs
@@ -84,7 +84,7 @@ namespace Lucene.Net.Index
             bool tombstones = Random().NextBoolean();
 
             // query variables
-            AtomicLong operations = new AtomicLong(AtLeast(10000)); // number of query operations to perform in total
+            AtomicInt64 operations = new AtomicInt64(AtLeast(10000)); // number of query operations to perform in total
 
             int nReadThreads = TestUtil.NextInt(Random(), 1, TEST_NIGHTLY ? 10 : 5);
             InitModel(ndocs);
@@ -108,7 +108,7 @@ namespace Lucene.Net.Index
                 Console.WriteLine("\n");
             }
 
-            AtomicInteger numCommitting = new AtomicInteger();
+            AtomicInt32 numCommitting = new AtomicInt32();
 
             IList<ThreadClass> threads = new List<ThreadClass>();
 
@@ -163,12 +163,12 @@ namespace Lucene.Net.Index
             private int Ndocs;
             private int MaxConcurrentCommits;
             private bool Tombstones;
-            private AtomicLong Operations;
+            private AtomicInt64 Operations;
             private FieldType StoredOnlyType;
-            private AtomicInteger NumCommitting;
+            private AtomicInt32 NumCommitting;
             private RandomIndexWriter Writer;
 
-            public ThreadAnonymousInnerClassHelper(TestStressNRT outerInstance, string str, int commitPercent, int softCommitPercent, int deletePercent, int deleteByQueryPercent, int ndocs, int maxConcurrentCommits, bool tombstones, AtomicLong operations, FieldType storedOnlyType, AtomicInteger numCommitting, RandomIndexWriter writer)
+            public ThreadAnonymousInnerClassHelper(TestStressNRT outerInstance, string str, int commitPercent, int softCommitPercent, int deletePercent, int deleteByQueryPercent, int ndocs, int maxConcurrentCommits, bool tombstones, AtomicInt64 operations, FieldType storedOnlyType, AtomicInt32 numCommitting, RandomIndexWriter writer)
                 : base(str)
             {
                 this.OuterInstance = outerInstance;
@@ -411,9 +411,9 @@ namespace Lucene.Net.Index
 
             private int Ndocs;
             private bool Tombstones;
-            private AtomicLong Operations;
+            private AtomicInt64 Operations;
 
-            public ThreadAnonymousInnerClassHelper2(TestStressNRT outerInstance, string str, int ndocs, bool tombstones, AtomicLong operations)
+            public ThreadAnonymousInnerClassHelper2(TestStressNRT outerInstance, string str, int ndocs, bool tombstones, AtomicInt64 operations)
                 : base(str)
             {
                 this.OuterInstance = outerInstance;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/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 edb37d0..54f2747 100644
--- a/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
+++ b/src/Lucene.Net.Tests/core/Index/TestTermsEnum.cs
@@ -17,7 +17,7 @@ namespace Lucene.Net.Index
     using DocIdSetIterator = Lucene.Net.Search.DocIdSetIterator;
     using Document = Documents.Document;
     using Field = Field;
-    using IntField = IntField;
+    using Int32Field = Int32Field;
     using LineFileDocs = Lucene.Net.Util.LineFileDocs;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
@@ -201,7 +201,7 @@ namespace Lucene.Net.Index
         private void AddDoc(RandomIndexWriter w, ICollection<string> terms, IDictionary<BytesRef, int?> termToID, int id)
         {
             Document doc = new Document();
-            doc.Add(new IntField("id", id, Field.Store.NO));
+            doc.Add(new Int32Field("id", id, Field.Store.NO));
             if (VERBOSE)
             {
                 Console.WriteLine("TEST: addDoc id:" + id + " terms=" + terms);
@@ -285,7 +285,7 @@ namespace Lucene.Net.Index
             w.Dispose();
 
             // NOTE: intentional insanity!!
-            FieldCache.Ints docIDToID = FieldCache.DEFAULT.GetInt32s(SlowCompositeReaderWrapper.Wrap(r), "id", false);
+            FieldCache.Int32s 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/8b7f4185/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 d157b3e..272d338 100644
--- a/src/Lucene.Net.Tests/core/Search/JustCompileSearch.cs
+++ b/src/Lucene.Net.Tests/core/Search/JustCompileSearch.cs
@@ -94,7 +94,7 @@ namespace Lucene.Net.Search
             }
         }
 
-        internal sealed class JustCompileExtendedFieldCacheLongParser : FieldCache.ILongParser
+        internal sealed class JustCompileExtendedFieldCacheLongParser : FieldCache.IInt64Parser
         {
             /// <summary>
             /// NOTE: This was parseLong() in Lucene

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestBooleanOr.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestBooleanOr.cs b/src/Lucene.Net.Tests/core/Search/TestBooleanOr.cs
index c57666b..ba4f218 100644
--- a/src/Lucene.Net.Tests/core/Search/TestBooleanOr.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestBooleanOr.cs
@@ -199,7 +199,7 @@ namespace Lucene.Net.Search
             BulkScorer scorer = w.GetBulkScorer(s.IndexReader.Leaves[0], false, null);
 
             FixedBitSet hits = new FixedBitSet(docCount);
-            AtomicInteger end = new AtomicInteger();
+            AtomicInt32 end = new AtomicInt32();
             ICollector c = new CollectorAnonymousInnerClassHelper(this, scorer, hits, end);
 
             while (end.Get() < docCount)
@@ -220,9 +220,9 @@ namespace Lucene.Net.Search
 
             private BulkScorer scorer;
             private FixedBitSet Hits;
-            private AtomicInteger End;
+            private AtomicInt32 End;
 
-            public CollectorAnonymousInnerClassHelper(TestBooleanOr outerInstance, BulkScorer scorer, FixedBitSet hits, AtomicInteger end)
+            public CollectorAnonymousInnerClassHelper(TestBooleanOr outerInstance, BulkScorer scorer, FixedBitSet hits, AtomicInt32 end)
             {
                 this.OuterInstance = outerInstance;
                 this.scorer = scorer;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/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 ab4dfcb..ebd3e72 100644
--- a/src/Lucene.Net.Tests/core/Search/TestDocValuesScoring.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestDocValuesScoring.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Search
     using Document = Documents.Document;
     using Field = Field;
     using FieldInvertState = Lucene.Net.Index.FieldInvertState;
-    using FloatDocValuesField = FloatDocValuesField;
+    using SingleDocValuesField = SingleDocValuesField;
     using IndexReader = Lucene.Net.Index.IndexReader;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
     using PerFieldSimilarityWrapper = Lucene.Net.Search.Similarities.PerFieldSimilarityWrapper;
@@ -56,7 +56,7 @@ namespace Lucene.Net.Search
             Document doc = new Document();
             Field field = NewTextField("foo", "", Field.Store.NO);
             doc.Add(field);
-            Field dvField = new FloatDocValuesField("foo_boost", 0.0F);
+            Field dvField = new SingleDocValuesField("foo_boost", 0.0F);
             doc.Add(dvField);
             Field field2 = NewTextField("bar", "", Field.Store.NO);
             doc.Add(field2);
@@ -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.GetSingles(context.AtomicReader, BoostField, false);
+                FieldCache.Singles values = FieldCache.DEFAULT.GetSingles(context.AtomicReader, BoostField, false);
 
                 return new SimScorerAnonymousInnerClassHelper(this, sub, values);
             }
@@ -194,9 +194,9 @@ namespace Lucene.Net.Search
                 private readonly BoostingSimilarity OuterInstance;
 
                 private SimScorer Sub;
-                private FieldCache.Floats Values;
+                private FieldCache.Singles Values;
 
-                public SimScorerAnonymousInnerClassHelper(BoostingSimilarity outerInstance, SimScorer sub, FieldCache.Floats values)
+                public SimScorerAnonymousInnerClassHelper(BoostingSimilarity outerInstance, SimScorer sub, FieldCache.Singles values)
                 {
                     this.OuterInstance = outerInstance;
                     this.Sub = sub;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/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 a161aff..918a693 100644
--- a/src/Lucene.Net.Tests/core/Search/TestFieldCache.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestFieldCache.cs
@@ -33,8 +33,8 @@ namespace Lucene.Net.Search
     using Document = Lucene.Net.Documents.Document;
     using Field = Lucene.Net.Documents.Field;
     using Store = Lucene.Net.Documents.Field.Store;
-    using IntField = Lucene.Net.Documents.IntField;
-    using LongField = Lucene.Net.Documents.LongField;
+    using Int32Field = Lucene.Net.Documents.Int32Field;
+    using Int64Field = Lucene.Net.Documents.Int64Field;
     using NumericDocValuesField = Lucene.Net.Documents.NumericDocValuesField;
     using SortedDocValuesField = Lucene.Net.Documents.SortedDocValuesField;
     using SortedSetDocValuesField = Lucene.Net.Documents.SortedSetDocValuesField;
@@ -53,10 +53,10 @@ namespace Lucene.Net.Search
     using TermsEnum = Lucene.Net.Index.TermsEnum;
     using Bytes = Lucene.Net.Search.FieldCache.Bytes;
     using Doubles = Lucene.Net.Search.FieldCache.Doubles;
-    using Floats = Lucene.Net.Search.FieldCache.Floats;
-    using Ints = Lucene.Net.Search.FieldCache.Ints;
-    using Longs = Lucene.Net.Search.FieldCache.Longs;
-    using Shorts = Lucene.Net.Search.FieldCache.Shorts;
+    using Singles = Lucene.Net.Search.FieldCache.Singles;
+    using Int32s = Lucene.Net.Search.FieldCache.Int32s;
+    using Int64s = Lucene.Net.Search.FieldCache.Int64s;
+    using Int16s = Lucene.Net.Search.FieldCache.Int16s;
     using Directory = Lucene.Net.Store.Directory;
     using IBits = Lucene.Net.Util.IBits;
     using BytesRef = Lucene.Net.Util.BytesRef;
@@ -137,7 +137,7 @@ namespace Lucene.Net.Search
 
                 if (i % 2 == 0)
                 {
-                    doc.Add(new IntField("numInt", i, Field.Store.NO));
+                    doc.Add(new Int32Field("numInt", i, Field.Store.NO));
                 }
 
                 // sometimes skip the field:
@@ -209,7 +209,7 @@ 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.GetInt64s(Reader, "theLong", Random().NextBoolean());
+            FieldCache.Int64s 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++)
@@ -226,7 +226,7 @@ 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.GetInt16s(Reader, "theShort", Random().NextBoolean());
+            FieldCache.Int16s 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++)
@@ -235,7 +235,7 @@ namespace Lucene.Net.Search
             }
 #pragma warning restore 612, 618
 
-            FieldCache.Ints ints = cache.GetInt32s(Reader, "theInt", Random().NextBoolean());
+            FieldCache.Int32s 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++)
@@ -243,7 +243,7 @@ namespace Lucene.Net.Search
                 Assert.IsTrue(ints.Get(i) == (int.MaxValue - i), ints.Get(i) + " does not equal: " + (int.MaxValue - i));
             }
 
-            FieldCache.Floats floats = cache.GetSingles(Reader, "theFloat", Random().NextBoolean());
+            FieldCache.Singles 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++)
@@ -435,7 +435,7 @@ namespace Lucene.Net.Search
             Assert.AreEqual(3, cache.GetCacheEntries().Length);
             Assert.IsTrue(bits is Bits.MatchAllBits);
 
-            Ints ints = cache.GetInt32s(Reader, "sparse", true);
+            Int32s 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.GetInt32s(Reader, "numInt", Random().NextBoolean());
+            Int32s numInts = cache.GetInt32s(Reader, "numInt", Random().NextBoolean());
             docsWithField = cache.GetDocsWithField(Reader, "numInt");
             for (int i = 0; i < docsWithField.Length; i++)
             {
@@ -477,7 +477,7 @@ namespace Lucene.Net.Search
             int NUM_THREADS = 3;
             ThreadClass[] threads = new ThreadClass[NUM_THREADS];
             AtomicBoolean failed = new AtomicBoolean();
-            AtomicInteger iters = new AtomicInteger();
+            AtomicInt32 iters = new AtomicInt32();
             int NUM_ITER = 200 * RANDOM_MULTIPLIER;
             Barrier restart = new Barrier(NUM_THREADS, (barrier) => new RunnableAnonymousInnerClassHelper(this, cache, iters).Run());
             for (int threadIDX = 0; threadIDX < NUM_THREADS; threadIDX++)
@@ -498,9 +498,9 @@ namespace Lucene.Net.Search
             private readonly TestFieldCache OuterInstance;
 
             private IFieldCache Cache;
-            private AtomicInteger Iters;
+            private AtomicInt32 Iters;
 
-            public RunnableAnonymousInnerClassHelper(TestFieldCache outerInstance, IFieldCache cache, AtomicInteger iters)
+            public RunnableAnonymousInnerClassHelper(TestFieldCache outerInstance, IFieldCache cache, AtomicInt32 iters)
             {
                 this.OuterInstance = outerInstance;
                 this.Cache = cache;
@@ -520,11 +520,11 @@ namespace Lucene.Net.Search
 
             private IFieldCache Cache;
             private AtomicBoolean Failed;
-            private AtomicInteger Iters;
+            private AtomicInt32 Iters;
             private int NUM_ITER;
             private Barrier Restart;
 
-            public ThreadAnonymousInnerClassHelper(TestFieldCache outerInstance, IFieldCache cache, AtomicBoolean failed, AtomicInteger iters, int NUM_ITER, Barrier restart)
+            public ThreadAnonymousInnerClassHelper(TestFieldCache outerInstance, IFieldCache cache, AtomicBoolean failed, AtomicInt32 iters, int NUM_ITER, Barrier restart)
             {
                 this.OuterInstance = outerInstance;
                 this.Cache = cache;
@@ -562,7 +562,7 @@ namespace Lucene.Net.Search
                         }
                         else
                         {
-                            Ints ints = Cache.GetInt32s(Reader, "sparse", true);
+                            Int32s ints = Cache.GetInt32s(Reader, "sparse", true);
                             IBits docsWithField = Cache.GetDocsWithField(Reader, "sparse");
                             for (int i = 0; i < docsWithField.Length; i++)
                             {
@@ -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.GetInt32s(ar, "numeric", false);
+            Int32s numeric = FieldCache.DEFAULT.GetInt32s(ar, "numeric", false);
             Assert.AreEqual(42, numeric.Get(0));
 
             try
@@ -837,17 +837,17 @@ namespace Lucene.Net.Search
             Bytes bytes = cache.GetBytes(ar, "bogusbytes", true);
             Assert.AreEqual(0, bytes.Get(0));
 
-            Shorts shorts = cache.GetInt16s(ar, "bogusshorts", true);
+            Int16s shorts = cache.GetInt16s(ar, "bogusshorts", true);
             Assert.AreEqual(0, shorts.Get(0));
 #pragma warning restore 612, 618
 
-            Ints ints = cache.GetInt32s(ar, "bogusints", true);
+            Int32s ints = cache.GetInt32s(ar, "bogusints", true);
             Assert.AreEqual(0, ints.Get(0));
 
-            Longs longs = cache.GetInt64s(ar, "boguslongs", true);
+            Int64s longs = cache.GetInt64s(ar, "boguslongs", true);
             Assert.AreEqual(0, longs.Get(0));
 
-            Floats floats = cache.GetSingles(ar, "bogusfloats", true);
+            Singles 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.GetInt16s(ar, "bogusshorts", true);
+            Int16s shorts = cache.GetInt16s(ar, "bogusshorts", true);
             Assert.AreEqual(0, shorts.Get(0));
 #pragma warning restore 612, 618
 
-            Ints ints = cache.GetInt32s(ar, "bogusints", true);
+            Int32s ints = cache.GetInt32s(ar, "bogusints", true);
             Assert.AreEqual(0, ints.Get(0));
 
-            Longs longs = cache.GetInt64s(ar, "boguslongs", true);
+            Int64s longs = cache.GetInt64s(ar, "boguslongs", true);
             Assert.AreEqual(0, longs.Get(0));
 
-            Floats floats = cache.GetSingles(ar, "bogusfloats", true);
+            Singles floats = cache.GetSingles(ar, "bogusfloats", true);
             Assert.AreEqual(0, floats.Get(0), 0.0f);
 
             Doubles doubles = cache.GetDoubles(ar, "bogusdoubles", true);
@@ -954,7 +954,7 @@ namespace Lucene.Net.Search
             cfg.SetMergePolicy(NewLogMergePolicy());
             RandomIndexWriter iw = new RandomIndexWriter(Random(), dir, cfg);
             Document doc = new Document();
-            LongField field = new LongField("f", 0L, Field.Store.YES);
+            Int64Field field = new Int64Field("f", 0L, Field.Store.YES);
             doc.Add(field);
             long[] values = new long[TestUtil.NextInt(Random(), 1, 10)];
             for (int i = 0; i < values.Length; ++i)
@@ -989,7 +989,7 @@ namespace Lucene.Net.Search
             }
             iw.ForceMerge(1);
             DirectoryReader reader = iw.Reader;
-            Longs longs = FieldCache.DEFAULT.GetInt64s(GetOnlySegmentReader(reader), "f", false);
+            Int64s longs = FieldCache.DEFAULT.GetInt64s(GetOnlySegmentReader(reader), "f", false);
             for (int i = 0; i < values.Length; ++i)
             {
                 Assert.AreEqual(values[i], longs.Get(i));
@@ -1008,7 +1008,7 @@ namespace Lucene.Net.Search
             cfg.SetMergePolicy(NewLogMergePolicy());
             RandomIndexWriter iw = new RandomIndexWriter(Random(), dir, cfg);
             Document doc = new Document();
-            IntField field = new IntField("f", 0, Field.Store.YES);
+            Int32Field field = new Int32Field("f", 0, Field.Store.YES);
             doc.Add(field);
             int[] values = new int[TestUtil.NextInt(Random(), 1, 10)];
             for (int i = 0; i < values.Length; ++i)
@@ -1043,7 +1043,7 @@ namespace Lucene.Net.Search
             }
             iw.ForceMerge(1);
             DirectoryReader reader = iw.Reader;
-            Ints ints = FieldCache.DEFAULT.GetInt32s(GetOnlySegmentReader(reader), "f", false);
+            Int32s ints = FieldCache.DEFAULT.GetInt32s(GetOnlySegmentReader(reader), "f", false);
             for (int i = 0; i < values.Length; ++i)
             {
                 Assert.AreEqual(values[i], ints.Get(i));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestLiveFieldValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestLiveFieldValues.cs b/src/Lucene.Net.Tests/core/Search/TestLiveFieldValues.cs
index 5f2a627..9cd902c 100644
--- a/src/Lucene.Net.Tests/core/Search/TestLiveFieldValues.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestLiveFieldValues.cs
@@ -15,7 +15,7 @@ namespace Lucene.Net.Search
     using IndexReader = Lucene.Net.Index.IndexReader;
     using IndexWriter = Lucene.Net.Index.IndexWriter;
     using IndexWriterConfig = Lucene.Net.Index.IndexWriterConfig;
-    using IntField = IntField;
+    using Int32Field = Int32Field;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
     /*
@@ -181,7 +181,7 @@ namespace Lucene.Net.Search
                             string id = string.Format(CultureInfo.InvariantCulture, "{0}_{1:X4}", ThreadID, ThreadRandom.Next(IdCount));
                             int field = ThreadRandom.Next(int.MaxValue);
                             doc.Add(new StringField("id", id, Field.Store.YES));
-                            doc.Add(new IntField("field", (int)field, Field.Store.YES));
+                            doc.Add(new Int32Field("field", (int)field, Field.Store.YES));
                             w.UpdateDocument(new Term("id", id), doc);
                             Rt.Add(id, field);
                             if (!values.ContainsKey(id))//Key didn't exist before

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs b/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs
index 8c5b83a..5c66182 100644
--- a/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestMultiValuedNumericRangeQuery.cs
@@ -8,7 +8,7 @@ namespace Lucene.Net.Search
     using Document = Documents.Document;
     using Field = Field;
     using IndexReader = Lucene.Net.Index.IndexReader;
-    using IntField = IntField;
+    using Int32Field = Int32Field;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
     /*
@@ -56,7 +56,7 @@ namespace Lucene.Net.Search
                 {
                     int value = Random().Next(int.MaxValue);
                     doc.Add(NewStringField("asc", value.ToString(format), Field.Store.NO));
-                    doc.Add(new IntField("trie", value, Field.Store.NO));
+                    doc.Add(new Int32Field("trie", value, Field.Store.NO));
                 }
                 writer.AddDocument(doc);
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs b/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs
index cc0da97..5236870 100644
--- a/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery32.cs
@@ -13,9 +13,9 @@ namespace Lucene.Net.Search
     using Document = Documents.Document;
     using Field = Field;
     using FieldType = FieldType;
-    using FloatField = FloatField;
+    using SingleField = SingleField;
     using IndexReader = Lucene.Net.Index.IndexReader;
-    using IntField = IntField;
+    using Int32Field = Int32Field;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
     /*
@@ -73,7 +73,7 @@ namespace Lucene.Net.Search
             Directory = NewDirectory();
             RandomIndexWriter writer = new RandomIndexWriter(Random(), Directory, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())).SetMaxBufferedDocs(TestUtil.NextInt(Random(), 100, 1000)).SetMergePolicy(NewLogMergePolicy()));
 
-            FieldType storedInt = new FieldType(IntField.TYPE_NOT_STORED);
+            FieldType storedInt = new FieldType(Int32Field.TYPE_NOT_STORED);
             storedInt.IsStored = true;
             storedInt.Freeze();
 
@@ -89,7 +89,7 @@ namespace Lucene.Net.Search
             FieldType storedIntNone = new FieldType(storedInt);
             storedIntNone.NumericPrecisionStep = int.MaxValue;
 
-            FieldType unstoredInt = IntField.TYPE_NOT_STORED;
+            FieldType unstoredInt = Int32Field.TYPE_NOT_STORED;
 
             FieldType unstoredInt8 = new FieldType(unstoredInt);
             unstoredInt8.NumericPrecisionStep = 8;
@@ -100,7 +100,7 @@ namespace Lucene.Net.Search
             FieldType unstoredInt2 = new FieldType(unstoredInt);
             unstoredInt2.NumericPrecisionStep = 2;
 
-            IntField field8 = new IntField("field8", 0, storedInt8), field4 = new IntField("field4", 0, storedInt4), field2 = new IntField("field2", 0, storedInt2), fieldNoTrie = new IntField("field" + int.MaxValue, 0, storedIntNone), ascfield8 = new IntField("ascfield8", 0, unstoredInt8), ascfield4 = new IntField("ascfield4", 0, unstoredInt4), ascfield2 = new IntField("ascfield2", 0, unstoredInt2);
+            Int32Field field8 = new Int32Field("field8", 0, storedInt8), field4 = new Int32Field("field4", 0, storedInt4), field2 = new Int32Field("field2", 0, storedInt2), fieldNoTrie = new Int32Field("field" + int.MaxValue, 0, storedIntNone), ascfield8 = new Int32Field("ascfield8", 0, unstoredInt8), ascfield4 = new Int32Field("ascfield4", 0, unstoredInt4), ascfield2 = new Int32Field("ascfield2", 0, unstoredInt2);
 
             Document doc = new Document();
             // add fields, that have a distance to test general functionality
@@ -332,24 +332,24 @@ namespace Lucene.Net.Search
             Directory dir = NewDirectory();
             RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())));
             Document doc = new Document();
-            doc.Add(new FloatField("float", float.NegativeInfinity, Field.Store.NO));
-            doc.Add(new IntField("int", int.MinValue, Field.Store.NO));
+            doc.Add(new SingleField("float", float.NegativeInfinity, Field.Store.NO));
+            doc.Add(new Int32Field("int", int.MinValue, Field.Store.NO));
             writer.AddDocument(doc);
 
             doc = new Document();
-            doc.Add(new FloatField("float", float.PositiveInfinity, Field.Store.NO));
-            doc.Add(new IntField("int", int.MaxValue, Field.Store.NO));
+            doc.Add(new SingleField("float", float.PositiveInfinity, Field.Store.NO));
+            doc.Add(new Int32Field("int", int.MaxValue, Field.Store.NO));
             writer.AddDocument(doc);
 
             doc = new Document();
-            doc.Add(new FloatField("float", 0.0f, Field.Store.NO));
-            doc.Add(new IntField("int", 0, Field.Store.NO));
+            doc.Add(new SingleField("float", 0.0f, Field.Store.NO));
+            doc.Add(new Int32Field("int", 0, Field.Store.NO));
             writer.AddDocument(doc);
 
             foreach (float f in TestNumericUtils.FLOAT_NANs)
             {
                 doc = new Document();
-                doc.Add(new FloatField("float", f, Field.Store.NO));
+                doc.Add(new SingleField("float", f, Field.Store.NO));
                 writer.AddDocument(doc);
             }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs b/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs
index a1525f7..97da973 100644
--- a/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestNumericRangeQuery64.cs
@@ -15,7 +15,7 @@ namespace Lucene.Net.Search
     using Field = Field;
     using FieldType = FieldType;
     using IndexReader = Lucene.Net.Index.IndexReader;
-    using LongField = LongField;
+    using Int64Field = Int64Field;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
 
     /*
@@ -73,7 +73,7 @@ namespace Lucene.Net.Search
             Directory = NewDirectory();
             RandomIndexWriter writer = new RandomIndexWriter(Random(), Directory, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())).SetMaxBufferedDocs(TestUtil.NextInt(Random(), 100, 1000)).SetMergePolicy(NewLogMergePolicy()));
 
-            FieldType storedLong = new FieldType(LongField.TYPE_NOT_STORED);
+            FieldType storedLong = new FieldType(Int64Field.TYPE_NOT_STORED);
             storedLong.IsStored = true;
             storedLong.Freeze();
 
@@ -92,7 +92,7 @@ namespace Lucene.Net.Search
             FieldType storedLongNone = new FieldType(storedLong);
             storedLongNone.NumericPrecisionStep = int.MaxValue;
 
-            FieldType unstoredLong = LongField.TYPE_NOT_STORED;
+            FieldType unstoredLong = Int64Field.TYPE_NOT_STORED;
 
             FieldType unstoredLong8 = new FieldType(unstoredLong);
             unstoredLong8.NumericPrecisionStep = 8;
@@ -106,7 +106,7 @@ namespace Lucene.Net.Search
             FieldType unstoredLong2 = new FieldType(unstoredLong);
             unstoredLong2.NumericPrecisionStep = 2;
 
-            LongField field8 = new LongField("field8", 0L, storedLong8), field6 = new LongField("field6", 0L, storedLong6), field4 = new LongField("field4", 0L, storedLong4), field2 = new LongField("field2", 0L, storedLong2), fieldNoTrie = new LongField("field" + int.MaxValue, 0L, storedLongNone), ascfield8 = new LongField("ascfield8", 0L, unstoredLong8), ascfield6 = new LongField("ascfield6", 0L, unstoredLong6), ascfield4 = new LongField("ascfield4", 0L, unstoredLong4), ascfield2 = new LongField("ascfield2", 0L, unstoredLong2);
+            Int64Field field8 = new Int64Field("field8", 0L, storedLong8), field6 = new Int64Field("field6", 0L, storedLong6), field4 = new Int64Field("field4", 0L, storedLong4), field2 = new Int64Field("field2", 0L, storedLong2), fieldNoTrie = new Int64Field("field" + int.MaxValue, 0L, storedLongNone), ascfield8 = new Int64Field("ascfield8", 0L, unstoredLong8), ascfield6 = new Int64Field("ascfield6", 0L, unstoredLong6), ascfield4 = new Int64Field("ascfield4", 0L, unstoredLong4), ascfield2 = new Int64Field("ascfield2", 0L, unstoredLong2);
 
             Document doc = new Document();
             // add fields, that have a distance to test general functionality
@@ -360,17 +360,17 @@ namespace Lucene.Net.Search
             RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random())));
             Document doc = new Document();
             doc.Add(new DoubleField("double", double.NegativeInfinity, Field.Store.NO));
-            doc.Add(new LongField("long", long.MinValue, Field.Store.NO));
+            doc.Add(new Int64Field("long", long.MinValue, Field.Store.NO));
             writer.AddDocument(doc);
 
             doc = new Document();
             doc.Add(new DoubleField("double", double.PositiveInfinity, Field.Store.NO));
-            doc.Add(new LongField("long", long.MaxValue, Field.Store.NO));
+            doc.Add(new Int64Field("long", long.MaxValue, Field.Store.NO));
             writer.AddDocument(doc);
 
             doc = new Document();
             doc.Add(new DoubleField("double", 0.0, Field.Store.NO));
-            doc.Add(new LongField("long", 0L, Field.Store.NO));
+            doc.Add(new Int64Field("long", 0L, Field.Store.NO));
             writer.AddDocument(doc);
 
             foreach (double d in TestNumericUtils.DOUBLE_NANs)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestSearchAfter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSearchAfter.cs b/src/Lucene.Net.Tests/core/Search/TestSearchAfter.cs
index d460d91..c4635b1 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSearchAfter.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSearchAfter.cs
@@ -35,11 +35,11 @@ namespace Lucene.Net.Search
     using DoubleField = DoubleField;
     using English = Lucene.Net.Util.English;
     using Field = Field;
-    using FloatDocValuesField = FloatDocValuesField;
-    using FloatField = FloatField;
+    using SingleDocValuesField = SingleDocValuesField;
+    using SingleField = SingleField;
     using IndexReader = Lucene.Net.Index.IndexReader;
-    using IntField = IntField;
-    using LongField = LongField;
+    using Int32Field = Int32Field;
+    using Int64Field = Int64Field;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
     using NumericDocValuesField = NumericDocValuesField;
     using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter;
@@ -153,10 +153,10 @@ namespace Lucene.Net.Search
                 fields.Add(NewTextField("oddeven", (i % 2 == 0) ? "even" : "odd", Field.Store.NO));
                 fields.Add(NewStringField("byte", "" + ((sbyte)Random().Next()), Field.Store.NO));
                 fields.Add(NewStringField("short", "" + ((short)Random().Next()), Field.Store.NO));
-                fields.Add(new IntField("int", Random().Next(), Field.Store.NO));
-                fields.Add(new LongField("long", Random().NextLong(), Field.Store.NO));
+                fields.Add(new Int32Field("int", Random().Next(), Field.Store.NO));
+                fields.Add(new Int64Field("long", Random().NextLong(), Field.Store.NO));
 
-                fields.Add(new FloatField("float", (float)Random().NextDouble(), Field.Store.NO));
+                fields.Add(new SingleField("float", (float)Random().NextDouble(), Field.Store.NO));
                 fields.Add(new DoubleField("double", Random().NextDouble(), Field.Store.NO));
                 fields.Add(NewStringField("bytes", TestUtil.RandomRealisticUnicodeString(Random()), Field.Store.NO));
                 fields.Add(NewStringField("bytesval", TestUtil.RandomRealisticUnicodeString(Random()), Field.Store.NO));
@@ -165,7 +165,7 @@ namespace Lucene.Net.Search
                 if (SupportsDocValues)
                 {
                     fields.Add(new NumericDocValuesField("intdocvalues", Random().Next()));
-                    fields.Add(new FloatDocValuesField("floatdocvalues", (float)Random().NextDouble()));
+                    fields.Add(new SingleDocValuesField("floatdocvalues", (float)Random().NextDouble()));
                     fields.Add(new SortedDocValuesField("sortedbytesdocvalues", new BytesRef(TestUtil.RandomRealisticUnicodeString(Random()))));
                     fields.Add(new SortedDocValuesField("sortedbytesdocvaluesval", new BytesRef(TestUtil.RandomRealisticUnicodeString(Random()))));
                     fields.Add(new BinaryDocValuesField("straightbytesdocvalues", new BytesRef(TestUtil.RandomRealisticUnicodeString(Random()))));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestSearchWithThreads.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSearchWithThreads.cs b/src/Lucene.Net.Tests/core/Search/TestSearchWithThreads.cs
index ce1e5d9..1ce0552 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSearchWithThreads.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSearchWithThreads.cs
@@ -87,7 +87,7 @@ namespace Lucene.Net.Search
             IndexSearcher s = NewSearcher(r);
 
             AtomicBoolean failed = new AtomicBoolean();
-            AtomicLong netSearch = new AtomicLong();
+            AtomicInt64 netSearch = new AtomicInt64();
 
             ThreadClass[] threads = new ThreadClass[NUM_SEARCH_THREADS];
             for (int threadID = 0; threadID < NUM_SEARCH_THREADS; threadID++)
@@ -121,9 +121,9 @@ namespace Lucene.Net.Search
 
             private IndexSearcher s;
             private AtomicBoolean Failed;
-            private AtomicLong NetSearch;
+            private AtomicInt64 NetSearch;
 
-            public ThreadAnonymousInnerClassHelper(TestSearchWithThreads outerInstance, IndexSearcher s, AtomicBoolean failed, AtomicLong netSearch)
+            public ThreadAnonymousInnerClassHelper(TestSearchWithThreads outerInstance, IndexSearcher s, AtomicBoolean failed, AtomicInt64 netSearch)
             {
                 this.OuterInstance = outerInstance;
                 this.s = s;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestSort.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSort.cs b/src/Lucene.Net.Tests/core/Search/TestSort.cs
index 92253c2..9d09ed2 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSort.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSort.cs
@@ -1547,7 +1547,7 @@ namespace Lucene.Net.Search
             dir.Dispose();
         }
 
-        private class IntParserAnonymousInnerClassHelper : FieldCache.IIntParser
+        private class IntParserAnonymousInnerClassHelper : FieldCache.IInt32Parser
         {
             private readonly TestSort OuterInstance;
 
@@ -1666,7 +1666,7 @@ namespace Lucene.Net.Search
             dir.Dispose();
         }
 
-        private class ShortParserAnonymousInnerClassHelper : FieldCache.IShortParser
+        private class ShortParserAnonymousInnerClassHelper : FieldCache.IInt16Parser
         {
             private readonly TestSort OuterInstance;
 
@@ -1727,7 +1727,7 @@ namespace Lucene.Net.Search
             dir.Dispose();
         }
 
-        private class LongParserAnonymousInnerClassHelper : FieldCache.ILongParser
+        private class LongParserAnonymousInnerClassHelper : FieldCache.IInt64Parser
         {
             private readonly TestSort OuterInstance;
 
@@ -1788,7 +1788,7 @@ namespace Lucene.Net.Search
             dir.Dispose();
         }
 
-        private class FloatParserAnonymousInnerClassHelper : FieldCache.IFloatParser
+        private class FloatParserAnonymousInnerClassHelper : FieldCache.ISingleParser
         {
             private readonly TestSort OuterInstance;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestSortDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSortDocValues.cs b/src/Lucene.Net.Tests/core/Search/TestSortDocValues.cs
index 04146e0..7f58afb 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSortDocValues.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSortDocValues.cs
@@ -27,7 +27,7 @@ namespace Lucene.Net.Search
     using Document = Documents.Document;
     using DoubleDocValuesField = DoubleDocValuesField;
     using Field = Field;
-    using FloatDocValuesField = FloatDocValuesField;
+    using SingleDocValuesField = SingleDocValuesField;
     using IndexReader = Lucene.Net.Index.IndexReader;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
     using NumericDocValuesField = NumericDocValuesField;
@@ -701,15 +701,15 @@ namespace Lucene.Net.Search
             Directory dir = NewDirectory();
             RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
             Document doc = new Document();
-            doc.Add(new FloatDocValuesField("value", 30.1F));
+            doc.Add(new SingleDocValuesField("value", 30.1F));
             doc.Add(NewStringField("value", "30.1", Field.Store.YES));
             writer.AddDocument(doc);
             doc = new Document();
-            doc.Add(new FloatDocValuesField("value", -1.3F));
+            doc.Add(new SingleDocValuesField("value", -1.3F));
             doc.Add(NewStringField("value", "-1.3", Field.Store.YES));
             writer.AddDocument(doc);
             doc = new Document();
-            doc.Add(new FloatDocValuesField("value", 4.2F));
+            doc.Add(new SingleDocValuesField("value", 4.2F));
             doc.Add(NewStringField("value", "4.2", Field.Store.YES));
             writer.AddDocument(doc);
             IndexReader ir = writer.Reader;
@@ -738,15 +738,15 @@ namespace Lucene.Net.Search
             Directory dir = NewDirectory();
             RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
             Document doc = new Document();
-            doc.Add(new FloatDocValuesField("value", 30.1F));
+            doc.Add(new SingleDocValuesField("value", 30.1F));
             doc.Add(NewStringField("value", "30.1", Field.Store.YES));
             writer.AddDocument(doc);
             doc = new Document();
-            doc.Add(new FloatDocValuesField("value", -1.3F));
+            doc.Add(new SingleDocValuesField("value", -1.3F));
             doc.Add(NewStringField("value", "-1.3", Field.Store.YES));
             writer.AddDocument(doc);
             doc = new Document();
-            doc.Add(new FloatDocValuesField("value", 4.2F));
+            doc.Add(new SingleDocValuesField("value", 4.2F));
             doc.Add(NewStringField("value", "4.2", Field.Store.YES));
             writer.AddDocument(doc);
             IndexReader ir = writer.Reader;
@@ -777,11 +777,11 @@ namespace Lucene.Net.Search
             Document doc = new Document();
             writer.AddDocument(doc);
             doc = new Document();
-            doc.Add(new FloatDocValuesField("value", -1.3F));
+            doc.Add(new SingleDocValuesField("value", -1.3F));
             doc.Add(NewStringField("value", "-1.3", Field.Store.YES));
             writer.AddDocument(doc);
             doc = new Document();
-            doc.Add(new FloatDocValuesField("value", 4.2F));
+            doc.Add(new SingleDocValuesField("value", 4.2F));
             doc.Add(NewStringField("value", "4.2", Field.Store.YES));
             writer.AddDocument(doc);
             IndexReader ir = writer.Reader;
@@ -811,11 +811,11 @@ namespace Lucene.Net.Search
             Document doc = new Document();
             writer.AddDocument(doc);
             doc = new Document();
-            doc.Add(new FloatDocValuesField("value", -1.3F));
+            doc.Add(new SingleDocValuesField("value", -1.3F));
             doc.Add(NewStringField("value", "-1.3", Field.Store.YES));
             writer.AddDocument(doc);
             doc = new Document();
-            doc.Add(new FloatDocValuesField("value", 4.2F));
+            doc.Add(new SingleDocValuesField("value", 4.2F));
             doc.Add(NewStringField("value", "4.2", Field.Store.YES));
             writer.AddDocument(doc);
             IndexReader ir = writer.Reader;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs b/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs
index 5687659..03ad57a 100644
--- a/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestSortRandom.cs
@@ -345,7 +345,7 @@ namespace Lucene.Net.Search
             public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
             {
                 int maxDoc = context.Reader.MaxDoc;
-                FieldCache.Ints idSource = FieldCache.DEFAULT.GetInt32s(context.AtomicReader, "id", false);
+                FieldCache.Int32s idSource = FieldCache.DEFAULT.GetInt32s(context.AtomicReader, "id", false);
                 Assert.IsNotNull(idSource);
                 FixedBitSet bits = new FixedBitSet(maxDoc);
                 for (int docID = 0; docID < maxDoc; docID++)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Search/TestTopDocsMerge.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Search/TestTopDocsMerge.cs b/src/Lucene.Net.Tests/core/Search/TestTopDocsMerge.cs
index 8cc6507..b454cd2 100644
--- a/src/Lucene.Net.Tests/core/Search/TestTopDocsMerge.cs
+++ b/src/Lucene.Net.Tests/core/Search/TestTopDocsMerge.cs
@@ -31,10 +31,10 @@ namespace Lucene.Net.Search
 
     using Document = Documents.Document;
     using Field = Field;
-    using FloatField = FloatField;
+    using SingleField = SingleField;
     using IndexReader = Lucene.Net.Index.IndexReader;
     using IndexReaderContext = Lucene.Net.Index.IndexReaderContext;
-    using IntField = IntField;
+    using Int32Field = Int32Field;
     using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;
     using RandomIndexWriter = Lucene.Net.Index.RandomIndexWriter;
     using ReaderUtil = Lucene.Net.Index.ReaderUtil;
@@ -122,7 +122,7 @@ namespace Lucene.Net.Search
                     Document doc = new Document();
                     doc.Add(NewStringField("string", TestUtil.RandomRealisticUnicodeString(Random()), Field.Store.NO));
                     doc.Add(NewTextField("text", content[Random().Next(content.Length)], Field.Store.NO));
-                    doc.Add(new FloatField("float", (float)Random().NextDouble(), Field.Store.NO));
+                    doc.Add(new SingleField("float", (float)Random().NextDouble(), Field.Store.NO));
                     int intValue;
                     if (Random().Next(100) == 17)
                     {
@@ -136,7 +136,7 @@ namespace Lucene.Net.Search
                     {
                         intValue = Random().Next();
                     }
-                    doc.Add(new IntField("int", intValue, Field.Store.NO));
+                    doc.Add(new Int32Field("int", intValue, Field.Store.NO));
                     if (VERBOSE)
                     {
                         Console.WriteLine("  doc=" + doc);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs b/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs
index b386f4d..0412025 100644
--- a/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs
+++ b/src/Lucene.Net.Tests/core/Support/TestByteBuffer.cs
@@ -181,7 +181,7 @@ namespace Lucene.Net.Support
             //checkBytes(b, new byte[] { 0, 0, 0, (byte)ic(0) });
             //checkInvalidMarkException(ib);
 
-            LongBuffer lb = b.AsInt64Buffer();
+            Int64Buffer lb = b.AsInt64Buffer();
             TestLongBuffer.test(level, lb, direct);
             checkBytes(b, new byte[] { 0, 0, 0, 0, 0, 0, 0, (byte)Ic(0) });
             checkInvalidMarkException(lb);


Mime
View raw message