From 54df2afaa61c6a03cbb4a33c9b90fa572b6d07b8 Mon Sep 17 00:00:00 2001 From: Jesse Morgan Date: Sat, 17 Dec 2016 21:28:53 -0800 Subject: Berkeley DB 4.8 with rust build script for linux. --- db-4.8.30/test/TESTS | 3199 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3199 insertions(+) create mode 100644 db-4.8.30/test/TESTS (limited to 'db-4.8.30/test/TESTS') diff --git a/db-4.8.30/test/TESTS b/db-4.8.30/test/TESTS new file mode 100644 index 0000000..1a7efa2 --- /dev/null +++ b/db-4.8.30/test/TESTS @@ -0,0 +1,3199 @@ +# Automatically built by dist/s_test; may require local editing. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +Allocate and lock a self-blocking mutex. Start another process. + Try to lock the mutex again -- it will block. + Unlock the mutex from the other process, and the blocked + lock should be obtained. Clean up. + Do another test with a "-process-only" mutex. The second + process should not be able to unlock the mutex. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +Allocate, lock, unlock, and free a bunch of mutexes. + Set basic configuration options and check mutex_stat and + the mutex getters for the correct values. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +backup + Test of hotbackup functionality. + + Do all the of the following tests with and without + the -c (checkpoint) option. Make sure that -c and + -d (data_dir) are not allowed together. + + (1) Test that plain and simple hotbackup works. + (2) Test with -data_dir (-d). + (3) Test updating an existing hot backup (-u). + (4) Test with absolute path. + (5) Test with DB_CONFIG (-D), setting log_dir (-l) + and data_dir (-d). + (6) DB_CONFIG and update. + (7) Repeat hot backup (non-update) with DB_CONFIG and + existing directories. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +bigfile001 + Create a database greater than 4 GB in size. Close, verify. + Grow the database somewhat. Close, reverify. Lather, rinse, + repeat. Since it will not work on all systems, this test is + not run by default. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +bigfile002 + This one should be faster and not require so much disk space, + although it doesn't test as extensively. Create an mpool file + with 1K pages. Dirty page 6000000. Sync. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +dbm + Historic DBM interface test. Use the first 1000 entries from the + dictionary. Insert each with self as key and data; retrieve each. + After all are entered, retrieve all; compare output to original. + Then reopen the file, re-retrieve everything. Finally, delete + everything. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +db_reptest + Wrapper to configure and run the db_reptest program. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +dead001 + Use two different configurations to test deadlock detection among a + variable number of processes. One configuration has the processes + deadlocked in a ring. The other has the processes all deadlocked on + a single resource. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +dead002 + Same test as dead001, but use "detect on every collision" instead + of separate deadlock detector. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +dead003 + + Same test as dead002, but explicitly specify DB_LOCK_OLDEST and + DB_LOCK_YOUNGEST. Verify the correct lock was aborted/granted. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +dead006 + use timeouts rather than the normal dd algorithm. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +dead007 + Tests for locker and txn id wraparound. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env001 + Test of env remove interface (formerly env_remove). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env002 + Test of DB_LOG_DIR and env name resolution. + With an environment path specified using -home, and then again + with it specified by the environment variable DB_HOME: + 1) Make sure that the set_lg_dir option is respected + a) as a relative pathname. + b) as an absolute pathname. + 2) Make sure that the DB_LOG_DIR db_config argument is respected, + again as relative and absolute pathnames. + 3) Make sure that if -both- db_config and a file are present, + only the file is respected (see doc/env/naming.html). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env003 + Test DB_TMP_DIR and env name resolution + With an environment path specified using -home, and then again + with it specified by the environment variable DB_HOME: + 1) Make sure that the DB_TMP_DIR config file option is respected + a) as a relative pathname. + b) as an absolute pathname. + 2) Make sure that the -tmp_dir config option is respected, + again as relative and absolute pathnames. + 3) Make sure that if -both- -tmp_dir and a file are present, + only the file is respected (see doc/env/naming.html). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env004 + Test multiple data directories. Do a bunch of different opens + to make sure that the files are detected in different directories. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env005 + Test that using subsystems without initializing them correctly + returns an error. Cannot test mpool, because it is assumed in + the Tcl code. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env006 + Make sure that all the utilities exist and run. + Test that db_load -r options don't blow up. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env007 + Test DB_CONFIG config file options for berkdb env. + 1) Make sure command line option is respected + 2) Make sure that config file option is respected + 3) Make sure that if -both- DB_CONFIG and the set_ + method is used, only the file is respected. + Then test all known config options. + Also test config options on berkdb open. This isn't + really env testing, but there's no better place to put it. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env008 + Test environments and subdirectories. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env009 + Test calls to all the various stat functions. We have several + sprinkled throughout the test suite, but this will ensure that + we run all of them at least once. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env010 + Run recovery in an empty directory, and then make sure we can still + create a database in that directory. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env011 + Run with region overwrite flag. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env012 + Test DB_REGISTER. + + DB_REGISTER will fail on systems without fcntl. If it + fails, make sure we got the expected DB_OPNOTSUP return. + + Then, the real tests: + For each test, we start a process that opens an env with -register. + + 1. Verify that a 2nd process can enter the existing env with -register. + + 2. Kill the 1st process, and verify that the 2nd process can enter + with "-register -recover". + + 3. Kill the 1st process, and verify that the 2nd process cannot + enter with just "-register". + + 4. While the 1st process is still running, a 2nd process enters + with "-register". Kill the 1st process. Verify that a 3rd process + can enter with "-register -recover". Verify that the 3rd process, + entering, causes process 2 to fail with the message DB_RUNRECOVERY. + + 5. We had a bug where recovery was always run with -register + if there were empty slots in the process registry file. Verify + that recovery doesn't automatically run if there is an empty slot. + + 6. Verify process cannot connect when specifying -failchk and an + isalive function has not been declared. + + 7. Verify that a 2nd process can enter the existing env with -register + and -failchk and having specified an isalive function + + 8. Kill the 1st process, and verify that the 2nd process can enter + with "-register -failchk -recover" + + 9. 2nd process enters with "-register -failchk". Kill the 1st process. + 2nd process may get blocked on a mutex held by process one. Verify + 3rd process can enter with "-register -recover -failchk". 3rd process + should run failchk, clear out open txn/log from process 1. It will + enter env without need for any additional recovery. We look for + "Freeing log information .." sentence in the log for 3rd process as + an indication that failchk ran. If DB_RUNRECOVERY were returned + instead it would mean failchk could not recover. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env013 + Test of basic functionality of fileid_reset. + + Create a database in an env. Copy it to a new file within + the same env. Reset the file id and make sure it has changed. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env014 + + Make sure that attempts to open an environment with + incompatible flags (e.g. replication without transactions) + fail with the appropriate messages. + + A new thread of control joining an env automatically + initializes the same subsystems as the original env. + Make sure that the attempt to change subsystems when + joining an env fails with the appropriate messages. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env015 + Rename the underlying directory of an env, make sure everything + still works. Test runs with regular named databases and with + in-memory named databases. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env016 + Replication settings and DB_CONFIG + + Create a DB_CONFIG for various replication settings. Use + rep_stat or getter functions to verify they're set correctly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env017 + Check documented "stat" fields against the fields + returned by the "stat" functions. Make sure they + match, and that none are missing. + These are the stat functions we test: + env log_stat + env lock_stat + env txn_stat + env mutex_stat + env rep_stat + env repmgr_stat + env mpool_stat + db_stat + seq_stat + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +env018 + Test getters when joining an env. When a second handle is + opened on an existing env, get_open_flags needs to return + the correct flags to the second handle so it knows what sort + of environment it's just joined. + + For several different flags to env_open, open an env. Open + a second handle on the same env, get_open_flags and verify + the flag is returned. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +fop001.tcl + Test file system operations, combined in a transaction. [#7363] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +fop002.tcl + Test file system operations in the presence of bad permissions. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +fop003 + + Test behavior of create and truncate for compatibility + with sendmail. + 1. DB_TRUNCATE is not allowed with locking or transactions. + 2. Can -create into zero-length existing file. + 3. Can -create into non-zero-length existing file if and + only if DB_TRUNCATE is specified. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +fop004 + Test of DB->rename(). (formerly test075) + Test that files can be renamed from one directory to another. + Test that files can be renamed using absolute or relative + pathnames. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +fop005 + Test of DB->remove() + Formerly test080. + Test use of dbremove with and without envs, with absolute + and relative paths, and with subdirectories. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +fop006 + Test file system operations in multiple simultaneous + transactions. Start one transaction, do a file operation. + Start a second transaction, do a file operation. Abort + or commit txn1, then abort or commit txn2, and check for + appropriate outcome. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +fop007 + Test file system operations on named in-memory databases. + Combine two ops in one transaction. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +fop008 + Test file system operations on named in-memory databases. + Combine two ops in one transaction. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +jointest + Test duplicate assisted joins. Executes 1, 2, 3 and 4-way joins + with differing index orders and selectivity. + + We'll test 2-way, 3-way, and 4-way joins and figure that if those + work, everything else does as well. We'll create test databases + called join1.db, join2.db, join3.db, and join4.db. The number on + the database describes the duplication -- duplicates are of the + form 0, N, 2N, 3N, ... where N is the number of the database. + Primary.db is the primary database, and null.db is the database + that has no matching duplicates. + + We should test this on all btrees, all hash, and a combination thereof + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +lock001 + Make sure that the basic lock tests work. Do some simple gets + and puts for a single locker. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +lock002 + Exercise basic multi-process aspects of lock. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +lock003 + Exercise multi-process aspects of lock. Generate a bunch of parallel + testers that try to randomly obtain locks; make sure that the locks + correctly protect corresponding objects. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +lock004 + Test locker ids wraping around. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +lock005 + Check that page locks are being released properly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +lock006 + Test lock_vec interface. We do all the same things that + lock001 does, using lock_vec instead of lock_get and lock_put, + plus a few more things like lock-coupling. + 1. Get and release one at a time. + 2. Release with put_obj (all locks for a given locker/obj). + 3. Release with put_all (all locks for a given locker). + Regularly check lock_stat to verify all locks have been + released. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log001 + Read/write log records. + Test with and without fixed-length, in-memory logging, + and encryption. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log002 + Tests multiple logs + Log truncation + LSN comparison and file functionality. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log003 + Verify that log_flush is flushing records correctly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log004 + Make sure that if we do PREVs on a log, but the beginning of the + log has been truncated, we do the right thing. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log005 + Check that log file sizes can change on the fly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log006 + Test log file auto-remove. + Test normal operation. + Test a long-lived txn. + Test log_archive flags. + Test db_archive flags. + Test turning on later. + Test setting via DB_CONFIG. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log007 + Test of in-memory logging bugs. [#11505] + + Test db_printlog with in-memory logs. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log008 + Test what happens if a txn_ckp record falls into a + different log file than the DBREG_CKP records generated + by the same checkpoint. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +log009 + Test of logging and getting log file version information. + Each time we cross a log file boundary verify we can + get the version via the log cursorlag. + Do this both forward and backward. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +memp001 + Randomly updates pages. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +memp002 + Tests multiple processes accessing and modifying the same files. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +memp003 + Test reader-only/writer process combinations; we use the access methods + for testing. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +memp004 + Test that small read-only databases are mapped into memory. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +mut001 + Exercise the mutex API. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +mut002 + Two-process mutex test. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +mut003 + Try doing mutex operations out of order. Make sure + we get appropriate errors. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +plat001 + + Test of portability of sequences. + + Create and dump a database containing sequences. Save the dump. + This test is used in conjunction with the upgrade tests, which + will compare the saved dump to a locally created dump. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd001 + Per-operation recovery tests for non-duplicate, non-split + messages. Makes sure that we exercise redo, undo, and do-nothing + condition. Any test that appears with the message (change state) + indicates that we've already run the particular test, but we are + running it again so that we can change the state of the data base + to prepare for the next test (this applies to all other recovery + tests as well). + + These are the most basic recovery tests. We do individual recovery + tests for each operation in the access method interface. First we + create a file and capture the state of the database (i.e., we copy + it. Then we run a transaction containing a single operation. In + one test, we abort the transaction and compare the outcome to the + original copy of the file. In the second test, we restore the + original copy of the database and then run recovery and compare + this against the actual database. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd002 + Split recovery tests. For every known split log message, makes sure + that we exercise redo, undo, and do-nothing condition. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd003 + Duplicate recovery tests. For every known duplicate log message, + makes sure that we exercise redo, undo, and do-nothing condition. + + Test all the duplicate log messages and recovery operations. We make + sure that we exercise all possible recovery actions: redo, undo, undo + but no fix necessary and redo but no fix necessary. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd004 + Big key test where big key gets elevated to internal page. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd005 + Verify reuse of file ids works on catastrophic recovery. + + Make sure that we can do catastrophic recovery even if we open + files using the same log file id. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd006 + Nested transactions. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd007 + File create/delete tests. + + This is a recovery test for create/delete of databases. We have + hooks in the database so that we can abort the process at various + points and make sure that the transaction doesn't commit. We + then need to recover and make sure the file is correctly existing + or not, as the case may be. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd008 + Test deeply nested transactions and many-child transactions. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd009 + Verify record numbering across split/reverse splits and recovery. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd010 + Test stability of btree duplicates across btree off-page dup splits + and reverse splits and across recovery. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd011 + Verify that recovery to a specific timestamp works. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd012 + Test of log file ID management. [#2288] + Test recovery handling of file opens and closes. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd013 + Test of cursor adjustment on child transaction aborts. [#2373] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd014 + This is a recovery test for create/delete of queue extents. We + then need to recover and make sure the file is correctly existing + or not, as the case may be. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd015 + This is a recovery test for testing lots of prepared txns. + This test is to force the use of txn_recover to call with the + DB_FIRST flag and then DB_NEXT. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd016 + Test recovery after checksum error. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd017 + Test recovery and security. This is basically a watered + down version of recd001 just to verify that encrypted environments + can be recovered. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd018 + Test recover of closely interspersed checkpoints and commits. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd019 + Test txn id wrap-around and recovery. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd020 + Test creation of intermediate directories -- an + undocumented, UNIX-only feature. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd021 + Test of failed opens in recovery. + + If a file was deleted through the file system (and not + within Berkeley DB), an error message should appear. + Test for regular files and subdbs. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd022 + Test that pages allocated by an aborted subtransaction + within an aborted prepared parent transaction are returned + to the free list after recovery. This exercises + __db_pg_prepare in systems without FTRUNCATE. [#7403] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd023 + Test recover of reverse split. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +recd024 + Test recovery of streaming partial insert operations. These are + operations that do multiple partial puts that append to an existing + data item (as long as the data item is on an overflow page). + The interesting cases are: + * Simple streaming operations + * Operations that cause the overflow item to flow onto another page. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep001 + Replication rename and forced-upgrade test. + + Run rep_test in a replicated master environment. + Verify that the database on the client is correct. + Next, remove the database, close the master, upgrade the + client, reopen the master, and make sure the new master can + correctly run rep_test and propagate it in the other direction. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep002 + Basic replication election test. + + Run a modified version of test001 in a replicated master + environment; hold an election among a group of clients to + make sure they select a proper master from amongst themselves, + in various scenarios. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep003 + Repeated shutdown/restart replication test + + Run a quick put test in a replicated master environment; + start up, shut down, and restart client processes, with + and without recovery. To ensure that environment state + is transient, use DB_PRIVATE. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep005 + Replication election test with error handling. + + Run rep_test in a replicated master environment; + hold an election among a group of clients to make sure they select + a proper master from amongst themselves, forcing errors at various + locations in the election path. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep006 + Replication and non-rep env handles. + + Run a modified version of test001 in a replicated master + environment; verify that the database on the client is correct. + Next, create a non-rep env handle to the master env. + Attempt to open the database r/w to force error. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep007 + Replication and bad LSNs + + Run rep_test in a replicated master env. + Close the client. Make additional changes to master. + Close the master. Open the client as the new master. + Make several different changes. Open the old master as + the client. Verify periodically that contents are correct. + This test is not appropriate for named in-memory db testing + because the databases are lost when both envs are closed. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep008 + Replication, back up and synchronizing + + Run a modified version of test001 in a replicated master + environment. + Close master and client. + Copy the master log to the client. + Clean the master. + Reopen the master and client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep009 + Replication and DUPMASTERs + Run test001 in a replicated environment. + + Declare one of the clients to also be a master. + Close a client, clean it and then declare it a 2nd master. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep010 + Replication and ISPERM + + With consecutive message processing, make sure every + DB_REP_PERMANENT is responded to with an ISPERM when + processed. With gaps in the processing, make sure + every DB_REP_PERMANENT is responded to with an ISPERM + or a NOTPERM. Verify in both cases that the LSN returned + with ISPERM is found in the log. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep011 + Replication: test open handle across an upgrade. + + Open and close test database in master environment. + Update the client. Check client, and leave the handle + to the client open as we close the masterenv and upgrade + the client to master. Reopen the old master as client + and catch up. Test that we can still do a put to the + handle we created on the master while it was still a + client, and then make sure that the change can be + propagated back to the new client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep012 + Replication and dead DB handles. + + Run a modified version of test001 in a replicated master env. + Run in replicated environment with secondary indices too. + Make additional changes to master, but not to the client. + Downgrade the master and upgrade the client with open db handles. + Verify that the roll back on clients gives dead db handles. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep013 + Replication and swapping master/clients with open dbs. + + Run a modified version of test001 in a replicated master env. + Make additional changes to master, but not to the client. + Swap master and client. + Verify that the roll back on clients gives dead db handles. + Rerun the test, turning on client-to-client synchronization. + Swap and verify several times. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep014 + Replication and multiple replication handles. + Test multiple client handles, opening and closing to + make sure we get the right openfiles. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep015 + Locking across multiple pages with replication. + + Open master and client with small pagesize and + generate more than one page and generate off-page + dups on the first page (second key) and last page + (next-to-last key). + Within a single transaction, for each database, open + 2 cursors and delete the first and last entries (this + exercises locks on regular pages). Intermittently + update client during the process. + Within a single transaction, for each database, open + 2 cursors. Walk to the off-page dups and delete one + from each end (this exercises locks on off-page dups). + Intermittently update client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep016 + Replication election test with varying required nvotes. + + Run a modified version of test001 in a replicated master environment; + hold an election among a group of clients to make sure they select + the master with varying required participants. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep017 + Concurrency with checkpoints. + + Verify that we achieve concurrency in the presence of checkpoints. + Here are the checks that we wish to make: + While dbenv1 is handling the checkpoint record: + Subsequent in-order log records are accepted. + Accepted PERM log records get NOTPERM + A subsequent checkpoint gets NOTPERM + After checkpoint completes, next txn returns PERM + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep018 + Replication with dbremove. + + Verify that the attempt to remove a database file + on the master hangs while another process holds a + handle on the client. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep019 + Replication and multiple clients at same LSN. + Have several clients at the same LSN. Run recovery at + different times. Declare a client master and after sync-up + verify all client logs are identical. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep020 + Replication elections - test election generation numbers. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep021 + Replication and multiple environments. + Run similar tests in separate environments, making sure + that some data overlaps. Then, "move" one client env + from one replication group to another and make sure that + we do not get divergent logs. We either match the first + record and end up with identical logs or we get an error. + Verify all client logs are identical if successful. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep022 + Replication elections - test election generation numbers + during simulated network partition. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep023 + Replication using two master handles. + + Open two handles on one master env. Create two + databases, one through each master handle. Process + all messages through the first master handle. Make + sure changes made through both handles are picked + up properly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep024 + Replication page allocation / verify test + + Start a master (site 1) and a client (site 2). Master + closes (simulating a crash). Site 2 becomes the master + and site 1 comes back up as a client. Verify database. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep025 + Test of DB_REP_JOIN_FAILURE. + + One master, one client. + Generate several log files. + Remove old master log files. + Delete client files and restart client. + Put one more record to the master. At the next + processing of messages, the client should get JOIN_FAILURE. + Recover with a hot failover. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep026 + Replication elections - simulate a crash after sending + a vote. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep027 + Replication and secondary indexes. + + Set up a secondary index on the master and make sure + it can be accessed from the client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep028 + Replication and non-rep env handles. (Also see rep006.) + + Open second non-rep env on client, and create a db + through this handle. Open the db on master and put + some data. Check whether the non-rep handle keeps + working. Also check if opening the client database + in the non-rep env writes log records. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep029 + Test of internal initialization. + + One master, one client. + Generate several log files. + Remove old master log files. + Delete client files and restart client. + Put one more record to the master. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep030 + Test of internal initialization multiple files and pagesizes. + Hold some databases open on master. + + One master, one client using a data_dir for internal init. + Generate several log files. + Remove old master log files. + Delete client files and restart client. + Put one more record to the master. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep031 + Test of internal initialization and blocked operations. + + One master, one client. + Put one more record to the master. + Test that internal initialization blocks: + log_archive, rename, remove, fileid_reset, lsn_reset. + Sleep 30+ seconds. + Test that blocked operations are now unblocked. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep032 + Test of log gap processing. + + One master, one client. + Run rep_test. + Run rep_test without sending messages to client. + Make sure client missing the messages catches up properly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep033 + Test of internal initialization with rename and remove of dbs. + + One master, one client. + Generate several databases. Replicate to client. + Do some renames and removes, both before and after + closing the client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep034 + Test of STARTUPDONE notification. + + STARTUPDONE can now be recognized without the need for new "live" log + records from the master (under favorable conditions). The response to + the ALL_REQ at the end of synchronization includes an end-of-log marker + that now triggers it. However, the message containing that end marker + could get lost, so live log records still serve as a back-up mechanism. + The end marker may also be set under c2c sync, but only if the serving + client has itself achieved STARTUPDONE. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep035 + Test sync-up recovery in replication. + + We need to fork off 3 child tclsh processes to operate + on Site 3's (client always) home directory: + Process 1 continually calls lock_detect. + Process 2 continually calls txn_checkpoint. + Process 3 continually calls memp_trickle. + Process 4 continually calls log_archive. + Sites 1 and 2 will continually swap being master + (forcing site 3 to continually run sync-up recovery) + New master performs 1 operation, replicates and downgrades. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep036 + Multiple master processes writing to the database. + One process handles all message processing. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep037 + Test of internal initialization and page throttling. + + One master, one client, force page throttling. + Generate several log files. + Remove old master log files. + Delete client files and restart client. + Put one more record to the master. + Verify page throttling occurred. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep038 + Test of internal initialization and ongoing master updates. + + One master, one client. + Generate several log files. + Remove old master log files. + Delete client files and restart client. + Put more records on master while initialization is in progress. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep039 + Test of interrupted internal initialization. The + interruption is due to a changed master, or the client crashing, + or both. + + One master, two clients. + Generate several log files. Remove old master log files. + Restart client, optionally having "cleaned" client env dir. Either + way, this has the effect of forcing an internal init. + Interrupt the internal init. + Vary the number of times we process messages to make sure + the interruption occurs at varying stages of the first internal + initialization. + + Run for btree and queue only because of the number of permutations. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep040 + Test of racing rep_start and transactions. + + One master, one client. + Have master in the middle of a transaction. + Call rep_start to make master a client. + Commit the transaction. + Call rep_start to make master the master again. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep041 + Turn replication on and off at run-time. + + Start a master with replication OFF (noop transport function). + Run rep_test to advance log files and archive. + Start up client; change master to working transport function. + Now replication is ON. + Do more ops, make sure client is up to date. + Close client, turn replication OFF on master, do more ops. + Repeat from point A. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep042 + Concurrency with updates. + + Verify racing role changes and updates don't result in + pages with LSN 0,1. Set up an environment that is master. + Spawn child process that does a delete, but using the + $env check so that it sleeps in the middle of the call. + Master downgrades and then sleeps as a client so that + child will run. Verify child does not succeed (should + get read-only error) due to role change in the middle of + its call. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep043 + + Constant writes during upgrade/downgrade. + + Three envs take turns being master. Each env + has a child process which does writes all the + time. They will succeed when that env is master + and fail when it is not. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep044 + + Test rollbacks with open file ids. + + We have one master with two handles and one client. + Each time through the main loop, we open a db, write + to the db, and close the db. Each one of these actions + is propagated to the client, or a roll back is forced + by swapping masters. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep045 + + Replication with versions. + + Mimic an application where a database is set up in the + background and then put into a replication group for use. + The "version database" identifies the current live + version, the database against which queries are made. + For example, the version database might say the current + version is 3, and queries would then be sent to db.3. + Version 4 is prepared for use while version 3 is in use. + When version 4 is complete, the version database is updated + to point to version 4 so queries can be directed there. + + This test has a master and two clients. One client swaps + roles with the master, and the other client runs constantly + in another process. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep046 + Replication and basic bulk transfer. + Set bulk transfer replication option. + Run long txns on master and then commit. Process on client + and verify contents. Run a very long txn so that logging + must send the log. Process and verify on client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep047 + Replication and log gap bulk transfers. + Set bulk transfer replication option. + Run test. Start a new client (to test ALL_REQ and bulk). + Run small test again. Clear messages for 1 client. + Run small test again to test LOG_REQ gap processing and bulk. + Process and verify on clients. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep048 + Replication and log gap bulk transfers. + Have two master env handles. Turn bulk on in + one (turns it on for both). Turn it off in the other. + While toggling, send log records from both handles. + Process message and verify master and client match. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep049 + Replication and delay syncing clients - basic test. + + Open and start up a master and two clients. Turn on delay sync + in the delayed client. Change master, add data and process messages. + Verify delayed client does not match. Make additional changes and + update the delayted client. Verify all match. + Add in a fresh delayed client to test delay of ALL_REQ. + Process startup messages and verify freshc client has no database. + Sync and verify fresh client matches. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep050 + Replication and delay syncing clients - change master test. + + Open and start up master and 4 clients. Turn on delay for 3 clients. + Switch masters, add data and verify delayed clients are out of date. + Make additional changes to master. And change masters again. + Sync/update delayed client and verify. The 4th client is a brand + new delayed client added in to test the non-verify path. + + Then test two different things: + 1. Swap master again while clients are still delayed. + 2. Swap master again while sync is proceeding for one client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep051 + Test of compaction with replication. + + Run rep_test in a replicated master environment. + Delete a large number of entries and compact with -freespace. + Propagate the changes to the client and make sure client and + master match. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep052 + Test of replication with NOWAIT. + + One master, one client. After initializing + everything normally, close client and let the + master get ahead -- far enough that the master + no longer has the client's last log file. + Reopen the client and turn on NOWAIT. + Process a few messages to get the client into + recovery mode, and verify that lockout occurs + on a txn API call (txn_begin) and an env API call. + Process all the messages and verify that lockout + is over. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep053 + Replication and basic client-to-client synchronization. + + Open and start up master and 1 client. + Start up a second client later and verify it sync'ed from + the original client, not the master. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep054 + Test of internal initialization where a far-behind + client takes over as master. + + One master, two clients. + Run rep_test and process. + Close client 1. + Run rep_test, opening new databases, and processing + messages. Archive as we go so that log files get removed. + Close master and reopen client 1 as master. Process messages. + Verify that new master and client are in sync. + Run rep_test again, adding data to one of the new + named databases. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep055 + Test of internal initialization and log archiving. + + One master, one client. + Generate several log files. + Remove old master log files and generate several more. + Get list of archivable files from db_archive and restart client. + As client is in the middle of internal init, remove + the log files returned earlier by db_archive. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep058 + + Replication with early databases + + Mimic an application where they create a database before + calling rep_start, thus writing log records on a client + before it is a client. Verify we cannot join repl group. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep060 + Test of normally running clients and internal initialization. + Have a client running normally, but slow/far behind the master. + Then the master checkpoints and archives, causing the client + to suddenly be thrown into internal init. This test tests + that we clean up the old files/pages in mpool and dbreg. + Also test same thing but the app holding an open dbp as well. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep061 + Test of internal initialization multiple files and pagesizes + with page gaps. + + One master, one client. + Generate several log files. + Remove old master log files. + Delete client files and restart client. + Put one more record to the master. + Force some page messages to get dropped. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep062 + Test of internal initialization where client has a different + kind of database than the master. + + Create a master of one type, and let the client catch up. + Close the client. + Remove the database on the master, and create a new + database of the same name but a different type. + Run the master ahead far enough that internal initialization + will be required on the reopen of the client. + Reopen the client and verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep063 + Replication election test with simulated different versions + for each site. This tests that old sites with real priority + trump ELECTABLE sites with zero priority even with greater LSNs. + There is a special case in the code for testing that if the + priority is <= 10, we simulate mixed versions for elections. + + Run a rep_test in a replicated master environment and close; + hold an election among a group of clients to make sure they select + the master with varying LSNs and priorities. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep064 + Replication rename and forced-upgrade test. + + The test verifies that the client correctly + (internally) closes files when upgrading to master. + It does this by having the master have a database + open, then crashing. The client upgrades to master, + and attempts to remove the open database. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep065 + Tests replication running with different versions. + This capability is introduced with 4.5. + + Start a replication group of 1 master and N sites, all + running some historical version greater than or equal to 4.4. + Take down a client and bring it up again running current. + Run some upgrades, make sure everything works. + + Each site runs the tcllib of its own version, but uses + the current tcl code (e.g. test.tcl). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep066 + Replication and dead log handles. + + Run rep_test on master and a client. + Simulate client crashes (master continues) until log 2. + Open 2nd master env handle and put something in log and flush. + Downgrade master, restart client as master. + Run rep_test on newmaster until log 2. + New master writes log records, newclient processes records + and 2nd newclient env handle calls log_flush. + New master commits, newclient processes and should succeed. + Make sure 2nd handle detects the old log handle and doesn't + write to a stale handle (if it does, the processing of the + commit will fail). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep067 + Replication election test with large timeouts. + + Test replication elections among clients with widely varying + timeouts. This test is used to simulate a customer that + wants to force full participation in an election, but only + if all sites are present (i.e. if all sites are restarted + together). If any site has already been part of the group, + then we want to be able to elect a master based on majority. + Using varied timeouts, we can force full participation if + all sites are present with "long_timeout" amount of time and + then revert to majority. + + A long_timeout would be several minutes whereas a normal + short timeout would be a few seconds. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep068 + Verify replication of dbreg operations does not hang clients. + In a simple replication group, create a database with very + little data. With DB_TXN_NOSYNC the database can be created + at the client even though the log is not flushed. If we crash + and restart, the application of the log starts over again, even + though the database is still there. The application can open + the database before replication tries to re-apply the create. + This causes a hang as replication waits to be able to get a + handle lock. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep069 + Test of internal initialization and elections. + + If a client is in a recovery mode of any kind, it + participates in elections at priority 0 so it can + never be elected master. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep070 + Test of startup_done condition with idle master. + + Join a client to an existing master, and verify that + the client detects startup_done even if the master + does not execute any new transactions. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep071 + Test of multiple simultaneous client env handles and + upgrading/downgrading. Tests use of temp db handle + internally. + + Open a master and 2 handles to the same client env. + Run rep_test. + Close master and upgrade client to master using one env handle. + Run rep_test again, and then downgrade back to client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep072 + Verify that internal init does not leak resources from + the locking subsystem. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep073 + + Test of allowing clients to create and update their own scratch + databases within the environment. Doing so requires the use + use of the DB_TXN_NOT_DURABLE flag for those databases. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep074 + Verify replication withstands send errors processing requests. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep075 + Replication and prepared transactions. + Test having outstanding prepared transactions and simulating + crashing or upgrading or downgrading sites. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep076 + Replication elections - what happens if elected client + does not become master? + + Set up a master and 3 clients. Take down master, run election. + The elected client will ignore the fact that it's been elected, + so we still have 2 clients. + + Run another election, a regular election that allows the winner + to become master, and make sure it goes okay. We do this both + for the client that ignored its election and for the other client. + + This simulates what would happen if, say, we had a temporary + network partition and lost the winner. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep077 + + Replication, recovery and applying log records immediately. + Master and 1 client. Start up both sites. + Close client and run rep_test on the master so that the + log record is the same LSN the client would be expecting. + Reopen client with recovery and verify the client does not + try to apply that "expected" record before it synchronizes + with the master. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep078 + + Replication and basic lease test. + Set leases on master and 2 clients. + Do a lease operation and process to all clients. + Read with lease on master. Do another lease operation + and don't process on any client. Try to read with + on the master and verify it fails. Process the messages + to the clients and retry the read. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep079 + Replication leases and invalid usage. + + Open a client without leases. Attempt to set leases after rep_start. + Attempt to declare as master without election. + Run an election with an nsites parameter value. + Elect a master with leases. Put some data and send to clients. + Cleanly shutdown master env. Restart without + recovery and verify leases are expired and refreshed. + Add a new client without leases to a group using leases. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep080 + NOAUTOINIT with empty client logs. + + Verify that a fresh client trying to join the group for + the first time observes the setting of DELAY_SYNC and NOAUTOINIT + properly. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep081 + Test of internal initialization and missing database files. + + One master, one client, two databases. + Generate several log files. + Remove old master log files. + Start up client. + Remove or replace one master database file while client initialization + is in progress, make sure other master database can keep processing. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep082 + Sending replication requests to correct master site. + + Regression test for a bug [#16592] where a client could send an + UPDATE_REQ to another client instead of the master. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep083 + Replication clients must never send VERIFY_FAIL to a c2c request. + + Regression test for a bug [#16592] where a client could send a + VERIFY_FAIL to another client, which is illegal. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep084 + Abbreviated internal init for named in-memory databases (NIMDBs). + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep085 + Skipping unnecessary abbreviated internal init. + + Make sure that once we've materialized NIMDBs, we don't bother + trying to do it again on subsequent sync without recovery. Make + sure we do probe for the need to materialize NIMDBs, but don't do + any internal init at all if there are no NIMDBs. Note that in order to + do this test we don't even need any NIMDBs. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep086 + Interrupted abbreviated internal init. + + Make sure we cleanly remove partially loaded named in-memory + databases (NIMDBs). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep087 + Abbreviated internal init with open file handles. + + Client has open handle to an on-disk DB when abbreviated + internal init starts. Make sure we lock out access, and make sure + it ends up as HANDLE_DEAD. Also, make sure that if there are + no NIMDBs, that we *don't* get HANDLE_DEAD. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rep088 + Replication roll-back preserves checkpoint. + + Create a situation where a client has to roll back its + log, discarding some existing transactions, in order to sync + with a new master. + + 1. When the client still has its entire log file history, all + the way back to log file #1, it's OK if the roll-back discards + any/all checkpoints. + 2. When old log files have been archived, if the roll-back would + remove all existing checkpoints it must be forbidden. The log + must always have a checkpoint (or all files back through #1). + The client must do internal init or return JOIN_FAILURE. + 3. (the normal case) Old log files archived, and a checkpoint + still exists in the portion of the log which will remain after + the roll-back: no internal-init/JOIN_FAILURE necessary. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr001 + Basic repmgr test. + + Create an appointed master and two clients, process some records and + verify resulting databases. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr002 + Basic repmgr election test. + + Open three clients of different priorities and make sure repmgr + elects expected master. Shut master down, make sure repmgr elects + expected remaining client master, make sure former master can join + as client. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr003 + Basic repmgr internal init test. + + Start an appointed master site and two clients, processing + transactions between each additional site. Verify all expected + transactions are replicated. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr004 + Basic repmgr test with in-memory logs. + + Create an appointed master and two clients, process some records and + verify resulting databases. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr005 + Basic repmgr test with in-memory databases. + + Create an appointed master and two clients, process some records and + verify resulting databases. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr006 + Basic repmgr test with bulk processing. + + Create an appointed master and two clients, process some records and + verify resulting databases. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr007 + Basic repmgr client shutdown/restart test. + + Start an appointed master site and two clients. Shutdown and + restart each client, processing transactions after each restart. + Verify all expected transactions are replicated. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr008 + Basic repmgr test with client-to-client configuration. + + Create a master and two clients, process some records and verify + resulting databases. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr009 + repmgr API error test. + + Try a variety of repmgr calls that result in errors. Also + try combinations of repmgr and base replication API calls + that result in errors. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr010 + Acknowledgement policy and timeout test. + + Verify that "quorum" acknowledgement policy succeeds with fewer than + nsites running. Verify that "all" acknowledgement policy results in + ack failures with fewer than nsites running. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr011 + repmgr two site strict majority test. + + Start an appointed master and one client with 2 site strict + majority set. Shut down the master site, wait and verify that + the client site was not elected master. Start up master site + and verify that transactions are processed as expected. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr012 + repmgr heartbeat test. + + Start an appointed master and one client site. Set heartbeat + send and monitor values and process some transactions. Stop + sending heartbeats from master and verify that client sees + a dropped connection. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr013 + Site list test. + + Configure a master and two clients where one client is a peer of + the other and verify resulting site lists. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr014 + Basic repmgr in-memory test. + + Create an appointed master and two clients, process some records and + verify resulting databases. Put databases, logs and replication files + in-memory. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr015 + Basic repmgr in-memory election test. + + Open three clients of different priorities and make sure repmgr + elects expected master. Shut master down, make sure repmgr elects + expected remaining client master, make sure former master can join + as client. Replication files are in-memory; databases, logs and + environment regions are on-disk. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr016 + Basic repmgr in-memory internal init test. + + Start an appointed master site and two clients, processing + transactions between each additional site. Verify all expected + transactions are replicated. Replication files are in-memory; + databases, logs and environment regions are on-disk. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr017 + repmgr in-memory cache overflow test. + + Start an appointed master site and one client, putting databases, + environment regions, logs and replication files in-memory. Set + very small cachesize and run enough transactions to overflow cache. + Shut down and restart master and client, giving master a larger cache. + Run and verify a small number of transactions. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr018 + Check repmgr stats. + + Start an appointed master and one client. Shut down the client, + run some transactions at the master and verify that there are + acknowledgement failures and one dropped connection. Shut down + and restart client again and verify that there are two dropped + connections. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr019 + Basic repmgr test with in-memory databases and in-memory logs. + + Create an appointed master and two clients, process some records and + verify resulting databases. + + Run for btree only because access method shouldn't matter. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr022 + Basic test of repmgr's multi-process master support. + + Set up a simple 2-site group, create data and replicate it. + Add a second process at the master and have it write some + updates. It does not explicitly start repmgr (nor do any + replication configuration, for that matter). Its first + update triggers initiation of connections, and so it doesn't + get to the client without a log request. But later updates + should go directly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr023 + Repmgr support for multi-process master. + + Start two processes at the master. + Add a client site (not previously known to the master + processes), and make sure + both master processes connect to it. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr024 + Ensuring exactly one listener process. + + Start a repmgr process with a listener. + Start a second process, and see that it does not become the listener. + Shut down the first process (gracefully). Now a second process should + become listener. + Kill the listener process abruptly. Running failchk should show that + recovery is necessary. Run recovery and start a clean listener. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr025 + Repmgr site address discovery via handshakes. + + Master with 2 processes, does not know client's address. + Client processes start in either order, connect to master. + Master learns of client's address via handshake message. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr026 + Repmgr site address discovery via NEWSITE + + New client, previously unknown to (main) master process, connects to an + existing client, which broadcasts NEWSITE message. + This causes master to discover its address, and connect to it. + Other new clients may also have been added to master's configuration in + the interim (via a subordinate master process). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr027 + Repmgr recognition of peer setting, across processes. + + Set up a master and two clients, synchronized with some data. + Add a new client, configured to use c2c sync with one of the original + clients. Check stats to make sure the correct c2c peer was used. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr028 + Simple smoke test for repmgr elections with multi-process envs. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr029 + Repmgr combined with replication-unaware process at master. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr030 + Subordinate connections and processes should not trigger elections. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr031 + Test repmgr's internal juggling of peer EID's. + + Set up master and 2 clients, A and B. + Add a third client (C), with two processes. + The first process will be configured to know about A. + The second process will know about B, and set that as peer, + but when it joins the env site B will have to be shuffled + into a later position in the list, because A is already first. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +repmgr032 + Multi-process repmgr start-up policies. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rpc001 + Test RPC server timeouts for cursor, txn and env handles. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rpc002 + Test invalid RPC functions and make sure we error them correctly + Test server home directory error cases + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rpc003 + Test RPC and secondary indices. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rpc004 + Test RPC server and security + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rpc005 + Test RPC server handle ID sharing + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rpc006 + Test RPC server and multiple operations to server. + Make sure the server doesn't deadlock itself, but + returns DEADLOCK to the client. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rsrc001 + Recno backing file test. Try different patterns of adding + records and making sure that the corresponding file matches. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rsrc002 + Recno backing file test #2: test of set_re_delim. Specify a backing + file with colon-delimited records, and make sure they are correctly + interpreted. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rsrc003 + Recno backing file test. Try different patterns of adding + records and making sure that the corresponding file matches. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +rsrc004 + Recno backing file test for EOF-terminated records. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +scr### + The scr### directories are shell scripts that test a variety of + things, including things about the distribution itself. These + tests won't run on most systems, so don't even try to run them. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb001 Tests mixing db and subdb operations + Tests mixing db and subdb operations + Create a db, add data, try to create a subdb. + Test naming db and subdb with a leading - for correct parsing + Existence check -- test use of -excl with subdbs + + Test non-subdb and subdb operations + Test naming (filenames begin with -) + Test existence (cannot create subdb of same name with -excl) + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb002 + Tests basic subdb functionality + Small keys, small data + Put/get per key + Dump file + Close, reopen + Dump file + + Use the first 10,000 entries from the dictionary. + Insert each with self as key and data; retrieve each. + After all are entered, retrieve all; compare output to original. + Close file, reopen, do retrieve and re-verify. + Then repeat using an environment. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb003 + Tests many subdbs + Creates many subdbs and puts a small amount of + data in each (many defaults to 1000) + + Use the first 1000 entries from the dictionary as subdbnames. + Insert each with entry as name of subdatabase and a partial list + as key/data. After all are entered, retrieve all; compare output + to original. Close file, reopen, do retrieve and re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb004 + Tests large subdb names + subdb name = filecontents, + key = filename, data = filecontents + Put/get per key + Dump file + Dump subdbs, verify data and subdb name match + + Create 1 db with many large subdbs. Use the contents as subdb names. + Take the source files and dbtest executable and enter their names as + the key with their contents as data. After all are entered, retrieve + all; compare output to original. Close file, reopen, do retrieve and + re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb005 + Tests cursor operations in subdbs + Put/get per key + Verify cursor operations work within subdb + Verify cursor operations do not work across subdbs + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb006 + Tests intra-subdb join + + We'll test 2-way, 3-way, and 4-way joins and figure that if those work, + everything else does as well. We'll create test databases called + sub1.db, sub2.db, sub3.db, and sub4.db. The number on the database + describes the duplication -- duplicates are of the form 0, N, 2N, 3N, + ... where N is the number of the database. Primary.db is the primary + database, and sub0.db is the database that has no matching duplicates. + All of these are within a single database. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb007 + Tests page size difference errors between subdbs. + If the physical file already exists, we ignore pagesize specifications + on any subsequent -creates. + + 1. Create/open a subdb with system default page size. + Create/open a second subdb specifying a different page size. + The create should succeed, but the pagesize of the new db + will be the system default page size. + 2. Create/open a subdb with a specified, non-default page size. + Create/open a second subdb specifying a different page size. + The create should succeed, but the pagesize of the new db + will be the specified page size from the first create. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb008 + Tests explicit setting of lorders for subdatabases -- the + lorder should be ignored. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb009 + Test DB->rename() method for subdbs + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb010 + Test DB->remove() method and DB->truncate() for subdbs + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb011 + Test deleting Subdbs with overflow pages + Create 1 db with many large subdbs. + Test subdatabases with overflow pages. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb012 + Test subdbs with locking and transactions + Tests creating and removing subdbs while handles + are open works correctly, and in the face of txns. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb013 + Tests in-memory subdatabases. + Create an in-memory subdb. Test for persistence after + overflowing the cache. Test for conflicts when we have + two in-memory files. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb014 + Tests mixing in-memory named and in-memory unnamed dbs. + Create a regular in-memory db, add data. + Create a named in-memory db. + Try to create the same named in-memory db again (should fail). + Try to create a different named in-memory db (should succeed). + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb015 + Tests basic in-memory named database functionality + Small keys, small data + Put/get per key + + Use the first 10,000 entries from the dictionary. + Insert each with self as key and data; retrieve each. + After all are entered, retrieve all; compare output to original. + Close file, reopen, do retrieve and re-verify. + Then repeat using an environment. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb016 + Creates many in-memory named dbs and puts a small amount of + data in each (many defaults to 100) + + Use the first 100 entries from the dictionary as names. + Insert each with entry as name of subdatabase and a partial list + as key/data. After all are entered, retrieve all; compare output + to original. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb017 + Test DB->rename() for in-memory named databases. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb018 + Tests join of in-memory named databases. + + We'll test 2-way, 3-way, and 4-way joins and figure that if those work, + everything else does as well. We'll create test databases called + sub1.db, sub2.db, sub3.db, and sub4.db. The number on the database + describes the duplication -- duplicates are of the form 0, N, 2N, 3N, + ... where N is the number of the database. Primary.db is the primary + database, and sub0.db is the database that has no matching duplicates. + All of these are within a single database. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb019 + Tests in-memory subdatabases. + Create an in-memory subdb. Test for persistence after + overflowing the cache. Test for conflicts when we have + two in-memory files. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdb020 + Tests in-memory subdatabases. + Create an in-memory subdb with one page size. Close, and + open with a different page size: should fail. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdbtest001 + Tests multiple access methods in one subdb + Open several subdbs, each with a different access method + Small keys, small data + Put/get per key per subdb + Dump file, verify per subdb + Close, reopen per subdb + Dump file, verify per subdb + + Make several subdb's of different access methods all in one DB. + Rotate methods and repeat [#762]. + Use the first 10,000 entries from the dictionary. + Insert each with self as key and data; retrieve each. + After all are entered, retrieve all; compare output to original. + Close file, reopen, do retrieve and re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sdbtest002 + Tests multiple access methods in one subdb access by multiple + processes. + Open several subdbs, each with a different access method + Small keys, small data + Put/get per key per subdb + Fork off several child procs to each delete selected + data from their subdb and then exit + Dump file, verify contents of each subdb is correct + Close, reopen per subdb + Dump file, verify per subdb + + Make several subdb's of different access methods all in one DB. + Fork of some child procs to each manipulate one subdb and when + they are finished, verify the contents of the databases. + Use the first 10,000 entries from the dictionary. + Insert each with self as key and data; retrieve each. + After all are entered, retrieve all; compare output to original. + Close file, reopen, do retrieve and re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sec001 + Test of security interface + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sec002 + Test of security interface and catching errors in the + face of attackers overwriting parts of existing files. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +si001 + Secondary index put/delete with lorder test + + Put data in primary db and check that pget on secondary + index finds the right entries. Alter the primary in the + following ways, checking for correct data each time: + Overwrite data in primary database. + Delete half of entries through primary. + Delete half of remaining entries through secondary. + Append data (for record-based primaries only). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +si002 + Basic cursor-based secondary index put/delete test + + Cursor put data in primary db and check that pget + on secondary index finds the right entries. + Open and use a second cursor to exercise the cursor + comparison API on secondaries. + Overwrite while walking primary, check pget again. + Overwrite while walking secondary (use c_pget), check + pget again. + Cursor delete half of entries through primary, check. + Cursor delete half of remainder through secondary, check. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +si003 + si001 with secondaries created and closed mid-test + Basic secondary index put/delete test with secondaries + created mid-test. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +si004 + si002 with secondaries created and closed mid-test + Basic cursor-based secondary index put/delete test, with + secondaries created mid-test. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +si005 + Basic secondary index put/delete test with transactions + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +si006 + + Test -immutable_key interface. + + DB_IMMUTABLE_KEY is an optimization to be used when a + secondary key will not be changed. It does not prevent + a deliberate change to the secondary key, it just does not + propagate that change when it is made to the primary. + This test verifies that a change to the primary is propagated + to the secondary or not as specified by -immutable_key. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +si007 + Secondary index put/delete with lorder test + + This test is the same as si001 with the exception + that we create and populate the primary and THEN + create the secondaries and associate them with -create. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +si008 + Secondary index put/delete with lorder test + + This test is the same as si001 except that we + create the secondaries with different byte orders: + one native, one swapped. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +sijointest: Secondary index and join test. + This used to be si005.tcl. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test001 + Small keys/data + Put/get per key + Dump file + Close, reopen + Dump file + + Use the first 10,000 entries from the dictionary. + Insert each with self as key and data; retrieve each. + After all are entered, retrieve all; compare output to original. + Close file, reopen, do retrieve and re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test002 + Small keys/medium data + Put/get per key + Dump file + Close, reopen + Dump file + + Use the first 10,000 entries from the dictionary. + Insert each with self as key and a fixed, medium length data string; + retrieve each. After all are entered, retrieve all; compare output + to original. Close file, reopen, do retrieve and re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test003 + Small keys/large data + Put/get per key + Dump file + Close, reopen + Dump file + + Take the source files and dbtest executable and enter their names + as the key with their contents as data. After all are entered, + retrieve all; compare output to original. Close file, reopen, do + retrieve and re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test004 + Small keys/medium data + Put/get per key + Sequential (cursor) get/delete + + Check that cursor operations work. Create a database. + Read through the database sequentially using cursors and + delete each element. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test005 + Small keys/medium data + Put/get per key + Close, reopen + Sequential (cursor) get/delete + + Check that cursor operations work. Create a database; close + it and reopen it. Then read through the database sequentially + using cursors and delete each element. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test006 + Small keys/medium data + Put/get per key + Keyed delete and verify + + Keyed delete test. + Create database. + Go through database, deleting all entries by key. + Then do the same for unsorted and sorted dups. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test007 + Small keys/medium data + Put/get per key + Close, reopen + Keyed delete + + Check that delete operations work. Create a database; close + database and reopen it. Then issues delete by key for each + entry. (Test006 plus reopen) + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test008 + Small keys/large data + Put/get per key + Loop through keys by steps (which change) + ... delete each key at step + ... add each key back + ... change step + Confirm that overflow pages are getting reused + + Take the source files and dbtest executable and enter their names as + the key with their contents as data. After all are entered, begin + looping through the entries; deleting some pairs and then readding them. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test009 + Small keys/large data + Same as test008; close and reopen database + + Check that we reuse overflow pages. Create database with lots of + big key/data pairs. Go through and delete and add keys back + randomly. Then close the DB and make sure that we have everything + we think we should. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test010 + Duplicate test + Small key/data pairs. + + Use the first 10,000 entries from the dictionary. + Insert each with self as key and data; add duplicate records for each. + After all are entered, retrieve all; verify output. + Close file, reopen, do retrieve and re-verify. + This does not work for recno + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test011 + Duplicate test + Small key/data pairs. + Test DB_KEYFIRST, DB_KEYLAST, DB_BEFORE and DB_AFTER. + To test off-page duplicates, run with small pagesize. + + Use the first 10,000 entries from the dictionary. + Insert each with self as key and data; add duplicate records for each. + Then do some key_first/key_last add_before, add_after operations. + This does not work for recno + + To test if dups work when they fall off the main page, run this with + a very tiny page size. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test012 + Large keys/small data + Same as test003 except use big keys (source files and + executables) and small data (the file/executable names). + + Take the source files and dbtest executable and enter their contents + as the key with their names as data. After all are entered, retrieve + all; compare output to original. Close file, reopen, do retrieve and + re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test013 + Partial put test + Overwrite entire records using partial puts. + Make sure that NOOVERWRITE flag works. + + 1. Insert 10000 keys and retrieve them (equal key/data pairs). + 2. Attempt to overwrite keys with NO_OVERWRITE set (expect error). + 3. Actually overwrite each one with its datum reversed. + + No partial testing here. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test014 + Exercise partial puts on short data + Run 5 combinations of numbers of characters to replace, + and number of times to increase the size by. + + Partial put test, small data, replacing with same size. The data set + consists of the first nentries of the dictionary. We will insert them + (and retrieve them) as we do in test 1 (equal key/data pairs). Then + we'll try to perform partial puts of some characters at the beginning, + some at the end, and some at the middle. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test015 + Partial put test + Partial put test where the key does not initially exist. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test016 + Partial put test + Partial put where the datum gets shorter as a result of the put. + + Partial put test where partial puts make the record smaller. + Use the first 10,000 entries from the dictionary. + Insert each with self as key and a fixed, medium length data string; + retrieve each. After all are entered, go back and do partial puts, + replacing a random-length string with the key value. + Then verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test017 + Basic offpage duplicate test. + + Run duplicates with small page size so that we test off page duplicates. + Then after we have an off-page database, test with overflow pages too. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test018 + Offpage duplicate test + Key_{first,last,before,after} offpage duplicates. + Run duplicates with small page size so that we test off page + duplicates. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test019 + Partial get test. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test020 + In-Memory database tests. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test021 + Btree range tests. + + Use the first 10,000 entries from the dictionary. + Insert each with self, reversed as key and self as data. + After all are entered, retrieve each using a cursor SET_RANGE, and + getting about 20 keys sequentially after it (in some cases we'll + run out towards the end of the file). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test022 + Test of DB->getbyteswapped(). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test023 + Duplicate test + Exercise deletes and cursor operations within a duplicate set. + Add a key with duplicates (first time on-page, second time off-page) + Number the dups. + Delete dups and make sure that CURRENT/NEXT/PREV work correctly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test024 + Record number retrieval test. + Test the Btree and Record number get-by-number functionality. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test025 + DB_APPEND flag test. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test026 + Small keys/medium data w/duplicates + Put/get per key. + Loop through keys -- delete each key + ... test that cursors delete duplicates correctly + + Keyed delete test through cursor. If ndups is small; this will + test on-page dups; if it's large, it will test off-page dups. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test027 + Off-page duplicate test + Test026 with parameters to force off-page duplicates. + + Check that delete operations work. Create a database; close + database and reopen it. Then issues delete by key for each + entry. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test028 + Cursor delete test + Test put operations after deleting through a cursor. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test029 + Test the Btree and Record number renumbering. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test030 + Test DB_NEXT_DUP Functionality. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test031 + Duplicate sorting functionality + Make sure DB_NODUPDATA works. + + Use the first 10,000 entries from the dictionary. + Insert each with self as key and "ndups" duplicates + For the data field, prepend random five-char strings (see test032) + that we force the duplicate sorting code to do something. + Along the way, test that we cannot insert duplicate duplicates + using DB_NODUPDATA. + + By setting ndups large, we can make this an off-page test + After all are entered, retrieve all; verify output. + Close file, reopen, do retrieve and re-verify. + This does not work for recno + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test032 + DB_GET_BOTH, DB_GET_BOTH_RANGE + + Use the first 10,000 entries from the dictionary. Insert each with + self as key and "ndups" duplicates. For the data field, prepend the + letters of the alphabet in a random order so we force the duplicate + sorting code to do something. By setting ndups large, we can make + this an off-page test. By setting overflow to be 1, we can make + this an overflow test. + + Test the DB_GET_BOTH functionality by retrieving each dup in the file + explicitly. Test the DB_GET_BOTH_RANGE functionality by retrieving + the unique key prefix (cursor only). Finally test the failure case. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test033 + DB_GET_BOTH without comparison function + + Use the first 10,000 entries from the dictionary. Insert each with + self as key and data; add duplicate records for each. After all are + entered, retrieve all and verify output using DB_GET_BOTH (on DB and + DBC handles) and DB_GET_BOTH_RANGE (on a DBC handle) on existent and + nonexistent keys. + + XXX + This does not work for rbtree. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test034 + test032 with off-page or overflow case with non-duplicates + and duplicates. + + DB_GET_BOTH, DB_GET_BOTH_RANGE functionality with off-page + or overflow case within non-duplicates and duplicates. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test035 + Test033 with off-page duplicates + DB_GET_BOTH functionality with off-page duplicates. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test036 + Test KEYFIRST and KEYLAST when the key doesn't exist + Put nentries key/data pairs (from the dictionary) using a cursor + and KEYFIRST and KEYLAST (this tests the case where use use cursor + put for non-existent keys). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test037 + Test DB_RMW + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test038 + DB_GET_BOTH, DB_GET_BOTH_RANGE on deleted items + + Use the first 10,000 entries from the dictionary. Insert each with + self as key and "ndups" duplicates. For the data field, prepend the + letters of the alphabet in a random order so we force the duplicate + sorting code to do something. By setting ndups large, we can make + this an off-page test + + Test the DB_GET_BOTH and DB_GET_BOTH_RANGE functionality by retrieving + each dup in the file explicitly. Then remove each duplicate and try + the retrieval again. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test039 + DB_GET_BOTH/DB_GET_BOTH_RANGE on deleted items without comparison + function. + + Use the first 10,000 entries from the dictionary. Insert each with + self as key and "ndups" duplicates. For the data field, prepend the + letters of the alphabet in a random order so we force the duplicate + sorting code to do something. By setting ndups large, we can make + this an off-page test. + + Test the DB_GET_BOTH and DB_GET_BOTH_RANGE functionality by retrieving + each dup in the file explicitly. Then remove each duplicate and try + the retrieval again. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test040 + Test038 with off-page duplicates + DB_GET_BOTH functionality with off-page duplicates. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test041 + Test039 with off-page duplicates + DB_GET_BOTH functionality with off-page duplicates. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test042 + Concurrent Data Store test (CDB) + + Multiprocess DB test; verify that locking is working for the + concurrent access method product. + + Use the first "nentries" words from the dictionary. Insert each with + self as key and a fixed, medium length data string. Then fire off + multiple processes that bang on the database. Each one should try to + read and write random keys. When they rewrite, they'll append their + pid to the data string (sometimes doing a rewrite sometimes doing a + partial put). Some will use cursors to traverse through a few keys + before finding one to write. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test043 + Recno renumbering and implicit creation test + Test the Record number implicit creation and renumbering options. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test044 + Small system integration tests + Test proper functioning of the checkpoint daemon, + recovery, transactions, etc. + + System integration DB test: verify that locking, recovery, checkpoint, + and all the other utilities basically work. + + The test consists of $nprocs processes operating on $nfiles files. A + transaction consists of adding the same key/data pair to some random + number of these files. We generate a bimodal distribution in key size + with 70% of the keys being small (1-10 characters) and the remaining + 30% of the keys being large (uniform distribution about mean $key_avg). + If we generate a key, we first check to make sure that the key is not + already in the dataset. If it is, we do a lookup. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test045 + Small random tester + Runs a number of random add/delete/retrieve operations. + Tests both successful conditions and error conditions. + + Run the random db tester on the specified access method. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test046 + Overwrite test of small/big key/data with cursor checks. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test047 + DBcursor->c_get get test with SET_RANGE option. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test048 + Cursor stability across Btree splits. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test049 + Cursor operations on uninitialized cursors. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test050 + Overwrite test of small/big key/data with cursor checks for Recno. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test051 + Fixed-length record Recno test. + 0. Test various flags (legal and illegal) to open + 1. Test partial puts where dlen != size (should fail) + 2. Partial puts for existent record -- replaces at beg, mid, and + end of record, as well as full replace + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test052 + Renumbering record Recno test. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test053 + Test of the DB_REVSPLITOFF flag in the Btree and Btree-w-recnum + methods. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test054 + Cursor maintenance during key/data deletion. + + This test checks for cursor maintenance in the presence of deletes. + There are N different scenarios to tests: + 1. No duplicates. Cursor A deletes a key, do a GET for the key. + 2. No duplicates. Cursor is positioned right before key K, Delete K, + do a next on the cursor. + 3. No duplicates. Cursor is positioned on key K, do a regular delete + of K, do a current get on K. + 4. Repeat 3 but do a next instead of current. + 5. Duplicates. Cursor A is on the first item of a duplicate set, A + does a delete. Then we do a non-cursor get. + 6. Duplicates. Cursor A is in a duplicate set and deletes the item. + do a delete of the entire Key. Test cursor current. + 7. Continue last test and try cursor next. + 8. Duplicates. Cursor A is in a duplicate set and deletes the item. + Cursor B is in the same duplicate set and deletes a different item. + Verify that the cursor is in the right place. + 9. Cursors A and B are in the place in the same duplicate set. A + deletes its item. Do current on B. + 10. Continue 8 and do a next on B. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test055 + Basic cursor operations. + This test checks basic cursor operations. + There are N different scenarios to tests: + 1. (no dups) Set cursor, retrieve current. + 2. (no dups) Set cursor, retrieve next. + 3. (no dups) Set cursor, retrieve prev. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test056 + Cursor maintenance during deletes. + Check if deleting a key when a cursor is on a duplicate of that + key works. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test057 + Cursor maintenance during key deletes. + 1. Delete a key with a cursor. Add the key back with a regular + put. Make sure the cursor can't get the new item. + 2. Put two cursors on one item. Delete through one cursor, + check that the other sees the change. + 3. Same as 2, with the two cursors on a duplicate. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test058 + Verify that deleting and reading duplicates results in correct ordering. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test059 + Cursor ops work with a partial length of 0. + Make sure that we handle retrieves of zero-length data items correctly. + The following ops, should allow a partial data retrieve of 0-length. + db_get + db_cget FIRST, NEXT, LAST, PREV, CURRENT, SET, SET_RANGE + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test060 + Test of the DB_EXCL flag to DB->open(). + 1) Attempt to open and create a nonexistent database; verify success. + 2) Attempt to reopen it; verify failure. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test061 + Test of txn abort and commit for in-memory databases. + a) Put + abort: verify absence of data + b) Put + commit: verify presence of data + c) Overwrite + abort: verify that data is unchanged + d) Overwrite + commit: verify that data has changed + e) Delete + abort: verify that data is still present + f) Delete + commit: verify that data has been deleted + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test062 + Test of partial puts (using DB_CURRENT) onto duplicate pages. + Insert the first 200 words into the dictionary 200 times each with + self as key and :self as data. Use partial puts to + append self again to data; verify correctness. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test063 + Test of the DB_RDONLY flag to DB->open + Attempt to both DB->put and DBC->c_put into a database + that has been opened DB_RDONLY, and check for failure. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test064 + Test of DB->get_type + Create a database of type specified by method. + Make sure DB->get_type returns the right thing with both a normal + and DB_UNKNOWN open. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test065 + Test of DB->stat, both -DB_FAST_STAT and row + counts with DB->stat -txn. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test066 + Test of cursor overwrites of DB_CURRENT w/ duplicates. + + Make sure a cursor put to DB_CURRENT acts as an overwrite in a + database with duplicates. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test067 + Test of DB_CURRENT partial puts onto almost empty duplicate + pages, with and without DB_DUP_SORT. + + Test of DB_CURRENT partial puts on almost-empty duplicate pages. + This test was written to address the following issue, #2 in the + list of issues relating to bug #0820: + + 2. DBcursor->put, DB_CURRENT flag, off-page duplicates, hash and btree: + In Btree, the DB_CURRENT overwrite of off-page duplicate records + first deletes the record and then puts the new one -- this could + be a problem if the removal of the record causes a reverse split. + Suggested solution is to acquire a cursor to lock down the current + record, put a new record after that record, and then delete using + the held cursor. + + It also tests the following, #5 in the same list of issues: + 5. DBcursor->put, DB_AFTER/DB_BEFORE/DB_CURRENT flags, DB_DBT_PARTIAL + set, duplicate comparison routine specified. + The partial change does not change how data items sort, but the + record to be put isn't built yet, and that record supplied is the + one that's checked for ordering compatibility. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test068 + Test of DB_BEFORE and DB_AFTER with partial puts. + Make sure DB_BEFORE and DB_AFTER work properly with partial puts, and + check that they return EINVAL if DB_DUPSORT is set or if DB_DUP is not. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test069 + Test of DB_CURRENT partial puts without duplicates-- test067 w/ + small ndups to ensure that partial puts to DB_CURRENT work + correctly in the absence of duplicate pages. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test070 + Test of DB_CONSUME (Four consumers, 1000 items.) + + Fork off six processes, four consumers and two producers. + The producers will each put 20000 records into a queue; + the consumers will each get 10000. + Then, verify that no record was lost or retrieved twice. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test071 + Test of DB_CONSUME (One consumer, 10000 items.) + This is DB Test 70, with one consumer, one producers, and 10000 items. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test072 + Test of cursor stability when duplicates are moved off-page. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test073 + Test of cursor stability on duplicate pages. + + Does the following: + a. Initialize things by DB->putting ndups dups and + setting a reference cursor to point to each. + b. c_put ndups dups (and correspondingly expanding + the set of reference cursors) after the last one, making sure + after each step that all the reference cursors still point to + the right item. + c. Ditto, but before the first one. + d. Ditto, but after each one in sequence first to last. + e. Ditto, but after each one in sequence from last to first. + occur relative to the new datum) + f. Ditto for the two sequence tests, only doing a + DBC->c_put(DB_CURRENT) of a larger datum instead of adding a + new one. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test074 + Test of DB_NEXT_NODUP. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test076 + Test creation of many small databases in a single environment. [#1528]. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test077 + Test of DB_GET_RECNO [#1206]. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test078 + Test of DBC->c_count(). [#303] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test079 + Test of deletes in large trees. (test006 w/ sm. pagesize). + + Check that delete operations work in large btrees. 10000 entries + and a pagesize of 512 push this out to a four-level btree, with a + small fraction of the entries going on overflow pages. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test081 + Test off-page duplicates and overflow pages together with + very large keys (key/data as file contents). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test082 + Test of DB_PREV_NODUP (uses test074). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test083 + Test of DB->key_range. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test084 + Basic sanity test (test001) with large (64K) pages. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test085 + Test of cursor behavior when a cursor is pointing to a deleted + btree key which then has duplicates added. [#2473] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test086 + Test of cursor stability across btree splits/rsplits with + subtransaction aborts (a variant of test048). [#2373] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test087 + Test of cursor stability when converting to and modifying + off-page duplicate pages with subtransaction aborts. [#2373] + + Does the following: + a. Initialize things by DB->putting ndups dups and + setting a reference cursor to point to each. Do each put twice, + first aborting, then committing, so we're sure to abort the move + to off-page dups at some point. + b. c_put ndups dups (and correspondingly expanding + the set of reference cursors) after the last one, making sure + after each step that all the reference cursors still point to + the right item. + c. Ditto, but before the first one. + d. Ditto, but after each one in sequence first to last. + e. Ditto, but after each one in sequence from last to first. + occur relative to the new datum) + f. Ditto for the two sequence tests, only doing a + DBC->c_put(DB_CURRENT) of a larger datum instead of adding a + new one. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test088 + Test of cursor stability across btree splits with very + deep trees (a variant of test048). [#2514] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test089 + Concurrent Data Store test (CDB) + + Enhanced CDB testing to test off-page dups, cursor dups and + cursor operations like c_del then c_get. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test090 + Test for functionality near the end of the queue using test001. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test091 + Test of DB_CONSUME_WAIT. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test092 + Test of DB_DIRTY_READ [#3395] + + We set up a database with nentries in it. We then open the + database read-only twice. One with dirty reads and one without. + We open the database for writing and update some entries in it. + Then read those new entries via db->get (clean and dirty), and + via cursors (clean and dirty). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test093 + Test set_bt_compare (btree key comparison function) and + set_h_compare (hash key comparison function). + + Open a database with a comparison function specified, + populate, and close, saving a list with that key order as + we do so. Reopen and read in the keys, saving in another + list; the keys should be in the order specified by the + comparison function. Sort the original saved list of keys + using the comparison function, and verify that it matches + the keys as read out of the database. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test094 + Test using set_dup_compare. + + Use the first 10,000 entries from the dictionary. + Insert each with self as key and data; retrieve each. + After all are entered, retrieve all; compare output to original. + Close file, reopen, do retrieve and re-verify. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test095 + Bulk get test for methods supporting dups. [#2934] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test096 + Db->truncate test. + For all methods: + Test that truncate empties an existing database. + Test that truncate-write in an aborted txn doesn't + change the original contents. + Test that truncate-write in a committed txn does + overwrite the original contents. + For btree and hash, do the same in a database with offpage dups. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test097 + Open up a large set of database files simultaneously. + Adjust for local file descriptor resource limits. + Then use the first 1000 entries from the dictionary. + Insert each with self as key and a fixed, medium length data string; + retrieve each. After all are entered, retrieve all; compare output + to original. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test098 + Test of DB_GET_RECNO and secondary indices. Open a primary and + a secondary, and do a normal cursor get followed by a get_recno. + (This is a smoke test for "Bug #1" in [#5811].) + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test099 + + Test of DB->get and DBC->c_get with set_recno and get_recno. + + Populate a small btree -recnum database. + After all are entered, retrieve each using -recno with DB->get. + Open a cursor and do the same for DBC->c_get with set_recno. + Verify that set_recno sets the record number position properly. + Verify that get_recno returns the correct record numbers. + + Using the same database, open 3 cursors and position one at + the beginning, one in the middle, and one at the end. Delete + by cursor and check that record renumbering is done properly. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test100 + Test for functionality near the end of the queue + using test025 (DB_APPEND). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test101 + Test for functionality near the end of the queue + using test070 (DB_CONSUME). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test102 + Bulk get test for record-based methods. [#2934] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test103 + Test bulk get when record numbers wrap around. + + Load database with items starting before and ending after + the record number wrap around point. Run bulk gets (-multi_key) + with various buffer sizes and verify the contents returned match + the results from a regular cursor get. + + Then delete items to create a sparse database and make sure it + still works. Test both -multi and -multi_key since they behave + differently. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test106 + + + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test107 + Test of read-committed (degree 2 isolation). [#8689] + + We set up a database. Open a read-committed transactional cursor and + a regular transactional cursor on it. Position each cursor on one page, + and do a put to a different page. + + Make sure that: + - the put succeeds if we are using degree 2 isolation. + - the put deadlocks within a regular transaction with + a regular cursor. + + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test109 + + Test of sequences. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test110 + Partial get test with duplicates. + + For hash and btree, create and populate a database + with dups. Randomly selecting offset and length, + retrieve data from each record and make sure we + get what we expect. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test111 + Test database compaction. + + Populate a database. Remove a high proportion of entries. + Dump and save contents. Compact the database, dump again, + and make sure we still have the same contents. + Add back some entries, delete more entries (this time by + cursor), dump, compact, and do the before/after check again. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test112 + Test database compaction with a deep tree. + + This is a lot like test111, but with a large number of + entries and a small page size to make the tree deep. + To make it simple we use numerical keys all the time. + + Dump and save contents. Compact the database, dump again, + and make sure we still have the same contents. + Add back some entries, delete more entries (this time by + cursor), dump, compact, and do the before/after check again. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test113 + Test database compaction with duplicates. + + This is essentially test111 with duplicates. + To make it simple we use numerical keys all the time. + + Dump and save contents. Compact the database, dump again, + and make sure we still have the same contents. + Add back some entries, delete more entries (this time by + cursor), dump, compact, and do the before/after check again. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test114 + Test database compaction with overflows. + + Populate a database. Remove a high proportion of entries. + Dump and save contents. Compact the database, dump again, + and make sure we still have the same contents. + Add back some entries, delete more entries (this time by + cursor), dump, compact, and do the before/after check again. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test115 + Test database compaction with user-specified btree sort. + + This is essentially test111 with the user-specified sort. + Populate a database. Remove a high proportion of entries. + Dump and save contents. Compact the database, dump again, + and make sure we still have the same contents. + Add back some entries, delete more entries (this time by + cursor), dump, compact, and do the before/after check again. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test116 + Test of basic functionality of lsn_reset. + + Create a database in an env. Copy it to a new file within + the same env. Reset the page LSNs. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test117 + Test database compaction with requested fill percent. + + Populate a database. Remove a high proportion of entries. + Dump and save contents. Compact the database, requesting + fill percentages starting at 10% and working our way up to + 100. On each cycle, make sure we still have the same contents. + + Unlike the other compaction tests, this one does not + use -freespace. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test119 + Test behavior when Berkeley DB returns DB_BUFFER_SMALL on a cursor. + + If the user-supplied buffer is not large enough to contain + the returned value, DB returns BUFFER_SMALL. If it does, + check that the cursor does not move -- if it moves, it will + skip items. [#13815] + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test120 + Test of multi-version concurrency control. + + Test basic functionality: a snapshot transaction started + before a regular transaction's put can't see the modification. + A snapshot transaction started after the put can see it. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test121 + Tests of multi-version concurrency control. + + MVCC and cursor adjustment. + Set up a -snapshot cursor and position it in the middle + of a database. + Write to the database, both before and after the cursor, + and verify that it stays on the same position. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test122 + Tests of multi-version concurrency control. + + MVCC and databases that turn multi-version on and off. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test123 + Concurrent Data Store cdsgroup smoke test. + + Open a CDS env with -cdb_alldb. + Start a "txn" with -cdsgroup. + Create two databases in the env, do a cursor put + in both within the same txn. This should succeed. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +test125 + Test cursor comparison API. + + The cursor comparison API reports whether two cursors within + the same database are at the same position. It does not report + any information about relative position. + + 1. Test two uninitialized cursors (error). + 2. Test one uninitialized cursor, one initialized (error). + 3. Test two cursors in different databases (error). + 4. Put two cursors in the same place, test for match. Walk + them back and forth a bit, more matching. + 5. Two cursors in the same spot. Delete through one. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn001 + Begin, commit, abort testing. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn002 + Verify that read-only transactions do not write log records. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn003 + Test abort/commit/prepare of txns with outstanding child txns. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn004 + Test of wraparound txnids (txn001) + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn005 + Test transaction ID wraparound and recovery. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn008 + Test of wraparound txnids (txn002) + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn009 + Test of wraparound txnids (txn003) + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn010 + Test DB_ENV->txn_checkpoint arguments/flags + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn011 + Test durable and non-durable txns. + Test a mixed env (with both durable and non-durable + dbs), then a purely non-durable env. Make sure commit + and abort work, and that only the log records we + expect are written. + Test that we can't get a durable handle on an open ND + database, or vice versa. Test that all subdb's + must be of the same type (D or ND). + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn012 + Test txn->getname and txn->setname. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn013 + Test of txns used in the wrong environment. + Set up two envs. Start a txn in one env, and attempt to use it + in the other env. Verify we get the appropriate error message. + +=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= +txn014 + Test of parent and child txns working on the same database. + A txn that will become a parent create a database. + A txn that will not become a parent creates another database. + Start a child txn of the 1st txn. + Verify that the parent txn is disabled while child is open. + 1. Child reads contents with child handle (should succeed). + 2. Child reads contents with parent handle (should succeed). + Verify that the non-parent txn can read from its database, + and that the child txn cannot. + Return to the child txn. + 3. Child writes with child handle (should succeed). + 4. Child writes with parent handle (should succeed). + + Commit the child, verify that the parent can write again. + Check contents of database with a second child. -- cgit v1.2.3