public void ConfigCase1(RecnoDatabaseConfig dbConfig)
 {
     dbConfig.Creation = CreatePolicy.IF_NEEDED;
     dbConfig.PageSize = 4096;
     dbConfig.Length = 4000;
     dbConfig.PadByte = 256;
 }

        /*
         * Open environment, database and write data into database.
         * Generated log files are put under testHome.
         */
        public void Logging(string home, string dbName,
		    out DatabaseEnvironment env, out RecnoDatabase recnoDB)
        {
            string dbFileName = dbName + ".db";

            Configuration.ClearDir(home);

            // Open environment with logging subsystem.
            DatabaseEnvironmentConfig envConfig =
                new DatabaseEnvironmentConfig();
            envConfig.Create = true;
            envConfig.UseLogging = true;
            envConfig.LogSystemCfg = new LogConfig();
            envConfig.LogSystemCfg.FileMode = 755;
            envConfig.LogSystemCfg.ZeroOnCreate = true;
            envConfig.UseMPool = true;
            env = DatabaseEnvironment.Open(home, envConfig);

            /*
             * Open recno database, write 100000 records into
             * the database and close it.
             */
            RecnoDatabaseConfig recnoConfig =
                new RecnoDatabaseConfig();
            recnoConfig.Creation = CreatePolicy.IF_NEEDED;
            recnoConfig.Env = env;
            // The db needs mpool to open.
            recnoConfig.NoMMap = false;
            recnoDB = RecnoDatabase.Open(dbFileName,
                recnoConfig);
            for (int i = 0; i < 1000; i++)
                recnoDB.Append(new DatabaseEntry(
                    ASCIIEncoding.ASCII.GetBytes("key")));
        }

        public static void Config(XmlElement xmlElement,
		    ref RecnoDatabaseConfig recnoDBConfig, bool compulsory)
        {
            int intValue = new int();
            uint uintValue = new uint();
            DatabaseConfig dbConfig = recnoDBConfig;
            Config(xmlElement, ref dbConfig, compulsory);

            // Configure specific fields/properties of Recno database
            Configuration.ConfigCreatePolicy(xmlElement, "Creation",
                ref recnoDBConfig.Creation, compulsory);
            if (Configuration.ConfigInt(xmlElement, "Delimiter",
                ref intValue, compulsory))
                recnoDBConfig.Delimiter = intValue;
            if (Configuration.ConfigUint(xmlElement, "Length",
                ref uintValue, compulsory))
                recnoDBConfig.Length = uintValue;
            if (Configuration.ConfigInt(xmlElement, "PadByte",
                ref intValue, compulsory))
                recnoDBConfig.PadByte = intValue;
            Configuration.ConfigBool(xmlElement, "Renumber",
                ref recnoDBConfig.Renumber, compulsory);
            Configuration.ConfigBool(xmlElement, "Snapshot",
                ref recnoDBConfig.Snapshot, compulsory);
        }

        public void GetCursorWithImplicitTxn(string home, 
		    string dbFile, bool ifConfig)
        {
            DatabaseEnvironmentConfig envConfig =
                new DatabaseEnvironmentConfig();
            envConfig.Create = true;
            envConfig.UseCDB = true;
            envConfig.UseMPool = true;
            DatabaseEnvironment env = DatabaseEnvironment.Open(
                home, envConfig);

            RecnoDatabaseConfig dbConfig =
                new RecnoDatabaseConfig();
            dbConfig.Creation = CreatePolicy.IF_NEEDED;
            dbConfig.Env = env;
            RecnoDatabase db = RecnoDatabase.Open(dbFile,
                dbConfig);

            RecnoCursor cursor;
            if (ifConfig == false)
                cursor = db.Cursor();
            else
                cursor = db.Cursor(new CursorConfig());

            cursor.Close();
            db.Close();
            env.Close();
        }

        public void GetCursorWithExplicitTxn(string home,
		    string dbFile, bool ifConfig)
        {
            DatabaseEnvironmentConfig envConfig =
                new DatabaseEnvironmentConfig();
            envConfig.Create = true;
            envConfig.UseTxns = true;
            envConfig.UseMPool = true;
            DatabaseEnvironment env = DatabaseEnvironment.Open(
                home, envConfig);

            Transaction openTxn = env.BeginTransaction();
            RecnoDatabaseConfig dbConfig =
                new RecnoDatabaseConfig();
            dbConfig.Creation = CreatePolicy.IF_NEEDED;
            dbConfig.Env = env;
            RecnoDatabase db = RecnoDatabase.Open(dbFile,
                dbConfig, openTxn);
            openTxn.Commit();

            Transaction cursorTxn = env.BeginTransaction();
            RecnoCursor cursor;
            if (ifConfig == false)
                cursor = db.Cursor(cursorTxn);
            else
                cursor = db.Cursor(new CursorConfig(), cursorTxn);
            cursor.Close();
            cursorTxn.Commit();
            db.Close();
            env.Close();
        }

 private void Config(RecnoDatabaseConfig cfg) {
     base.Config(cfg);
     /*
      * Database.Config calls set_flags, but that doesn't get the Recno
      * specific flags.  No harm in calling it again.
      */
     db.set_flags(cfg.flags);
     
     if (cfg.delimiterIsSet)
         RecordDelimiter = cfg.Delimiter;
     if (cfg.lengthIsSet)
         RecordLength = cfg.Length;
     if (cfg.padIsSet)
         RecordPad = cfg.PadByte;
     if (cfg.BackingFile != null)
         SourceFile = cfg.BackingFile;
 }

        public static void Confirm(XmlElement xmlElement,
		    RecnoDatabaseConfig recnoDBConfig, bool compulsory)
        {
            DatabaseConfig dbConfig = recnoDBConfig;
            Confirm(xmlElement, dbConfig, compulsory);

            // Confirm Recno database specific configuration
            Configuration.ConfirmString(xmlElement, "BackingFile",
                recnoDBConfig.BackingFile, compulsory);
            Configuration.ConfirmCreatePolicy(xmlElement,
                "Creation", recnoDBConfig.Creation, compulsory);
            Configuration.ConfirmInt(xmlElement, "Delimiter",
                recnoDBConfig.Delimiter, compulsory);
            Configuration.ConfirmUint(xmlElement, "Length",
                recnoDBConfig.Length, compulsory);
            Configuration.ConfirmInt(xmlElement, "PadByte",
                recnoDBConfig.PadByte, compulsory);
            Configuration.ConfirmBool(xmlElement, "Renumber",
                recnoDBConfig.Renumber, compulsory);
            Configuration.ConfirmBool(xmlElement, "Snapshot",
                recnoDBConfig.Snapshot, compulsory);
        }

        public void OpenSecRecnoDB(string className,
		    string funName, string dbFileName, string dbSecFileName,
		    bool ifDBName)
        {
            XmlElement xmlElem = Configuration.TestSetUp(
                className, funName);

            // Open a primary recno database.
            RecnoDatabaseConfig primaryDBConfig =
                new RecnoDatabaseConfig();
            primaryDBConfig.Creation = CreatePolicy.IF_NEEDED;
            RecnoDatabase primaryDB;

            /*
             * If secondary database name is given, the primary
             * database is also opened with database name.
             */
            if (ifDBName == false)
                primaryDB = RecnoDatabase.Open(dbFileName,
                    primaryDBConfig);
            else
                primaryDB = RecnoDatabase.Open(dbFileName,
                    "primary", primaryDBConfig);

            try
            {
                // Open a new secondary database.
                SecondaryRecnoDatabaseConfig secRecnoDBConfig =
                    new SecondaryRecnoDatabaseConfig(
                    primaryDB, null);
                SecondaryRecnoDatabaseConfigTest.Config(
                    xmlElem, ref secRecnoDBConfig, false);
                secRecnoDBConfig.Creation =
                    CreatePolicy.IF_NEEDED;

                SecondaryRecnoDatabase secRecnoDB;
                if (ifDBName == false)
                    secRecnoDB = SecondaryRecnoDatabase.Open(
                        dbSecFileName, secRecnoDBConfig);
                else
                    secRecnoDB = SecondaryRecnoDatabase.Open(
                        dbSecFileName, "secondary",
                        secRecnoDBConfig);

                // Close the secondary database.
                secRecnoDB.Close();

                // Open the existing secondary database.
                SecondaryDatabaseConfig secDBConfig =
                    new SecondaryDatabaseConfig(
                    primaryDB, null);

                SecondaryDatabase secDB;
                if (ifDBName == false)
                    secDB = SecondaryRecnoDatabase.Open(
                        dbSecFileName, secDBConfig);
                else
                    secDB = SecondaryRecnoDatabase.Open(
                        dbSecFileName, "secondary", secDBConfig);

                // Close secondary database.
                secDB.Close();
            }
            catch (DatabaseException)
            {
                throw new TestException();
            }
            finally
            {
                // Close primary database.
                primaryDB.Close();
            }
        }

        public void OpenSecRecnoDBWithinTxn(string className,
		    string funName, string home, string dbFileName,
		    string dbSecFileName, bool ifDbName)
        {
            XmlElement xmlElem = Configuration.TestSetUp(
                className, funName);

            // Open an environment.
            DatabaseEnvironmentConfig envConfig =
                new DatabaseEnvironmentConfig();
            envConfig.Create = true;
            envConfig.UseTxns = true;
            envConfig.UseMPool = true;
            envConfig.UseLogging = true;
            DatabaseEnvironment env = DatabaseEnvironment.Open(
                home, envConfig);

            // Open a primary recno database.
            Transaction openDBTxn = env.BeginTransaction();
            RecnoDatabaseConfig dbConfig =
                new RecnoDatabaseConfig();
            dbConfig.Creation = CreatePolicy.IF_NEEDED;

            dbConfig.Env = env;
            RecnoDatabase db = RecnoDatabase.Open(
                dbFileName, dbConfig, openDBTxn);
            openDBTxn.Commit();

            // Open a secondary recno database.
            Transaction openSecTxn = env.BeginTransaction();
            SecondaryRecnoDatabaseConfig secDBConfig =
                new SecondaryRecnoDatabaseConfig(db,
                new SecondaryKeyGenDelegate(SecondaryKeyGen));
            SecondaryRecnoDatabaseConfigTest.Config(xmlElem,
                ref secDBConfig, false);
            secDBConfig.Env = env;
            SecondaryRecnoDatabase secDB;
            if (ifDbName == false)
                secDB = SecondaryRecnoDatabase.Open(
                    dbSecFileName, secDBConfig, openSecTxn);
            else
                secDB = SecondaryRecnoDatabase.Open(
                    dbSecFileName, "secondary", secDBConfig,
                    openSecTxn);
            openSecTxn.Commit();

            // Confirm its flags configured in secDBConfig.
            Confirm(xmlElem, secDB, true);
            secDB.Close();

            // Open the existing secondary database.
            Transaction secTxn = env.BeginTransaction();
            SecondaryDatabaseConfig secConfig =
                new SecondaryDatabaseConfig(db,
                new SecondaryKeyGenDelegate(SecondaryKeyGen));
            secConfig.Env = env;

            SecondaryDatabase secExDB;
            if (ifDbName == false)
                secExDB = SecondaryRecnoDatabase.Open(
                    dbSecFileName, secConfig, secTxn);
            else
                secExDB = SecondaryRecnoDatabase.Open(
                    dbSecFileName, "secondary", secConfig,
                    secTxn);
            secExDB.Close();
            secTxn.Commit();

            db.Close();
            env.Close();
        }

        private void GetCursorWithConfig(string dbFile, string dbName, 
		    CursorConfig cfg, DatabaseType type)
        {
            Database db;
            Cursor cursor;
            Configuration.ClearDir(testHome);
            if (type == DatabaseType.BTREE) {
                BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
                dbConfig.Creation = CreatePolicy.IF_NEEDED;
                db = BTreeDatabase.Open(dbFile, dbName, dbConfig);
                cursor = ((BTreeDatabase)db).Cursor(cfg);
            } else if (type == DatabaseType.HASH) {
                HashDatabaseConfig dbConfig = new HashDatabaseConfig();
                dbConfig.Creation = CreatePolicy.IF_NEEDED;
                db = (HashDatabase)HashDatabase.Open(dbFile, dbName, dbConfig);
                cursor = ((HashDatabase)db).Cursor(cfg);
            } else if (type == DatabaseType.QUEUE) {
                QueueDatabaseConfig dbConfig = new QueueDatabaseConfig();
                dbConfig.Creation = CreatePolicy.IF_NEEDED;
                dbConfig.Length = 100;
                db = QueueDatabase.Open(dbFile, dbConfig);
                cursor = ((QueueDatabase)db).Cursor(cfg);
            } else if (type == DatabaseType.RECNO) {
                RecnoDatabaseConfig dbConfig = new RecnoDatabaseConfig();
                dbConfig.Creation = CreatePolicy.IF_NEEDED;
                db = RecnoDatabase.Open(dbFile, dbName, dbConfig);
                cursor = ((RecnoDatabase)db).Cursor(cfg);
            } else
                throw new TestException();

            if (cfg.Priority != null)
                Assert.AreEqual(cursor.Priority, cfg.Priority);
            else
                Assert.AreEqual(CachePriority.DEFAULT, cursor.Priority);

            Cursor dupCursor = cursor.Duplicate(false);
            Assert.AreEqual(cursor.Priority, dupCursor.Priority);
            cursor.Close();
            db.Close();
        }

        public void TestAppend()
        {
            uint recno;

            testName = "TestAppend";
            SetUpTest(true);
            string dbFileName = testHome + "/" + testName + ".db";

            RecnoDatabaseConfig recnoConfig =
                new RecnoDatabaseConfig();
            recnoConfig.Creation = CreatePolicy.IF_NEEDED;
            recnoConfig.Append = new AppendRecordDelegate(
                AppendRecord);
            RecnoDatabase recnoDB = RecnoDatabase.Open(
                dbFileName, recnoConfig);
            recno = recnoDB.Append(new DatabaseEntry(
                ASCIIEncoding.ASCII.GetBytes("data")));

            KeyValuePair<DatabaseEntry, DatabaseEntry> pair;
            pair = recnoDB.Get(
                new DatabaseEntry(BitConverter.GetBytes(recno)));
            Assert.AreEqual(ASCIIEncoding.ASCII.GetBytes("data"),
                pair.Value.Data);

            recnoDB.Close();
        }

        public void TestInsertToLoc()
        {
            RecnoDatabase db;
            RecnoDatabaseConfig dbConfig;
            RecnoCursor cursor;
            DatabaseEntry data;
            KeyValuePair<DatabaseEntry, DatabaseEntry> pair;
            string dbFileName;

            testName = "TestInsertToLoc";
            testHome = testFixtureHome + "/" + testName;
            dbFileName = testHome + "/" + testName + ".db";

            Configuration.ClearDir(testHome);

            // Open database and cursor.
            dbConfig = new RecnoDatabaseConfig();
            dbConfig.Creation = CreatePolicy.IF_NEEDED;
            dbConfig.Renumber = true;
            db = RecnoDatabase.Open(dbFileName, dbConfig);
            cursor = db.Cursor();

            // Add record(1,1) into database.
            /*
             * Add a record(1, 1) by cursor and move
             * the cursor to the current record.
             */
            AddOneByCursor(cursor);
            cursor.Refresh();

            /*
             * Insert the new record(1,10) after the
             * record(1,1).
             */
            data = new DatabaseEntry(
                BitConverter.GetBytes((int)10));
            cursor.Insert(data, Cursor.InsertLocation.AFTER);

            /*
             * Move the cursor to the record(1,1) and
             * confirm that the next record is the one just inserted.
             */
            pair = new KeyValuePair<DatabaseEntry, DatabaseEntry>(
                new DatabaseEntry(
                BitConverter.GetBytes((int)1)),
                new DatabaseEntry(
                BitConverter.GetBytes((int)1)));
            Assert.IsTrue(cursor.Move(pair, true));
            Assert.IsTrue(cursor.MoveNext());
            Assert.AreEqual(BitConverter.GetBytes((int)10),
                cursor.Current.Value.Data);

            cursor.Close();
            db.Close();
        }

        public void TestConfig()
        {
            testName = "TestConfig";
            SetUpTest(true);
            string dbFileName = testHome + "/" + testName + ".db";

            XmlElement xmlElem = Configuration.TestSetUp(
                testFixtureName, testName);

            // Open a primary btree database.
            RecnoDatabaseConfig recDBConfig =
                new RecnoDatabaseConfig();
            recDBConfig.Creation = CreatePolicy.IF_NEEDED;
            RecnoDatabase recDB = RecnoDatabase.Open(
                dbFileName, recDBConfig);

            SecondaryRecnoDatabaseConfig secDBConfig =
                new SecondaryRecnoDatabaseConfig(recDB, null);

            Config(xmlElem, ref secDBConfig, true);
            Confirm(xmlElem, secDBConfig, true);

            // Close the primary btree database.
            recDB.Close();
        }

        public void TestForeignKeyDelete(DatabaseType dbtype, ForeignKeyDeleteAction action)
        {
            SetUpTest(true);
            string dbFileName = testHome + "/" + testName + ".db";
            string fdbFileName = testHome + "/" + testName + "foreign.db";
            string sdbFileName = testHome + "/" + testName + "sec.db";

            Database primaryDB, fdb;
            SecondaryDatabase secDB;

            // Open primary database.
            if (dbtype == DatabaseType.BTREE) {
                BTreeDatabaseConfig btConfig = new BTreeDatabaseConfig();
                btConfig.Creation = CreatePolicy.ALWAYS;
                primaryDB = BTreeDatabase.Open(dbFileName, btConfig);
                fdb = BTreeDatabase.Open(fdbFileName, btConfig);
            } else if (dbtype == DatabaseType.HASH) {
                HashDatabaseConfig hConfig = new HashDatabaseConfig();
                hConfig.Creation = CreatePolicy.ALWAYS;
                primaryDB = HashDatabase.Open(dbFileName, hConfig);
                fdb = HashDatabase.Open(fdbFileName, hConfig);
            } else if (dbtype == DatabaseType.QUEUE) {
                QueueDatabaseConfig qConfig = new QueueDatabaseConfig();
                qConfig.Creation = CreatePolicy.ALWAYS;
                qConfig.Length = 4;
                primaryDB = QueueDatabase.Open(dbFileName, qConfig);
                fdb = QueueDatabase.Open(fdbFileName, qConfig);
            } else if (dbtype == DatabaseType.RECNO) {
                RecnoDatabaseConfig rConfig = new RecnoDatabaseConfig();
                rConfig.Creation = CreatePolicy.ALWAYS;
                primaryDB = RecnoDatabase.Open(dbFileName, rConfig);
                fdb = RecnoDatabase.Open(fdbFileName, rConfig);
            } else {
                throw new ArgumentException("Invalid DatabaseType");
            }

            // Open secondary database.
            if (dbtype == DatabaseType.BTREE) {
                SecondaryBTreeDatabaseConfig secbtConfig =
                    new SecondaryBTreeDatabaseConfig(primaryDB,
                    new SecondaryKeyGenDelegate(SecondaryKeyGen));
                secbtConfig.Creation = CreatePolicy.ALWAYS;
                secbtConfig.Duplicates = DuplicatesPolicy.SORTED;
                if (action == ForeignKeyDeleteAction.NULLIFY)
                    secbtConfig.SetForeignKeyConstraint(fdb, action, new ForeignKeyNullifyDelegate(Nullify));
                else
                    secbtConfig.SetForeignKeyConstraint(fdb, action);
                secDB = SecondaryBTreeDatabase.Open(sdbFileName, secbtConfig);
            } else if (dbtype == DatabaseType.HASH) {
                SecondaryHashDatabaseConfig sechConfig =
                    new SecondaryHashDatabaseConfig(primaryDB,
                    new SecondaryKeyGenDelegate(SecondaryKeyGen));
                sechConfig.Creation = CreatePolicy.ALWAYS;
                sechConfig.Duplicates = DuplicatesPolicy.SORTED;
                if (action == ForeignKeyDeleteAction.NULLIFY)
                    sechConfig.SetForeignKeyConstraint(fdb, action, new ForeignKeyNullifyDelegate(Nullify));
                else
                    sechConfig.SetForeignKeyConstraint(fdb, action);
                secDB = SecondaryHashDatabase.Open(sdbFileName, sechConfig);
            } else if (dbtype == DatabaseType.QUEUE) {
                SecondaryQueueDatabaseConfig secqConfig =
                    new SecondaryQueueDatabaseConfig(primaryDB,
                    new SecondaryKeyGenDelegate(SecondaryKeyGen));
                secqConfig.Creation = CreatePolicy.ALWAYS;
                secqConfig.Length = 4;
                if (action == ForeignKeyDeleteAction.NULLIFY)
                    secqConfig.SetForeignKeyConstraint(fdb, action, new ForeignKeyNullifyDelegate(Nullify));
                else
                    secqConfig.SetForeignKeyConstraint(fdb, action);
                secDB = SecondaryQueueDatabase.Open(sdbFileName, secqConfig);
            } else if (dbtype == DatabaseType.RECNO) {
                SecondaryRecnoDatabaseConfig secrConfig =
                    new SecondaryRecnoDatabaseConfig(primaryDB,
                    new SecondaryKeyGenDelegate(SecondaryKeyGen));
                secrConfig.Creation = CreatePolicy.ALWAYS;
                if (action == ForeignKeyDeleteAction.NULLIFY)
                    secrConfig.SetForeignKeyConstraint(fdb, action, new ForeignKeyNullifyDelegate(Nullify));
                else
                    secrConfig.SetForeignKeyConstraint(fdb, action);
                secDB = SecondaryRecnoDatabase.Open(sdbFileName, secrConfig);
            } else {
                throw new ArgumentException("Invalid DatabaseType");
            }

            /* Use integer keys for Queue/Recno support. */
            fdb.Put(new DatabaseEntry(BitConverter.GetBytes(100)),
                new DatabaseEntry(BitConverter.GetBytes(1001)));
            fdb.Put(new DatabaseEntry(BitConverter.GetBytes(200)),
                new DatabaseEntry(BitConverter.GetBytes(2002)));
            fdb.Put(new DatabaseEntry(BitConverter.GetBytes(300)),
                new DatabaseEntry(BitConverter.GetBytes(3003)));

            primaryDB.Put(new DatabaseEntry(BitConverter.GetBytes(1)),
                new DatabaseEntry(BitConverter.GetBytes(100)));
            primaryDB.Put(new DatabaseEntry(BitConverter.GetBytes(2)),
                new DatabaseEntry(BitConverter.GetBytes(200)));
            if (dbtype == DatabaseType.BTREE || dbtype == DatabaseType.HASH)
                primaryDB.Put(new DatabaseEntry(BitConverter.GetBytes(3)),
                    new DatabaseEntry(BitConverter.GetBytes(100)));

//.........这里部分代码省略.........

        public void TestOpenNewRecnoDB()
        {
            RecnoDatabase recnoDB;
            RecnoDatabaseConfig recnoConfig;

            testName = "TestOpenNewRecnoDB";
            testHome = testFixtureHome + "/" + testName;
            string recnoDBFileName = testHome + "/" +
                testName + ".db";

            Configuration.ClearDir(testHome);

            XmlElement xmlElem = Configuration.TestSetUp(
                testFixtureName, testName);
            recnoConfig = new RecnoDatabaseConfig();
            RecnoDatabaseConfigTest.Config(xmlElem,
                ref recnoConfig, true);
            recnoDB = RecnoDatabase.Open(recnoDBFileName,
                recnoConfig);
            Confirm(xmlElem, recnoDB, true);
            recnoDB.Close();
        }

        public void TestOpenExistingRecnoDB()
        {
            testName = "TestOpenExistingRecnoDB";
            testHome = testFixtureHome + "/" + testName;
            string recnoDBFileName = testHome + "/" +
                testName + ".db";

            Configuration.ClearDir(testHome);

            RecnoDatabaseConfig recConfig =
                new RecnoDatabaseConfig();
            recConfig.Creation = CreatePolicy.ALWAYS;
            RecnoDatabase recDB = RecnoDatabase.Open(
                recnoDBFileName, recConfig);
            recDB.Close();

            RecnoDatabaseConfig dbConfig = new RecnoDatabaseConfig();
            string backingFile = testHome + "/backingFile";
            File.Copy(recnoDBFileName, backingFile);
            dbConfig.BackingFile = backingFile;
            RecnoDatabase db = RecnoDatabase.Open(recnoDBFileName, dbConfig);
            Assert.AreEqual(db.Type, DatabaseType.RECNO);
            db.Close();
        }

        public void TestCompact()
        {
            testName = "TestCompact";
            testHome = testFixtureHome + "/" + testName;
            string recnoDBFileName = testHome + "/" +
                testName + ".db";

            Configuration.ClearDir(testHome);

            RecnoDatabaseConfig recnoConfig =
                new RecnoDatabaseConfig();
            recnoConfig.Creation = CreatePolicy.ALWAYS;
            recnoConfig.Length = 512;

            DatabaseEntry key, data;
            RecnoDatabase recnoDB;
            using (recnoDB = RecnoDatabase.Open(
                recnoDBFileName, recnoConfig))
            {
                for (int i = 1; i <= 5000; i++)
                {
                    data = new DatabaseEntry(
                        BitConverter.GetBytes(i));
                    recnoDB.Append(data);
                }

                for (int i = 1; i <= 5000; i++)
                {
                    if (i > 500 && (i % 5 != 0))
                    {
                        key = new DatabaseEntry(
                            BitConverter.GetBytes(i));
                        recnoDB.Delete(key);
                    }
                }

                int startInt = 1;
                int stopInt = 2500;
                DatabaseEntry start, stop;

                start = new DatabaseEntry(
                    BitConverter.GetBytes(startInt));
                stop = new DatabaseEntry(
                    BitConverter.GetBytes(stopInt));
                Assert.IsTrue(recnoDB.Exists(start));
                Assert.IsTrue(recnoDB.Exists(stop));

                CompactConfig cCfg = new CompactConfig();
                cCfg.start = start;
                cCfg.stop = stop;
                cCfg.FillPercentage = 30;
                cCfg.Pages = 1;
                cCfg.returnEnd = true;
                cCfg.Timeout = 5000;
                cCfg.TruncatePages = true;
                CompactData compactData = recnoDB.Compact(cCfg);

                Assert.IsNotNull(compactData.End);
                Assert.AreNotEqual(0, compactData.PagesExamined);
            }
        }

        public void TestAppendWithoutTxn()
        {
            testName = "TestAppendWithoutTxn";
            testHome = testFixtureHome + "/" + testName;
            string recnoDBFileName = testHome + "/" +
                testName + ".db";

            Configuration.ClearDir(testHome);

            RecnoDatabaseConfig recnoConfig =
                new RecnoDatabaseConfig();
            recnoConfig.Creation = CreatePolicy.ALWAYS;
            RecnoDatabase recnoDB = RecnoDatabase.Open(
                recnoDBFileName, recnoConfig);

            DatabaseEntry data = new DatabaseEntry(
                ASCIIEncoding.ASCII.GetBytes("data"));
            uint num = recnoDB.Append(data);
            DatabaseEntry key = new DatabaseEntry(
                BitConverter.GetBytes(num));
            Assert.IsTrue(recnoDB.Exists(key));
            KeyValuePair<DatabaseEntry, DatabaseEntry> record =
                recnoDB.Get(key);
            Assert.IsTrue(data.Data.Length ==
                record.Value.Data.Length);
            for (int i = 0; i < data.Data.Length; i++)
                Assert.IsTrue(data.Data[i] ==
                    record.Value.Data[i]);
            recnoDB.Close();
        }

        public void StatsInTxn(string home, string name, bool ifIsolation)
        {
            DatabaseEnvironmentConfig envConfig =
                new DatabaseEnvironmentConfig();
            EnvConfigCase1(envConfig);
            DatabaseEnvironment env = DatabaseEnvironment.Open(
                home, envConfig);

            Transaction openTxn = env.BeginTransaction();
            RecnoDatabaseConfig dbConfig =
                new RecnoDatabaseConfig();
            ConfigCase1(dbConfig);
            dbConfig.Env = env;
            RecnoDatabase db = RecnoDatabase.Open(name + ".db",
                dbConfig, openTxn);
            openTxn.Commit();

            Transaction statsTxn = env.BeginTransaction();
            RecnoStats stats;
            RecnoStats fastStats;
            if (ifIsolation == false)
            {
                stats = db.Stats(statsTxn);
                fastStats = db.FastStats(statsTxn);
            }
            else
            {
                stats = db.Stats(statsTxn, Isolation.DEGREE_ONE);
                fastStats = db.FastStats(statsTxn,
                    Isolation.DEGREE_ONE);
            }
            ConfirmStatsPart1Case1(stats);

            // Put 1000 records into the database.
            PutRecordCase1(db, statsTxn);

            if (ifIsolation == false)
            {
                stats = db.Stats(statsTxn);
                fastStats = db.FastStats(statsTxn);
            }
            else
            {
                stats = db.Stats(statsTxn, Isolation.DEGREE_TWO);
                fastStats = db.FastStats(statsTxn,
                    Isolation.DEGREE_TWO);
            }
            ConfirmStatsPart2Case1(stats);

            // Delete 500 records.
            for (int i = 250; i <= 750; i++)
                db.Delete(new DatabaseEntry(BitConverter.GetBytes(i)),
                    statsTxn);

            if (ifIsolation == false)
            {
                stats = db.Stats(statsTxn);
                fastStats = db.FastStats(statsTxn);
            }
            else
            {
                stats = db.Stats(statsTxn, Isolation.DEGREE_THREE);
                fastStats = db.FastStats(statsTxn,
                    Isolation.DEGREE_THREE);
            }
            ConfirmStatsPart3Case1(stats);

            statsTxn.Commit();
            db.Close();
            env.Close();
        }

        public void TestDuplicate()
        {
            KeyValuePair<DatabaseEntry, DatabaseEntry> pair;
            RecnoDatabase db;
            RecnoDatabaseConfig dbConfig;
            RecnoCursor cursor, dupCursor;
            string dbFileName;

            testName = "TestDuplicate";
            testHome = testFixtureHome + "/" + testName;
            dbFileName = testHome + "/" + testName + ".db";

            Configuration.ClearDir(testHome);

            dbConfig = new RecnoDatabaseConfig();
            dbConfig.Creation = CreatePolicy.IF_NEEDED;
            db = RecnoDatabase.Open(dbFileName, dbConfig);
            cursor = db.Cursor();

            /*
             * Add a record(1, 1) by cursor and move
             * the cursor to the current record.
             */
            AddOneByCursor(cursor);
            cursor.Refresh();

            //Duplicate a new cursor to the same position.
            dupCursor = cursor.Duplicate(true);

            // Overwrite the record.
            dupCursor.Overwrite(new DatabaseEntry(
                ASCIIEncoding.ASCII.GetBytes("newdata")));

            // Confirm that the original data doesn't exist.
            pair = new KeyValuePair<DatabaseEntry, DatabaseEntry>(
                new DatabaseEntry(
                BitConverter.GetBytes((int)1)),
                new DatabaseEntry(
                BitConverter.GetBytes((int)1)));
            Assert.IsFalse(dupCursor.Move(pair, true));

            dupCursor.Close();
            cursor.Close();
            db.Close();
        }