public override void TestPutSingleBuffer()
{
SingleBuffer other = SingleBuffer.Allocate(1);
try
{
buf.Put(other);
fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
}
catch (ReadOnlyBufferException e)
{
// expected
}
try
{
buf.Put((SingleBuffer)null);
fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
}
catch (ReadOnlyBufferException e)
{
// expected
}
try
{
buf.Put(buf);
fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
}
catch (ReadOnlyBufferException e)
{
// expected
}
}
public override void SetUp()
{
base.SetUp();
buf = SingleBuffer.Allocate(BUFFER_LENGTH);
loadTestData1(buf);
baseBuf = buf;
}
private static void testAllocate()
{
// An IllegalArgumentException will be thrown for negative capacities.
tryCatch((Buffer)null, typeof(ArgumentException), () =>
{
SingleBuffer.Allocate(-1);
});
}
public static void Test()
{
testAllocate();
test(0, SingleBuffer.Allocate(7 * 1024), false);
test(0, SingleBuffer.Wrap(new float[7 * 1024], 0, 7 * 1024), false);
test(new float[1024]);
callReset(SingleBuffer.Allocate(10));
putBuffer();
}
public void TestAllocatedFloatBuffer_IllegalArg()
{
try
{
SingleBuffer.Allocate(-1);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentException e)
{
// expected
}
}
public virtual void TestCompareTo()
{
// J2N: Changed the behavior from Java because in .NET CompareTo is supposed to return 1 instead of throwing an exception when passed null
//try
//{
// buf.CompareTo(null);
// fail("Should throw NPE");
//}
//catch (ArgumentNullException e)
//{
// // expected
//}
// J2N: Cover null for .NET. See: https://stackoverflow.com/a/4852537
assertEquals(1, buf.CompareTo(null));
// compare to self
assertEquals(0, buf.CompareTo(buf));
// normal cases
assertTrue(buf.Capacity > 5);
buf.Clear();
SingleBuffer other = SingleBuffer.Allocate(buf.Capacity);
loadTestData1(other);
assertEquals(0, buf.CompareTo(other));
assertEquals(0, other.CompareTo(buf));
buf.Position = (1);
assertTrue(buf.CompareTo(other) > 0);
assertTrue(other.CompareTo(buf) < 0);
other.Position = (2);
assertTrue(buf.CompareTo(other) < 0);
assertTrue(other.CompareTo(buf) > 0);
buf.Position = (2);
other.Limit = (5);
assertTrue(buf.CompareTo(other) > 0);
assertTrue(other.CompareTo(buf) < 0);
SingleBuffer fbuffer1 = SingleBuffer.Wrap(new float[] { float.NaN });
SingleBuffer fbuffer2 = SingleBuffer.Wrap(new float[] { float.NaN });
SingleBuffer fbuffer3 = SingleBuffer.Wrap(new float[] { 42f });
assertEquals("Failed equal comparison with NaN entry", 0, fbuffer1
.CompareTo(fbuffer2));
assertEquals("Failed greater than comparison with NaN entry", 1, fbuffer3
.CompareTo(fbuffer1));
assertEquals("Failed less than comparison with NaN entry", -1, fbuffer1 // J2N: Corrected this (Harmony) test to match JDK 7, which expects NaN to be symmetric. This also matches .NET float.CompareTo().
.CompareTo(fbuffer3));
}
private static void bulkPutBuffer(SingleBuffer b)
{
int n = b.Capacity;
b.Clear();
SingleBuffer c = SingleBuffer.Allocate(n + 7);
c.Position = (7);
for (int i = 0; i < n; i++)
{
c.Put((float)Ic(i));
}
c.Flip();
c.Position = (7);
b.Put(c);
b.Flip();
}
public virtual void TestCompareTo()
{
try
{
buf.CompareTo(null);
fail("Should throw NPE");
}
catch (ArgumentNullException e)
{
// expected
}
// compare to self
assertEquals(0, buf.CompareTo(buf));
// normal cases
assertTrue(buf.Capacity > 5);
buf.Clear();
SingleBuffer other = SingleBuffer.Allocate(buf.Capacity);
loadTestData1(other);
assertEquals(0, buf.CompareTo(other));
assertEquals(0, other.CompareTo(buf));
buf.Position = (1);
assertTrue(buf.CompareTo(other) > 0);
assertTrue(other.CompareTo(buf) < 0);
other.Position = (2);
assertTrue(buf.CompareTo(other) < 0);
assertTrue(other.CompareTo(buf) > 0);
buf.Position = (2);
other.Limit = (5);
assertTrue(buf.CompareTo(other) > 0);
assertTrue(other.CompareTo(buf) < 0);
SingleBuffer fbuffer1 = SingleBuffer.Wrap(new float[] { float.NaN });
SingleBuffer fbuffer2 = SingleBuffer.Wrap(new float[] { float.NaN });
SingleBuffer fbuffer3 = SingleBuffer.Wrap(new float[] { 42f });
assertEquals("Failed equal comparison with NaN entry", 0, fbuffer1
.CompareTo(fbuffer2));
assertEquals("Failed greater than comparison with NaN entry", 1, fbuffer3
.CompareTo(fbuffer1));
assertEquals("Failed less than comparison with NaN entry", -1, fbuffer1 // J2N: Corrected this (Harmony) test to match JDK 7, which expects NaN to be symmetric. This also matches .NET float.CompareTo().
.CompareTo(fbuffer3));
}
public virtual void TestPutSingleBuffer()
{
SingleBuffer other = SingleBuffer.Allocate(buf.Capacity);
try
{
buf.Put(buf);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentException e)
{
// expected
}
try
{
buf.Put(SingleBuffer.Allocate(buf.Capacity + 1));
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (BufferOverflowException e)
{
// expected
}
try
{
buf.Flip();
buf.Put((SingleBuffer)null);
fail("Should throw Exception"); //$NON-NLS-1$
}
catch (ArgumentNullException e)
{
// expected
}
buf.Clear();
loadTestData2(other);
other.Clear();
buf.Clear();
SingleBuffer ret = buf.Put(other);
assertEquals(other.Position, other.Capacity);
assertEquals(buf.Position, buf.Capacity);
assertContentEquals(other, buf);
assertSame(ret, buf);
}
public static void test(int level, SingleBuffer 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((float)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, (float)42);
});
tryCatch(b, typeof(InvalidMarkException), () =>
{
b.Position = (0);
b.Mark();
b.Compact();
b.Reset();
});
// Values
b.Clear();
b.Put((float)0);
b.Put((float)-1);
b.Put((float)1);
b.Put(float.MaxValue);
b.Put(float.MinValue);
b.Put(-float.MaxValue);
b.Put(-float.MinValue);
b.Put(float.NegativeInfinity);
b.Put(float.PositiveInfinity);
b.Put(float.NaN);
b.Put(0.91697687f); // Changes value if incorrectly swapped
float v;
b.Flip();
ck(b, b.Get(), 0);
ck(b, b.Get(), (float)-1);
ck(b, b.Get(), 1);
ck(b, b.Get(), float.MaxValue);
ck(b, b.Get(), float.MinValue);
ck(b, b.Get(), -float.MaxValue);
ck(b, b.Get(), -float.MinValue);
ck(b, b.Get(), float.NegativeInfinity);
ck(b, b.Get(), float.PositiveInfinity);
// J2N TODO: Investigate why this comparison fails in .NET and passes in Java
//if (BitConversion.SingleToRawInt32Bits(v = b.Get()) != BitConversion.SingleToRawInt32Bits(float.NaN))
if (!float.IsNaN(v = b.Get()))
{
fail(b, unchecked ((long)float.NaN), (long)v);
}
ck(b, b.Get(), 0.91697687f);
// Comparison
b.Rewind();
SingleBuffer b2 = SingleBuffer.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++)
{
float x = b.Get(i);
float 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((float)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, (float)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 (float x in VALUES)
{
SingleBuffer xb = SingleBuffer.Wrap(new float[] { 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 (float y in VALUES)
{
SingleBuffer yb = SingleBuffer.Wrap(new float[] { 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 SingleBuffer.compareTo",
xb, yb, x, y);
}
if (xb.Equals(yb) != ((x == y) || (float.IsNaN(x) && float.IsNaN(y))))
{
fail("Incorrect results for SingleBuffer.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);
SingleBuffer sb = b.Slice();
checkSlice(b, sb);
b.Position = (0);
SingleBuffer 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();
SingleBuffer 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
}
