private static void testAllocate() { // An IllegalArgumentException will be thrown for negative capacities. tryCatch((Buffer)null, typeof(ArgumentException), () => { SingleBuffer.Allocate(-1); }); }
void assertContentEquals(SingleBuffer buf, float[] array, int offset, int length) { for (int i = 0; i < length; i++) { assertEquals(buf.Get(i), array[offset + i], 0.01); } }
internal void loadTestData2(SingleBuffer buf) { buf.Clear(); for (int i = 0; i < buf.Capacity; i++) { buf.Put(i, (float)buf.Capacity - i); } }
//6231529 private static void callReset(SingleBuffer b) { b.Position = (0); b.Mark(); b.Duplicate().Reset(); b.AsReadOnlyBuffer().Reset(); }
void assertContentEquals(SingleBuffer buf, SingleBuffer other) { assertEquals(buf.Capacity, other.Capacity); for (int i = 0; i < buf.Capacity; i++) { assertEquals(buf.Get(i), other.Get(i), 0.01); } }
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(); }
void assertContentLikeTestData1(SingleBuffer buf, int startIndex, float startValue, int length) { float value = startValue; for (int i = 0; i < length; i++) { assertEquals(buf.Get(startIndex + i), value, 0.01); value = value + 1.0f; } }
private static void relPut(SingleBuffer b) { int n = b.Capacity; b.Clear(); for (int i = 0; i < n; i++) { b.Put((float)Ic(i)); } b.Flip(); }
private static void bulkGet(SingleBuffer b) { int n = b.Capacity; float[] a = new float[n + 7]; b.Get(a, 7, n); for (int i = 0; i < n; i++) { ck(b, (long)a[i + 7], (long)((float)Ic(i))); } }
private static void relGet(SingleBuffer b, int start) { int n = b.Remaining; float v; for (int i = start; i < n; i++) { ck(b, (long)b.Get(), (long)((float)Ic(i))); } b.Rewind(); }
private static void absGet(SingleBuffer b) { int n = b.Capacity; float v; for (int i = 0; i < n; i++) { ck(b, (long)b.Get(), (long)((float)Ic(i))); } b.Rewind(); }
public void TestAllocatedFloatBuffer_IllegalArg() { try { SingleBuffer.Allocate(-1); fail("Should throw Exception"); //$NON-NLS-1$ } catch (ArgumentException e) { // expected } }
private static void checkSlice(SingleBuffer b, SingleBuffer slice) { ck(slice, 0, slice.Position); ck(slice, b.Remaining, slice.Limit); ck(slice, b.Remaining, slice.Capacity); //if (b.IsDirect != slice.IsDirect) // J2N: IsDirect not supported // fail("Lost direction", slice); if (b.IsReadOnly != slice.IsReadOnly) { fail("Lost read-only", slice); } }
private static void absPut(SingleBuffer b) { int n = b.Capacity; b.Clear(); for (int i = 0; i < n; i++) { b.Put(i, (float)Ic(i)); } b.Limit = (n); b.Position = (0); }
public virtual void TestHashCode() { buf.Clear(); SingleBuffer @readonly = buf.AsReadOnlyBuffer(); SingleBuffer duplicate = buf.Duplicate(); assertTrue(buf.GetHashCode() == @readonly.GetHashCode()); assertTrue(buf.Capacity > 5); duplicate.Position = (buf.Capacity / 2); assertTrue(buf.GetHashCode() != duplicate.GetHashCode()); }
private static void bulkPutArray(SingleBuffer b) { int n = b.Capacity; b.Clear(); float[] a = new float[n + 7]; for (int i = 0; i < n; i++) { a[i + 7] = (float)Ic(i); } b.Put(a, 7, n); b.Flip(); }
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 virtual void TestPutfloat() { buf.Clear(); for (int i = 0; i < buf.Capacity; i++) { assertEquals(buf.Position, i); SingleBuffer ret = buf.Put((float)i); assertEquals(buf.Get(i), (float)i, 0.0); assertSame(ret, buf); } try { buf.Put(0); fail("Should throw Exception"); //$NON-NLS-1$ } catch (BufferOverflowException e) { // expected } }
public static void test(float[] ba) { int offset = 47; int length = 900; SingleBuffer b = SingleBuffer.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), () => { SingleBuffer.Wrap(ba, -1, ba.Length); }); tryCatch(ba, typeof(ArgumentOutOfRangeException), () => { SingleBuffer.Wrap(ba, ba.Length + 1, ba.Length); }); tryCatch(ba, typeof(ArgumentOutOfRangeException), () => { SingleBuffer.Wrap(ba, 0, -1); }); tryCatch(ba, typeof(ArgumentOutOfRangeException), () => { SingleBuffer.Wrap(ba, 0, ba.Length + 1); }); // A NullPointerException will be thrown if the array is null. tryCatch(ba, typeof(ArgumentNullException), () => { SingleBuffer.Wrap((float[])null, 0, 5); }); tryCatch(ba, typeof(ArgumentNullException), () => { SingleBuffer.Wrap((float[])null); }); }
private static void testViews(int level, ByteBuffer b, bool direct) { Int16Buffer sb = b.AsInt16Buffer(); TestInt16Buffer2.test(level, sb, direct); checkBytes(b, new byte[] { 0, (byte)Ic(0) }); checkInvalidMarkException(sb); CharBuffer cb = b.AsCharBuffer(); TestCharBuffer2.test(level, cb, direct); checkBytes(b, new byte[] { 0, (byte)Ic(0) }); checkInvalidMarkException(cb); Int32Buffer ib = b.AsInt32Buffer(); TestInt32Buffer2.test(level, ib, direct); checkBytes(b, new byte[] { 0, 0, 0, (byte)Ic(0) }); checkInvalidMarkException(ib); Int64Buffer lb = b.AsInt64Buffer(); TestInt64Buffer2.test(level, lb, direct); checkBytes(b, new byte[] { 0, 0, 0, 0, 0, 0, 0, (byte)Ic(0) }); checkInvalidMarkException(lb); SingleBuffer fb = b.AsSingleBuffer(); TestSingleBuffer2.test(level, fb, direct); checkBytes(b, new byte[] { 0x42, (byte)0xc2, 0, 0 }); checkInvalidMarkException(fb); DoubleBuffer db = b.AsDoubleBuffer(); TestDoubleBuffer2.test(level, db, direct); checkBytes(b, new byte[] { 0x40, 0x58, 0x40, 0, 0, 0, 0, 0 }); checkInvalidMarkException(db); }
// 6221101-6234263 private static void putBuffer() { int cap = 10; // J2N: AllocateDirect not implemented //SingleBuffer direct1 = ByteBuffer.AllocateDirect(cap).AsSingleBuffer(); SingleBuffer nondirect1 = ByteBuffer.Allocate(cap).AsSingleBuffer(); //direct1.Put(nondirect1); //SingleBuffer direct2 = ByteBuffer.AllocateDirect(cap).AsSingleBuffer(); SingleBuffer nondirect2 = ByteBuffer.Allocate(cap).AsSingleBuffer(); //nondirect2.Put(direct2); //SingleBuffer direct3 = ByteBuffer.AllocateDirect(cap).AsSingleBuffer(); //SingleBuffer direct4 = ByteBuffer.AllocateDirect(cap).AsSingleBuffer(); //direct3.Put(direct4); SingleBuffer nondirect3 = ByteBuffer.Allocate(cap).AsSingleBuffer(); SingleBuffer nondirect4 = ByteBuffer.Allocate(cap).AsSingleBuffer(); nondirect3.Put(nondirect4); }
public virtual void TestEquals() { // equal to self assertTrue(buf.Equals(buf)); SingleBuffer @readonly = buf.AsReadOnlyBuffer(); assertTrue(buf.Equals(@readonly)); SingleBuffer 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() { SingleBuffer duplicate = buf.Duplicate(); assertEquals(buf.GetHashCode(), duplicate.GetHashCode()); }
public void TestWrappedFloatBuffer_IllegalArg() { float[] array = new float[20]; try { SingleBuffer.Wrap(array, -1, 0); fail("Should throw Exception"); //$NON-NLS-1$ } catch (ArgumentOutOfRangeException e) { // expected } try { SingleBuffer.Wrap(array, 21, 0); fail("Should throw Exception"); //$NON-NLS-1$ } catch (ArgumentOutOfRangeException e) { // expected } try { SingleBuffer.Wrap(array, 0, -1); fail("Should throw Exception"); //$NON-NLS-1$ } catch (ArgumentOutOfRangeException e) { // expected } try { SingleBuffer.Wrap(array, 0, 21); fail("Should throw Exception"); //$NON-NLS-1$ } catch (ArgumentOutOfRangeException e) { // expected } try { SingleBuffer.Wrap(array, int.MaxValue, 1); fail("Should throw Exception"); //$NON-NLS-1$ } catch (ArgumentOutOfRangeException e) { // expected } try { SingleBuffer.Wrap(array, 1, int.MaxValue); fail("Should throw Exception"); //$NON-NLS-1$ } catch (ArgumentOutOfRangeException e) { // expected } try { SingleBuffer.Wrap((float[])null, -1, 0); fail("Should throw NPE"); //$NON-NLS-1$ } catch (ArgumentNullException e) { } SingleBuffer buf = SingleBuffer.Wrap(array, 2, 16); assertEquals(buf.Position, 2); assertEquals(buf.Limit, 18); assertEquals(buf.Capacity, 20); }
public virtual void TestPutfloatArrayintint() { buf.Clear(); float[] array = new float[buf.Capacity]; try { buf.Put(new float[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((float[])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); SingleBuffer 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 = SingleBuffer.Allocate(BUFFER_LENGTH); loadTestData1(buf); baseBuf = buf; }