Berkeley DB 4.8 with rust build script for linux.

7 files changed, 1104 insertions, 0 deletions

diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/util/test/ExceptionWrapperTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/ExceptionWrapperTest.java
new file mode 100644
index 0000000..0e09e15
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/ExceptionWrapperTest.java
@@ -0,0 +1,134 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.util.test;
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.sleepycat.util.ExceptionUnwrapper;
+import com.sleepycat.util.IOExceptionWrapper;
+import com.sleepycat.util.RuntimeExceptionWrapper;
+
+/**
+ * @author Mark Hayes
+ */
+public class ExceptionWrapperTest extends TestCase {
+
+    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(ExceptionWrapperTest.class);
+        return suite;
+    }
+
+    public ExceptionWrapperTest(String name) {
+
+        super(name);
+    }
+
+    @Override
+    public void setUp() {
+
+        SharedTestUtils.printTestName("ExceptionWrapperTest." + getName());
+    }
+
+    public void testIOWrapper() {
+        try {
+            throw new IOExceptionWrapper(new RuntimeException("msg"));
+        } catch (IOException e) {
+            Exception ee = ExceptionUnwrapper.unwrap(e);
+            assertTrue(ee instanceof RuntimeException);
+            assertEquals("msg", ee.getMessage());
+
+            Throwable t = ExceptionUnwrapper.unwrapAny(e);
+            assertTrue(t instanceof RuntimeException);
+            assertEquals("msg", t.getMessage());
+        }
+    }
+
+    public void testRuntimeWrapper() {
+        try {
+            throw new RuntimeExceptionWrapper(new IOException("msg"));
+        } catch (RuntimeException e) {
+            Exception ee = ExceptionUnwrapper.unwrap(e);
+            assertTrue(ee instanceof IOException);
+            assertEquals("msg", ee.getMessage());
+
+            Throwable t = ExceptionUnwrapper.unwrapAny(e);
+            assertTrue(t instanceof IOException);
+            assertEquals("msg", t.getMessage());
+        }
+    }
+
+    public void testErrorWrapper() {
+        try {
+            throw new RuntimeExceptionWrapper(new Error("msg"));
+        } catch (RuntimeException e) {
+            try {
+                ExceptionUnwrapper.unwrap(e);
+                fail();
+            } catch (Error ee) {
+                assertTrue(ee instanceof Error);
+                assertEquals("msg", ee.getMessage());
+            }
+
+            Throwable t = ExceptionUnwrapper.unwrapAny(e);
+            assertTrue(t instanceof Error);
+            assertEquals("msg", t.getMessage());
+        }
+    }
+
+    /**
+     * Generates a stack trace for a nested exception and checks the output
+     * for the nested exception.
+     */
+    public void testStackTrace() {
+
+        /* Nested stack traces are not avilable in Java 1.3. */
+        String version = System.getProperty("java.version");
+        if (version.startsWith("1.3.")) {
+            return;
+        }
+
+        Exception ex = new Exception("some exception");
+        String causedBy = "Caused by: java.lang.Exception: some exception";
+
+        try {
+            throw new RuntimeExceptionWrapper(ex);
+        } catch (RuntimeException e) {
+            StringWriter sw = new StringWriter();
+            e.printStackTrace(new PrintWriter(sw));
+            String s = sw.toString();
+            assertTrue(s.indexOf(causedBy) != -1);
+        }
+
+        try {
+            throw new IOExceptionWrapper(ex);
+        } catch (IOException e) {
+            StringWriter sw = new StringWriter();
+            e.printStackTrace(new PrintWriter(sw));
+            String s = sw.toString();
+            assertTrue(s.indexOf(causedBy) != -1);
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/util/test/FastOutputStreamTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/FastOutputStreamTest.java
new file mode 100644
index 0000000..a17ea9b
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/FastOutputStreamTest.java
@@ -0,0 +1,66 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.util.test;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.sleepycat.util.FastOutputStream;
+
+/**
+ * @author Mark Hayes
+ */
+public class FastOutputStreamTest extends TestCase {
+
+    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(FastOutputStreamTest.class);
+        return suite;
+    }
+
+    public FastOutputStreamTest(String name) {
+
+        super(name);
+    }
+
+    @Override
+    public void setUp() {
+
+        SharedTestUtils.printTestName("FastOutputStreamTest." + getName());
+    }
+
+    public void testBufferSizing() {
+        FastOutputStream fos = new FastOutputStream();
+        assertEquals
+            (FastOutputStream.DEFAULT_INIT_SIZE, fos.getBufferBytes().length);
+
+        /* Write X+1 bytes, expect array size 2X+1 */
+        fos.write(new byte[FastOutputStream.DEFAULT_INIT_SIZE + 1]);
+        assertEquals
+            ((FastOutputStream.DEFAULT_INIT_SIZE * 2) + 1,
+             fos.getBufferBytes().length);
+
+        /* Write X+1 bytes, expect array size 4X+3 = (2(2X+1) + 1) */
+        fos.write(new byte[FastOutputStream.DEFAULT_INIT_SIZE + 1]);
+        assertEquals
+            ((FastOutputStream.DEFAULT_INIT_SIZE * 4) + 3,
+             fos.getBufferBytes().length);
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/util/test/PackedIntegerTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/PackedIntegerTest.java
new file mode 100644
index 0000000..46e2a4e
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/PackedIntegerTest.java
@@ -0,0 +1,191 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.util.test;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+
+import com.sleepycat.util.PackedInteger;
+
+public class PackedIntegerTest extends TestCase
+{
+    static final long V119 = 119L;
+    static final long MAX_1 = 0xFFL;
+    static final long MAX_2 = 0xFFFFL;
+    static final long MAX_3 = 0xFFFFFFL;
+    static final long MAX_4 = 0xFFFFFFFFL;
+    static final long MAX_5 = 0xFFFFFFFFFFL;
+    static final long MAX_6 = 0xFFFFFFFFFFFFL;
+    static final long MAX_7 = 0xFFFFFFFFFFFFFFL;
+
+    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() {
+
+        return new PackedIntegerTest();
+    }
+
+    public PackedIntegerTest() {
+
+        super("PackedIntegerTest");
+    }
+
+    @Override
+    public void runTest() {
+
+        /* Packed int tests. */
+
+        testIntRange(-V119, V119, 1);
+
+        testIntRange(-MAX_1 - V119, -1 - V119, 2);
+        testIntRange(1 + V119, MAX_1 + V119, 2);
+
+        testIntRange(-MAX_2 - V119, -MAX_2 + 99, 3);
+        testIntRange(-MAX_1 - V119 - 99, -MAX_1 - V119 - 1, 3);
+        testIntRange(MAX_1 + V119 + 1, MAX_1 + V119 + 99, 3);
+        testIntRange(MAX_2 - 99, MAX_2 + V119, 3);
+
+        testIntRange(-MAX_3 - V119, -MAX_3 + 99, 4);
+        testIntRange(-MAX_2 - V119 - 99, -MAX_2 - V119 - 1, 4);
+        testIntRange(MAX_2 + V119 + 1, MAX_2 + V119 + 99, 4);
+        testIntRange(MAX_3 - 99, MAX_3 + V119, 4);
+
+        testIntRange(Integer.MIN_VALUE, Integer.MIN_VALUE + 99, 5);
+        testIntRange(Integer.MAX_VALUE - 99, Integer.MAX_VALUE, 5);
+
+        /* Packed long tests. */
+
+        testLongRange(-V119, V119, 1);
+
+        testLongRange(-MAX_1 - V119, -1 - V119, 2);
+        testLongRange(1 + V119, MAX_1 + V119, 2);
+
+        testLongRange(-MAX_2 - V119, -MAX_2 + 99, 3);
+        testLongRange(-MAX_1 - V119 - 99, -MAX_1 - V119 - 1, 3);
+        testLongRange(MAX_1 + V119 + 1, MAX_1 + V119 + 99, 3);
+        testLongRange(MAX_2 - 99, MAX_2 + V119, 3);
+
+        testLongRange(-MAX_3 - V119, -MAX_3 + 99, 4);
+        testLongRange(-MAX_2 - V119 - 99, -MAX_2 - V119 - 1, 4);
+        testLongRange(MAX_2 + V119 + 1, MAX_2 + V119 + 99, 4);
+        testLongRange(MAX_3 - 99, MAX_3 + V119, 4);
+
+        testLongRange(-MAX_4 - V119, -MAX_4 + 99, 5);
+        testLongRange(-MAX_3 - V119 - 99, -MAX_3 - V119 - 1, 5);
+        testLongRange(MAX_3 + V119 + 1, MAX_3 + V119 + 99, 5);
+        testLongRange(MAX_4 - 99, MAX_4 + V119, 5);
+
+        testLongRange(-MAX_5 - V119, -MAX_5 + 99, 6);
+        testLongRange(-MAX_4 - V119 - 99, -MAX_4 - V119 - 1, 6);
+        testLongRange(MAX_4 + V119 + 1, MAX_4 + V119 + 99, 6);
+        testLongRange(MAX_5 - 99, MAX_5 + V119, 6);
+
+        testLongRange(-MAX_6 - V119, -MAX_6 + 99, 7);
+        testLongRange(-MAX_5 - V119 - 99, -MAX_5 - V119 - 1, 7);
+        testLongRange(MAX_5 + V119 + 1, MAX_5 + V119 + 99, 7);
+        testLongRange(MAX_6 - 99, MAX_6 + V119, 7);
+
+        testLongRange(-MAX_7 - V119, -MAX_7 + 99, 8);
+        testLongRange(-MAX_6 - V119 - 99, -MAX_6 - V119 - 1, 8);
+        testLongRange(MAX_6 + V119 + 1, MAX_6 + V119 + 99, 8);
+        testLongRange(MAX_7 - 99, MAX_7 + V119, 8);
+
+        testLongRange(Long.MIN_VALUE, Long.MIN_VALUE + 99, 9);
+        testLongRange(Long.MAX_VALUE - 99, Long.MAX_VALUE - 1, 9);
+    }
+
+    private void testIntRange(long firstValue,
+                              long lastValue,
+                              int bytesExpected) {
+
+        byte[] buf = new byte[1000];
+        int off = 0;
+
+        for (long longI = firstValue; longI <= lastValue; longI += 1) {
+            int i = (int) longI;
+            int before = off;
+            off = PackedInteger.writeInt(buf, off, i);
+            int bytes = off - before;
+            if (bytes != bytesExpected) {
+                fail("output of value=" + i + " bytes=" + bytes +
+                     " bytesExpected=" + bytesExpected);
+            }
+            bytes = PackedInteger.getWriteIntLength(i);
+            if (bytes != bytesExpected) {
+                fail("count of value=" + i + " bytes=" + bytes +
+                     " bytesExpected=" + bytesExpected);
+            }
+        }
+
+        off = 0;
+
+        for (long longI = firstValue; longI <= lastValue; longI += 1) {
+            int i = (int) longI;
+            int bytes = PackedInteger.getReadIntLength(buf, off);
+            if (bytes != bytesExpected) {
+                fail("count of value=" + i + " bytes=" + bytes +
+                     " bytesExpected=" + bytesExpected);
+            }
+            int value = PackedInteger.readInt(buf, off);
+            if (value != i) {
+                fail("input of value=" + i + " but got=" + value);
+            }
+            off += bytes;
+        }
+    }
+
+    private void testLongRange(long firstValue,
+                               long lastValue,
+                               int bytesExpected) {
+
+        byte[] buf = new byte[2000];
+        int off = 0;
+
+        for (long longI = firstValue; longI <= lastValue; longI += 1) {
+            long i = longI;
+            int before = off;
+            off = PackedInteger.writeLong(buf, off, i);
+            int bytes = off - before;
+            if (bytes != bytesExpected) {
+                fail("output of value=" + i + " bytes=" + bytes +
+                     " bytesExpected=" + bytesExpected);
+            }
+            bytes = PackedInteger.getWriteLongLength(i);
+            if (bytes != bytesExpected) {
+                fail("count of value=" + i + " bytes=" + bytes +
+                     " bytesExpected=" + bytesExpected);
+            }
+        }
+
+        off = 0;
+
+        for (long longI = firstValue; longI <= lastValue; longI += 1) {
+            long i = longI;
+            int bytes = PackedInteger.getReadLongLength(buf, off);
+            if (bytes != bytesExpected) {
+                fail("count of value=" + i + " bytes=" + bytes +
+                     " bytesExpected=" + bytesExpected);
+            }
+            long value = PackedInteger.readLong(buf, off);
+            if (value != i) {
+                fail("input of value=" + i + " but got=" + value);
+            }
+            off += bytes;
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/util/test/SharedTestUtils.java b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/SharedTestUtils.java
new file mode 100644
index 0000000..109dd0c
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/SharedTestUtils.java
@@ -0,0 +1,178 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.util.test;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import junit.framework.TestCase;
+
+import com.sleepycat.db.DatabaseConfig;
+
+/**
+ * Test utility methods shared by JE and DB core tests.  Collections and
+ * persist package test are used in both JE and DB core.
+ */
+public class SharedTestUtils {
+
+    /* Common system properties for running tests */
+    public static String DEST_DIR = "testdestdir";
+    public static String NO_SYNC = "txnnosync";
+    public static String LONG_TEST =  "longtest";
+
+    public static final DatabaseConfig DBCONFIG_CREATE = new DatabaseConfig();
+    static {
+        DBCONFIG_CREATE.setAllowCreate(true);
+    }
+
+    private static File getTestDir() {
+        String dir = System.getProperty(DEST_DIR);
+        if (dir == null || dir.length() == 0) {
+            throw new IllegalArgumentException
+                ("System property must be set to test data directory: " +
+                 DEST_DIR);
+        }
+        return new File(dir);
+    }
+
+    /**
+     * @return true if long running tests are enabled via setting the system
+     * property longtest=true.
+     */
+    public static boolean runLongTests() {
+        String longTestProp =  System.getProperty(LONG_TEST);
+        if ((longTestProp != null)  &&
+            longTestProp.equalsIgnoreCase("true")) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public static void printTestName(String name) {
+        // don't want verbose printing for now
+        // System.out.println(name);
+    }
+
+    public static File getExistingDir(String name) {
+        File dir = new File(getTestDir(), name);
+        if (!dir.exists() || !dir.isDirectory()) {
+            throw new IllegalStateException(
+                    "Not an existing directory: " + dir);
+        }
+        return dir;
+    }
+
+    public static File getNewDir() {
+        return getNewDir("test-dir");
+    }
+
+    public static void emptyDir(File dir) {
+        if (dir.isDirectory()) {
+            String[] files = dir.list();
+            if (files != null) {
+                for (int i = 0; i < files.length; i += 1) {
+                    new File(dir, files[i]).delete();
+                }
+            }
+        } else {
+            dir.delete();
+            dir.mkdirs();
+        }
+    }
+
+    public static File getNewDir(String name) {
+        File dir = new File(getTestDir(), name);
+        emptyDir(dir);
+        return dir;
+    }
+
+    public static File getNewFile() {
+        return getNewFile("test-file");
+    }
+
+    public static File getNewFile(String name) {
+        return getNewFile(getTestDir(), name);
+    }
+
+    public static File getNewFile(File dir, String name) {
+        File file = new File(dir, name);
+        file.delete();
+        return file;
+    }
+
+    public static boolean copyResource(Class cls, String fileName, File toDir)
+        throws IOException {
+
+        InputStream in = cls.getResourceAsStream("testdata/" + fileName);
+        if (in == null) {
+            return false;
+        }
+        in = new BufferedInputStream(in);
+        File file = new File(toDir, fileName);
+        OutputStream out = new FileOutputStream(file);
+        out = new BufferedOutputStream(out);
+        int c;
+        while ((c = in.read()) >= 0) out.write(c);
+        in.close();
+        out.close();
+        return true;
+    }
+
+    public static String qualifiedTestName(TestCase test) {
+
+        String s = test.getClass().getName();
+        int i = s.lastIndexOf('.');
+        if (i >= 0) {
+            s = s.substring(i + 1);
+        }
+        return s + '.' + test.getName();
+    }
+
+    /**
+     * Copies all files in fromDir to toDir.  Does not copy subdirectories.
+     */
+    public static void copyFiles(File fromDir, File toDir)
+        throws IOException {
+
+        String[] names = fromDir.list();
+        if (names != null) {
+            for (int i = 0; i < names.length; i += 1) {
+                File fromFile = new File(fromDir, names[i]);
+                if (fromFile.isDirectory()) {
+                    continue;
+                }
+                File toFile = new File(toDir, names[i]);
+                int len = (int) fromFile.length();
+                byte[] data = new byte[len];
+                FileInputStream fis = null;
+                FileOutputStream fos = null;
+                try {
+                    fis = new FileInputStream(fromFile);
+                    fos = new FileOutputStream(toFile);
+                    fis.read(data);
+                    fos.write(data);
+                } finally {
+                    if (fis != null) {
+                        fis.close();
+                    }
+                    if (fos != null) {
+                        fos.close();
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/util/test/TestEnv.java b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/TestEnv.java
new file mode 100644
index 0000000..d065a43
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/TestEnv.java
@@ -0,0 +1,142 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.util.test;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import com.sleepycat.compat.DbCompat;
+import com.sleepycat.db.DatabaseException;
+import com.sleepycat.db.Environment;
+import com.sleepycat.db.EnvironmentConfig;
+
+/**
+ * @author Mark Hayes
+ */
+public class TestEnv {
+
+    public static final TestEnv BDB;
+    public static final TestEnv CDB;
+    public static final TestEnv TXN;
+    static {
+        EnvironmentConfig config;
+
+        config = newEnvConfig();
+        BDB = new TestEnv("bdb", config);
+
+        if (DbCompat.CDB) {
+            config = newEnvConfig();
+            DbCompat.setInitializeCDB(config, true);
+            CDB = new TestEnv("cdb", config);
+        } else {
+            CDB = null;
+        }
+
+        config = newEnvConfig();
+        config.setTransactional(true);
+        DbCompat.setInitializeLocking(config, true);
+        TXN = new TestEnv("txn", config);
+    }
+
+    private static EnvironmentConfig newEnvConfig() {
+
+        EnvironmentConfig config = new EnvironmentConfig();
+        config.setTxnNoSync(Boolean.getBoolean(SharedTestUtils.NO_SYNC));
+        if (DbCompat.MEMORY_SUBSYSTEM) {
+            DbCompat.setInitializeCache(config, true);
+        }
+        return config;
+    }
+
+    public static final TestEnv[] ALL;
+    static {
+        if (DbCompat.CDB) {
+            ALL = new TestEnv[] { BDB, CDB, TXN };
+        } else {
+            ALL = new TestEnv[] { BDB, TXN };
+        }
+    }
+
+    private final String name;
+    private final EnvironmentConfig config;
+
+    protected TestEnv(String name, EnvironmentConfig config) {
+
+        this.name = name;
+        this.config = config;
+    }
+
+    public String getName() {
+
+        return name;
+    }
+
+    public EnvironmentConfig getConfig() {
+        return config;
+    }
+
+    void copyConfig(EnvironmentConfig copyToConfig) {
+        DbCompat.setInitializeCache
+            (copyToConfig, DbCompat.getInitializeCache(config));
+        DbCompat.setInitializeLocking
+            (copyToConfig, DbCompat.getInitializeLocking(config));
+        DbCompat.setInitializeCDB
+            (copyToConfig, DbCompat.getInitializeCDB(config));
+        copyToConfig.setTransactional(config.getTransactional());
+    }
+
+    public boolean isTxnMode() {
+
+        return config.getTransactional();
+    }
+
+    public boolean isCdbMode() {
+
+        return DbCompat.getInitializeCDB(config);
+    }
+
+    public Environment open(String testName)
+        throws IOException, DatabaseException {
+
+        return open(testName, true);
+    }
+
+    public Environment open(String testName, boolean create)
+        throws IOException, DatabaseException {
+
+        config.setAllowCreate(create);
+        /* OLDEST deadlock detection on DB matches the use of timeouts on JE.*/
+        DbCompat.setLockDetectModeOldest(config);
+        File dir = getDirectory(testName, create);
+        return newEnvironment(dir, config);
+    }
+
+    /**
+     * Is overridden in XACollectionTest.
+     * @throws FileNotFoundException from DB core.
+     */
+    protected Environment newEnvironment(File dir, EnvironmentConfig config)
+        throws DatabaseException, FileNotFoundException {
+
+        return new Environment(dir, config);
+    }
+
+    public File getDirectory(String testName) {
+        return getDirectory(testName, true);
+    }
+
+    public File getDirectory(String testName, boolean create) {
+        if (create) {
+            return SharedTestUtils.getNewDir(testName);
+        } else {
+            return SharedTestUtils.getExistingDir(testName);
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/util/test/TxnTestCase.java b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/TxnTestCase.java
new file mode 100644
index 0000000..249ad2c
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/TxnTestCase.java
@@ -0,0 +1,230 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.util.test;
+
+import java.io.File;
+import java.util.Enumeration;
+
+import junit.framework.TestSuite;
+
+import com.sleepycat.db.DatabaseException;
+import com.sleepycat.db.Environment;
+import com.sleepycat.db.EnvironmentConfig;
+import com.sleepycat.db.Transaction;
+import com.sleepycat.db.TransactionConfig;
+import com.sleepycat.db.util.DualTestCase;
+
+/**
+ * Permutes test cases over three transaction types: null (non-transactional),
+ * auto-commit, and user (explicit).
+ *
+ * <p>Overrides runTest, setUp and tearDown to open/close the environment and
+ * to set up protected members for use by test cases.</p>
+ *
+ * <p>If a subclass needs to override setUp or tearDown, the overridden method
+ * should call super.setUp or super.tearDown.</p>
+ *
+ * <p>When writing a test case based on this class, write it as if a user txn
+ * were always used: call txnBegin, txnCommit and txnAbort for all write
+ * operations.  Use the isTransactional protected field for setup of a database
+ * config.</p>
+ */
+public abstract class TxnTestCase extends DualTestCase {
+
+    public static final String TXN_NULL = "txn-null";
+    public static final String TXN_AUTO = "txn-auto";
+    public static final String TXN_USER = "txn-user";
+
+    protected File envHome;
+    protected Environment env;
+    protected EnvironmentConfig envConfig;
+    protected String txnType;
+    protected boolean isTransactional;
+
+    /**
+     * Returns a txn test suite.  If txnTypes is null, all three types are run.
+     */
+    public static TestSuite txnTestSuite(Class<?> testCaseClass,
+                                         EnvironmentConfig envConfig,
+                                         String[] txnTypes) {
+        if (txnTypes == null) {
+            txnTypes =
+                isReplicatedTest(testCaseClass) ?
+                new String[] { // Skip non-transactional tests
+                               TxnTestCase.TXN_USER,
+                               TxnTestCase.TXN_AUTO  } :
+                new String[] { TxnTestCase.TXN_NULL,
+                               TxnTestCase.TXN_USER,
+                               TxnTestCase.TXN_AUTO } ;
+        }
+        if (envConfig == null) {
+            envConfig = new EnvironmentConfig();
+            envConfig.setAllowCreate(true);
+        }
+        TestSuite suite = new TestSuite();
+        for (int i = 0; i < txnTypes.length; i += 1) {
+            TestSuite baseSuite = new TestSuite(testCaseClass);
+            Enumeration e = baseSuite.tests();
+            while (e.hasMoreElements()) {
+                TxnTestCase test = (TxnTestCase) e.nextElement();
+                test.txnInit(envConfig, txnTypes[i]);
+                suite.addTest(test);
+            }
+        }
+        return suite;
+    }
+
+    private void txnInit(EnvironmentConfig envConfig, String txnType) {
+
+        this.envConfig = envConfig;
+        this.txnType = txnType;
+        isTransactional = (txnType != TXN_NULL);
+    }
+
+    @Override
+    public void setUp()
+        throws Exception {
+
+        super.setUp();
+        envHome = SharedTestUtils.getNewDir();
+    }
+
+    @Override
+    public void runTest()
+        throws Throwable {
+
+        openEnv();
+        super.runTest();
+        closeEnv();
+    }
+
+    @Override
+    public void tearDown()
+        throws Exception {
+
+        /* Set test name for reporting; cannot be done in the ctor or setUp. */
+        setName(txnType + ':' + getName());
+
+        super.tearDown();
+        env = null;
+
+        try {
+            SharedTestUtils.emptyDir(envHome);
+        } catch (Throwable e) {
+            System.out.println("tearDown: " + e);
+        }
+    }
+
+    /**
+     * Closes the environment and sets the env field to null.
+     * Used for closing and reopening the environment.
+     */
+    public void closeEnv()
+        throws DatabaseException {
+
+        if (env != null) {
+            close(env);
+            env = null;
+        }
+    }
+
+    /**
+     * Opens the environment based on the txnType for this test case.
+     * Used for closing and reopening the environment.
+     */
+    public void openEnv()
+        throws DatabaseException {
+
+        if (txnType == TXN_NULL) {
+            TestEnv.BDB.copyConfig(envConfig);
+            env = create(envHome, envConfig);
+        } else if (txnType == TXN_AUTO) {
+            TestEnv.TXN.copyConfig(envConfig);
+            env = create(envHome, envConfig);
+        } else if (txnType == TXN_USER) {
+            TestEnv.TXN.copyConfig(envConfig);
+            env = create(envHome, envConfig);
+        } else {
+            assert false;
+        }
+    }
+
+    /**
+     * Begin a txn if in TXN_USER mode; otherwise return null;
+     */
+    protected Transaction txnBegin()
+        throws DatabaseException {
+
+        return txnBegin(null, null);
+    }
+
+    /**
+     * Begin a txn if in TXN_USER mode; otherwise return null;
+     */
+    protected Transaction txnBegin(Transaction parentTxn,
+                                   TransactionConfig config)
+        throws DatabaseException {
+
+        /*
+         * Replicated tests need a user txn for auto txns args to
+         * Database.get/put methods.
+         */
+        if (txnType == TXN_USER ||
+            (isReplicatedTest(getClass()) && txnType == TXN_AUTO)) {
+            return env.beginTransaction(parentTxn, config);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Begin a txn if in TXN_USER or TXN_AUTO mode; otherwise return null;
+     */
+    protected Transaction txnBeginCursor()
+        throws DatabaseException {
+
+        return txnBeginCursor(null, null);
+    }
+
+    /**
+     * Begin a txn if in TXN_USER or TXN_AUTO mode; otherwise return null;
+     */
+    protected Transaction txnBeginCursor(Transaction parentTxn,
+                                         TransactionConfig config)
+        throws DatabaseException {
+
+        if (txnType == TXN_USER || txnType == TXN_AUTO) {
+            return env.beginTransaction(parentTxn, config);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Commit a txn if non-null.
+     */
+    protected void txnCommit(Transaction txn)
+        throws DatabaseException {
+
+        if (txn != null) {
+            txn.commit();
+        }
+    }
+
+    /**
+     * Commit a txn if non-null.
+     */
+    protected void txnAbort(Transaction txn)
+        throws DatabaseException {
+
+        if (txn != null) {
+            txn.abort();
+        }
+    }
+}
diff --git a/db-4.8.30/test/scr024/src/com/sleepycat/util/test/UtfTest.java b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/UtfTest.java
new file mode 100644
index 0000000..7b0ef53
--- /dev/null
+++ b/db-4.8.30/test/scr024/src/com/sleepycat/util/test/UtfTest.java
@@ -0,0 +1,163 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2002-2009 Oracle.  All rights reserved.
+ *
+ * $Id$
+ */
+
+package com.sleepycat.util.test;
+
+import java.io.DataOutputStream;
+import java.util.Arrays;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.sleepycat.util.FastOutputStream;
+import com.sleepycat.util.UtfOps;
+
+/**
+ * @author Mark Hayes
+ */
+public class UtfTest extends TestCase {
+
+    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(UtfTest.class);
+        return suite;
+    }
+
+    public UtfTest(String name) {
+
+        super(name);
+    }
+
+    @Override
+    public void setUp() {
+
+        SharedTestUtils.printTestName("UtfTest." + getName());
+    }
+
+    /**
+     * Compares the UtfOps implementation to the java.util.DataOutputStream
+     * (and by implication DataInputStream) implementation, character for
+     * character in the full Unicode set.
+     */
+    public void testMultibyte()
+        throws Exception {
+
+        char c = 0;
+        byte[] buf = new byte[10];
+        byte[] javaBuf = new byte[10];
+        char[] cArray = new char[1];
+        FastOutputStream javaBufStream = new FastOutputStream(javaBuf);
+        DataOutputStream javaOutStream = new DataOutputStream(javaBufStream);
+
+        try {
+            for (int cInt = Character.MIN_VALUE; cInt <= Character.MAX_VALUE;
+                 cInt += 1) {
+                c = (char) cInt;
+                cArray[0] = c;
+                int byteLen = UtfOps.getByteLength(cArray);
+
+                javaBufStream.reset();
+                javaOutStream.writeUTF(new String(cArray));
+                int javaByteLen = javaBufStream.size() - 2;
+
+                if (byteLen != javaByteLen) {
+                    fail("Character 0x" + Integer.toHexString(c) +
+                         " UtfOps size " + byteLen +
+                         " != JavaIO size " + javaByteLen);
+                }
+
+                Arrays.fill(buf, (byte) 0);
+                UtfOps.charsToBytes(cArray, 0, buf, 0, 1);
+
+                if (byteLen == 1 && buf[0] == (byte) 0xff) {
+                    fail("Character 0x" + Integer.toHexString(c) +
+                         " was encoded as FF, which is reserved for null");
+                }
+
+                for (int i = 0; i < byteLen; i += 1) {
+                    if (buf[i] != javaBuf[i + 2]) {
+                        fail("Character 0x" + Integer.toHexString(c) +
+                             " byte offset " + i +
+                             " UtfOps byte " + Integer.toHexString(buf[i]) +
+                             " != JavaIO byte " +
+                             Integer.toHexString(javaBuf[i + 2]));
+                    }
+                }
+
+                int charLen = UtfOps.getCharLength(buf, 0, byteLen);
+                if (charLen != 1) {
+                    fail("Character 0x" + Integer.toHexString(c) +
+                         " UtfOps char len " + charLen +
+                         " but should be one");
+                }
+
+                cArray[0] = (char) 0;
+                int len = UtfOps.bytesToChars(buf, 0, cArray, 0, byteLen,
+                                              true);
+                if (len != byteLen) {
+                    fail("Character 0x" + Integer.toHexString(c) +
+                         " UtfOps bytesToChars(w/byteLen) len " + len +
+                         " but should be " + byteLen);
+                }
+
+                if (cArray[0] != c) {
+                    fail("Character 0x" + Integer.toHexString(c) +
+                         " UtfOps bytesToChars(w/byteLen) char " +
+                         Integer.toHexString(cArray[0]));
+                }
+
+                cArray[0] = (char) 0;
+                len = UtfOps.bytesToChars(buf, 0, cArray, 0, 1, false);
+                if (len != byteLen) {
+                    fail("Character 0x" + Integer.toHexString(c) +
+                         " UtfOps bytesToChars(w/charLen) len " + len +
+                         " but should be " + byteLen);
+                }
+
+                if (cArray[0] != c) {
+                    fail("Character 0x" + Integer.toHexString(c) +
+                         " UtfOps bytesToChars(w/charLen) char " +
+                         Integer.toHexString(cArray[0]));
+                }
+
+                String s = new String(cArray, 0, 1);
+                byte[] sBytes = UtfOps.stringToBytes(s);
+                if (sBytes.length != byteLen) {
+                    fail("Character 0x" + Integer.toHexString(c) +
+                         " UtfOps stringToBytes() len " + sBytes.length +
+                         " but should be " + byteLen);
+                }
+
+                for (int i = 0; i < byteLen; i += 1) {
+                    if (sBytes[i] != javaBuf[i + 2]) {
+                        fail("Character 0x" + Integer.toHexString(c) +
+                             " byte offset " + i +
+                             " UtfOps byte " + Integer.toHexString(sBytes[i]) +
+                             " != JavaIO byte " +
+                             Integer.toHexString(javaBuf[i + 2]));
+                    }
+                }
+            }
+        } catch (Exception e) {
+            System.out.println("Character 0x" + Integer.toHexString(c) +
+                               " exception occurred");
+            throw e;
+        }
+    }
+}