tupleformattest.java

berkeley db 4.6.21的源码。berkeley db是一个简单的数据库管理系统

        unsignedIntTest(-0xFFFFFFFFL, 1L);

        out.reset();
        out.writeUnsignedInt(0L);
        out.writeUnsignedInt(1L);
        out.writeUnsignedInt(0xFFFFFFFFL);
        assertEquals(12, out.size());
        copyOutputToInput();
        assertEquals(0L, in.readUnsignedInt());
        assertEquals(1L, in.readUnsignedInt());
        assertEquals(0xFFFFFFFFL, in.readUnsignedInt());
        assertEquals(0L, in.available());
    }

    private void byteTest(int val) {

        out.reset();
        out.writeByte(val);
        assertEquals(1, out.size());
        copyOutputToInput();
        assertEquals((byte) val, in.readByte());
    }

    public void testByte() {

        byteTest(0);
        byteTest(1);
        byteTest(-1);
        byteTest(Byte.MAX_VALUE - 1);
        byteTest(Byte.MAX_VALUE);
        byteTest(Byte.MAX_VALUE + 1);
        byteTest(Byte.MIN_VALUE + 1);
        byteTest(Byte.MIN_VALUE);
        byteTest(Byte.MIN_VALUE - 1);
        byteTest(0x7F);
        byteTest(0xFF);
        byteTest(0x7FFF);
        byteTest(0xFFFF);
        byteTest(0x7FFFFFFF);
        byteTest(0xFFFFFFFF);

        out.reset();
        out.writeByte(0);
        out.writeByte(1);
        out.writeByte(-1);
        assertEquals(3, out.size());
        copyOutputToInput();
        assertEquals(0, in.readByte());
        assertEquals(1, in.readByte());
        assertEquals(-1, in.readByte());
        assertEquals(0, in.available());
    }

    private void shortTest(int val) {

        out.reset();
        out.writeShort(val);
        assertEquals(2, out.size());
        copyOutputToInput();
        assertEquals((short) val, in.readShort());
    }

    public void testShort() {

        shortTest(0);
        shortTest(1);
        shortTest(-1);
        shortTest(Short.MAX_VALUE - 1);
        shortTest(Short.MAX_VALUE);
        shortTest(Short.MAX_VALUE + 1);
        shortTest(Short.MIN_VALUE + 1);
        shortTest(Short.MIN_VALUE);
        shortTest(Short.MIN_VALUE - 1);
        shortTest(0x7F);
        shortTest(0xFF);
        shortTest(0x7FFF);
        shortTest(0xFFFF);
        shortTest(0x7FFFFFFF);
        shortTest(0xFFFFFFFF);

        out.reset();
        out.writeShort(0);
        out.writeShort(1);
        out.writeShort(-1);
        assertEquals(3 * 2, out.size());
        copyOutputToInput();
        assertEquals(0, in.readShort());
        assertEquals(1, in.readShort());
        assertEquals(-1, in.readShort());
        assertEquals(0, in.available());
    }

    private void intTest(int val) {

        out.reset();
        out.writeInt(val);
        assertEquals(4, out.size());
        copyOutputToInput();
        assertEquals((int) val, in.readInt());
    }

    public void testInt() {

        intTest(0);
        intTest(1);
        intTest(-1);
        intTest(Integer.MAX_VALUE - 1);
        intTest(Integer.MAX_VALUE);
        intTest(Integer.MAX_VALUE + 1);
        intTest(Integer.MIN_VALUE + 1);
        intTest(Integer.MIN_VALUE);
        intTest(Integer.MIN_VALUE - 1);
        intTest(0x7F);
        intTest(0xFF);
        intTest(0x7FFF);
        intTest(0xFFFF);
        intTest(0x7FFFFFFF);
        intTest(0xFFFFFFFF);

        out.reset();
        out.writeInt(0);
        out.writeInt(1);
        out.writeInt(-1);
        assertEquals(3 * 4, out.size());
        copyOutputToInput();
        assertEquals(0, in.readInt());
        assertEquals(1, in.readInt());
        assertEquals(-1, in.readInt());
        assertEquals(0, in.available());
    }

    private void longTest(long val) {

        out.reset();
        out.writeLong(val);
        assertEquals(8, out.size());
        copyOutputToInput();
        assertEquals((long) val, in.readLong());
    }

    public void testLong() {

        longTest(0);
        longTest(1);
        longTest(-1);
        longTest(Long.MAX_VALUE - 1);
        longTest(Long.MAX_VALUE);
        longTest(Long.MAX_VALUE + 1);
        longTest(Long.MIN_VALUE + 1);
        longTest(Long.MIN_VALUE);
        longTest(Long.MIN_VALUE - 1);
        longTest(0x7F);
        longTest(0xFF);
        longTest(0x7FFF);
        longTest(0xFFFF);
        longTest(0x7FFFFFFF);
        longTest(0xFFFFFFFF);
        longTest(0x7FFFFFFFFFFFFFFFL);
        longTest(0xFFFFFFFFFFFFFFFFL);

        out.reset();
        out.writeLong(0);
        out.writeLong(1);
        out.writeLong(-1);
        assertEquals(3 * 8, out.size());
        copyOutputToInput();
        assertEquals(0, in.readLong());
        assertEquals(1, in.readLong());
        assertEquals(-1, in.readLong());
        assertEquals(0, in.available());
    }

    private void floatTest(double val) {

        out.reset();
        out.writeFloat((float) val);
        assertEquals(4, out.size());
        copyOutputToInput();
        if (Double.isNaN(val)) {
            assertTrue(Float.isNaN(in.readFloat()));
        } else {
            assertEquals((float) val, in.readFloat(), 0);
        }
    }

    public void testFloat() {

        floatTest(0);
        floatTest(1);
        floatTest(-1);
        floatTest(1.0);
        floatTest(0.1);
        floatTest(-1.0);
        floatTest(-0.1);
        floatTest(Float.NaN);
        floatTest(Float.NEGATIVE_INFINITY);
        floatTest(Float.POSITIVE_INFINITY);
        floatTest(Short.MAX_VALUE);
        floatTest(Short.MIN_VALUE);
        floatTest(Integer.MAX_VALUE);
        floatTest(Integer.MIN_VALUE);
        floatTest(Long.MAX_VALUE);
        floatTest(Long.MIN_VALUE);
        floatTest(Float.MAX_VALUE);
        floatTest(Float.MAX_VALUE + 1);
        floatTest(Float.MIN_VALUE + 1);
        floatTest(Float.MIN_VALUE);
        floatTest(Float.MIN_VALUE - 1);
        floatTest(0x7F);
        floatTest(0xFF);
        floatTest(0x7FFF);
        floatTest(0xFFFF);
        floatTest(0x7FFFFFFF);
        floatTest(0xFFFFFFFF);
        floatTest(0x7FFFFFFFFFFFFFFFL);
        floatTest(0xFFFFFFFFFFFFFFFFL);

        out.reset();
        out.writeFloat(0);
        out.writeFloat(1);
        out.writeFloat(-1);
        assertEquals(3 * 4, out.size());
        copyOutputToInput();
        assertEquals(0, in.readFloat(), 0);
        assertEquals(1, in.readFloat(), 0);
        assertEquals(-1, in.readFloat(), 0);
        assertEquals(0, in.available(), 0);
    }

    private void doubleTest(double val) {

        out.reset();
        out.writeDouble((double) val);
        assertEquals(8, out.size());
        copyOutputToInput();
        if (Double.isNaN(val)) {
            assertTrue(Double.isNaN(in.readDouble()));
        } else {
            assertEquals((double) val, in.readDouble(), 0);
        }
    }

    public void testDouble() {

        doubleTest(0);
        doubleTest(1);
        doubleTest(-1);
        doubleTest(1.0);
        doubleTest(0.1);
        doubleTest(-1.0);
        doubleTest(-0.1);
        doubleTest(Double.NaN);
        doubleTest(Double.NEGATIVE_INFINITY);
        doubleTest(Double.POSITIVE_INFINITY);
        doubleTest(Short.MAX_VALUE);
        doubleTest(Short.MIN_VALUE);
        doubleTest(Integer.MAX_VALUE);
        doubleTest(Integer.MIN_VALUE);
        doubleTest(Long.MAX_VALUE);
        doubleTest(Long.MIN_VALUE);
        doubleTest(Float.MAX_VALUE);
        doubleTest(Float.MIN_VALUE);
        doubleTest(Double.MAX_VALUE - 1);
        doubleTest(Double.MAX_VALUE);
        doubleTest(Double.MAX_VALUE + 1);
        doubleTest(Double.MIN_VALUE + 1);
        doubleTest(Double.MIN_VALUE);
        doubleTest(Double.MIN_VALUE - 1);
        doubleTest(0x7F);
        doubleTest(0xFF);
        doubleTest(0x7FFF);
        doubleTest(0xFFFF);
        doubleTest(0x7FFFFFFF);
        doubleTest(0xFFFFFFFF);
        doubleTest(0x7FFFFFFFFFFFFFFFL);
        doubleTest(0xFFFFFFFFFFFFFFFFL);

        out.reset();
        out.writeDouble(0);
        out.writeDouble(1);
        out.writeDouble(-1);
        assertEquals(3 * 8, out.size());
        copyOutputToInput();
        assertEquals(0, in.readDouble(), 0);
        assertEquals(1, in.readDouble(), 0);
        assertEquals(-1, in.readDouble(), 0);
        assertEquals(0, in.available(), 0);
    }

    private void sortedFloatTest(double val) {

        out.reset();
        out.writeSortedFloat((float) val);
        assertEquals(4, out.size());
        copyOutputToInput();
        if (Double.isNaN(val)) {
            assertTrue(Float.isNaN(in.readSortedFloat()));
        } else {
            assertEquals((float) val, in.readSortedFloat(), 0);
        }
    }

    public void testSortedFloat() {

        sortedFloatTest(0);
        sortedFloatTest(1);
        sortedFloatTest(-1);
        sortedFloatTest(1.0);
        sortedFloatTest(0.1);
        sortedFloatTest(-1.0);
        sortedFloatTest(-0.1);
        sortedFloatTest(Float.NaN);
        sortedFloatTest(Float.NEGATIVE_INFINITY);
        sortedFloatTest(Float.POSITIVE_INFINITY);
        sortedFloatTest(Short.MAX_VALUE);
        sortedFloatTest(Short.MIN_VALUE);
        sortedFloatTest(Integer.MAX_VALUE);
        sortedFloatTest(Integer.MIN_VALUE);
        sortedFloatTest(Long.MAX_VALUE);
        sortedFloatTest(Long.MIN_VALUE);
        sortedFloatTest(Float.MAX_VALUE);
        sortedFloatTest(Float.MAX_VALUE + 1);
        sortedFloatTest(Float.MIN_VALUE + 1);
        sortedFloatTest(Float.MIN_VALUE);
        sortedFloatTest(Float.MIN_VALUE - 1);
        sortedFloatTest(0x7F);
        sortedFloatTest(0xFF);
        sortedFloatTest(0x7FFF);
        sortedFloatTest(0xFFFF);
        sortedFloatTest(0x7FFFFFFF);
        sortedFloatTest(0xFFFFFFFF);
        sortedFloatTest(0x7FFFFFFFFFFFFFFFL);
        sortedFloatTest(0xFFFFFFFFFFFFFFFFL);

        out.reset();
        out.writeSortedFloat(0);
        out.writeSortedFloat(1);
        out.writeSortedFloat(-1);
        assertEquals(3 * 4, out.size());
        copyOutputToInput();
        assertEquals(0, in.readSortedFloat(), 0);
        assertEquals(1, in.readSortedFloat(), 0);
        assertEquals(-1, in.readSortedFloat(), 0);
        assertEquals(0, in.available(), 0);
    }

    private void sortedDoubleTest(double val) {

        out.reset();
        out.writeSortedDouble((double) val);
        assertEquals(8, out.size());
        copyOutputToInput();
        if (Double.isNaN(val)) {
            assertTrue(Double.isNaN(in.readSortedDouble()));
        } else {
            assertEquals((double) val, in.readSortedDouble(), 0);
        }
    }

    public void testSortedDouble() {

        sortedDoubleTest(0);
        sortedDoubleTest(1);
        sortedDoubleTest(-1);
        sortedDoubleTest(1.0);
        sortedDoubleTest(0.1);
        sortedDoubleTest(-1.0);
        sortedDoubleTest(-0.1);
        sortedDoubleTest(Double.NaN);
        sortedDoubleTest(Double.NEGATIVE_INFINITY);
        sortedDoubleTest(Double.POSITIVE_INFINITY);
        sortedDoubleTest(Short.MAX_VALUE);
        sortedDoubleTest(Short.MIN_VALUE);
        sortedDoubleTest(Integer.MAX_VALUE);
        sortedDoubleTest(Integer.MIN_VALUE);
        sortedDoubleTest(Long.MAX_VALUE);
        sortedDoubleTest(Long.MIN_VALUE);
        sortedDoubleTest(Float.MAX_VALUE);
        sortedDoubleTest(Float.MIN_VALUE);
        sortedDoubleTest(Double.MAX_VALUE - 1);
        sortedDoubleTest(Double.MAX_VALUE);
        sortedDoubleTest(Double.MAX_VALUE + 1);
        sortedDoubleTest(Double.MIN_VALUE + 1);
        sortedDoubleTest(Double.MIN_VALUE);
        sortedDoubleTest(Double.MIN_VALUE - 1);
        sortedDoubleTest(0x7F);
        sortedDoubleTest(0xFF);
        sortedDoubleTest(0x7FFF);
        sortedDoubleTest(0xFFFF);
        sortedDoubleTest(0x7FFFFFFF);
        sortedDoubleTest(0xFFFFFFFF);
        sortedDoubleTest(0x7FFFFFFFFFFFFFFFL);
        sortedDoubleTest(0xFFFFFFFFFFFFFFFFL);

        out.reset();
        out.writeSortedDouble(0);
        out.writeSortedDouble(1);
        out.writeSortedDouble(-1);
        assertEquals(3 * 8, out.size());
        copyOutputToInput();
        assertEquals(0, in.readSortedDouble(), 0);
        assertEquals(1, in.readSortedDouble(), 0);
        assertEquals(-1, in.readSortedDouble(), 0);
        assertEquals(0, in.available(), 0);
    }

    private void packedIntTest(int val, int size) {

        out.reset();
        out.writePackedInt(val);
        assertEquals(size, out.size());
        copyOutputToInput();
        assertEquals(size, in.getPackedIntByteLength());
        assertEquals(val, in.readPackedInt());
    }

    public void testPackedInt() {

        /* Exhaustive value testing is in PackedIntTest. */
        packedIntTest(119, 1);
        packedIntTest(0xFFFF + 119, 3);
        packedIntTest(Integer.MAX_VALUE, 5);

        out.reset();
        out.writePackedInt(119);
        out.writePackedInt(0xFFFF + 119);
        out.writePackedInt(Integer.MAX_VALUE);
        assertEquals(1 + 3 + 5, out.size());
        copyOutputToInput();
        assertEquals(119, in.readPackedInt(), 0);
        assertEquals(0xFFFF + 119, in.readPackedInt(), 0);
        assertEquals(Integer.MAX_VALUE, in.readPackedInt(), 0);
        assertEquals(0, in.available(), 0);
    }

    private void packedLongTest(long val, int size) {

        out.reset();
        out.writePackedLong(val);
        assertEquals(size, out.size());
        copyOutputToInput();
        assertEquals(size, in.getPackedLongByteLength());
        assertEquals(val, in.readPackedLong());
    }

    public void testPackedLong() {

        /* Exhaustive value testing is in PackedIntTest. */
        packedLongTest(119, 1);
        packedLongTest(0xFFFFFFFFL + 119, 5);
        packedLongTest(Long.MAX_VALUE, 9);

        out.reset();
        out.writePackedLong(119);
        out.writePackedLong(0xFFFFFFFFL + 119);
        out.writePackedLong(Long.MAX_VALUE);
        assertEquals(1 + 5 + 9, out.size());
        copyOutputToInput();
        assertEquals(119, in.readPackedLong(), 0);
        assertEquals(0xFFFFFFFFL + 119, in.readPackedLong(), 0);
        assertEquals(Long.MAX_VALUE, in.readPackedLong(), 0);
        assertEquals(0, in.available(), 0);
    }
}