private static void absPut(ByteBufferN 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 checkSlice(ByteBufferN b, ByteBufferN 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); } }
public static void test() { testAllocate(); test(0, ByteBufferN.allocate(7 * 1024), false); test(0, ByteBufferN.wrap(new byte[7 * 1024], 0, 7 * 1024), false); test(new byte[1024]); ByteBufferN b = ByteBufferN.allocateDirect(7 * 1024); for (b.position(0); b.position() < b.limit();) { ck(b, b.get(), 0); } test(0, b, true); callReset(ByteBufferN.allocate(10)); }
public static void test(byte[] ba) { int offset = 47; int length = 900; ByteBufferN b = ByteBufferN.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(IndexOutOfBoundsException), () => { ByteBufferN.wrap(ba, -1, ba.Length); }); tryCatch(ba, typeof(IndexOutOfBoundsException), () => { ByteBufferN.wrap(ba, ba.Length + 1, ba.Length); }); tryCatch(ba, typeof(IndexOutOfBoundsException), () => { ByteBufferN.wrap(ba, 0, -1); }); tryCatch(ba, typeof(IndexOutOfBoundsException), () => { ByteBufferN.wrap(ba, 0, ba.Length + 1); }); // A NullPointerException will be thrown if the array is null. tryCatch(ba, typeof(NullReferenceException), () => { ByteBufferN.wrap(null, 0, 5); }); tryCatch(ba, typeof(NullReferenceException), () => { ByteBufferN.wrap(null); }); }
public static void test(int level, ByteBufferN b, bool direct) { show(level, b); //TODO if (direct != b.isDirect()) //TODO 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(42); }); // The index must be non-negative and lesss than the buffer's limit. tryCatch(b, typeof(IndexOutOfBoundsException), () => { b.get(b.limit()); }); tryCatch(b, typeof(IndexOutOfBoundsException), () => { b.get(-1); }); tryCatch(b, typeof(IndexOutOfBoundsException), () => { b.put(b.limit(), 42); }); tryCatch(b, typeof(InvalidMarkException), () => { b.position(0); b.mark(); b.compact(); b.reset(); }); // Values b.clear(); b.put(0); b.put(0xff); b.put(1); b.put(Byte.MAX_VALUE); b.put(Byte.MIN_VALUE); b.flip(); ck(b, b.get(), 0); ck(b, b.get(), 0xff); ck(b, b.get(), 1); ck(b, b.get(), Byte.MAX_VALUE); ck(b, b.get(), Byte.MIN_VALUE); // Comparison b.rewind(); ByteBufferN b2 = ByteBufferN.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 ) { outt.println("[" + 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(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, 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); } // 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); ByteBufferN sb = b.slice(); checkSlice(b, sb); b.position(0); ByteBufferN 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 /* TODO * b.rewind(); * ByteBuffer rb = b.asReadOnlyBuffer(); * if (!b.equals(rb)) * fail("BufferN 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(); }); * * * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putChar((char)1); }); * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putChar(0, (char)1); }); * * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putShort(1); }); * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putShort(0, 1); }); * * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putInt(1); }); * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putInt(0, 1); }); * * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putLong(1); }); * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putLong(0, 1); }); * * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putFloat(1); }); * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putFloat(0, 1); }); * * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putDouble(1); }); * tryCatch(b, typeof(ReadOnlyBufferException), () => { rb.putDouble(0, 1); }); * * * // Bulk puts from read-only buffers * * b.clear(); * rb.rewind(); * b.put(rb); * * * // For byte buffers, test both the direct and non-direct cases * ByteBuffer ob * = (b.isDirect() * ? ByteBuffer.allocate(rb.capacity()) * : ByteBuffer.allocateDirect(rb.capacity())); * rb.rewind(); * ob.put(rb); * * */ relPut(b); // Required by testViews }
private static void testHet(int level, ByteBufferN b) { int p = b.position(); b.limit(b.capacity()); show(level, b); outt.print(" put:"); b.putChar((char)1); b.putChar(Character.MAX_VALUE); outt.print(" char"); b.putShort(1); b.putShort(Short.MAX_VALUE); outt.print(" short"); b.putInt(1); b.putInt(Integer.MAX_VALUE); outt.print(" int"); b.putLong(1); b.putLong(Long.MAX_VALUE); outt.print(" long"); b.putFloat(1); b.putFloat(Float.MIN_VALUE); b.putFloat(Float.MAX_VALUE); outt.print(" float"); b.putDouble(1); b.putDouble(Double.MIN_VALUE); b.putDouble(Double.MAX_VALUE); outt.print(" double"); outt.println(); b.limit(b.position()); b.position(p); show(level, b); outt.print(" get:"); ck(b, b.getChar(), 1); ck(b, b.getChar(), Character.MAX_VALUE); outt.print(" char"); ck(b, b.getShort(), 1); ck(b, b.getShort(), Short.MAX_VALUE); outt.print(" short"); ck(b, b.getInt(), 1); ck(b, b.getInt(), Integer.MAX_VALUE); outt.print(" int"); ck(b, b.getLong(), 1); ck(b, b.getLong(), Long.MAX_VALUE); outt.print(" long"); ck(b, (long)b.getFloat(), 1); ck(b, (long)b.getFloat(), (long)Float.MIN_VALUE); ck(b, (long)b.getFloat(), (long)Float.MAX_VALUE); outt.print(" float"); ck(b, (long)b.getDouble(), 1); ck(b, (long)b.getDouble(), (long)Double.MIN_VALUE); ck(b, (long)b.getDouble(), (long)Double.MAX_VALUE); outt.print(" double"); outt.println(); }