lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [10/45] lucenenet git commit: Ported ByteBuffer, LongBuffer, and other Buffer-related types from the Apache Harmony project (since the OpenJDK has a license that is off-limits)
Date Sun, 30 Apr 2017 21:55:49 GMT
Ported ByteBuffer, LongBuffer, and other Buffer-related types from the Apache Harmony project (since the OpenJDK has a license that is off-limits)


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/38d3a3d5
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/38d3a3d5
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/38d3a3d5

Branch: refs/heads/master
Commit: 38d3a3d5ccdec91e14f158bb9229c162e7e02f9b
Parents: f3ac940
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Fri Apr 28 11:28:16 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Mon May 1 04:45:03 2017 +0700

----------------------------------------------------------------------
 LICENSE.txt                                     |   11 +-
 src/Lucene.Net.Tests/Lucene.Net.Tests.csproj    |    9 +-
 .../Support/BaseBufferTestCase.cs               |   22 +-
 .../Support/IO/TestByteBuffer.cs                |  760 +++++
 .../Support/IO/TestLongBuffer.cs                |  544 ++++
 src/Lucene.Net.Tests/Support/TestByteBuffer.cs  |  760 -----
 src/Lucene.Net.Tests/Support/TestLongBuffer.cs  |  544 ----
 .../Util/Packed/TestPackedInts.cs               |    1 +
 src/Lucene.Net/Lucene.Net.csproj                |   26 +-
 src/Lucene.Net/Store/ByteBufferIndexInput.cs    |    2 +-
 src/Lucene.Net/Store/MMapDirectory.cs           |    4 +-
 src/Lucene.Net/Store/NIOFSDirectory.cs          |    1 +
 src/Lucene.Net/Support/Buffer.cs                |  425 ---
 src/Lucene.Net/Support/BufferExceptions.cs      |  120 -
 src/Lucene.Net/Support/ByteBuffer.cs            | 1794 ------------
 src/Lucene.Net/Support/ByteOrder.cs             |   36 -
 src/Lucene.Net/Support/FileStreamExtensions.cs  |   56 -
 src/Lucene.Net/Support/ICallable.cs             |   44 +-
 src/Lucene.Net/Support/IO/Buffer.cs             |  729 +++++
 src/Lucene.Net/Support/IO/BufferExceptions.cs   |  114 +
 src/Lucene.Net/Support/IO/ByteBuffer.cs         | 2682 ++++++++++++++++++
 src/Lucene.Net/Support/IO/ByteOrder.cs          |   81 +
 src/Lucene.Net/Support/IO/Endianness.cs         |   49 +
 .../Support/IO/FileStreamExtensions.cs          |   56 +
 src/Lucene.Net/Support/IO/HeapByteBuffer.cs     |  383 +++
 src/Lucene.Net/Support/IO/LongArrayBuffer.cs    |  105 +
 src/Lucene.Net/Support/IO/LongBuffer.cs         |  739 +++++
 .../Support/IO/LongToByteBufferAdapter.cs       |  233 ++
 .../Support/IO/MemoryMappedFileByteBuffer.cs    |  999 +++++++
 .../Support/IO/ReadOnlyHeapByteBuffer.cs        |  182 ++
 .../Support/IO/ReadWriteHeapByteBuffer.cs       |  241 ++
 .../Support/IO/ReadWriteLongArrayBuffer.cs      |  143 +
 src/Lucene.Net/Support/LongBuffer.cs            |  458 ---
 .../Support/MemoryMappedFileByteBuffer.cs       |  438 ---
 34 files changed, 8098 insertions(+), 4693 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/38d3a3d5/LICENSE.txt
----------------------------------------------------------------------
diff --git a/LICENSE.txt b/LICENSE.txt
index 617d392..e0722ab 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -760,8 +760,10 @@ THE SOFTWARE.
 
 =============================
 
-Some code in 
+Some code in
+src/Lucene.Net/Support/IO
 src/Lucene.Net.Analysis.Common/Util/BufferedCharFilter.cs
+src/Lucene.Net.Tests/Support/IO
 src/Lucene.Net.Tests.Analysis.Common/Util/TestBufferedCharFilter.cs 
 was sourced from the Apache Harmony project, which falls under the 
 following license:
@@ -784,18 +786,11 @@ limitations under the License.
 =============================
 
 Some code in 
-src/Lucene.Net/Support/Buffer.cs
-src/Lucene.Net/Support/BufferExceptions.cs
-src/Lucene.Net/Support/ByteBuffer.cs
-src/Lucene.Net/Support/ByteOrder.cs
 src/Lucene.Net/Support/DataInputStream.cs
 src/Lucene.Net/Support/DataOutputStream.cs
-src/Lucene.Net/Support/ICallable.cs
 src/Lucene.Net/Support/IDataInput.cs
 src/Lucene.Net/Support/IDataOutput.cs
-src/Lucene.Net/Support/LongBuffer.cs
 src/Lucene.Net/Support/PriorityQueue.cs
-src/Lucene.Net.Analysis.Common/Util/BufferedCharFilter.cs 
 was derived from the Java Development Kit (JDK) and falls under the following license:
 
 Copyright (c) 1999, 2008, Oracle and/or its affiliates. All rights reserved.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/38d3a3d5/src/Lucene.Net.Tests/Lucene.Net.Tests.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Lucene.Net.Tests.csproj b/src/Lucene.Net.Tests/Lucene.Net.Tests.csproj
index bc4aa2e..c8d7257 100644
--- a/src/Lucene.Net.Tests/Lucene.Net.Tests.csproj
+++ b/src/Lucene.Net.Tests/Lucene.Net.Tests.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!--
 
  Licensed to the Apache Software Foundation (ASF) under one
@@ -19,7 +19,6 @@
  under the License.
 
 -->
-
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
@@ -526,8 +525,8 @@
     <Compile Include="Support\TestHashMap.cs" />
     <Compile Include="Support\TestIDisposable.cs" />
     <Compile Include="Support\TestLinkedHashMap.cs" />
-    <Compile Include="Support\TestLongBuffer.cs" />
-    <Compile Include="Support\TestByteBuffer.cs" />
+    <Compile Include="Support\IO\TestLongBuffer.cs" />
+    <Compile Include="Support\IO\TestByteBuffer.cs" />
     <Compile Include="Support\TestLurchTable.cs" />
     <Compile Include="Support\TestLurchTableThreading.cs" />
     <Compile Include="Support\TestDataInputStream.cs" />
@@ -751,4 +750,4 @@
     <EmbeddedResource Include="Support\ReadFully.txt" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.Targets" />
-</Project>
+</Project>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/38d3a3d5/src/Lucene.Net.Tests/Support/BaseBufferTestCase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Support/BaseBufferTestCase.cs b/src/Lucene.Net.Tests/Support/BaseBufferTestCase.cs
index 051e0d6..7cb077c 100644
--- a/src/Lucene.Net.Tests/Support/BaseBufferTestCase.cs
+++ b/src/Lucene.Net.Tests/Support/BaseBufferTestCase.cs
@@ -26,7 +26,7 @@ using System.Globalization;
 using System.IO;
 using System.Text;
 
-namespace Lucene.Net.Support
+namespace Lucene.Net.Support.IO
 {
     /// <summary>
     /// Base class for tests from JDK/nio/Basic.java
@@ -41,7 +41,7 @@ namespace Lucene.Net.Support
             return j + 'a' + ((j > 26) ? 128 : 0);
         }
 
-        internal static string ToString(Lucene.Net.Support.Buffer b)
+        internal static string ToString(IO.Buffer b)
         {
             return (b.GetType().Name
                     + "[pos=" + b.Position
@@ -50,7 +50,7 @@ namespace Lucene.Net.Support
                     + "]");
         }
 
