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);
}
public static void TestAllocate()
{
// An IllegalArgumentException will be thrown for negative capacities.
tryCatch((Buffer)null, typeof(ArgumentException), () =>
{
Int64Buffer.Allocate(-1);
});
}
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();
}
//6231529
private static void callReset(Int64Buffer b)
{
b.Position = (0);
b.Mark();
b.Duplicate().Reset();
// LUCENENET: AsReadOnlyBuffer() not implemented
//b.AsReadOnlyBuffer().Reset();
}
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 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 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 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 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();
}
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(ArgumentOutOfRangeException), () =>
{
Int64Buffer.Wrap(ba, -1, ba.Length);
});
tryCatch(ba, typeof(ArgumentOutOfRangeException), () =>
{
Int64Buffer.Wrap(ba, ba.Length + 1, ba.Length);
});
tryCatch(ba, typeof(ArgumentOutOfRangeException), () =>
{
Int64Buffer.Wrap(ba, 0, -1);
});
tryCatch(ba, typeof(ArgumentOutOfRangeException), () =>
{
Int64Buffer.Wrap(ba, 0, ba.Length + 1);
});
// A NullPointerException will be thrown if the array is null.
tryCatch(ba, typeof(NullReferenceException), () =>
{
Int64Buffer.Wrap((long[])null, 0, 5);
});
tryCatch(ba, typeof(NullReferenceException), () =>
{
Int64Buffer.Wrap((long[])null);
});
}
// 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);
}
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
}
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(long[] t, Type ex, Action thunk)
{
tryCatch(Int64Buffer.Wrap(t), ex, thunk);
}
