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 <[email protected]> Authored: Fri Apr 28 11:28:16 2017 +0700 Committer: Shad Storhaug <[email protected]> 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)); - } - } -}