-        internal static void Show(int level, Lucene.Net.Support.Buffer b)
+        internal static void Show(int level, IO.Buffer b)
         {
             for (int i = 0; i < level; i++)
                 output.Write("  ");
@@ -62,18 +62,18 @@ namespace Lucene.Net.Support
         //    Assert.Fail(s);
         //}
 
-        internal static void fail(string s, Lucene.Net.Support.Buffer b)
+        internal static void fail(string s, IO.Buffer b)
         {
             fail(s + ": " + ToString(b));
         }
 
-        internal static void fail(String s, Lucene.Net.Support.Buffer b, Lucene.Net.Support.Buffer b2)
+        internal static void fail(String s, IO.Buffer b, IO.Buffer b2)
         {
             fail(s + ": "
                                        + ToString(b) + ", " + ToString(b2));
         }
 
-        internal static void fail(Lucene.Net.Support.Buffer b,
+        internal static void fail(IO.Buffer b,
                          string expected, char expectedChar,
                          string got, char gotChar)
         {
@@ -98,26 +98,26 @@ namespace Lucene.Net.Support
                                        + got);
         }
 
-        internal static void fail(Lucene.Net.Support.Buffer b, long expected, long got)
+        internal static void fail(IO.Buffer b, long expected, long got)
         {
             fail(b,
                  (expected).ToString("x4", CultureInfo.InvariantCulture), (char)expected,
                  (got).ToString("x4", CultureInfo.InvariantCulture), (char)got);
         }
 
-        internal static void ck(Lucene.Net.Support.Buffer b, bool cond)
+        internal static void ck(IO.Buffer b, bool cond)
         {
             if (!cond)
                 fail("Condition failed", b);
         }
 
-        internal static void ck(Lucene.Net.Support.Buffer b, long got, long expected)
+        internal static void ck(IO.Buffer b, long got, long expected)
         {
             if (expected != got)
                 fail(b, expected, got);
         }
 
-        internal static void ck(Lucene.Net.Support.Buffer b, float got, float expected)
+        internal static void ck(IO.Buffer b, float got, float expected)
         {
             if (expected != got)
                 fail(b,
@@ -125,7 +125,7 @@ namespace Lucene.Net.Support
                      got.ToString("0.0##########", CultureInfo.InvariantCulture), (char)got);
         }
 
-        internal static void ck(Lucene.Net.Support.Buffer b, double got, double expected)
+        internal static void ck(IO.Buffer b, double got, double expected)
         {
             if (expected != got)
                 fail(b,

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/38d3a3d5/src/Lucene.Net.Tests/Support/IO/TestByteBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Support/IO/TestByteBuffer.cs b/src/Lucene.Net.Tests/Support/IO/TestByteBuffer.cs
new file mode 100644
index 0000000..f0833c8
--- /dev/null
+++ b/src/Lucene.Net.Tests/Support/IO/TestByteBuffer.cs
@@ -0,0 +1,760 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+using Lucene.Net.Attributes;
+using NUnit.Framework;
+using System;
+using System.Reflection;
+
+namespace Lucene.Net.Support.IO
+{
+    /// <summary>
+    /// Tests from JDK/nio/BasicByte.java
+    /// </summary>
+    [TestFixture]
+    public class TestByteBuffer : BaseBufferTestCase
+    {
+        private static readonly sbyte[] VALUES = {
+            sbyte.MinValue,
+            (sbyte) -1,
+            (sbyte) 0,
+            (sbyte) 1,
+            sbyte.MaxValue,
+        };
+
+
+        private static void relGet(ByteBuffer b)
+        {
+            int n = b.Capacity;
+            //byte v; // LUCENENET: Not used
+            for (int i = 0; i < n; i++)
+                ck(b, (long)b.Get(), (long)((byte)Ic(i)));
+            b.Rewind();
+        }
+
+        private static void relGet(ByteBuffer b, int start)
+        {
+            int n = b.Remaining;
+            //byte v; // LUCENENET: Not used
+            for (int i = start; i < n; i++)
+                ck(b, (long)b.Get(), (long)((byte)Ic(i)));
+            b.Rewind();
+        }
+
+        private static void absGet(ByteBuffer b)
+        {
+            int n = b.Capacity;
+            //byte v; // LUCENENET: Not used
+            for (int i = 0; i < n; i++)
+                ck(b, (long)b.Get(), (long)((byte)Ic(i)));
+            b.Rewind();
+        }
+
+        private static void bulkGet(ByteBuffer b)
+        {
+            int n = b.Capacity;
+            byte[] a = new byte[n + 7];
+            b.Get(a, 7, n);
+            for (int i = 0; i < n; i++)
+                ck(b, (long)a[i + 7], (long)((byte)Ic(i)));
+        }
+
+        private static void relPut(ByteBuffer b)
+        {
+            int n = b.Capacity;
+            b.Clear();
+            for (int i = 0; i < n; i++)
+                b.Put((byte)Ic(i));
+            b.Flip();
+        }
+
+        private static void absPut(ByteBuffer b)
+        {
+            int n = b.Capacity;
+            b.Clear();
+            for (int i = 0; i < n; i++)
+                b.Put(i, (byte)Ic(i));
+            b.Limit = (n);
+            b.Position = (0);
+        }
+
+        private static void bulkPutArray(ByteBuffer b)
+        {
+            int n = b.Capacity;
+            b.Clear();
+            byte[] a = new byte[n + 7];
+            for (int i = 0; i < n; i++)
+                a[i + 7] = (byte)Ic(i);
+            b.Put(a, 7, n);
+            b.Flip();
+        }
+
+        private static void bulkPutBuffer(ByteBuffer b)
+        {
+            int n = b.Capacity;
+            b.Clear();
+            ByteBuffer c = ByteBuffer.Allocate(n + 7);
+            c.Position = (7);
+            for (int i = 0; i < n; i++)
+                c.Put((byte)Ic(i));
+            c.Flip();
+            c.Position = (7);
+            b.Put(c);
+            b.Flip();
+        }
+
+        //6231529
+        private static void callReset(ByteBuffer b)
+        {
+            b.Position = (0);
+            b.Mark();
+
+            b.Duplicate().Reset();
+            // LUCENENET: AsReadOnlyBuffer() not implemented
+            //b.AsReadOnlyBuffer().Reset();
+        }
+
+        private static void checkSlice(ByteBuffer b, ByteBuffer slice)
+        {
+            ck(slice, 0, slice.Position);
+            ck(slice, b.Remaining, slice.Limit);
+            ck(slice, b.Remaining, slice.Capacity);
+            if (b.IsDirect != slice.IsDirect)
+                fail("Lost direction", slice);
+            if (b.IsReadOnly != slice.IsReadOnly)
+                fail("Lost read-only", slice);
+        }
+
+        private static void checkBytes(ByteBuffer b, byte[] bs)
+        {
+            int n = bs.Length;
+            int p = b.Position;
+            //byte v; // LUCENENET: Not used
+            if (b.Order == ByteOrder.BIG_ENDIAN)
+            {
+                for (int i = 0; i < n; i++)
+                ck(b, b.Get(), bs[i]);
+            }
+            else
+            {
+                for (int i = n - 1; i >= 0; i--)
+                    ck(b, b.Get(), bs[i]);
+            }
+            b.Position = (p);
+        }
+
+        private static void compact(IO.Buffer b)
+        {
+            try
+            {
+                Type cl = b.GetType();
+                MethodInfo m = cl.GetMethod("Compact", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+                m.Invoke(b, new object[0]);
+            }
+            catch (Exception e)
+            {
+                fail(e.ToString(), b);
+            }
+        }
+
+        private static void checkInvalidMarkException(IO.Buffer b)
+        {
+            tryCatch(b, typeof(InvalidMarkException), () =>
+                {
+                    b.Mark();
+                    compact(b);
+                    b.Reset();
+                });
+        }
+
+        private static void testViews(int level, ByteBuffer b, bool direct)
+        {
+            //ShortBuffer sb = b.asShortBuffer();
+            //BasicShort.test(level, sb, direct);
+            //checkBytes(b, new byte[] { 0, (byte)ic(0) });
+            //checkInvalidMarkException(sb);
+
+            //CharBuffer cb = b.asCharBuffer();
+            //BasicChar.test(level, cb, direct);
+            //checkBytes(b, new byte[] { 0, (byte)ic(0) });
+            //checkInvalidMarkException(cb);
+
+            //IntBuffer ib = b.asIntBuffer();
+            //BasicInt.test(level, ib, direct);
+            //checkBytes(b, new byte[] { 0, 0, 0, (byte)ic(0) });
+            //checkInvalidMarkException(ib);
+
+            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);
+
+            //FloatBuffer fb = b.asFloatBuffer();
+            //BasicFloat.test(level, fb, direct);
+            //checkBytes(b, new byte[] { 0x42, (byte)0xc2, 0, 0 });
+            //checkInvalidMarkException(fb);
+
+            //DoubleBuffer db = b.asDoubleBuffer();
+            //BasicDouble.test(level, db, direct);
+            //checkBytes(b, new byte[] { 0x40, 0x58, 0x40, 0, 0, 0, 0, 0 });
+            //checkInvalidMarkException(db);
+        }
+
+        private static void testHet(int level, ByteBuffer b)
+        {
+
+            int p = b.Position;
+            b.Limit = (b.Capacity);
+            Show(level, b);
+            output.Write("    put:");
+
+            b.PutChar((char)1);
+            b.PutChar((char)char.MaxValue);
+            output.Write(" char");
+
+            b.PutInt16((short)1);
+            b.PutInt16((short)short.MaxValue);
+            output.Write(" short");
+
+            b.PutInt32(1);
+            b.PutInt32(int.MaxValue);
+            output.Write(" int");
+
+            b.PutInt64((long)1);
+            b.PutInt64((long)long.MaxValue);
+            output.Write(" long");
+
+            b.PutSingle((float)1);
+            b.PutSingle((float)float.MinValue);
+            b.PutSingle((float)float.MaxValue);
+            output.Write(" float");
+
+            b.PutDouble((double)1);
+            b.PutDouble((double)double.MinValue);
+            b.PutDouble((double)double.MaxValue);
+            output.Write(" double");
+
+            output.WriteLine();
+            b.Limit = (b.Position);
+            b.Position = (p);
+            Show(level, b);
+            output.Write("    get:");
+
+            ck(b, b.GetChar(), 1);
+            ck(b, b.GetChar(), char.MaxValue);
+            output.Write(" char");
+
+            ck(b, b.GetInt16(), 1);
+            ck(b, b.GetInt16(), short.MaxValue);
+            output.Write(" short");
+
+            ck(b, b.GetInt32(), 1);
+            ck(b, b.GetInt32(), int.MaxValue);
+            output.Write(" int");
+
+            ck(b, b.GetInt64(), 1);
+            ck(b, b.GetInt64(), long.MaxValue);
+            output.Write(" long");
+
+            ck(b, (long)b.GetSingle(), 1);
+            ck(b, (long)b.GetSingle(), unchecked((long)float.MinValue));
+            ck(b, (long)b.GetSingle(), unchecked((long)float.MaxValue));
+            output.Write(" float");
+
+            ck(b, (long)b.GetDouble(), 1);
+            ck(b, (long)b.GetDouble(), unchecked((long)double.MinValue));
+            ck(b, (long)b.GetDouble(), unchecked((long)double.MaxValue));
+            output.Write(" double");
+
+            output.WriteLine();
+        }
+
+        private static void fail(string problem,
+                                 ByteBuffer xb, ByteBuffer yb,
+                                 byte x, byte y)
+        {
+            fail(problem + string.Format(": x={0} y={1}", x, y), xb, yb);
+        }
+
+        private static void tryCatch(IO.Buffer b, Type ex, Action thunk)
+        {
+            bool caught = false;
+            try
+            {
+                thunk();
+            }
+            catch (Exception x)
+            {
+                if (ex.IsAssignableFrom(x.GetType()))
+                {
+                    caught = true;
+                }
+                else
+                {
+                    fail(x.Message + " not expected");
+                }
+            }
+            if (!caught)
+                fail(ex.Name + " not thrown", b);
+        }
+
+        private static void tryCatch(byte[] t, Type ex, Action thunk)
+        {
+            tryCatch(ByteBuffer.Wrap(t), ex, thunk);
+        }
+
+        public static void test(int level, ByteBuffer b, bool direct)
+        {
+            Show(level, b);
+
+            if (direct != b.IsDirect)
+                fail("Wrong direction", b);
+
+            // Gets and puts
+
+            relPut(b);
+            relGet(b);
+            absGet(b);
+            bulkGet(b);
+
+            absPut(b);
+            relGet(b);
+            absGet(b);
+            bulkGet(b);
+
+            bulkPutArray(b);
+            relGet(b);
+
+            bulkPutBuffer(b);
+            relGet(b);
+
+
+            // Compact
+
+            relPut(b);
+            b.Position = (13);
+            b.Compact();
+            b.Flip();
+            relGet(b, 13);
+
+            // Exceptions
+
+            relPut(b);
+            b.Limit = (b.Capacity / 2);
+            b.Position = (b.Limit);
+
+            tryCatch(b, typeof(BufferUnderflowException), () =>
+            {
+                b.Get();
+            });
+
+            tryCatch(b, typeof(BufferOverflowException), () =>
+            {
+                b.Put((byte)42);
+            });
+
+            // The index must be non-negative and lesss than the buffer's limit.
+            tryCatch(b, typeof(IndexOutOfRangeException), () =>
+            {
+                b.Get(b.Limit);
+            });
+            tryCatch(b, typeof(IndexOutOfRangeException), () =>
+            {
+                b.Get(-1);
+            });
+
+            tryCatch(b, typeof(IndexOutOfRangeException), () =>
+            {
+                b.Put(b.Limit, (byte)42);
+            });
+
+            tryCatch(b, typeof(InvalidMarkException), () =>
+            {
+                b.Position = (0);
+                b.Mark();
+                b.Compact();
+                b.Reset();
+            });
+
+            // Values
+
+            b.Clear();
+            b.Put((byte)0);
+            b.Put(unchecked((byte)-1));
+            b.Put((byte)1);
+            b.Put(unchecked((byte)sbyte.MaxValue));
+            b.Put(unchecked((byte)sbyte.MinValue));
+
+            //byte v; // LUCENENET: Not used
+            b.Flip();
+            ck(b, b.Get(), 0);
+            ck(b, b.Get(), unchecked((byte)-1));
+            ck(b, b.Get(), 1);
+            ck(b, b.Get(), unchecked((byte)sbyte.MaxValue));
+            ck(b, b.Get(), unchecked((byte)sbyte.MinValue));
+
+
+            // Comparison
+            b.Rewind();
+            ByteBuffer b2 = ByteBuffer.Allocate(b.Capacity);
+            b2.Put(b);
+            b2.Flip();
+            b.Position = (2);
+            b2.Position = (2);
+            if (!b.Equals(b2))
+            {
+                for (int i = 2; i < b.Limit; i++)
+                {
+                    byte x = b.Get(i);
+                    byte y = b2.Get(i);
+                    if (x != y)
+                        output.WriteLine("[" + i + "] " + x + " != " + y);
+                }
+                fail("Identical buffers not equal", b, b2);
+            }
+            if (b.CompareTo(b2) != 0)
+                fail("Comparison to identical buffer != 0", b, b2);
+
+            b.Limit = (b.Limit + 1);
+            b.Position = (b.Limit - 1);
+            b.Put((byte)99);
+            b.Rewind();
+            b2.Rewind();
+            if (b.Equals(b2))
+                fail("Non-identical buffers equal", b, b2);
+            if (b.CompareTo(b2) <= 0)
+                fail("Comparison to shorter buffer <= 0", b, b2);
+            b.Limit = (b.Limit - 1);
+
+            b.Put(2, (byte)42);
+            if (b.equals(b2))
+                fail("Non-identical buffers equal", b, b2);
+            if (b.CompareTo(b2) <= 0)
+                fail("Comparison to lesser buffer <= 0", b, b2);
+
+            // Check equals and compareTo with interesting values
+            foreach (byte x in VALUES)
+            {
+                ByteBuffer xb = ByteBuffer.Wrap(new byte[] { x });
+                if (xb.CompareTo(xb) != 0)
+                {
+                    fail("compareTo not reflexive", xb, xb, x, x);
+                }
+                if (!xb.Equals(xb))
+                {
+                    fail("equals not reflexive", xb, xb, x, x);
+                }
+                foreach (byte y in VALUES)
+                {
+                    ByteBuffer yb = ByteBuffer.Wrap(new byte[] { y });
+                    if (xb.CompareTo(yb) != -yb.CompareTo(xb))
+                    {
+                        fail("compareTo not anti-symmetric",
+                             xb, yb, x, y);
+                    }
+                    if ((xb.CompareTo(yb) == 0) != xb.Equals(yb))
+                    {
+                        fail("compareTo inconsistent with equals",
+                             xb, yb, x, y);
+                    }
+                    // from Byte.compare(x, y)
+                    //return x - y;
+                    if (xb.CompareTo(yb) != (x - y) /* Byte.Compare(x, y)*/)
+                    {
+                        fail("Incorrect results for ByteBuffer.compareTo",
+                             xb, yb, x, y);
+                    }
+                    if (xb.equals(yb) != ((x == y) /*|| ((x != x) && (y != y))*/))
+                    {
+                        fail("Incorrect results for ByteBuffer.equals",
+                             xb, yb, x, y);
+                    }
+                }
+            }
+
+            // Sub, dup
+
+            relPut(b);
+            relGet(b.Duplicate());
+            b.Position = (13);
+            relGet(b.Duplicate(), 13);
+            relGet(b.Duplicate().Slice(), 13);
+            relGet(b.Slice(), 13);
+            relGet(b.Slice().Duplicate(), 13);
+
+            // Slice
+
+            b.Position = (5);
+            ByteBuffer sb = b.Slice();
+            checkSlice(b, sb);
+            b.Position = (0);
+            ByteBuffer sb2 = sb.Slice();
+            checkSlice(sb, sb2);
+
+            if (!sb.Equals(sb2))
+                fail("Sliced slices do not match", sb, sb2);
+            if ((sb.HasArray) && (sb.ArrayOffset != sb2.ArrayOffset))
+                fail("Array offsets do not match: "
+                     + sb.ArrayOffset + " != " + sb2.ArrayOffset, sb, sb2);
+
+            // Views
+
+            b.Clear();
+            b.Order = (ByteOrder.BIG_ENDIAN);
+            testViews(level + 1, b, direct);
+
+            for (int i = 1; i <= 9; i++)
+            {
+                b.Position = (i);
+                Show(level + 1, b);
+                testViews(level + 2, b, direct);
+            }
+
+            b.Position=(0);
+            b.Order=(ByteOrder.LITTLE_ENDIAN);
+            testViews(level + 1, b, direct);
+
+            // Heterogeneous accessors
+
+            b.Order = (ByteOrder.BIG_ENDIAN);
+            for (int i = 0; i <= 9; i++)
+            {
+                b.Position = (i);
+                testHet(level + 1, b);
+            }
+            b.Order = (ByteOrder.LITTLE_ENDIAN);
+            b.Position = (3);
+            testHet(level + 1, b);
+
+            // Read-only views
+
+            b.Rewind();
+            ByteBuffer rb = b.AsReadOnlyBuffer();
+            if (!b.equals(rb))
+                fail("Buffer not equal to read-only view", b, rb);
+            Show(level + 1, rb);
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                relPut(rb);
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                absPut(rb);
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                bulkPutArray(rb);
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                bulkPutBuffer(rb);
+            });
+
+            // put(ByteBuffer) should not change source position
+            ByteBuffer src = ByteBuffer.Allocate(1);
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.Put(src);
+            });
+            ck(src, src.Position, 0);
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.Compact();
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutChar((char)1);
+            });
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutChar(0, (char)1);
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutInt16((short)1);
+            });
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutInt16(0, (short)1);
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutInt32(1);
+            });
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutInt32(0, 1);
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutInt64((long)1);
+            });
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutInt64(0, (long)1);
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutSingle((float)1);
+            });
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutSingle(0, (float)1);
+            });
+
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutDouble((double)1);
+            });
+            tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            {
+                rb.PutDouble(0, (double)1);
+            });
+
+
+            if (rb.GetType().Name.StartsWith("java.nio.Heap", StringComparison.Ordinal))
+            {
+
+                tryCatch(b, typeof(ReadOnlyBufferException), () =>
+                {
+                    var x = rb.Array;
+                });
+
+                tryCatch(b, typeof(ReadOnlyBufferException), () =>
+                {
+                    var x = rb.ArrayOffset;
+                });
+
+                if (rb.HasArray)
+                    fail("Read-only heap buffer's backing array is accessible",
+                         rb);
+
+            }
+
+            // Bulk puts from read-only buffers
+
+            b.Clear();
+            rb.Rewind();
+            b.Put(rb);
+
+            // LUCENENET: AllocateDirect not implemented
+
+            // For byte buffers, test both the direct and non-direct cases
+            //ByteBuffer ob
+            //    = (b.IsDirect
+            //       ? ByteBuffer.Allocate(rb.Capacity)
+            //       : ByteBuffer.AllocateDirect(rb.Capacity));
+            ByteBuffer ob = ByteBuffer.Allocate(rb.Capacity);
+            rb.Rewind();
+            ob.Put(rb);
+
+
+            relPut(b);                       // Required by testViews
+        }
+
+        public static void test(byte[] ba)
+        {
+            int offset = 47;
+            int length = 900;
+            ByteBuffer b = ByteBuffer.Wrap(ba, offset, length);
+            Show(0, b);
+            ck(b, b.Capacity, ba.Length);
+            ck(b, b.Position, offset);
+            ck(b, b.Limit, offset + length);
+
+            // The offset must be non-negative and no larger than <array.length>.
+            tryCatch(ba, typeof(IndexOutOfRangeException), () =>
+            {
+                ByteBuffer.Wrap(ba, -1, ba.Length);
+            });
+            tryCatch(ba, typeof(IndexOutOfRangeException), () =>
+            {
+                ByteBuffer.Wrap(ba, ba.Length + 1, ba.Length);
+            });
+            tryCatch(ba, typeof(IndexOutOfRangeException), () =>
+            {
+                ByteBuffer.Wrap(ba, 0, -1);
+            });
+            tryCatch(ba, typeof(IndexOutOfRangeException), () =>
+            {
+                ByteBuffer.Wrap(ba, 0, ba.Length + 1);
+            });
+
+            // A NullPointerException will be thrown if the array is null.
+            tryCatch(ba, typeof(NullReferenceException), () =>
+            {
+                ByteBuffer.Wrap((byte[])null, 0, 5);
+            });
+            tryCatch(ba, typeof(NullReferenceException), () =>
+            {
+                ByteBuffer.Wrap((byte[])null);
+            });
+        }
+
+        private static void testAllocate()
+        {
+            // An IllegalArgumentException will be thrown for negative capacities.
+            tryCatch((Buffer)null, typeof(ArgumentException), () =>
+            {
+                ByteBuffer.Allocate(-1);
+            });
+
+            // LUCENENET: AllocateDirect not implemented
+            //tryCatch((Buffer)null, typeof(ArgumentException), () =>
+            //{
+            //    ByteBuffer.AllocateDirect(-1);
+            //});
+
+            // LUCENENET: AllocateDirect not implemented
+            tryCatch((Buffer)null, typeof(NotImplementedException), () =>
+            {
+                ByteBuffer.AllocateDirect(-1);
+            });
+        }
+
+        [Test, LuceneNetSpecific]
+        public static void Test()
+        {
+            testAllocate();
+            test(0, ByteBuffer.Allocate(7 * 1024), false);
+            test(0, ByteBuffer.Wrap(new byte[7 * 1024], 0, 7 * 1024), false);
+            test(new byte[1024]);
+
+            // LUCENENET: AllocateDirect not implemented
+            //ByteBuffer b = ByteBuffer.AllocateDirect(7 * 1024);
+            //for (b.Position = (0); b.Position < b.Limit;)
+            //    ck(b, b.Get(), 0);
+            //test(0, b, true);
+
+            callReset(ByteBuffer.Allocate(10));
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/38d3a3d5/src/Lucene.Net.Tests/Support/IO/TestLongBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Support/IO/TestLongBuffer.cs b/src/Lucene.Net.Tests/Support/IO/TestLongBuffer.cs
new file mode 100644
index 0000000..ee4605f
--- /dev/null
+++ b/src/Lucene.Net.Tests/Support/IO/TestLongBuffer.cs
@@ -0,0 +1,544 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+using Lucene.Net.Attributes;
+using NUnit.Framework;
+using System;
+using System.Reflection;
+
+namespace Lucene.Net.Support.IO
+{
+    /// <summary>
+    /// Tests from JDK/nio/BasicLong.java
+    /// </summary>
+    public class TestLongBuffer : BaseBufferTestCase
+    {
+        private static readonly long[] VALUES = {
+            long.MinValue,
+            (long) -1,
+            (long) 0,
+            (long) 1,
+            long.MaxValue,
+        };
+
+
+        private static void relGet(Int64Buffer b)
+        {
+            int n = b.Capacity;
+            //long v; // LUCENENET: Not used
+            for (int i = 0; i < n; i++)
+                ck(b, (long)b.Get(), (long)((long)Ic(i)));
+            b.Rewind();
+        }
+
+        private static void relGet(Int64Buffer b, int start)
+        {
+            int n = b.Remaining;
+            //long v; // LUCENENET: Not used
+            for (int i = start; i < n; i++)
+                ck(b, (long)b.Get(), (long)((long)Ic(i)));
+            b.Rewind();
+        }
+
+        private static void absGet(Int64Buffer b)
+        {
+            int n = b.Capacity;
+            //long v; // LUCENENET: Not used
+            for (int i = 0; i < n; i++)
+                ck(b, (long)b.Get(), (long)((long)Ic(i)));
+            b.Rewind();
+        }
+
+        private static void bulkGet(Int64Buffer b)
+        {
+            int n = b.Capacity;
+            long[] a = new long[n + 7];
+            b.Get(a, 7, n);
+            for (int i = 0; i < n; i++)
+                ck(b, (long)a[i + 7], (long)((long)Ic(i)));
+        }
+
+        private static void relPut(Int64Buffer b)
+        {
+            int n = b.Capacity;
+            b.Clear();
+            for (int i = 0; i < n; i++)
+                b.Put((long)Ic(i));
+            b.Flip();
+        }
+
+        private static void absPut(Int64Buffer b)
+        {
+            int n = b.Capacity;
+            b.Clear();
+            for (int i = 0; i < n; i++)
+                b.Put(i, (long)Ic(i));
+            b.Limit = (n);
+            b.Position = (0);
+        }
+
+        private static void bulkPutArray(Int64Buffer b)
+        {
+            int n = b.Capacity;
+            b.Clear();
+            long[] a = new long[n + 7];
+            for (int i = 0; i < n; i++)
+                a[i + 7] = (long)Ic(i);
+            b.Put(a, 7, n);
+            b.Flip();
+        }
+
+        private static void bulkPutBuffer(Int64Buffer b)
+        {
+            int n = b.Capacity;
+            b.Clear();
+            Int64Buffer c = Int64Buffer.Allocate(n + 7);
+            c.Position = (7);
+            for (int i = 0; i < n; i++)
+                c.Put((long)Ic(i));
+            c.Flip();
+            c.Position = (7);
+            b.Put(c);
+            b.Flip();
+        }
+
+        //6231529
+        private static void callReset(Int64Buffer b)
+        {
+            b.Position = (0);
+            b.Mark();
+
+            b.Duplicate().Reset();
+
+            // LUCENENET: AsReadOnlyBuffer() not implemented
+            //b.AsReadOnlyBuffer().Reset();
+        }
+
+
+
+        // 6221101-6234263
+
+        private static void putBuffer()
+        {
+            int cap = 10;
+
+            // LUCENENET: AllocateDirect not implemented
+
+            //LongBuffer direct1 = ByteBuffer.AllocateDirect(cap).AsLongBuffer();
+            Int64Buffer nondirect1 = ByteBuffer.Allocate(cap).AsInt64Buffer();
+            //direct1.Put(nondirect1);
+
+            //LongBuffer direct2 = ByteBuffer.AllocateDirect(cap).AsLongBuffer();
+            Int64Buffer nondirect2 = ByteBuffer.Allocate(cap).AsInt64Buffer();
+            //nondirect2.Put(direct2);
+
+            //LongBuffer direct3 = ByteBuffer.AllocateDirect(cap).AsLongBuffer();
+            //LongBuffer direct4 = ByteBuffer.AllocateDirect(cap).AsLongBuffer();
+            //direct3.Put(direct4);
+
+            Int64Buffer nondirect3 = ByteBuffer.Allocate(cap).AsInt64Buffer();
+            Int64Buffer nondirect4 = ByteBuffer.Allocate(cap).AsInt64Buffer();
+            nondirect3.Put(nondirect4);
+        }
+
+        private static void checkSlice(Int64Buffer b, Int64Buffer slice)
+        {
+            ck(slice, 0, slice.Position);
+            ck(slice, b.Remaining, slice.Limit);
+            ck(slice, b.Remaining, slice.Capacity);
+            if (b.IsDirect != slice.IsDirect)
+                fail("Lost direction", slice);
+            if (b.IsReadOnly != slice.IsReadOnly)
+                fail("Lost read-only", slice);
+        }
+
+        private static void fail(string problem,
+                                 Int64Buffer xb, Int64Buffer yb,
+                                 long x, long y)
+        {
+            fail(problem + string.Format(": x={0} y={1}", x, y), xb, yb);
+        }
+
+        private static void tryCatch(IO.Buffer b, Type ex, Action thunk)
+        {
+            bool caught = false;
+            try
+            {
+                thunk();
+            }
+            catch (Exception x)
+            {
+                if (ex.GetTypeInfo().IsAssignableFrom(x.GetType()))
+                {
+                    caught = true;
+                }
+                else
+                {
+                    fail(x.Message + " not expected");
+                }
+            }
+            if (!caught)
+                fail(ex.Name + " not thrown", b);
+        }
+
+        private static void tryCatch(long[] t, Type ex, Action thunk)
+        {
+            tryCatch(Int64Buffer.Wrap(t), ex, thunk);
+        }
+
+        public static void test(int level, Int64Buffer b, bool direct)
+        {
+
+            Show(level, b);
+
+            if (direct != b.IsDirect)
+                fail("Wrong direction", b);
+
+            // Gets and puts
+
+            relPut(b);
+            relGet(b);
+            absGet(b);
+            bulkGet(b);
+
+            absPut(b);
+            relGet(b);
+            absGet(b);
+            bulkGet(b);
+
+            bulkPutArray(b);
+            relGet(b);
+
+            bulkPutBuffer(b);
+            relGet(b);
+
+            // Compact
+
+            relPut(b);
+            b.Position = (13);
+            b.Compact();
+            b.Flip();
+            relGet(b, 13);
+
+            // Exceptions
+
+            relPut(b);
+            b.Limit = (b.Capacity / 2);
+            b.Position = (b.Limit);
+
+            tryCatch(b, typeof(BufferUnderflowException), () =>
+            {
+                b.Get();
+            });
+
+            tryCatch(b, typeof(BufferOverflowException), () =>
+            {
+                b.Put((long)42);
+            });
+
+            // The index must be non-negative and lesss than the buffer's limit.
+            tryCatch(b, typeof(IndexOutOfRangeException), () =>
+            {
+                b.Get(b.Limit);
+            });
+            tryCatch(b, typeof(IndexOutOfRangeException), () =>
+            {
+                b.Get(-1);
+            });
+
+            tryCatch(b, typeof(IndexOutOfRangeException), () =>
+            {
+                b.Put(b.Limit, (long)42);
+            });
+
+            tryCatch(b, typeof(InvalidMarkException), () =>
+            {
+                b.Position = (0);
+                b.Mark();
+                b.Compact();
+                b.Reset();
+            });
+
+            // Values
+
+            b.Clear();
+            b.Put((long)0);
+            b.Put((long)-1);
+            b.Put((long)1);
+            b.Put(long.MaxValue);
+            b.Put(long.MinValue);
+
+            //long v; // LUCENENET: Not used
+            b.Flip();
+            ck(b, b.Get(), 0);
+            ck(b, b.Get(), (long)-1);
+            ck(b, b.Get(), 1);
+            ck(b, b.Get(), long.MaxValue);
+            ck(b, b.Get(), long.MinValue);
+
+
+            // Comparison
+            b.Rewind();
+            Int64Buffer b2 = Int64Buffer.Allocate(b.Capacity);
+            b2.Put(b);
+            b2.Flip();
+            b.Position = (2);
+            b2.Position = (2);
+            if (!b.equals(b2))
+            {
+                for (int i = 2; i < b.Limit; i++)
+                {
+                    long x = b.Get(i);
+                    long y = b2.Get(i);
+                    if (x != y)
+                        output.WriteLine("[" + i + "] " + x + " != " + y);
+                }
+                fail("Identical buffers not equal", b, b2);
+            }
+            if (b.CompareTo(b2) != 0)
+                fail("Comparison to identical buffer != 0", b, b2);
+
+            b.Limit = (b.Limit + 1);
+            b.Position = (b.Limit - 1);
+            b.Put((long)99);
+            b.Rewind();
+            b2.Rewind();
+            if (b.Equals(b2))
+                fail("Non-identical buffers equal", b, b2);
+            if (b.CompareTo(b2) <= 0)
+                fail("Comparison to shorter buffer <= 0", b, b2);
+            b.Limit = (b.Limit - 1);
+
+            b.Put(2, (long)42);
+            if (b.equals(b2))
+                fail("Non-identical buffers equal", b, b2);
+            if (b.CompareTo(b2) <= 0)
+                fail("Comparison to lesser buffer <= 0", b, b2);
+
+            // Check equals and compareTo with interesting values
+            foreach (long x in VALUES)
+            {
+                Int64Buffer xb = Int64Buffer.Wrap(new long[] { x });
+                if (xb.CompareTo(xb) != 0)
+                {
+                    fail("compareTo not reflexive", xb, xb, x, x);
+                }
+                if (!xb.equals(xb))
+                {
+                    fail("equals not reflexive", xb, xb, x, x);
+                }
+                foreach (long y in VALUES)
+                {
+                    Int64Buffer yb = Int64Buffer.Wrap(new long[] { y });
+                    if (xb.CompareTo(yb) != -yb.CompareTo(xb))
+                    {
+                        fail("compareTo not anti-symmetric",
+                             xb, yb, x, y);
+                    }
+                    if ((xb.CompareTo(yb) == 0) != xb.equals(yb))
+                    {
+                        fail("compareTo inconsistent with equals",
+                             xb, yb, x, y);
+                    }
+                    // from Long.compare(x, y)
+                    if (xb.CompareTo(yb) != ((x < y) ? -1 : ((x == y) ? 0 : 1)))
+                    {
+
+                        fail("Incorrect results for LongBuffer.compareTo",
+                             xb, yb, x, y);
+                    }
+                    if (xb.equals(yb) != ((x == y) /*|| (x != x) && (y != y)*/))
+                    {
+                        fail("Incorrect results for LongBuffer.equals",
+                             xb, yb, x, y);
+                    }
+                }
+            }
+
+            // Sub, dup
+
+            relPut(b);
+            relGet(b.Duplicate());
+            b.Position = (13);
+            relGet(b.Duplicate(), 13);
+            relGet(b.Duplicate().Slice(), 13);
+            relGet(b.Slice(), 13);
+            relGet(b.Slice().Duplicate(), 13);
+
+            // Slice
+
+            b.Position = (5);
+            Int64Buffer sb = b.Slice();
+            checkSlice(b, sb);
+            b.Position = (0);
+            Int64Buffer sb2 = sb.Slice();
+            checkSlice(sb, sb2);
+
+            if (!sb.equals(sb2))
+                fail("Sliced slices do not match", sb, sb2);
+            if ((sb.HasArray) && (sb.ArrayOffset != sb2.ArrayOffset))
+                fail("Array offsets do not match: "
+                     + sb.ArrayOffset + " != " + sb2.ArrayOffset, sb, sb2);
+
+
+            // Read-only views
+
+            b.Rewind();
+
+            // LUCENENET: AsReadOnlyBuffer() not implemented
+            tryCatch(b, typeof(NotImplementedException), () =>
+            {
+                b.AsReadOnlyBuffer();
+            });
+
+            //// LUCENENET: AsReadOnlyBuffer() not implemented
+            //Int64Buffer rb = b.AsReadOnlyBuffer();
+            //if (!b.Equals(rb))
+            //    fail("Buffer not equal to read-only view", b, rb);
+            //Show(level + 1, rb);
+
+            //tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            //{
+            //    relPut(rb);
+            //});
+
+            //tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            //{
+            //    absPut(rb);
+            //});
+
+            //tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            //{
+            //    bulkPutArray(rb);
+            //});
+
+            //tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            //{
+            //    bulkPutBuffer(rb);
+            //});
+
+            //// put(LongBuffer) should not change source position
+            //Int64Buffer src = Int64Buffer.Allocate(1);
+            //tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            //{
+            //    rb.Put(src);
+            //});
+            //ck(src, src.Position, 0);
+
+            //tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            //{
+            //    rb.Compact();
+            //});
+
+
+            //if (rb.GetType().Name.StartsWith("Heap", StringComparison.Ordinal))
+            //{
+
+            //    tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            //    {
+            //        var x = rb.Array;
+            //    });
+
+            //    tryCatch(b, typeof(ReadOnlyBufferException), () =>
+            //    {
+            //        var x = rb.ArrayOffset;
+            //    });
+
+            //    if (rb.HasArray)
+            //        fail("Read-only heap buffer's backing array is accessible",
+            //             rb);
+
+            //}
+
+            // Bulk puts from read-only buffers
+
+            b.Clear();
+            //rb.Rewind();
+            //b.Put(rb);
+
+            relPut(b);                       // Required by testViews
+
+        }
+
+
+        public static void test(long[] ba)
+        {
+            int offset = 47;
+            int length = 900;
+            Int64Buffer b = Int64Buffer.Wrap(ba, offset, length);
+            Show(0, b);
+            ck(b, b.Capacity, ba.Length);
+            ck(b, b.Position, offset);
+            ck(b, b.Limit, offset + length);
+
+            // The offset must be non-negative and no larger than <array.length>.
+            tryCatch(ba, typeof(IndexOutOfRangeException), () =>
+            {
+                Int64Buffer.Wrap(ba, -1, ba.Length);
+            });
+            tryCatch(ba, typeof(IndexOutOfRangeException), () =>
+            {
+                Int64Buffer.Wrap(ba, ba.Length + 1, ba.Length);
+            });
+            tryCatch(ba, typeof(IndexOutOfRangeException), () =>
+            {
+                Int64Buffer.Wrap(ba, 0, -1);
+            });
+            tryCatch(ba, typeof(IndexOutOfRangeException), () =>
+            {
+                Int64Buffer.Wrap(ba, 0, ba.Length + 1);
+            });
+
+            // A NullPointerException will be thrown if the array is null.
+            tryCatch(ba, typeof(ArgumentNullException), () =>
+            {
+                Int64Buffer.Wrap((long[])null, 0, 5);
+            });
+            tryCatch(ba, typeof(ArgumentNullException), () =>
+            {
+                Int64Buffer.Wrap((long[])null);
+            });
+        }
+
+
+        public static void TestAllocate()
+        {
+            // An IllegalArgumentException will be thrown for negative capacities.
+            tryCatch((Buffer)null, typeof(ArgumentException), () =>
+            {
+                Int64Buffer.Allocate(-1);
+            });
+        }
+
+        [Test, LuceneNetSpecific]
+        public static void Test()
+        {
+            TestAllocate();
+            test(0, Int64Buffer.Allocate(7 * 1024), false);
+            test(0, Int64Buffer.Wrap(new long[7 * 1024], 0, 7 * 1024), false);
+            test(new long[1024]);
+
+            callReset(Int64Buffer.Allocate(10));
+            putBuffer();
+
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/38d3a3d5/src/Lucene.Net.Tests/Support/TestByteBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests/Support/TestByteBuffer.cs b/src/Lucene.Net.Tests/Support/TestByteBuffer.cs
deleted file mode 100644
index 4ce3302..0000000
--- a/src/Lucene.Net.Tests/Support/TestByteBuffer.cs
+++ /dev/null
@@ -1,760 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-using Lucene.Net.Attributes;
-using NUnit.Framework;
-using System;
-using System.Reflection;
-
-namespace Lucene.Net.Support
-{
-    /// <summary>
-    /// Tests from JDK/nio/BasicByte.java
-    /// </summary>
-    [TestFixture]
-    public class TestByteBuffer : BaseBufferTestCase
-    {
-        private static readonly sbyte[] VALUES = {
-            sbyte.MinValue,
-            (sbyte) -1,
-            (sbyte) 0,
-            (sbyte) 1,
-            sbyte.MaxValue,
-        };
-
-
-        private static void relGet(ByteBuffer b)
-        {
-            int n = b.Capacity;
-            //byte v; // LUCENENET: Not used
-            for (int i = 0; i < n; i++)
-                ck(b, (long)b.Get(), (long)((byte)Ic(i)));
-            b.Rewind();
-        }
-
-        private static void relGet(ByteBuffer b, int start)
-        {
-            int n = b.Remaining;
-            //byte v; // LUCENENET: Not used
-            for (int i = start; i < n; i++)
-                ck(b, (long)b.Get(), (long)((byte)Ic(i)));
-            b.Rewind();
-        }
-
-        private static void absGet(ByteBuffer b)
-        {
-            int n = b.Capacity;
-            //byte v; // LUCENENET: Not used
-            for (int i = 0; i < n; i++)
-                ck(b, (long)b.Get(), (long)((byte)Ic(i)));
-            b.Rewind();
-        }
-
-        private static void bulkGet(ByteBuffer b)
-        {
-            int n = b.Capacity;
-            byte[] a = new byte[n + 7];
-            b.Get(a, 7, n);
-            for (int i = 0; i < n; i++)
-                ck(b, (long)a[i + 7], (long)((byte)Ic(i)));
-        }
-
-        private static void relPut(ByteBuffer b)
-        {
-            int n = b.Capacity;
-            b.Clear();
-            for (int i = 0; i < n; i++)
-                b.Put((byte)Ic(i));
-            b.Flip();
-        }
-
-        private static void absPut(ByteBuffer b)
-        {
-            int n = b.Capacity;
-            b.Clear();
-            for (int i = 0; i < n; i++)
-                b.Put(i, (byte)Ic(i));
-            b.Limit = (n);
-            b.Position = (0);
-        }
-
-        private static void bulkPutArray(ByteBuffer b)
-        {
-            int n = b.Capacity;
-            b.Clear();
-            byte[] a = new byte[n + 7];
-            for (int i = 0; i < n; i++)
-                a[i + 7] = (byte)Ic(i);
-            b.Put(a, 7, n);
-            b.Flip();
-        }
-
-        private static void bulkPutBuffer(ByteBuffer b)
-        {
-            int n = b.Capacity;
-            b.Clear();
-            ByteBuffer c = ByteBuffer.Allocate(n + 7);
-            c.Position = (7);
-            for (int i = 0; i < n; i++)
-                c.Put((byte)Ic(i));
-            c.Flip();
-            c.Position = (7);
-            b.Put(c);
-            b.Flip();
-        }
-
-        //6231529
-        private static void callReset(ByteBuffer b)
-        {
-            b.Position = (0);
-            b.Mark();
-
-            b.Duplicate().Reset();
-            // LUCENENET: AsReadOnlyBuffer() not implemented
-            //b.AsReadOnlyBuffer().Reset();
-        }
-
-        private static void checkSlice(ByteBuffer b, ByteBuffer slice)
-        {
-            ck(slice, 0, slice.Position);
-            ck(slice, b.Remaining, slice.Limit);
-            ck(slice, b.Remaining, slice.Capacity);
-            if (b.IsDirect != slice.IsDirect)
-                fail("Lost direction", slice);
-            if (b.IsReadOnly != slice.IsReadOnly)
-                fail("Lost read-only", slice);
-        }
-
-        private static void checkBytes(ByteBuffer b, byte[] bs)
-        {
-            int n = bs.Length;
-            int p = b.Position;
-            //byte v; // LUCENENET: Not used
-            if (b.Order == ByteOrder.BIG_ENDIAN)
-            {
-                for (int i = 0; i < n; i++)
-                ck(b, b.Get(), bs[i]);
-            }
-            else
-            {
-                for (int i = n - 1; i >= 0; i--)
-                    ck(b, b.Get(), bs[i]);
-            }
-            b.Position = (p);
-        }
-
-        private static void compact(Buffer b)
-        {
-            try
-            {
-                Type cl = b.GetType();
-                MethodInfo m = cl.GetMethod("Compact", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
-                m.Invoke(b, new object[0]);
-            }
-            catch (Exception e)
-            {
-                fail(e.ToString(), b);
-            }
-        }
-
-        private static void checkInvalidMarkException(Buffer b)
-        {
-            tryCatch(b, typeof(InvalidMarkException), () =>
-                {
-                    b.Mark();
-                    compact(b);
-                    b.Reset();
-                });
-        }
-
-        private static void testViews(int level, ByteBuffer b, bool direct)
-        {
-            //ShortBuffer sb = b.asShortBuffer();
-            //BasicShort.test(level, sb, direct);
-            //checkBytes(b, new byte[] { 0, (byte)ic(0) });
-            //checkInvalidMarkException(sb);
-
-            //CharBuffer cb = b.asCharBuffer();
-            //BasicChar.test(level, cb, direct);
-            //checkBytes(b, new byte[] { 0, (byte)ic(0) });
-            //checkInvalidMarkException(cb);
-
-            //IntBuffer ib = b.asIntBuffer();
-            //BasicInt.test(level, ib, direct);
-            //checkBytes(b, new byte[] { 0, 0, 0, (byte)ic(0) });
-            //checkInvalidMarkException(ib);
-
-            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);
-
-            //FloatBuffer fb = b.asFloatBuffer();
-            //BasicFloat.test(level, fb, direct);
-            //checkBytes(b, new byte[] { 0x42, (byte)0xc2, 0, 0 });
-            //checkInvalidMarkException(fb);
-
-            //DoubleBuffer db = b.asDoubleBuffer();
-            //BasicDouble.test(level, db, direct);
-            //checkBytes(b, new byte[] { 0x40, 0x58, 0x40, 0, 0, 0, 0, 0 });
-            //checkInvalidMarkException(db);
-        }
-
-        private static void testHet(int level, ByteBuffer b)
-        {
-
-            int p = b.Position;
-            b.Limit = (b.Capacity);
-            Show(level, b);
-            output.Write("    put:");
-
-            b.PutChar((char)1);
-            b.PutChar((char)char.MaxValue);
-            output.Write(" char");
-
-            b.PutInt16((short)1);
-            b.PutInt16((short)short.MaxValue);
-            output.Write(" short");
-
-            b.PutInt32(1);
-            b.PutInt32(int.MaxValue);
-            output.Write(" int");
-
-            b.PutInt64((long)1);
-            b.PutInt64((long)long.MaxValue);
-            output.Write(" long");
-
-            b.PutSingle((float)1);
-            b.PutSingle((float)float.MinValue);
-            b.PutSingle((float)float.MaxValue);
-            output.Write(" float");
-
-            b.PutDouble((double)1);
-            b.PutDouble((double)double.MinValue);
-            b.PutDouble((double)double.MaxValue);
-            output.Write(" double");
-
-            output.WriteLine();
-            b.Limit = (b.Position);
-            b.Position = (p);
-            Show(level, b);
-            output.Write("    get:");
-
-            ck(b, b.GetChar(), 1);
-            ck(b, b.GetChar(), char.MaxValue);
-            output.Write(" char");
-
-            ck(b, b.GetInt16(), 1);
-            ck(b, b.GetInt16(), short.MaxValue);
-            output.Write(" short");
-
-            ck(b, b.GetInt32(), 1);
-            ck(b, b.GetInt32(), int.MaxValue);
-            output.Write(" int");
-
-            ck(b, b.GetInt64(), 1);
-            ck(b, b.GetInt64(), long.MaxValue);
-            output.Write(" long");
-
-            ck(b, (long)b.GetSingle(), 1);
-            ck(b, (long)b.GetSingle(), unchecked((long)float.MinValue));
-            ck(b, (long)b.GetSingle(), unchecked((long)float.MaxValue));
-            output.Write(" float");
-
-            ck(b, (long)b.GetDouble(), 1);
-            ck(b, (long)b.GetDouble(), unchecked((long)double.MinValue));
-            ck(b, (long)b.GetDouble(), unchecked((long)double.MaxValue));
-            output.Write(" double");
-
-            output.WriteLine();
-        }
-
-        private static void fail(string problem,
-                                 ByteBuffer xb, ByteBuffer yb,
-                                 byte x, byte y)
-        {
-            fail(problem + string.Format(": x={0} y={1}", x, y), xb, yb);
-        }
-
-        private static void tryCatch(Buffer b, Type ex, Action thunk)
-        {
-            bool caught = false;
-            try
-            {
-                thunk();
-            }
-            catch (Exception x)
-            {
-                if (ex.IsAssignableFrom(x.GetType()))
-                {
-                    caught = true;
-                }
-                else
-                {
-                    fail(x.Message + " not expected");
-                }
-            }
-            if (!caught)
-                fail(ex.Name + " not thrown", b);
-        }
-
-        private static void tryCatch(byte[] t, Type ex, Action thunk)
-        {
-            tryCatch(ByteBuffer.Wrap(t), ex, thunk);
-        }
-
-        public static void test(int level, ByteBuffer b, bool direct)
-        {
-            Show(level, b);
-
-            if (direct != b.IsDirect)
-                fail("Wrong direction", b);
-
-            // Gets and puts
-
-            relPut(b);
-            relGet(b);
-            absGet(b);
-            bulkGet(b);
-
-            absPut(b);
-            relGet(b);
-            absGet(b);
-            bulkGet(b);
-
-            bulkPutArray(b);
-            relGet(b);
-
-            bulkPutBuffer(b);
-            relGet(b);
-
-
-            // Compact
-
-            relPut(b);
-            b.Position = (13);
-            b.Compact();
-            b.Flip();
-            relGet(b, 13);
-
-            // Exceptions
-
-            relPut(b);
-            b.Limit = (b.Capacity / 2);
-            b.Position = (b.Limit);
-
-            tryCatch(b, typeof(BufferUnderflowException), () =>
-            {
-                b.Get();
-            });
-
-            tryCatch(b, typeof(BufferOverflowException), () =>
-            {
-                b.Put((byte)42);
-            });
-
-            // The index must be non-negative and lesss than the buffer's limit.
-            tryCatch(b, typeof(IndexOutOfRangeException), () =>
-            {
-                b.Get(b.Limit);
-            });
-            tryCatch(b, typeof(IndexOutOfRangeException), () =>
-            {
-                b.Get(-1);
-            });
-
-            tryCatch(b, typeof(IndexOutOfRangeException), () =>
-            {
-                b.Put(b.Limit, (byte)42);
-            });
-
-            tryCatch(b, typeof(InvalidMarkException), () =>
-            {
-                b.Position = (0);
-                b.Mark();
-                b.Compact();
-                b.Reset();
-            });
-
-            // Values
-
-            b.Clear();
-            b.Put((byte)0);
-            b.Put(unchecked((byte)-1));
-            b.Put((byte)1);
-            b.Put(unchecked((byte)sbyte.MaxValue));
-            b.Put(unchecked((byte)sbyte.MinValue));
-
-            //byte v; // LUCENENET: Not used
-            b.Flip();
-            ck(b, b.Get(), 0);
-            ck(b, b.Get(), unchecked((byte)-1));
-            ck(b, b.Get(), 1);
-            ck(b, b.Get(), unchecked((byte)sbyte.MaxValue));
-            ck(b, b.Get(), unchecked((byte)sbyte.MinValue));
-
-
-            // Comparison
-            b.Rewind();
-            ByteBuffer b2 = Lucene.Net.Support.ByteBuffer.Allocate(b.Capacity);
-            b2.Put(b);
-            b2.Flip();
-            b.Position = (2);
-            b2.Position = (2);
-            if (!b.Equals(b2))
-            {
-                for (int i = 2; i < b.Limit; i++)
-                {
-                    byte x = b.Get(i);
-                    byte y = b2.Get(i);
-                    if (x != y)
-                        output.WriteLine("[" + i + "] " + x + " != " + y);
-                }
-                fail("Identical buffers not equal", b, b2);
-            }
-            if (b.CompareTo(b2) != 0)
-                fail("Comparison to identical buffer != 0", b, b2);
-
-            b.Limit = (b.Limit + 1);
-            b.Position = (b.Limit - 1);
-            b.Put((byte)99);
-            b.Rewind();
-            b2.Rewind();
-            if (b.Equals(b2))
-                fail("Non-identical buffers equal", b, b2);
-            if (b.CompareTo(b2) <= 0)
-                fail("Comparison to shorter buffer <= 0", b, b2);
-            b.Limit = (b.Limit - 1);
-
-            b.Put(2, (byte)42);
-            if (b.equals(b2))
-                fail("Non-identical buffers equal", b, b2);
-            if (b.CompareTo(b2) <= 0)
-                fail("Comparison to lesser buffer <= 0", b, b2);
-
-            // Check equals and compareTo with interesting values
-            foreach (byte x in VALUES)
-            {
-                ByteBuffer xb = Lucene.Net.Support.ByteBuffer.Wrap(new byte[] { x });
-                if (xb.CompareTo(xb) != 0)
-                {
-                    fail("compareTo not reflexive", xb, xb, x, x);
-                }
-                if (!xb.Equals(xb))
-                {
-                    fail("equals not reflexive", xb, xb, x, x);
-                }
-                foreach (byte y in VALUES)
-                {
-                    ByteBuffer yb = Lucene.Net.Support.ByteBuffer.Wrap(new byte[] { y });
-                    if (xb.CompareTo(yb) != -yb.CompareTo(xb))
-                    {
-                        fail("compareTo not anti-symmetric",
-                             xb, yb, x, y);
-                    }
-                    if ((xb.CompareTo(yb) == 0) != xb.Equals(yb))
-                    {
-                        fail("compareTo inconsistent with equals",
-                             xb, yb, x, y);
-                    }
-                    // from Byte.compare(x, y)
-                    //return x - y;
-                    if (xb.CompareTo(yb) != (x - y) /* Byte.Compare(x, y)*/)
-                    {
-                        fail("Incorrect results for ByteBuffer.compareTo",
-                             xb, yb, x, y);
-                    }
-                    if (xb.equals(yb) != ((x == y) /*|| ((x != x) && (y != y))*/))
-                    {
-                        fail("Incorrect results for ByteBuffer.equals",
-                             xb, yb, x, y);
-                    }
-                }
-            }
-
-            // Sub, dup
-
-            relPut(b);
-            relGet(b.Duplicate());
-            b.Position = (13);
-            relGet(b.Duplicate(), 13);
-            relGet(b.Duplicate().Slice(), 13);
-            relGet(b.Slice(), 13);
-            relGet(b.Slice().Duplicate(), 13);
-
-            // Slice
-
-            b.Position = (5);
-            ByteBuffer sb = b.Slice();
-            checkSlice(b, sb);
-            b.Position = (0);
-            ByteBuffer sb2 = sb.Slice();
-            checkSlice(sb, sb2);
-
-            if (!sb.Equals(sb2))
-                fail("Sliced slices do not match", sb, sb2);
-            if ((sb.HasArray) && (sb.ArrayOffset != sb2.ArrayOffset))
-                fail("Array offsets do not match: "
-                     + sb.ArrayOffset + " != " + sb2.ArrayOffset, sb, sb2);
-
-            // Views
-
-            b.Clear();
-            b.Order = (ByteOrder.BIG_ENDIAN);
-            testViews(level + 1, b, direct);
-
-            for (int i = 1; i <= 9; i++)
-            {
-                b.Position = (i);
-                Show(level + 1, b);
-                testViews(level + 2, b, direct);
-            }
-
-            b.Position=(0);
-            b.Order=(ByteOrder.LITTLE_ENDIAN);
-            testViews(level + 1, b, direct);
-
-            // Heterogeneous accessors
-
-            b.Order = (ByteOrder.BIG_ENDIAN);
-            for (int i = 0; i <= 9; i++)
-            {
-                b.Position = (i);
-                testHet(level + 1, b);
-            }
-            b.Order = (ByteOrder.LITTLE_ENDIAN);
-            b.Position = (3);
-            testHet(level + 1, b);
-
-            // Read-only views
-
-            b.Rewind();
-            ByteBuffer rb = b.AsReadOnlyBuffer();
-            if (!b.equals(rb))
-                fail("Buffer not equal to read-only view", b, rb);
-            Show(level + 1, rb);
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                relPut(rb);
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                absPut(rb);
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                bulkPutArray(rb);
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                bulkPutBuffer(rb);
-            });
-
-            // put(ByteBuffer) should not change source position
-            ByteBuffer src = ByteBuffer.Allocate(1);
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.Put(src);
-            });
-            ck(src, src.Position, 0);
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.Compact();
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutChar((char)1);
-            });
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutChar(0, (char)1);
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutInt16((short)1);
-            });
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutInt16(0, (short)1);
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutInt32(1);
-            });
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutInt32(0, 1);
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutInt64((long)1);
-            });
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutInt64(0, (long)1);
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutSingle((float)1);
-            });
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutSingle(0, (float)1);
-            });
-
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutDouble((double)1);
-            });
-            tryCatch(b, typeof(ReadOnlyBufferException), () =>
-            {
-                rb.PutDouble(0, (double)1);
-            });
-
-
-            if (rb.GetType().Name.StartsWith("java.nio.Heap", StringComparison.Ordinal))
-            {
-
-                tryCatch(b, typeof(ReadOnlyBufferException), () =>
-                {
-                    var x = rb.Array;
-                });
-
-                tryCatch(b, typeof(ReadOnlyBufferException), () =>
-                {
-                    var x = rb.ArrayOffset;
-                });
-
-                if (rb.HasArray)
-                    fail("Read-only heap buffer's backing array is accessible",
-                         rb);
-
-            }
-
-            // Bulk puts from read-only buffers
-
-            b.Clear();
-            rb.Rewind();
-            b.Put(rb);
-
-            // LUCENENET: AllocateDirect not implemented
-
-            // For byte buffers, test both the direct and non-direct cases
-            //ByteBuffer ob
-            //    = (b.IsDirect
-            //       ? ByteBuffer.Allocate(rb.Capacity)
-            //       : ByteBuffer.AllocateDirect(rb.Capacity));
-            ByteBuffer ob = ByteBuffer.Allocate(rb.Capacity);
-            rb.Rewind();
-            ob.Put(rb);
-
-
-            relPut(b);                       // Required by testViews
-        }
-
-        public static void test(byte[] ba)
-        {
-            int offset = 47;
-            int length = 900;
-            ByteBuffer b = ByteBuffer.Wrap(ba, offset, length);
-            Show(0, b);
-            ck(b, b.Capacity, ba.Length);
-            ck(b, b.Position, offset);
-            ck(b, b.Limit, offset + length);
-
-            // The offset must be non-negative and no larger than <array.length>.
-            tryCatch(ba, typeof(ArgumentOutOfRangeException), () =>
-            {
-                ByteBuffer.Wrap(ba, -1, ba.Length);
-            });
-            tryCatch(ba, typeof(ArgumentOutOfRangeException), () =>
-            {
-                ByteBuffer.Wrap(ba, ba.Length + 1, ba.Length);
-            });
-            tryCatch(ba, typeof(ArgumentOutOfRangeException), () =>
-            {
-                ByteBuffer.Wrap(ba, 0, -1);
-            });
-            tryCatch(ba, typeof(ArgumentOutOfRangeException), () =>
-            {
-                ByteBuffer.Wrap(ba, 0, ba.Length + 1);
-            });
-
-            // A NullPointerException will be thrown if the array is null.
-            tryCatch(ba, typeof(NullReferenceException), () =>
-            {
-                ByteBuffer.Wrap((byte[])null, 0, 5);
-            });
-            tryCatch(ba, typeof(NullReferenceException), () =>
-            {
-                ByteBuffer.Wrap((byte[])null);
-            });
-        }
-
-        private static void testAllocate()
-        {
-            // An IllegalArgumentException will be thrown for negative capacities.
-            tryCatch((Buffer)null, typeof(ArgumentException), () =>
-            {
-                ByteBuffer.Allocate(-1);
-            });
-
-            // LUCENENET: AllocateDirect not implemented
-            //tryCatch((Buffer)null, typeof(ArgumentException), () =>
-            //{
-            //    ByteBuffer.AllocateDirect(-1);
-            //});
-
-            // LUCENENET: AllocateDirect not implemented
-            tryCatch((Buffer)null, typeof(NotImplementedException), () =>
-            {
-                ByteBuffer.AllocateDirect(-1);
-            });
-        }
-
-        [Test, LuceneNetSpecific]
-        public static void Test()
-        {
-            testAllocate();
-            test(0, ByteBuffer.Allocate(7 * 1024), false);
-            test(0, ByteBuffer.Wrap(new byte[7 * 1024], 0, 7 * 1024), false);
-            test(new byte[1024]);
-
-            // LUCENENET: AllocateDirect not implemented
-            //ByteBuffer b = ByteBuffer.AllocateDirect(7 * 1024);
-            //for (b.Position = (0); b.Position < b.Limit;)
-            //    ck(b, b.Get(), 0);
-            //test(0, b, true);
-
-            callReset(ByteBuffer.Allocate(10));
-        }
-    }
-}


Mime
View raw message