Exemplo n.º 1
0
        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
        }
Exemplo n.º 2
0
 private static void bulkPutBuffer(ByteBufferN b)
 {
     int n = b.capacity();
     b.clear();
     ByteBufferN c = ByteBufferN.allocate(n + 7);
     c.position(7);
     for (int i = 0; i < n; i++)
         c.put((byte)ic(i));
     c.flip();
     c.position(7);
     b.put(c);
     b.flip();
 }
Exemplo n.º 3
0
 private static void relPut(ByteBufferN b)
 {
     int n = b.capacity();
     b.clear();
     for (int i = 0; i < n; i++)
         b.put((byte)ic(i));
     b.flip();
 }
Exemplo n.º 4
0
 private static void bulkPutArray(ByteBufferN b)
 {
     int n = b.capacity();
     b.clear();
     var a = new byte[n + 7];
     for (int i = 0; i < n; i++)
         a[i + 7] = (byte)ic(i);
     b.put(a, 7, n);
     b.flip();
 }