Berkeley DB 4.8 with rust build script for linux.

9 files changed, 3000 insertions, 0 deletions

diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/MarshalledObject.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/MarshalledObject.java
new file mode 100644
index 0000000..b03584a
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/MarshalledObject.java
@@ -0,0 +1,127 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.serial.test;
+
+import java.io.Serializable;
+
+import com.sleepycat.bind.tuple.MarshalledTupleKeyEntity;
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * @author Mark Hayes
+ */
+@SuppressWarnings("serial")
+public class MarshalledObject
+    implements Serializable, MarshalledTupleKeyEntity {
+
+    private String data;
+    private transient String primaryKey;
+    private String indexKey1;
+    private String indexKey2;
+
+    public MarshalledObject(String data, String primaryKey,
+                            String indexKey1, String indexKey2) {
+        this.data = data;
+        this.primaryKey = primaryKey;
+        this.indexKey1 = indexKey1;
+        this.indexKey2 = indexKey2;
+    }
+
+    public boolean equals(Object o) {
+
+        try {
+            MarshalledObject other = (MarshalledObject) o;
+
+            return this.data.equals(other.data) &&
+                   this.primaryKey.equals(other.primaryKey) &&
+                   this.indexKey1.equals(other.indexKey1) &&
+                   this.indexKey2.equals(other.indexKey2);
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    public String getData() {
+
+        return data;
+    }
+
+    public String getPrimaryKey() {
+
+        return primaryKey;
+    }
+
+    public String getIndexKey1() {
+
+        return indexKey1;
+    }
+
+    public String getIndexKey2() {
+
+        return indexKey2;
+    }
+
+    public int expectedKeyLength() {
+
+        return primaryKey.length() + 1;
+    }
+
+    public void marshalPrimaryKey(TupleOutput keyOutput) {
+
+        keyOutput.writeString(primaryKey);
+    }
+
+    public void unmarshalPrimaryKey(TupleInput keyInput) {
+
+        primaryKey = keyInput.readString();
+    }
+
+    public boolean marshalSecondaryKey(String keyName, TupleOutput keyOutput) {
+
+        if ("1".equals(keyName)) {
+            if (indexKey1.length() > 0) {
+                keyOutput.writeString(indexKey1);
+                return true;
+            } else {
+                return false;
+            }
+        } else if ("2".equals(keyName)) {
+            if (indexKey2.length() > 0) {
+                keyOutput.writeString(indexKey2);
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            throw new IllegalArgumentException("Unknown keyName: " + keyName);
+        }
+    }
+
+    public boolean nullifyForeignKey(String keyName) {
+
+        if ("1".equals(keyName)) {
+            if (indexKey1.length() > 0) {
+                indexKey1 = "";
+                return true;
+            } else {
+                return false;
+            }
+        } else if ("2".equals(keyName)) {
+            if (indexKey2.length() > 0) {
+                indexKey2 = "";
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            throw new IllegalArgumentException("Unknown keyName: " + keyName);
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/NullClassCatalog.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/NullClassCatalog.java
new file mode 100644
index 0000000..a8ad23e
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/NullClassCatalog.java
@@ -0,0 +1,37 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.serial.test;
+
+import java.io.ObjectStreamClass;
+import java.math.BigInteger;
+
+import com.sleepycat.bind.serial.ClassCatalog;
+
+/**
+ * NullCatalog is a dummy Catalog implementation that simply
+ * returns large (8 byte) class IDs so that ObjectOutput
+ * can be simulated when computing a serialized size.
+ *
+ * @author Mark Hayes
+ */
+class NullClassCatalog implements ClassCatalog {
+
+    private long id = Long.MAX_VALUE;
+
+    public void close() {
+    }
+
+    public byte[] getClassID(ObjectStreamClass classFormat) {
+        return BigInteger.valueOf(id--).toByteArray();
+    }
+
+    public ObjectStreamClass getClassFormat(byte[] classID) {
+        return null; // ObjectInput not supported
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/SerialBindingTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/SerialBindingTest.java
new file mode 100644
index 0000000..a9ddbed
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/SerialBindingTest.java
@@ -0,0 +1,330 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.serial.test;
+
+import java.io.Serializable;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.sleepycat.bind.EntityBinding;
+import com.sleepycat.bind.serial.ClassCatalog;
+import com.sleepycat.bind.serial.SerialBinding;
+import com.sleepycat.bind.serial.SerialSerialBinding;
+import com.sleepycat.bind.serial.TupleSerialMarshalledBinding;
+import com.sleepycat.db.DatabaseEntry;
+import com.sleepycat.util.ExceptionUnwrapper;
+import com.sleepycat.util.FastOutputStream;
+import com.sleepycat.util.test.SharedTestUtils;
+
+/**
+ * @author Mark Hayes
+ */
+public class SerialBindingTest extends TestCase {
+
+    private ClassCatalog catalog;
+    private DatabaseEntry buffer;
+    private DatabaseEntry keyBuffer;
+
+    public static void main(String[] args) {
+        junit.framework.TestResult tr =
+            junit.textui.TestRunner.run(suite());
+        if (tr.errorCount() > 0 ||
+            tr.failureCount() > 0) {
+            System.exit(1);
+        } else {
+            System.exit(0);
+        }
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite(SerialBindingTest.class);
+        return suite;
+    }
+
+    public SerialBindingTest(String name) {
+
+        super(name);
+    }
+
+    @Override
+    public void setUp() {
+
+        SharedTestUtils.printTestName("SerialBindingTest." + getName());
+        catalog = new TestClassCatalog();
+        buffer = new DatabaseEntry();
+        keyBuffer = new DatabaseEntry();
+    }
+
+    @Override
+    public void tearDown() {
+
+        /* Ensure that GC can cleanup. */
+        catalog = null;
+        buffer = null;
+        keyBuffer = null;
+    }
+
+    @Override
+    public void runTest()
+        throws Throwable {
+
+        try {
+            super.runTest();
+        } catch (Exception e) {
+            throw ExceptionUnwrapper.unwrap(e);
+        }
+    }
+
+    private void primitiveBindingTest(Object val) {
+
+        Class cls = val.getClass();
+        SerialBinding binding = new SerialBinding(catalog, cls);
+
+        binding.objectToEntry(val, buffer);
+        assertTrue(buffer.getSize() > 0);
+
+        Object val2 = binding.entryToObject(buffer);
+        assertSame(cls, val2.getClass());
+        assertEquals(val, val2);
+
+        Object valWithWrongCls = (cls == String.class)
+                      ? ((Object) new Integer(0)) : ((Object) new String(""));
+        try {
+            binding.objectToEntry(valWithWrongCls, buffer);
+        } catch (IllegalArgumentException expected) {}
+    }
+
+    public void testPrimitiveBindings() {
+
+        primitiveBindingTest("abc");
+        primitiveBindingTest(new Character('a'));
+        primitiveBindingTest(new Boolean(true));
+        primitiveBindingTest(new Byte((byte) 123));
+        primitiveBindingTest(new Short((short) 123));
+        primitiveBindingTest(new Integer(123));
+        primitiveBindingTest(new Long(123));
+        primitiveBindingTest(new Float(123.123));
+        primitiveBindingTest(new Double(123.123));
+    }
+
+    public void testNullObjects() {
+
+        SerialBinding binding = new SerialBinding(catalog, null);
+        buffer.setSize(0);
+        binding.objectToEntry(null, buffer);
+        assertTrue(buffer.getSize() > 0);
+        assertEquals(null, binding.entryToObject(buffer));
+    }
+
+    public void testSerialSerialBinding() {
+
+        SerialBinding keyBinding = new SerialBinding(catalog, String.class);
+        SerialBinding valueBinding = new SerialBinding(catalog, String.class);
+        EntityBinding binding = new MySerialSerialBinding(keyBinding,
+                                                          valueBinding);
+
+        String val = "key#value?indexKey";
+        binding.objectToData(val, buffer);
+        assertTrue(buffer.getSize() > 0);
+        binding.objectToKey(val, keyBuffer);
+        assertTrue(keyBuffer.getSize() > 0);
+
+        Object result = binding.entryToObject(keyBuffer, buffer);
+        assertEquals(val, result);
+    }
+
+    // also tests TupleSerialBinding since TupleSerialMarshalledBinding extends
+    // it
+    public void testTupleSerialMarshalledBinding() {
+
+        SerialBinding valueBinding = new SerialBinding(catalog,
+                                                    MarshalledObject.class);
+        EntityBinding binding =
+            new TupleSerialMarshalledBinding(valueBinding);
+
+        MarshalledObject val = new MarshalledObject("abc", "primary",
+                                                    "index1", "index2");
+        binding.objectToData(val, buffer);
+        assertTrue(buffer.getSize() > 0);
+        binding.objectToKey(val, keyBuffer);
+        assertEquals(val.expectedKeyLength(), keyBuffer.getSize());
+
+        Object result = binding.entryToObject(keyBuffer, buffer);
+        assertTrue(result instanceof MarshalledObject);
+        val = (MarshalledObject) result;
+        assertEquals("abc", val.getData());
+        assertEquals("primary", val.getPrimaryKey());
+        assertEquals("index1", val.getIndexKey1());
+        assertEquals("index2", val.getIndexKey2());
+    }
+
+    public void testBufferSize() {
+
+        CaptureSizeBinding binding =
+            new CaptureSizeBinding(catalog, String.class);
+
+        binding.objectToEntry("x", buffer);
+        assertEquals("x", binding.entryToObject(buffer));
+        assertEquals(FastOutputStream.DEFAULT_INIT_SIZE, binding.bufSize);
+
+        binding.setSerialBufferSize(1000);
+        binding.objectToEntry("x", buffer);
+        assertEquals("x", binding.entryToObject(buffer));
+        assertEquals(1000, binding.bufSize);
+    }
+
+    private static class CaptureSizeBinding extends SerialBinding {
+
+        int bufSize;
+
+        CaptureSizeBinding(ClassCatalog classCatalog, Class baseClass) {
+            super(classCatalog, baseClass);
+        }
+
+        @Override
+        public FastOutputStream getSerialOutput(Object object) {
+            FastOutputStream fos = super.getSerialOutput(object);
+            bufSize = fos.getBufferBytes().length;
+            return fos;
+        }
+    }
+
+    public void testBufferOverride() {
+
+        FastOutputStream out = new FastOutputStream(10);
+        CachedOutputBinding binding =
+            new CachedOutputBinding(catalog, String.class, out);
+
+        binding.used = false;
+        binding.objectToEntry("x", buffer);
+        assertEquals("x", binding.entryToObject(buffer));
+        assertTrue(binding.used);
+
+        binding.used = false;
+        binding.objectToEntry("aaaaaaaaaaaaaaaaaaaaaa", buffer);
+        assertEquals("aaaaaaaaaaaaaaaaaaaaaa", binding.entryToObject(buffer));
+        assertTrue(binding.used);
+
+        binding.used = false;
+        binding.objectToEntry("x", buffer);
+        assertEquals("x", binding.entryToObject(buffer));
+        assertTrue(binding.used);
+    }
+
+    private static class CachedOutputBinding extends SerialBinding {
+
+        FastOutputStream out;
+        boolean used;
+
+        CachedOutputBinding(ClassCatalog classCatalog,
+                            Class baseClass,
+                            FastOutputStream out) {
+            super(classCatalog, baseClass);
+            this.out = out;
+        }
+
+        @Override
+        public FastOutputStream getSerialOutput(Object object) {
+            out.reset();
+            used = true;
+            return out;
+        }
+    }
+
+    private static class MySerialSerialBinding extends SerialSerialBinding {
+
+        private MySerialSerialBinding(SerialBinding keyBinding,
+                                      SerialBinding valueBinding) {
+
+            super(keyBinding, valueBinding);
+        }
+
+        @Override
+        public Object entryToObject(Object keyInput, Object valueInput) {
+
+            return "" + keyInput + '#' + valueInput;
+        }
+
+        @Override
+        public Object objectToKey(Object object) {
+
+            String s = (String) object;
+            int i = s.indexOf('#');
+            if (i < 0 || i == s.length() - 1) {
+                throw new IllegalArgumentException(s);
+            } else {
+                return s.substring(0, i);
+            }
+        }
+
+        @Override
+        public Object objectToData(Object object) {
+
+            String s = (String) object;
+            int i = s.indexOf('#');
+            if (i < 0 || i == s.length() - 1) {
+                throw new IllegalArgumentException(s);
+            } else {
+                return s.substring(i + 1);
+            }
+        }
+    }
+
+    /**
+     * Tests that overriding SerialBinding.getClassLoader is possible.  This is
+     * a crude test because to create a truly working class loader is a large
+     * undertaking.
+     */
+    public void testClassloaderOverride() {
+        DatabaseEntry entry = new DatabaseEntry();
+
+        SerialBinding binding = new CustomLoaderBinding
+            (catalog, null, new FailureClassLoader());
+
+        try {
+            binding.objectToEntry(new MyClass(), entry);
+            binding.entryToObject(entry);
+            fail();
+        } catch (RuntimeException e) {
+            assertTrue(e.getMessage().startsWith("expect failure"));
+        }
+    }
+
+    private static class CustomLoaderBinding extends SerialBinding {
+
+        private final ClassLoader loader;
+
+        CustomLoaderBinding(ClassCatalog classCatalog,
+                            Class baseClass,
+                            ClassLoader loader) {
+
+            super(classCatalog, baseClass);
+            this.loader = loader;
+        }
+
+        @Override
+        public ClassLoader getClassLoader() {
+            return loader;
+        }
+    }
+
+    private static class FailureClassLoader extends ClassLoader {
+
+        @Override
+        public Class loadClass(String name) {
+            throw new RuntimeException("expect failure: " + name);
+        }
+    }
+
+    @SuppressWarnings("serial")
+    private static class MyClass implements Serializable {
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/TestClassCatalog.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/TestClassCatalog.java
new file mode 100644
index 0000000..5311302
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/serial/test/TestClassCatalog.java
@@ -0,0 +1,56 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.serial.test;
+
+import java.io.ObjectStreamClass;
+import java.util.HashMap;
+
+import com.sleepycat.bind.serial.ClassCatalog;
+import com.sleepycat.db.DatabaseException;
+
+/**
+ * @author Mark Hayes
+ */
+public class TestClassCatalog implements ClassCatalog {
+
+    private final HashMap idToDescMap = new HashMap();
+    private final HashMap nameToIdMap = new HashMap();
+    private int nextId = 1;
+
+    public TestClassCatalog() {
+    }
+
+    public void close() {
+    }
+
+    public synchronized byte[] getClassID(ObjectStreamClass desc) {
+        String className = desc.getName();
+        byte[] id = (byte[]) nameToIdMap.get(className);
+        if (id == null) {
+            String strId = String.valueOf(nextId);
+            id = strId.getBytes();
+            nextId += 1;
+
+            idToDescMap.put(strId, desc);
+            nameToIdMap.put(className, id);
+        }
+        return id;
+    }
+
+    public synchronized ObjectStreamClass getClassFormat(byte[] id)
+        throws DatabaseException {
+
+        String strId = new String(id);
+        ObjectStreamClass desc = (ObjectStreamClass) idToDescMap.get(strId);
+        if (desc == null) {
+            throw new DatabaseException("classID not found");
+        }
+        return desc;
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/test/BindingSpeedTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/test/BindingSpeedTest.java
new file mode 100644
index 0000000..8bf52d5
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/test/BindingSpeedTest.java
@@ -0,0 +1,484 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.test;
+
+import java.io.Externalizable;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutput;
+import java.io.ObjectOutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Serializable;
+import java.io.Writer;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+import javax.xml.parsers.SAXParserFactory;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.xml.sax.InputSource;
+import org.xml.sax.XMLReader;
+
+import com.sleepycat.bind.serial.SerialInput;
+import com.sleepycat.bind.serial.SerialOutput;
+import com.sleepycat.bind.serial.test.TestClassCatalog;
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+import com.sleepycat.util.FastInputStream;
+import com.sleepycat.util.FastOutputStream;
+import com.sleepycat.util.test.SharedTestUtils;
+
+/**
+ * @author Mark Hayes
+ */
+public class BindingSpeedTest extends TestCase {
+
+    static final String JAVA_UNSHARED = "java-unshared".intern();
+    static final String JAVA_SHARED = "java-shared".intern();
+    static final String JAVA_EXTERNALIZABLE = "java-externalizable".intern();
+    static final String XML_SAX = "xml-sax".intern();
+    static final String TUPLE = "tuple".intern();
+    static final String REFLECT_METHOD = "reflectMethod".intern();
+    static final String REFLECT_FIELD = "reflectField".intern();
+
+    static final int RUN_COUNT = 1000;
+    static final boolean VERBOSE = false;
+
+    public static void main(String[] args) {
+        junit.framework.TestResult tr =
+            junit.textui.TestRunner.run(suite());
+        if (tr.errorCount() > 0 ||
+            tr.failureCount() > 0) {
+            System.exit(1);
+        } else {
+            System.exit(0);
+        }
+    }
+
+    public static Test suite() {
+
+        TestSuite suite = new TestSuite();
+        suite.addTest(new BindingSpeedTest(JAVA_UNSHARED));
+        suite.addTest(new BindingSpeedTest(JAVA_SHARED));
+        suite.addTest(new BindingSpeedTest(JAVA_EXTERNALIZABLE));
+        suite.addTest(new BindingSpeedTest(XML_SAX));
+        suite.addTest(new BindingSpeedTest(TUPLE));
+        suite.addTest(new BindingSpeedTest(REFLECT_METHOD));
+        suite.addTest(new BindingSpeedTest(REFLECT_FIELD));
+        return suite;
+    }
+
+    private String command;
+    private FastOutputStream fo;
+    private TupleOutput to;
+    private TestClassCatalog jtc;
+    private byte[] buf;
+    private XMLReader parser;
+    private Method[] getters;
+    private Method[] setters;
+    private Field[] fields;
+
+    public BindingSpeedTest(String name) {
+
+        super("BindingSpeedTest." + name);
+        command = name;
+    }
+
+    @Override
+    public void runTest()
+        throws Exception {
+
+        SharedTestUtils.printTestName(getName());
+
+        boolean isTuple = false;
+        boolean isReflectMethod = false;
+        boolean isReflectField = false;
+        boolean isXmlSax = false;
+        boolean isSerial = false;
+        boolean isShared = false;
+        boolean isExternalizable = false;
+
+        if (command == TUPLE) {
+            isTuple = true;
+        } else if (command == REFLECT_METHOD) {
+            isReflectMethod = true;
+        } else if (command == REFLECT_FIELD) {
+            isReflectField = true;
+        } else if (command == XML_SAX) {
+            isXmlSax = true;
+        } else if (command == JAVA_UNSHARED) {
+            isSerial = true;
+        } else if (command == JAVA_SHARED) {
+            isSerial = true;
+            isShared = true;
+        } else if (command == JAVA_EXTERNALIZABLE) {
+            isSerial = true;
+            isShared = true;
+            isExternalizable = true;
+        } else {
+            throw new Exception("invalid command: " + command);
+        }
+
+        // Do initialization
+
+        if (isTuple) {
+            initTuple();
+        } else if (isReflectMethod) {
+            initReflectMethod();
+        } else if (isReflectField) {
+            initReflectField();
+        } else if (isXmlSax) {
+            initXmlSax();
+        } else if (isSerial) {
+            if (isShared) {
+                initSerialShared();
+            } else {
+                initSerialUnshared();
+            }
+        }
+
+        // Prime the Java compiler
+
+        int size = 0;
+        for (int i = 0; i < RUN_COUNT; i += 1) {
+
+            if (isTuple) {
+                size = runTuple();
+            } else if (isReflectMethod) {
+                size = runReflectMethod();
+            } else if (isReflectField) {
+                size = runReflectField();
+            } else if (isXmlSax) {
+                size = runXmlSax();
+            } else if (isSerial) {
+                if (isShared) {
+                    if (isExternalizable) {
+                        size = runSerialExternalizable();
+                    } else {
+                        size = runSerialShared();
+                    }
+                } else {
+                    size = runSerialUnshared();
+                }
+            }
+        }
+
+        // Then run the timing tests
+
+        long startTime = System.currentTimeMillis();
+
+        for (int i = 0; i < RUN_COUNT; i += 1) {
+            if (isTuple) {
+                size = runTuple();
+            } else if (isReflectMethod) {
+                size = runReflectMethod();
+            } else if (isReflectField) {
+                size = runReflectField();
+            } else if (isXmlSax) {
+                size = runXmlSax();
+            } else if (isSerial) {
+                if (isShared) {
+                    if (isExternalizable) {
+                        size = runSerialExternalizable();
+                    } else {
+                        size = runSerialShared();
+                    }
+                } else {
+                    size = runSerialUnshared();
+                }
+            }
+        }
+
+        long stopTime = System.currentTimeMillis();
+
+	assertTrue("data size too big", size < 250);
+
+        if (VERBOSE) {
+            System.out.println(command);
+            System.out.println("data size: " + size);
+            System.out.println("run time:  " +
+                ((stopTime - startTime) / (double) RUN_COUNT));
+        }
+    }
+
+    @Override
+    public void tearDown() {
+
+        /* Ensure that GC can cleanup. */
+        command = null;
+        fo = null;
+        to = null;
+        jtc = null;
+        buf = null;
+        parser = null;
+    }
+
+    void initSerialUnshared() {
+        fo = new FastOutputStream();
+    }
+
+    int runSerialUnshared()
+        throws Exception {
+
+        fo.reset();
+        ObjectOutputStream oos = new ObjectOutputStream(fo);
+        oos.writeObject(new Data());
+        byte[] bytes = fo.toByteArray();
+        FastInputStream fi = new FastInputStream(bytes);
+        ObjectInputStream ois = new ObjectInputStream(fi);
+        ois.readObject();
+        return bytes.length;
+    }
+
+    void initSerialShared() {
+        jtc = new TestClassCatalog();
+        fo = new FastOutputStream();
+    }
+
+    int runSerialShared()
+        throws Exception {
+
+        fo.reset();
+        SerialOutput oos = new SerialOutput(fo, jtc);
+        oos.writeObject(new Data());
+        byte[] bytes = fo.toByteArray();
+        FastInputStream fi = new FastInputStream(bytes);
+        SerialInput ois = new SerialInput(fi, jtc);
+        ois.readObject();
+        return (bytes.length - SerialOutput.getStreamHeader().length);
+    }
+
+    int runSerialExternalizable()
+        throws Exception {
+
+        fo.reset();
+        SerialOutput oos = new SerialOutput(fo, jtc);
+        oos.writeObject(new Data2());
+        byte[] bytes = fo.toByteArray();
+        FastInputStream fi = new FastInputStream(bytes);
+        SerialInput ois = new SerialInput(fi, jtc);
+        ois.readObject();
+        return (bytes.length - SerialOutput.getStreamHeader().length);
+    }
+
+    void initTuple() {
+        buf = new byte[500];
+        to = new TupleOutput(buf);
+    }
+
+    int runTuple() {
+        to.reset();
+        new Data().writeTuple(to);
+
+        TupleInput ti = new TupleInput(
+                          to.getBufferBytes(), to.getBufferOffset(),
+                          to.getBufferLength());
+        new Data().readTuple(ti);
+
+        return to.getBufferLength();
+    }
+
+    void initReflectMethod()
+        throws Exception {
+
+        initTuple();
+
+        Class cls = Data.class;
+
+        getters = new Method[5];
+        getters[0] = cls.getMethod("getField1", new Class[0]);
+        getters[1] = cls.getMethod("getField2", new Class[0]);
+        getters[2] = cls.getMethod("getField3", new Class[0]);
+        getters[3] = cls.getMethod("getField4", new Class[0]);
+        getters[4] = cls.getMethod("getField5", new Class[0]);
+
+        setters = new Method[5];
+        setters[0] = cls.getMethod("setField1", new Class[] {String.class});
+        setters[1] = cls.getMethod("setField2", new Class[] {String.class});
+        setters[2] = cls.getMethod("setField3", new Class[] {Integer.TYPE});
+        setters[3] = cls.getMethod("setField4", new Class[] {Integer.TYPE});
+        setters[4] = cls.getMethod("setField5", new Class[] {String.class});
+    }
+
+    int runReflectMethod()
+        throws Exception {
+
+        to.reset();
+        Data data = new Data();
+        to.writeString((String) getters[0].invoke(data, (Object[]) null));
+        to.writeString((String) getters[1].invoke(data, (Object[]) null));
+        to.writeInt(((Integer) getters[2].invoke(data, (Object[]) null)).intValue());
+        to.writeInt(((Integer) getters[3].invoke(data, (Object[]) null)).intValue());
+        to.writeString((String) getters[4].invoke(data, (Object[]) null));
+
+        TupleInput ti = new TupleInput(
+                          to.getBufferBytes(), to.getBufferOffset(),
+                          to.getBufferLength());
+        data = new Data();
+        setters[0].invoke(data, new Object[] {ti.readString()});
+        setters[1].invoke(data, new Object[] {ti.readString()});
+        setters[2].invoke(data, new Object[] {new Integer(ti.readInt())});
+        setters[3].invoke(data, new Object[] {new Integer(ti.readInt())});
+        setters[4].invoke(data, new Object[] {ti.readString()});
+
+        return to.getBufferLength();
+    }
+
+    void initReflectField()
+        throws Exception {
+
+        initTuple();
+
+        Class cls = Data.class;
+
+        fields = new Field[5];
+        fields[0] = cls.getField("field1");
+        fields[1] = cls.getField("field2");
+        fields[2] = cls.getField("field3");
+        fields[3] = cls.getField("field4");
+        fields[4] = cls.getField("field5");
+    }
+
+    int runReflectField()
+        throws Exception {
+
+        to.reset();
+        Data data = new Data();
+        to.writeString((String) fields[0].get(data));
+        to.writeString((String) fields[1].get(data));
+        to.writeInt(((Integer) fields[2].get(data)).intValue());
+        to.writeInt(((Integer) fields[3].get(data)).intValue());
+        to.writeString((String) fields[4].get(data));
+
+        TupleInput ti = new TupleInput(
+                          to.getBufferBytes(), to.getBufferOffset(),
+                          to.getBufferLength());
+        data = new Data();
+        fields[0].set(data, ti.readString());
+        fields[1].set(data, ti.readString());
+        fields[2].set(data, new Integer(ti.readInt()));
+        fields[3].set(data, new Integer(ti.readInt()));
+        fields[4].set(data, ti.readString());
+
+        return to.getBufferLength();
+    }
+
+    void initXmlSax()
+        throws Exception {
+
+        buf = new byte[500];
+        fo = new FastOutputStream();
+        SAXParserFactory saxFactory = SAXParserFactory.newInstance();
+        saxFactory.setNamespaceAware(true);
+        parser = saxFactory.newSAXParser().getXMLReader();
+    }
+
+    int runXmlSax()
+        throws Exception {
+
+        fo.reset();
+        OutputStreamWriter writer = new OutputStreamWriter(fo);
+        new Data().writeXmlText(writer);
+
+        byte[] bytes = fo.toByteArray();
+        FastInputStream fi = new FastInputStream(bytes);
+        InputSource input = new InputSource(fi);
+        parser.parse(input);
+
+        //InputStreamReader reader = new InputStreamReader(fi);
+        //new Data().readXmlText(??);
+
+        return bytes.length;
+    }
+
+    static class Data2 extends Data implements Externalizable {
+
+        public Data2() {}
+
+        public void readExternal(ObjectInput in)
+            throws IOException {
+
+            field1 = in.readUTF();
+            field2 = in.readUTF();
+            field3 = in.readInt();
+            field4 = in.readInt();
+            field5 = in.readUTF();
+        }
+
+        public void writeExternal(ObjectOutput out)
+            throws IOException {
+
+            out.writeUTF(field1);
+            out.writeUTF(field2);
+            out.writeInt(field3);
+            out.writeInt(field4);
+            out.writeUTF(field5);
+        }
+    }
+
+    @SuppressWarnings("serial")
+    static class Data implements Serializable {
+
+        public String field1 = "field1";
+        public String field2 = "field2";
+        public int field3 = 333;
+        public int field4 = 444;
+        public String field5 = "field5";
+
+        public String getField1() { return field1; }
+        public String getField2() { return field2; }
+        public int getField3() { return field3; }
+        public int getField4() { return field4; }
+        public String getField5() { return field5; }
+
+        public void setField1(String v) { field1 = v; }
+        public void setField2(String v) { field2 = v; }
+        public void setField3(int v) { field3 = v; }
+        public void setField4(int v) { field4 = v; }
+        public void setField5(String v) { field5 = v; }
+
+        void readTuple(TupleInput _input) {
+
+            field1 = _input.readString();
+            field2 = _input.readString();
+            field3 = _input.readInt();
+            field4 = _input.readInt();
+            field5 = _input.readString();
+        }
+
+        void writeTuple(TupleOutput _output) {
+
+            _output.writeString(field1);
+            _output.writeString(field2);
+            _output.writeInt(field3);
+            _output.writeInt(field4);
+            _output.writeString(field5);
+        }
+
+        void writeXmlText(Writer writer) throws IOException {
+
+            writer.write("<Data><Field1>");
+            writer.write(field1);
+            writer.write("</Field1><Field2>");
+            writer.write(field2);
+            writer.write("</Field2><Field3>");
+            writer.write(String.valueOf(field3));
+            writer.write("</Field3><Field4>");
+            writer.write(String.valueOf(field4));
+            writer.write("</Field4><Field5>");
+            writer.write(field5);
+            writer.write("</Field5></Data>");
+            writer.flush();
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/MarshalledObject.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/MarshalledObject.java
new file mode 100644
index 0000000..bf98785
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/MarshalledObject.java
@@ -0,0 +1,136 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.tuple.test;
+
+import com.sleepycat.bind.tuple.MarshalledTupleEntry;
+import com.sleepycat.bind.tuple.MarshalledTupleKeyEntity;
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+
+/**
+ * @author Mark Hayes
+ */
+public class MarshalledObject
+    implements MarshalledTupleEntry, MarshalledTupleKeyEntity {
+
+    private String data;
+    private String primaryKey;
+    private String indexKey1;
+    private String indexKey2;
+
+    public MarshalledObject() {
+    }
+
+    MarshalledObject(String data, String primaryKey,
+                     String indexKey1, String indexKey2) {
+
+        this.data = data;
+        this.primaryKey = primaryKey;
+        this.indexKey1 = indexKey1;
+        this.indexKey2 = indexKey2;
+    }
+
+    String getData() {
+
+        return data;
+    }
+
+    String getPrimaryKey() {
+
+        return primaryKey;
+    }
+
+    String getIndexKey1() {
+
+        return indexKey1;
+    }
+
+    String getIndexKey2() {
+
+        return indexKey2;
+    }
+
+    int expectedDataLength() {
+
+        return data.length() + 1 +
+               indexKey1.length() + 1 +
+               indexKey2.length() + 1;
+    }
+
+    int expectedKeyLength() {
+
+        return primaryKey.length() + 1;
+    }
+
+    public void marshalEntry(TupleOutput dataOutput) {
+
+        dataOutput.writeString(data);
+        dataOutput.writeString(indexKey1);
+        dataOutput.writeString(indexKey2);
+    }
+
+    public void unmarshalEntry(TupleInput dataInput) {
+
+        data = dataInput.readString();
+        indexKey1 = dataInput.readString();
+        indexKey2 = dataInput.readString();
+    }
+
+    public void marshalPrimaryKey(TupleOutput keyOutput) {
+
+        keyOutput.writeString(primaryKey);
+    }
+
+    public void unmarshalPrimaryKey(TupleInput keyInput) {
+
+        primaryKey = keyInput.readString();
+    }
+
+    public boolean marshalSecondaryKey(String keyName, TupleOutput keyOutput) {
+
+        if ("1".equals(keyName)) {
+            if (indexKey1.length() > 0) {
+                keyOutput.writeString(indexKey1);
+                return true;
+            } else {
+                return false;
+            }
+        } else if ("2".equals(keyName)) {
+            if (indexKey1.length() > 0) {
+                keyOutput.writeString(indexKey2);
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            throw new IllegalArgumentException("Unknown keyName: " + keyName);
+        }
+    }
+
+    public boolean nullifyForeignKey(String keyName) {
+
+        if ("1".equals(keyName)) {
+            if (indexKey1.length() > 0) {
+                indexKey1 = "";
+                return true;
+            } else {
+                return false;
+            }
+        } else if ("2".equals(keyName)) {
+            if (indexKey1.length() > 0) {
+                indexKey2 = "";
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            throw new IllegalArgumentException("Unknown keyName: " + keyName);
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleBindingTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleBindingTest.java
new file mode 100644
index 0000000..8f315ff
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleBindingTest.java
@@ -0,0 +1,426 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.tuple.test;
+
+import java.math.BigInteger;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.sleepycat.bind.EntityBinding;
+import com.sleepycat.bind.EntryBinding;
+import com.sleepycat.bind.tuple.BigIntegerBinding;
+import com.sleepycat.bind.tuple.BooleanBinding;
+import com.sleepycat.bind.tuple.ByteBinding;
+import com.sleepycat.bind.tuple.CharacterBinding;
+import com.sleepycat.bind.tuple.DoubleBinding;
+import com.sleepycat.bind.tuple.FloatBinding;
+import com.sleepycat.bind.tuple.IntegerBinding;
+import com.sleepycat.bind.tuple.LongBinding;
+import com.sleepycat.bind.tuple.ShortBinding;
+import com.sleepycat.bind.tuple.SortedDoubleBinding;
+import com.sleepycat.bind.tuple.SortedFloatBinding;
+import com.sleepycat.bind.tuple.StringBinding;
+import com.sleepycat.bind.tuple.TupleBinding;
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleInputBinding;
+import com.sleepycat.bind.tuple.TupleMarshalledBinding;
+import com.sleepycat.bind.tuple.TupleOutput;
+import com.sleepycat.bind.tuple.TupleTupleMarshalledBinding;
+import com.sleepycat.db.DatabaseEntry;
+import com.sleepycat.util.ExceptionUnwrapper;
+import com.sleepycat.util.FastOutputStream;
+import com.sleepycat.util.test.SharedTestUtils;
+
+/**
+ * @author Mark Hayes
+ */
+public class TupleBindingTest extends TestCase {
+
+    private DatabaseEntry buffer;
+    private DatabaseEntry keyBuffer;
+
+    public static void main(String[] args) {
+        junit.framework.TestResult tr =
+            junit.textui.TestRunner.run(suite());
+        if (tr.errorCount() > 0 ||
+            tr.failureCount() > 0) {
+            System.exit(1);
+        } else {
+            System.exit(0);
+        }
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite(TupleBindingTest.class);
+        return suite;
+    }
+
+    public TupleBindingTest(String name) {
+
+        super(name);
+    }
+
+    @Override
+    public void setUp() {
+
+        SharedTestUtils.printTestName("TupleBindingTest." + getName());
+        buffer = new DatabaseEntry();
+        keyBuffer = new DatabaseEntry();
+    }
+
+    @Override
+    public void tearDown() {
+
+        /* Ensure that GC can cleanup. */
+        buffer = null;
+        keyBuffer = null;
+    }
+
+    @Override
+    public void runTest()
+        throws Throwable {
+
+        try {
+            super.runTest();
+        } catch (Exception e) {
+            throw ExceptionUnwrapper.unwrap(e);
+        }
+    }
+
+    private void primitiveBindingTest(Class primitiveCls, Class compareCls,
+                                      Object val, int byteSize) {
+
+        TupleBinding binding = TupleBinding.getPrimitiveBinding(primitiveCls);
+
+        /* Test standard object binding. */
+
+        binding.objectToEntry(val, buffer);
+        assertEquals(byteSize, buffer.getSize());
+
+        Object val2 = binding.entryToObject(buffer);
+        assertSame(compareCls, val2.getClass());
+        assertEquals(val, val2);
+
+        Object valWithWrongCls = (primitiveCls == String.class)
+                      ? ((Object) new Integer(0)) : ((Object) new String(""));
+        try {
+            binding.objectToEntry(valWithWrongCls, buffer);
+        }
+        catch (ClassCastException expected) {}
+
+        /* Test nested tuple binding. */
+	forMoreCoverageTest(binding, val);
+    }
+
+    private void forMoreCoverageTest(TupleBinding val1,Object val2) {
+
+        TupleOutput output = new TupleOutput();
+        output.writeString("abc");
+        val1.objectToEntry(val2, output);
+        output.writeString("xyz");
+
+        TupleInput input = new TupleInput(output);
+        assertEquals("abc", input.readString());
+        Object val3 = val1.entryToObject(input);
+        assertEquals("xyz", input.readString());
+
+        assertEquals(0, input.available());
+        assertSame(val2.getClass(), val3.getClass());
+        assertEquals(val2, val3);
+    }
+
+    public void testPrimitiveBindings() {
+
+        primitiveBindingTest(String.class, String.class,
+                             "abc", 4);
+
+        primitiveBindingTest(Character.class, Character.class,
+                             new Character('a'), 2);
+        primitiveBindingTest(Boolean.class, Boolean.class,
+                             new Boolean(true), 1);
+        primitiveBindingTest(Byte.class, Byte.class,
+                             new Byte((byte) 123), 1);
+        primitiveBindingTest(Short.class, Short.class,
+                             new Short((short) 123), 2);
+        primitiveBindingTest(Integer.class, Integer.class,
+                             new Integer(123), 4);
+	primitiveBindingTest(Long.class, Long.class,
+                             new Long(123), 8);
+        primitiveBindingTest(Float.class, Float.class,
+                             new Float(123.123), 4);
+        primitiveBindingTest(Double.class, Double.class,
+                             new Double(123.123), 8);
+
+        primitiveBindingTest(Character.TYPE, Character.class,
+                             new Character('a'), 2);
+        primitiveBindingTest(Boolean.TYPE, Boolean.class,
+                             new Boolean(true), 1);
+        primitiveBindingTest(Byte.TYPE, Byte.class,
+                             new Byte((byte) 123), 1);
+        primitiveBindingTest(Short.TYPE, Short.class,
+                             new Short((short) 123), 2);
+        primitiveBindingTest(Integer.TYPE, Integer.class,
+                             new Integer(123), 4);
+        primitiveBindingTest(Long.TYPE, Long.class,
+                             new Long(123), 8);
+        primitiveBindingTest(Float.TYPE, Float.class,
+                             new Float(123.123), 4);
+        primitiveBindingTest(Double.TYPE, Double.class,
+                             new Double(123.123), 8);
+
+        DatabaseEntry entry = new DatabaseEntry();
+
+        StringBinding.stringToEntry("abc", entry);
+	assertEquals(4, entry.getData().length);
+        assertEquals("abc", StringBinding.entryToString(entry));
+
+        new StringBinding().objectToEntry("abc", entry);
+	assertEquals(4, entry.getData().length);
+
+        StringBinding.stringToEntry(null, entry);
+	assertEquals(2, entry.getData().length);
+        assertEquals(null, StringBinding.entryToString(entry));
+
+        new StringBinding().objectToEntry(null, entry);
+	assertEquals(2, entry.getData().length);
+
+        CharacterBinding.charToEntry('a', entry);
+	assertEquals(2, entry.getData().length);
+        assertEquals('a', CharacterBinding.entryToChar(entry));
+
+        new CharacterBinding().objectToEntry(new Character('a'), entry);
+	assertEquals(2, entry.getData().length);
+
+        BooleanBinding.booleanToEntry(true, entry);
+	assertEquals(1, entry.getData().length);
+        assertEquals(true, BooleanBinding.entryToBoolean(entry));
+
+        new BooleanBinding().objectToEntry(Boolean.TRUE, entry);
+	assertEquals(1, entry.getData().length);
+
+        ByteBinding.byteToEntry((byte) 123, entry);
+	assertEquals(1, entry.getData().length);
+        assertEquals((byte) 123, ByteBinding.entryToByte(entry));
+
+        ShortBinding.shortToEntry((short) 123, entry);
+	assertEquals(2, entry.getData().length);
+        assertEquals((short) 123, ShortBinding.entryToShort(entry));
+
+        new ByteBinding().objectToEntry(new Byte((byte) 123), entry);
+	assertEquals(1, entry.getData().length);
+
+        IntegerBinding.intToEntry(123, entry);
+	assertEquals(4, entry.getData().length);
+        assertEquals(123, IntegerBinding.entryToInt(entry));
+
+        new IntegerBinding().objectToEntry(new Integer(123), entry);
+	assertEquals(4, entry.getData().length);
+
+        LongBinding.longToEntry(123, entry);
+	assertEquals(8, entry.getData().length);
+        assertEquals(123, LongBinding.entryToLong(entry));
+
+        new LongBinding().objectToEntry(new Long(123), entry);
+	assertEquals(8, entry.getData().length);
+
+        FloatBinding.floatToEntry((float) 123.123, entry);
+	assertEquals(4, entry.getData().length);
+        assertTrue(((float) 123.123) == FloatBinding.entryToFloat(entry));
+
+        new FloatBinding().objectToEntry(new Float((float) 123.123), entry);
+	assertEquals(4, entry.getData().length);
+
+        DoubleBinding.doubleToEntry(123.123, entry);
+	assertEquals(8, entry.getData().length);
+        assertTrue(123.123 == DoubleBinding.entryToDouble(entry));
+
+        new DoubleBinding().objectToEntry(new Double(123.123), entry);
+	assertEquals(8, entry.getData().length);
+
+        BigIntegerBinding.bigIntegerToEntry
+                (new BigInteger("1234567890123456"), entry);
+        assertEquals(9, entry.getData().length);
+        assertTrue((new BigInteger("1234567890123456")).equals
+		   (BigIntegerBinding.entryToBigInteger(entry)));
+
+        new BigIntegerBinding().objectToEntry
+                (new BigInteger("1234567890123456"), entry);
+        assertEquals(9, entry.getData().length);
+        forMoreCoverageTest(new BigIntegerBinding(),
+                            new BigInteger("1234567890123456"));
+
+        SortedFloatBinding.floatToEntry((float) 123.123, entry);
+	assertEquals(4, entry.getData().length);
+        assertTrue(((float) 123.123) ==
+                   SortedFloatBinding.entryToFloat(entry));
+
+        new SortedFloatBinding().objectToEntry
+            (new Float((float) 123.123), entry);
+	assertEquals(4, entry.getData().length);
+        forMoreCoverageTest(new SortedFloatBinding(),
+                            new Float((float) 123.123));
+
+        SortedDoubleBinding.doubleToEntry(123.123, entry);
+	assertEquals(8, entry.getData().length);
+        assertTrue(123.123 == SortedDoubleBinding.entryToDouble(entry));
+
+        new SortedDoubleBinding().objectToEntry(new Double(123.123), entry);
+	assertEquals(8, entry.getData().length);
+        forMoreCoverageTest(new SortedDoubleBinding(),
+                            new Double(123.123));
+    }
+
+    public void testTupleInputBinding() {
+
+        EntryBinding binding = new TupleInputBinding();
+
+        TupleOutput out = new TupleOutput();
+        out.writeString("abc");
+        binding.objectToEntry(new TupleInput(out), buffer);
+        assertEquals(4, buffer.getSize());
+
+        Object result = binding.entryToObject(buffer);
+        assertTrue(result instanceof TupleInput);
+        TupleInput in = (TupleInput) result;
+        assertEquals("abc", in.readString());
+        assertEquals(0, in.available());
+    }
+
+    // also tests TupleBinding since TupleMarshalledBinding extends it
+    public void testTupleMarshalledBinding() {
+
+        EntryBinding binding =
+            new TupleMarshalledBinding(MarshalledObject.class);
+
+        MarshalledObject val = new MarshalledObject("abc", "", "", "");
+        binding.objectToEntry(val, buffer);
+        assertEquals(val.expectedDataLength(), buffer.getSize());
+
+        Object result = binding.entryToObject(buffer);
+        assertTrue(result instanceof MarshalledObject);
+        val = (MarshalledObject) result;
+        assertEquals("abc", val.getData());
+    }
+
+    // also tests TupleTupleBinding since TupleTupleMarshalledBinding extends
+    // it
+    public void testTupleTupleMarshalledBinding() {
+
+        EntityBinding binding =
+            new TupleTupleMarshalledBinding(MarshalledObject.class);
+
+        MarshalledObject val = new MarshalledObject("abc", "primary",
+                                                    "index1", "index2");
+        binding.objectToData(val, buffer);
+        assertEquals(val.expectedDataLength(), buffer.getSize());
+        binding.objectToKey(val, keyBuffer);
+        assertEquals(val.expectedKeyLength(), keyBuffer.getSize());
+
+        Object result = binding.entryToObject(keyBuffer, buffer);
+        assertTrue(result instanceof MarshalledObject);
+        val = (MarshalledObject) result;
+        assertEquals("abc", val.getData());
+        assertEquals("primary", val.getPrimaryKey());
+        assertEquals("index1", val.getIndexKey1());
+        assertEquals("index2", val.getIndexKey2());
+    }
+
+    public void testBufferSize() {
+
+        CaptureSizeBinding binding = new CaptureSizeBinding();
+
+        binding.objectToEntry("x", buffer);
+        assertEquals("x", binding.entryToObject(buffer));
+        assertEquals(FastOutputStream.DEFAULT_INIT_SIZE, binding.bufSize);
+
+        binding.setTupleBufferSize(1000);
+        binding.objectToEntry("x", buffer);
+        assertEquals("x", binding.entryToObject(buffer));
+        assertEquals(1000, binding.bufSize);
+    }
+
+    private class CaptureSizeBinding extends TupleBinding {
+
+        int bufSize;
+
+        CaptureSizeBinding() {
+            super();
+        }
+
+        @Override
+        public TupleOutput getTupleOutput(Object object) {
+            TupleOutput out = super.getTupleOutput(object);
+            bufSize = out.getBufferBytes().length;
+            return out;
+        }
+
+        @Override
+        public Object entryToObject(TupleInput input) {
+            return input.readString();
+        }
+
+        @Override
+        public void objectToEntry(Object object, TupleOutput output) {
+            assertEquals(bufSize, output.getBufferBytes().length);
+            output.writeString((String) object);
+        }
+    }
+
+    public void testBufferOverride() {
+
+        TupleOutput out = new TupleOutput(new byte[10]);
+        CachedOutputBinding binding = new CachedOutputBinding(out);
+
+        binding.used = false;
+        binding.objectToEntry("x", buffer);
+        assertEquals("x", binding.entryToObject(buffer));
+        assertTrue(binding.used);
+
+        binding.used = false;
+        binding.objectToEntry("aaaaaaaaaaaaaaaaaaaaaa", buffer);
+        assertEquals("aaaaaaaaaaaaaaaaaaaaaa", binding.entryToObject(buffer));
+        assertTrue(binding.used);
+
+        binding.used = false;
+        binding.objectToEntry("x", buffer);
+        assertEquals("x", binding.entryToObject(buffer));
+        assertTrue(binding.used);
+    }
+
+    private class CachedOutputBinding extends TupleBinding {
+
+        TupleOutput out;
+        boolean used;
+
+        CachedOutputBinding(TupleOutput out) {
+            super();
+            this.out = out;
+        }
+
+        @Override
+        public TupleOutput getTupleOutput(Object object) {
+            out.reset();
+            used = true;
+            return out;
+        }
+
+        @Override
+        public Object entryToObject(TupleInput input) {
+            return input.readString();
+        }
+
+        @Override
+        public void objectToEntry(Object object, TupleOutput output) {
+            assertSame(out, output);
+            output.writeString((String) object);
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleFormatTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleFormatTest.java
new file mode 100644
index 0000000..4c2ece6
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleFormatTest.java
@@ -0,0 +1,927 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.tuple.test;
+
+import java.util.Arrays;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.sleepycat.bind.tuple.TupleBinding;
+import com.sleepycat.bind.tuple.TupleInput;
+import com.sleepycat.bind.tuple.TupleOutput;
+import com.sleepycat.db.DatabaseEntry;
+import com.sleepycat.util.test.SharedTestUtils;
+
+/**
+ * @author Mark Hayes
+ */
+public class TupleFormatTest extends TestCase {
+
+    private TupleInput in;
+    private TupleOutput out;
+    private DatabaseEntry buffer;
+
+    public static void main(String[] args) {
+        junit.framework.TestResult tr =
+            junit.textui.TestRunner.run(suite());
+        if (tr.errorCount() > 0 ||
+            tr.failureCount() > 0) {
+            System.exit(1);
+        } else {
+            System.exit(0);
+        }
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite(TupleFormatTest.class);
+        return suite;
+    }
+
+    public TupleFormatTest(String name) {
+
+        super(name);
+    }
+
+    @Override
+    public void setUp() {
+
+        SharedTestUtils.printTestName("TupleFormatTest." + getName());
+        buffer = new DatabaseEntry();
+        out = new TupleOutput();
+    }
+
+    @Override
+    public void tearDown() {
+
+        /* Ensure that GC can cleanup. */
+        in = null;
+        out = null;
+        buffer = null;
+    }
+
+    private void copyOutputToInput() {
+
+        TupleBinding.outputToEntry(out, buffer);
+        assertEquals(out.size(), buffer.getSize());
+        in = TupleBinding.entryToInput(buffer);
+        assertEquals(in.available(), buffer.getSize());
+        assertEquals(in.getBufferLength(), buffer.getSize());
+    }
+
+    private void stringTest(String val) {
+
+        out.reset();
+        out.writeString(val);
+        assertEquals(val.length() + 1, out.size()); // assume 1-byte chars
+        copyOutputToInput();
+        assertEquals(val, in.readString());
+        assertEquals(0, in.available());
+    }
+
+    public void testString() {
+
+        stringTest("");
+        stringTest("a");
+        stringTest("abc");
+
+        out.reset();
+        out.writeString("abc");
+        out.writeString("defg");
+        assertEquals(9, out.size());
+        copyOutputToInput();
+        assertEquals("abc", in.readString());
+        assertEquals("defg", in.readString());
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeString("abc");
+        out.writeString("defg");
+        out.writeString("hijkl");
+        assertEquals(15, out.size());
+        copyOutputToInput();
+        assertEquals("abc", in.readString());
+        assertEquals("defg", in.readString());
+        assertEquals("hijkl", in.readString());
+        assertEquals(0, in.available());
+    }
+
+    private void fixedStringTest(char[] val) {
+
+        out.reset();
+        out.writeString(val);
+        assertEquals(val.length, out.size()); // assume 1 byte chars
+        copyOutputToInput();
+        char[] val2 = new char[val.length];
+        in.readString(val2);
+        assertTrue(Arrays.equals(val, val2));
+        assertEquals(0, in.available());
+        in.reset();
+        String val3 = in.readString(val.length);
+        assertTrue(Arrays.equals(val, val3.toCharArray()));
+        assertEquals(0, in.available());
+    }
+
+    public void testFixedString() {
+
+        fixedStringTest(new char[0]);
+        fixedStringTest(new char[] {'a'});
+        fixedStringTest(new char[] {'a', 'b', 'c'});
+
+        out.reset();
+        out.writeString(new char[] {'a', 'b', 'c'});
+        out.writeString(new char[] {'d', 'e', 'f', 'g'});
+        assertEquals(7, out.size());
+        copyOutputToInput();
+        assertEquals("abc", in.readString(3));
+        assertEquals("defg", in.readString(4));
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeString(new char[] {'a', 'b', 'c'});
+        out.writeString(new char[] {'d', 'e', 'f', 'g'});
+        out.writeString(new char[] {'h', 'i', 'j', 'k', 'l'});
+        assertEquals(12, out.size());
+        copyOutputToInput();
+        assertEquals("abc", in.readString(3));
+        assertEquals("defg", in.readString(4));
+        assertEquals("hijkl", in.readString(5));
+        assertEquals(0, in.available());
+    }
+
+    public void testNullString() {
+
+        out.reset();
+        out.writeString((String) null);
+        assertEquals(2, out.size());
+        copyOutputToInput();
+        assertEquals(null, in.readString());
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeString((String) null);
+        out.writeString("x");
+        assertEquals(4, out.size());
+        copyOutputToInput();
+        assertEquals(null, in.readString());
+        assertEquals(2, in.available());
+        assertEquals("x", in.readString());
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeString("x");
+        out.writeString((String) null);
+        assertEquals(4, out.size());
+        copyOutputToInput();
+        assertEquals("x", in.readString());
+        assertEquals(2, in.available());
+        assertEquals(null, in.readString());
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeString((String) null);
+        out.writeInt(123);
+        assertEquals(6, out.size());
+        copyOutputToInput();
+        assertEquals(null, in.readString());
+        assertEquals(4, in.available());
+        assertEquals(123, in.readInt());
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeInt(123);
+        out.writeString((String) null);
+        assertEquals(6, out.size());
+        copyOutputToInput();
+        assertEquals(123, in.readInt());
+        assertEquals(2, in.available());
+        assertEquals(null, in.readString());
+        assertEquals(0, in.available());
+    }
+
+    private void charsTest(char[] val) {
+
+        for (int mode = 0; mode < 2; mode += 1) {
+            out.reset();
+            switch (mode) {
+                case 0: out.writeChars(val); break;
+                case 1: out.writeChars(new String(val)); break;
+                default: throw new IllegalStateException();
+            }
+            assertEquals(val.length * 2, out.size());
+            copyOutputToInput();
+            char[] val2 = new char[val.length];
+            in.readChars(val2);
+            assertTrue(Arrays.equals(val, val2));
+            assertEquals(0, in.available());
+            in.reset();
+            String val3 = in.readChars(val.length);
+            assertTrue(Arrays.equals(val, val3.toCharArray()));
+            assertEquals(0, in.available());
+        }
+    }
+
+    public void testChars() {
+
+        charsTest(new char[0]);
+        charsTest(new char[] {'a'});
+        charsTest(new char[] {'a', 'b', 'c'});
+
+        out.reset();
+        out.writeChars("abc");
+        out.writeChars("defg");
+        assertEquals(7 * 2, out.size());
+        copyOutputToInput();
+        assertEquals("abc", in.readChars(3));
+        assertEquals("defg", in.readChars(4));
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeChars("abc");
+        out.writeChars("defg");
+        out.writeChars("hijkl");
+        assertEquals(12 * 2, out.size());
+        copyOutputToInput();
+        assertEquals("abc", in.readChars(3));
+        assertEquals("defg", in.readChars(4));
+        assertEquals("hijkl", in.readChars(5));
+        assertEquals(0, in.available());
+    }
+
+    private void bytesTest(char[] val) {
+
+        char[] valBytes = new char[val.length];
+        for (int i = 0; i < val.length; i += 1)
+            valBytes[i] = (char) (val[i] & 0xFF);
+
+        for (int mode = 0; mode < 2; mode += 1) {
+            out.reset();
+            switch (mode) {
+                case 0: out.writeBytes(val); break;
+                case 1: out.writeBytes(new String(val)); break;
+                default: throw new IllegalStateException();
+            }
+            assertEquals(val.length, out.size());
+            copyOutputToInput();
+            char[] val2 = new char[val.length];
+            in.readBytes(val2);
+            assertTrue(Arrays.equals(valBytes, val2));
+            assertEquals(0, in.available());
+            in.reset();
+            String val3 = in.readBytes(val.length);
+            assertTrue(Arrays.equals(valBytes, val3.toCharArray()));
+            assertEquals(0, in.available());
+        }
+    }
+
+    public void testBytes() {
+
+        bytesTest(new char[0]);
+        bytesTest(new char[] {'a'});
+        bytesTest(new char[] {'a', 'b', 'c'});
+        bytesTest(new char[] {0x7F00, 0x7FFF, 0xFF00, 0xFFFF});
+
+        out.reset();
+        out.writeBytes("abc");
+        out.writeBytes("defg");
+        assertEquals(7, out.size());
+        copyOutputToInput();
+        assertEquals("abc", in.readBytes(3));
+        assertEquals("defg", in.readBytes(4));
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeBytes("abc");
+        out.writeBytes("defg");
+        out.writeBytes("hijkl");
+        assertEquals(12, out.size());
+        copyOutputToInput();
+        assertEquals("abc", in.readBytes(3));
+        assertEquals("defg", in.readBytes(4));
+        assertEquals("hijkl", in.readBytes(5));
+        assertEquals(0, in.available());
+    }
+
+    private void booleanTest(boolean val) {
+
+        out.reset();
+        out.writeBoolean(val);
+        assertEquals(1, out.size());
+        copyOutputToInput();
+        assertEquals(val, in.readBoolean());
+        assertEquals(0, in.available());
+    }
+
+    public void testBoolean() {
+
+        booleanTest(true);
+        booleanTest(false);
+
+        out.reset();
+        out.writeBoolean(true);
+        out.writeBoolean(false);
+        assertEquals(2, out.size());
+        copyOutputToInput();
+        assertEquals(true, in.readBoolean());
+        assertEquals(false, in.readBoolean());
+        assertEquals(0, in.available());
+
+        out.reset();
+        out.writeBoolean(true);
+        out.writeBoolean(false);
+        out.writeBoolean(true);
+        assertEquals(3, out.size());
+        copyOutputToInput();
+        assertEquals(true, in.readBoolean());
+        assertEquals(false, in.readBoolean());
+        assertEquals(true, in.readBoolean());
+        assertEquals(0, in.available());
+    }
+
+    private void unsignedByteTest(int val) {
+
+        unsignedByteTest(val, val);
+    }
+
+    private void unsignedByteTest(int val, int expected) {
+
+        out.reset();
+        out.writeUnsignedByte(val);
+        assertEquals(1, out.size());
+        copyOutputToInput();
+        assertEquals(expected, in.readUnsignedByte());
+    }
+
+    public void testUnsignedByte() {
+
+        unsignedByteTest(0);
+        unsignedByteTest(1);
+        unsignedByteTest(254);
+        unsignedByteTest(255);
+        unsignedByteTest(256, 0);
+        unsignedByteTest(-1, 255);
+        unsignedByteTest(-2, 254);
+        unsignedByteTest(-255, 1);
+
+        out.reset();
+        out.writeUnsignedByte(0);
+        out.writeUnsignedByte(1);
+        out.writeUnsignedByte(255);
+        assertEquals(3, out.size());
+        copyOutputToInput();
+        assertEquals(0, in.readUnsignedByte());
+        assertEquals(1, in.readUnsignedByte());
+        assertEquals(255, in.readUnsignedByte());
+        assertEquals(0, in.available());
+    }
+
+    private void unsignedShortTest(int val) {
+
+        unsignedShortTest(val, val);
+    }
+
+    private void unsignedShortTest(int val, int expected) {
+
+        out.reset();
+        out.writeUnsignedShort(val);
+        assertEquals(2, out.size());
+        copyOutputToInput();
+        assertEquals(expected, in.readUnsignedShort());
+    }
+
+    public void testUnsignedShort() {
+
+        unsignedShortTest(0);
+        unsignedShortTest(1);
+        unsignedShortTest(255);
+        unsignedShortTest(256);
+        unsignedShortTest(257);
+        unsignedShortTest(Short.MAX_VALUE - 1);
+        unsignedShortTest(Short.MAX_VALUE);
+        unsignedShortTest(Short.MAX_VALUE + 1);
+        unsignedShortTest(0xFFFF - 1);
+        unsignedShortTest(0xFFFF);
+        unsignedShortTest(0xFFFF + 1, 0);
+        unsignedShortTest(0x7FFF0000, 0);
+        unsignedShortTest(0xFFFF0000, 0);
+        unsignedShortTest(-1, 0xFFFF);
+        unsignedShortTest(-2, 0xFFFF - 1);
+        unsignedShortTest(-0xFFFF, 1);
+
+        out.reset();
+        out.writeUnsignedShort(0);
+        out.writeUnsignedShort(1);
+        out.writeUnsignedShort(0xFFFF);
+        assertEquals(6, out.size());
+        copyOutputToInput();
+        assertEquals(0, in.readUnsignedShort());
+        assertEquals(1, in.readUnsignedShort());
+        assertEquals(0xFFFF, in.readUnsignedShort());
+        assertEquals(0, in.available());
+    }
+
+    private void unsignedIntTest(long val) {
+
+        unsignedIntTest(val, val);
+    }
+
+    private void unsignedIntTest(long val, long expected) {
+
+        out.reset();
+        out.writeUnsignedInt(val);
+        assertEquals(4, out.size());
+        copyOutputToInput();
+        assertEquals(expected, in.readUnsignedInt());
+    }
+
+    public void testUnsignedInt() {
+
+        unsignedIntTest(0L);
+        unsignedIntTest(1L);
+        unsignedIntTest(255L);
+        unsignedIntTest(256L);
+        unsignedIntTest(257L);
+        unsignedIntTest(Short.MAX_VALUE - 1L);
+        unsignedIntTest(Short.MAX_VALUE);
+        unsignedIntTest(Short.MAX_VALUE + 1L);
+        unsignedIntTest(Integer.MAX_VALUE - 1L);
+        unsignedIntTest(Integer.MAX_VALUE);
+        unsignedIntTest(Integer.MAX_VALUE + 1L);
+        unsignedIntTest(0xFFFFFFFFL - 1L);
+        unsignedIntTest(0xFFFFFFFFL);
+        unsignedIntTest(0xFFFFFFFFL + 1L, 0L);
+        unsignedIntTest(0x7FFFFFFF00000000L, 0L);
+        unsignedIntTest(0xFFFFFFFF00000000L, 0L);
+        unsignedIntTest(-1, 0xFFFFFFFFL);
+        unsignedIntTest(-2, 0xFFFFFFFFL - 1L);
+        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(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(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(val);
+        assertEquals(8, out.size());
+        copyOutputToInput();
+        if (Double.isNaN(val)) {
+            assertTrue(Double.isNaN(in.readDouble()));
+        } else {
+            assertEquals(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(val);
+        assertEquals(8, out.size());
+        copyOutputToInput();
+        if (Double.isNaN(val)) {
+            assertTrue(Double.isNaN(in.readSortedDouble()));
+        } else {
+            assertEquals(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);
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleOrderingTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleOrderingTest.java
new file mode 100644
index 0000000..4a70246
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/bind/tuple/test/TupleOrderingTest.java
@@ -0,0 +1,477 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.bind.tuple.test;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.sleepycat.bind.tuple.TupleOutput;
+import com.sleepycat.util.test.SharedTestUtils;
+
+/**
+ * @author Mark Hayes
+ */
+public class TupleOrderingTest extends TestCase {
+
+    private TupleOutput out;
+    private byte[] prevBuf;
+
+    public static void main(String[] args) {
+        junit.framework.TestResult tr =
+            junit.textui.TestRunner.run(suite());
+        if (tr.errorCount() > 0 ||
+            tr.failureCount() > 0) {
+            System.exit(1);
+        } else {
+            System.exit(0);
+        }
+    }
+
+    public static Test suite() {
+        TestSuite suite = new TestSuite(TupleOrderingTest.class);
+        return suite;
+    }
+
+    public TupleOrderingTest(String name) {
+
+        super(name);
+    }
+
+    @Override
+    public void setUp() {
+
+        SharedTestUtils.printTestName("TupleOrderingTest." + getName());
+        out = new TupleOutput();
+        prevBuf = null;
+    }
+
+    @Override
+    public void tearDown() {
+
+        /* Ensure that GC can cleanup. */
+        out = null;
+        prevBuf = null;
+    }
+
+    /**
+     * Each tuple written must be strictly less than (by comparison of bytes)
+     * the tuple written just before it.  The check() method compares bytes
+     * just written to those written before the previous call to check().
+     */
+    private void check() {
+
+        check(-1);
+    }
+
+    private void check(int dataIndex) {
+
+        byte[] buf = new byte[out.size()];
+        System.arraycopy(out.getBufferBytes(), out.getBufferOffset(),
+                         buf, 0, buf.length);
+        if (prevBuf != null) {
+            int errOffset = -1;
+            int len = Math.min(prevBuf.length,  buf.length);
+            boolean areEqual = true;
+            for (int i = 0; i < len; i += 1) {
+                int val1 = prevBuf[i] & 0xFF;
+                int val2 = buf[i] & 0xFF;
+                if (val1 < val2) {
+                    areEqual = false;
+                    break;
+                } else if (val1 > val2) {
+                    errOffset = i;
+                    break;
+                }
+            }
+            if (areEqual) {
+                if (prevBuf.length < buf.length) {
+                    areEqual = false;
+                } else if (prevBuf.length > buf.length) {
+                    areEqual = false;
+                    errOffset = buf.length + 1;
+                }
+            }
+            if (errOffset != -1 || areEqual) {
+                StringBuffer msg = new StringBuffer();
+                if (errOffset != -1) {
+                    msg.append("Left >= right at byte offset " + errOffset);
+                } else if (areEqual) {
+                    msg.append("Bytes are equal");
+                } else {
+                    throw new IllegalStateException();
+                }
+                msg.append("\nLeft hex bytes: ");
+                for (int i = 0; i < prevBuf.length; i += 1) {
+                    msg.append(' ');
+                    int val = prevBuf[i] & 0xFF;
+                    if ((val & 0xF0) == 0) {
+                        msg.append('0');
+                    }
+                    msg.append(Integer.toHexString(val));
+                }
+                msg.append("\nRight hex bytes:");
+                for (int i = 0; i < buf.length; i += 1) {
+                    msg.append(' ');
+                    int val = buf[i] & 0xFF;
+                    if ((val & 0xF0) == 0) {
+                        msg.append('0');
+                    }
+                    msg.append(Integer.toHexString(val));
+                }
+                if (dataIndex >= 0) {
+                    msg.append("\nData index: " + dataIndex);
+                }
+                fail(msg.toString());
+            }
+        }
+        prevBuf = buf;
+        out.reset();
+    }
+
+    private void reset() {
+
+        prevBuf = null;
+        out.reset();
+    }
+
+    public void testString() {
+
+        final String[] DATA = {
+            "", "\u0001", "\u0002",
+            "A", "a", "ab", "b", "bb", "bba",
+            "c", "c\u0001", "d",
+            new String(new char[] { 0x7F }),
+            new String(new char[] { 0x7F, 0 }),
+            new String(new char[] { 0xFF }),
+            new String(new char[] { Character.MAX_VALUE }),
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeString(DATA[i]);
+            check(i);
+        }
+        reset();
+        out.writeString("a");
+        check();
+        out.writeString("a");
+        out.writeString("");
+        check();
+        out.writeString("a");
+        out.writeString("");
+        out.writeString("a");
+        check();
+        out.writeString("a");
+        out.writeString("b");
+        check();
+        out.writeString("aa");
+        check();
+        out.writeString("b");
+        check();
+    }
+
+    public void testFixedString() {
+
+        final char[][] DATA = {
+            {}, {'a'}, {'a', 'b'}, {'b'}, {'b', 'b'}, {0x7F}, {0xFF},
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeString(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testChars() {
+
+        final char[][] DATA = {
+            {}, {0}, {'a'}, {'a', 0}, {'a', 'b'}, {'b'}, {'b', 'b'},
+            {0x7F}, {0x7F, 0}, {0xFF}, {0xFF, 0},
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeChars(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testBytes() {
+
+        final char[][] DATA = {
+            {}, {0}, {'a'}, {'a', 0}, {'a', 'b'}, {'b'}, {'b', 'b'},
+            {0x7F}, {0xFF},
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeBytes(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testBoolean() {
+
+        final boolean[] DATA = {
+            false, true
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeBoolean(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testUnsignedByte() {
+
+        final int[] DATA = {
+            0, 1, 0x7F, 0xFF
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeUnsignedByte(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testUnsignedShort() {
+
+        final int[] DATA = {
+            0, 1, 0xFE, 0xFF, 0x800, 0x7FFF, 0xFFFF
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeUnsignedShort(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testUnsignedInt() {
+
+        final long[] DATA = {
+            0, 1, 0xFE, 0xFF, 0x800, 0x7FFF, 0xFFFF, 0x80000,
+            0x7FFFFFFF, 0x80000000, 0xFFFFFFFF
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeUnsignedInt(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testByte() {
+
+        final byte[] DATA = {
+            Byte.MIN_VALUE, Byte.MIN_VALUE + 1,
+            -1, 0, 1,
+            Byte.MAX_VALUE - 1, Byte.MAX_VALUE,
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeByte(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testShort() {
+
+        final short[] DATA = {
+            Short.MIN_VALUE, Short.MIN_VALUE + 1,
+            Byte.MIN_VALUE, Byte.MIN_VALUE + 1,
+            -1, 0, 1,
+            Byte.MAX_VALUE - 1, Byte.MAX_VALUE,
+            Short.MAX_VALUE - 1, Short.MAX_VALUE,
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeShort(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testInt() {
+
+        final int[] DATA = {
+            Integer.MIN_VALUE, Integer.MIN_VALUE + 1,
+            Short.MIN_VALUE, Short.MIN_VALUE + 1,
+            Byte.MIN_VALUE, Byte.MIN_VALUE + 1,
+            -1, 0, 1,
+            Byte.MAX_VALUE - 1, Byte.MAX_VALUE,
+            Short.MAX_VALUE - 1, Short.MAX_VALUE,
+            Integer.MAX_VALUE - 1, Integer.MAX_VALUE,
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeInt(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testLong() {
+
+        final long[] DATA = {
+            Long.MIN_VALUE, Long.MIN_VALUE + 1,
+            Integer.MIN_VALUE, Integer.MIN_VALUE + 1,
+            Short.MIN_VALUE, Short.MIN_VALUE + 1,
+            Byte.MIN_VALUE, Byte.MIN_VALUE + 1,
+            -1, 0, 1,
+            Byte.MAX_VALUE - 1, Byte.MAX_VALUE,
+            Short.MAX_VALUE - 1, Short.MAX_VALUE,
+            Integer.MAX_VALUE - 1, Integer.MAX_VALUE,
+            Long.MAX_VALUE - 1, Long.MAX_VALUE,
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeLong(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testFloat() {
+
+        // Only positive floats and doubles are ordered deterministically
+
+        final float[] DATA = {
+            0, Float.MIN_VALUE, 2 * Float.MIN_VALUE,
+            (float) 0.01, (float) 0.02, (float) 0.99,
+            1, (float) 1.01, (float) 1.02, (float) 1.99,
+            Byte.MAX_VALUE - 1, Byte.MAX_VALUE,
+            Short.MAX_VALUE - 1, Short.MAX_VALUE,
+            Integer.MAX_VALUE,
+            Long.MAX_VALUE / 2, Long.MAX_VALUE,
+            Float.MAX_VALUE,
+            Float.POSITIVE_INFINITY,
+            Float.NaN,
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeFloat(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testDouble() {
+
+        // Only positive floats and doubles are ordered deterministically
+
+        final double[] DATA = {
+            0, Double.MIN_VALUE, 2 * Double.MIN_VALUE,
+            0.001, 0.002, 0.999,
+            1, 1.001, 1.002, 1.999,
+            Byte.MAX_VALUE - 1, Byte.MAX_VALUE,
+            Short.MAX_VALUE - 1, Short.MAX_VALUE,
+            Integer.MAX_VALUE - 1, Integer.MAX_VALUE,
+            Long.MAX_VALUE / 2, Long.MAX_VALUE,
+            Float.MAX_VALUE, Double.MAX_VALUE,
+            Double.POSITIVE_INFINITY,
+            Double.NaN,
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeDouble(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testSortedFloat() {
+
+        final float[] DATA = {
+            Float.NEGATIVE_INFINITY,
+            (- Float.MAX_VALUE),
+            Long.MIN_VALUE,
+            Long.MIN_VALUE / 2,
+            Integer.MIN_VALUE,
+            Short.MIN_VALUE,
+            Short.MIN_VALUE + 1,
+            Byte.MIN_VALUE,
+            Byte.MIN_VALUE + 1,
+            (float) -1.99,
+            (float) -1.02,
+            (float) -1.01,
+            -1,
+            (float) -0.99,
+            (float) -0.02,
+            (float) -0.01,
+            2 * (- Float.MIN_VALUE),
+            (- Float.MIN_VALUE),
+            0,
+            Float.MIN_VALUE,
+            2 * Float.MIN_VALUE,
+            (float) 0.01,
+            (float) 0.02,
+            (float) 0.99,
+            1,
+            (float) 1.01,
+            (float) 1.02,
+            (float) 1.99,
+            Byte.MAX_VALUE - 1,
+            Byte.MAX_VALUE,
+            Short.MAX_VALUE - 1,
+            Short.MAX_VALUE,
+            Integer.MAX_VALUE,
+            Long.MAX_VALUE / 2,
+            Long.MAX_VALUE,
+            Float.MAX_VALUE,
+            Float.POSITIVE_INFINITY,
+            Float.NaN,
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeSortedFloat(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testSortedDouble() {
+
+        final double[] DATA = {
+            Double.NEGATIVE_INFINITY,
+            (- Double.MAX_VALUE),
+            (- Float.MAX_VALUE),
+            Long.MIN_VALUE,
+            Long.MIN_VALUE / 2,
+            Integer.MIN_VALUE,
+            Short.MIN_VALUE,
+            Short.MIN_VALUE + 1,
+            Byte.MIN_VALUE,
+            Byte.MIN_VALUE + 1,
+            -1.999,
+            -1.002,
+            -1.001,
+            -1,
+            -0.999,
+            -0.002,
+            -0.001,
+            2 * (- Double.MIN_VALUE),
+            (- Double.MIN_VALUE),
+            0,
+            Double.MIN_VALUE,
+            2 * Double.MIN_VALUE,
+            0.001,
+            0.002,
+            0.999,
+            1,
+            1.001,
+            1.002,
+            1.999,
+            Byte.MAX_VALUE - 1,
+            Byte.MAX_VALUE,
+            Short.MAX_VALUE - 1,
+            Short.MAX_VALUE,
+            Integer.MAX_VALUE - 1,
+            Integer.MAX_VALUE,
+            Long.MAX_VALUE / 2,
+            Long.MAX_VALUE,
+            Float.MAX_VALUE,
+            Double.MAX_VALUE,
+            Double.POSITIVE_INFINITY,
+            Double.NaN,
+        };
+        for (int i = 0; i < DATA.length; i += 1) {
+            out.writeSortedDouble(DATA[i]);
+            check(i);
+        }
+    }
+
+    public void testPackedIntAndLong() {
+        /* Only packed int/long values from 0 to 630 are ordered correctly */
+        for (int i = 0; i <= 630; i += 1) {
+            out.writePackedInt(i);
+            check(i);
+        }
+        reset();
+        for (int i = 0; i <= 630; i += 1) {
+            out.writePackedLong(i);
+            check(i);
+        }
+    }
+}