public virtual void TestEquals()
{
// equal to self
assertTrue(buf.Equals(buf));
DoubleBuffer @readonly = buf.AsReadOnlyBuffer();
assertTrue(buf.Equals(@readonly));
DoubleBuffer duplicate = buf.Duplicate();
assertTrue(buf.Equals(duplicate));
// always false, if type mismatch
assertFalse(buf.Equals(true));
assertTrue(buf.Capacity > 5);
buf.SetLimit(buf.Capacity).SetPosition(0);
@readonly.SetLimit(@readonly.Capacity).SetPosition(1);
assertFalse(buf.Equals(@readonly));
buf.SetLimit(buf.Capacity - 1).SetPosition(0);
duplicate.SetLimit(duplicate.Capacity).SetPosition(0);
assertFalse(buf.Equals(duplicate));
}
public override void TestHashCode()
{
DoubleBuffer duplicate = buf.Duplicate();
assertEquals(buf.GetHashCode(), duplicate.GetHashCode());
}
public virtual void TestPutdoubleArrayintint()
{
buf.Clear();
double[] array = new double[buf.Capacity];
try
{
buf.Put(new double[buf.Capacity + 1], 0, buf.Capacity + 1);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (BufferOverflowException e)
{
// expected
}
assertEquals(buf.Position, 0);
try
{
buf.Put(array, -1, array.Length);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
buf.Put(array, array.Length + 1, 0);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
buf.Put(array, array.Length, 0);
assertEquals(buf.Position, 0);
try
{
buf.Put(array, 0, -1);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
buf.Put((double[])null, 0, -1);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentNullException e)
{
// expected
}
try
{
buf.Put(array, 2, array.Length);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
buf.Put(array, int.MaxValue, 1);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
buf.Put(array, 1, int.MaxValue);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
assertEquals(buf.Position, 0);
loadTestData2(array, 0, array.Length);
DoubleBuffer ret = buf.Put(array, 0, array.Length);
assertEquals(buf.Position, buf.Capacity);
assertContentEquals(buf, array, 0, array.Length);
assertSame(ret, buf);
}
public override void TearDown()
{
buf = null;
baseBuf = null;
}
public override void SetUp()
{
buf = DoubleBuffer.Allocate(BUFFER_LENGTH);
loadTestData1(buf);
baseBuf = buf;
}
public virtual void TestCompact()
{
// case: buffer is full
buf.Clear();
buf.Mark();
loadTestData1(buf);
DoubleBuffer ret = buf.Compact();
assertSame(ret, buf);
assertEquals(buf.Position, buf.Capacity);
assertEquals(buf.Limit, buf.Capacity);
assertContentLikeTestData1(buf, 0, 0.0, buf.Capacity);
try
{
buf.Reset();
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (InvalidMarkException e)
{
// expected
}
// case: buffer is empty
buf.Position = (0);
buf.Limit = (0);
buf.Mark();
ret = buf.Compact();
assertSame(ret, buf);
assertEquals(buf.Position, 0);
assertEquals(buf.Limit, buf.Capacity);
assertContentLikeTestData1(buf, 0, 0.0, buf.Capacity);
try
{
buf.Reset();
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (InvalidMarkException e)
{
// expected
}
// case: normal
assertTrue(buf.Capacity > 5);
buf.Position = (1);
buf.Limit = (5);
buf.Mark();
ret = buf.Compact();
assertSame(ret, buf);
assertEquals(buf.Position, 4);
assertEquals(buf.Limit, buf.Capacity);
assertContentLikeTestData1(buf, 0, 1.0, 4);
try
{
buf.Reset();
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (InvalidMarkException e)
{
// expected
}
}
public void TestWrappedDoubleuffer_IllegalArg()
{
double[] array = new double[20];
try
{
DoubleBuffer.Wrap(array, -1, 0);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
DoubleBuffer.Wrap(array, 21, 0);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
DoubleBuffer.Wrap(array, 0, -1);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
DoubleBuffer.Wrap(array, 0, 21);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
DoubleBuffer.Wrap(array, int.MaxValue, 1);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
DoubleBuffer.Wrap(array, 1, int.MaxValue);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentOutOfRangeException e)
{
// expected
}
try
{
DoubleBuffer.Wrap((double[])null, -1, 0);
fail("Should throw NPE"); //$NON-NLS-1$
}
catch (ArgumentNullException e)
{
}
DoubleBuffer buf = DoubleBuffer.Wrap(array, 2, 16);
assertEquals(buf.Position, 2);
assertEquals(buf.Limit, 18);
assertEquals(buf.Capacity, 20);
}
public static void test(int level, DoubleBuffer b, bool direct)
{
Show(level, b);
//if (direct != b.IsDirect) // J2N: IsDirect not supported
// 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((double)42);
});
// The index must be non-negative and lesss than the buffer's limit.
tryCatch(b, typeof(ArgumentOutOfRangeException), () =>
{
b.Get(b.Limit);
});
tryCatch(b, typeof(ArgumentOutOfRangeException), () =>
{
b.Get(-1);
});
tryCatch(b, typeof(ArgumentOutOfRangeException), () =>
{
b.Put(b.Limit, (double)42);
});
tryCatch(b, typeof(InvalidMarkException), () =>
{
b.Position = (0);
b.Mark();
b.Compact();
b.Reset();
});
// Values
b.Clear();
b.Put((double)0);
b.Put((double)-1);
b.Put((double)1);
b.Put(double.MaxValue);
b.Put(double.MinValue);
b.Put(-double.MaxValue);
b.Put(-double.MinValue);
b.Put(double.NegativeInfinity);
b.Put(double.PositiveInfinity);
b.Put(double.NaN);
b.Put(0.5121609353879392); // Changes value if incorrectly swapped
double v;
b.Flip();
ck(b, b.Get(), 0);
ck(b, b.Get(), (double)-1);
ck(b, b.Get(), 1);
ck(b, b.Get(), double.MaxValue);
ck(b, b.Get(), double.MinValue);
ck(b, b.Get(), -double.MaxValue);
ck(b, b.Get(), -double.MinValue);
ck(b, b.Get(), double.NegativeInfinity);
ck(b, b.Get(), double.PositiveInfinity);
if (BitConversion.DoubleToRawInt64Bits(v = b.Get())
!= BitConversion.DoubleToRawInt64Bits(double.NaN))
{
fail(b, unchecked ((long)double.NaN), (long)v);
}
ck(b, b.Get(), 0.5121609353879392);
// Comparison
b.Rewind();
DoubleBuffer b2 = DoubleBuffer.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++)
{
double x = b.Get(i);
double y = b2.Get(i);
if (x != y || x.CompareTo(y) != 0)
{
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((double)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, (double)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 (double x in VALUES)
{
DoubleBuffer xb = DoubleBuffer.Wrap(new double[] { 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 (double y in VALUES)
{
DoubleBuffer yb = DoubleBuffer.Wrap(new double[] { 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);
}
if (xb.CompareTo(yb) != x.CompareTo(y))
{
if (x == 0.0 && y == 0.0)
{
continue;
}
fail("Incorrect results for DoubleBuffer.compareTo",
xb, yb, x, y);
}
if (xb.Equals(yb) != ((x == y) || (double.IsNaN(x) && double.IsNaN(y))))
{
fail("Incorrect results for DoubleBuffer.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);
DoubleBuffer sb = b.Slice();
checkSlice(b, sb);
b.Position = (0);
DoubleBuffer 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();
DoubleBuffer 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);
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
rb.Compact();
});
if (rb.GetType().Name.StartsWith("Heap", StringComparison.Ordinal))
{
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
var _ = rb.Array;
});
tryCatch(b, typeof(ReadOnlyBufferException), () =>
{
var _ = 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 tryCatch(double[] t, Type ex, Action thunk)
{
tryCatch(DoubleBuffer.Wrap(t), ex, thunk);
}
private static void fail(String problem,
DoubleBuffer xb, DoubleBuffer yb,
double x, double y)
{
fail(problem + string.Format(": x={0} y={1}", x, y), xb, yb);
}
