Import SQLite 3.10.2.

third_party/sqlite/src/test/threadtest3.c

-
 /*
+** 2010-07-22
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+**
 ** The code in this file runs a few multi-threaded test cases using the
 ** SQLite library. It can be compiled to an executable on unix using the
 ** following command:
 **
 **   gcc -O2 threadtest3.c sqlite3.c -ldl -lpthread -lm
 **
-** Then run the compiled program. The exit status is non-zero if any tests
-** failed (hopefully there is also some output to stdout to clarify what went
-** wrong).
+** Even though threadtest3.c is the only C source code file mentioned on
+** the compiler command-line, #include macros are used to pull in additional
+** C code files named "tt3_*.c".
 **
-** There are three parts to the code in this file, in the following order:
+** After compiling, run this program with an optional argument telling
+** which test to run.  All tests are run if no argument is given.  The
+** argument can be a glob pattern to match multiple tests.  Examples:
 **
-**   1. Code for the SQL aggregate function md5sum() copied from 
-**      tclsqlite.c in the SQLite distribution. The names of all the 
-**      types and functions in this section begin with "MD5" or "md5".
+**        ./a.out                 -- Run all tests
+**        ./a.out walthread3      -- Run the "walthread3" test
+**        ./a.out 'wal*'          -- Run all of the wal* tests
+**        ./a.out --help          -- List all available tests
 **
-**   2. A set of utility functions that may be used to implement
-**      multi-threaded test cases. These are all called by test code
-**      via macros that help with error reporting. The macros are defined
-**      immediately below this comment.
-**
-**   3. The test code itself. And a main() routine to drive the test 
-**      code.
+** The exit status is non-zero if any test fails.
 */
 
-/*************************************************************************
-** Start of test code/infrastructure interface macros.
-**
-** The following macros constitute the interface between the test
-** programs and the test infrastructure. Test infrastructure code 
-** does not itself use any of these macros. Test code should not
-** call any of the macroname_x() functions directly.
-**
-** See the header comments above the corresponding macroname_x()
-** function for a description of each interface.
+/* 
+** The "Set Error Line" macro.
 */
+#define SEL(e) ((e)->iLine = ((e)->rc ? (e)->iLine : __LINE__))
 
 /* Database functions */
 #define opendb(w,x,y,z)         (SEL(w), opendb_x(w,x,y,z))
 #define closedb(y,z)            (SEL(y), closedb_x(y,z))
 
 /* Functions to execute SQL */
 #define sql_script(x,y,z)       (SEL(x), sql_script_x(x,y,z))
 #define integrity_check(x,y)    (SEL(x), integrity_check_x(x,y))
 #define execsql_i64(x,y,...)    (SEL(x), execsql_i64_x(x,y,__VA_ARGS__))
 #define execsql_text(x,y,z,...) (SEL(x), execsql_text_x(x,y,z,__VA_ARGS__))
 #define execsql(x,y,...)        (SEL(x), (void)execsql_i64_x(x,y,__VA_ARGS__))
+#define sql_script_printf(x,y,z,...) (                \
+    SEL(x), sql_script_printf_x(x,y,z,__VA_ARGS__)    \
+) 
 
 /* Thread functions */
-#define launch_thread(w,x,y,z)  (SEL(w), launch_thread_x(w,x,y,z))
-#define join_all_threads(y,z)   (SEL(y), join_all_threads_x(y,z))
+#define launch_thread(w,x,y,z)     (SEL(w), launch_thread_x(w,x,y,z))
+#define join_all_threads(y,z)      (SEL(y), join_all_threads_x(y,z))
 
 /* Timer functions */
 #define setstoptime(y,z)        (SEL(y), setstoptime_x(y,z))
 #define timetostop(z)           (SEL(z), timetostop_x(z))
 
 /* Report/clear errors. */
 #define test_error(z, ...)      test_error_x(z, sqlite3_mprintf(__VA_ARGS__))
 #define clear_error(y,z)        clear_error_x(y, z)
 
 /* File-system operations */
 #define filesize(y,z)           (SEL(y), filesize_x(y,z))
 #define filecopy(x,y,z)         (SEL(x), filecopy_x(x,y,z))
 
+#define PTR2INT(x) ((int)((intptr_t)x))
+#define INT2PTR(x) ((void*)((intptr_t)x))
+
 /*
 ** End of test code/infrastructure interface macros.
 *************************************************************************/
 
 
 
 
 #include <sqlite3.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <pthread.h>
 #include <assert.h>
 #include <sys/types.h> 
 #include <sys/stat.h> 
 #include <string.h>
 #include <fcntl.h>
 #include <errno.h>
 
+#include "test_multiplex.h"
+
+/* Required to link test_multiplex.c */
+#ifndef SQLITE_OMIT_WSD
+int sqlite3PendingByte = 0x40000000;
+#endif
+
 /*
  * This code implements the MD5 message-digest algorithm.
  * The algorithm is due to Ron Rivest.  This code was
  * written by Colin Plumb in 1993, no copyright is claimed.
  * This code is in the public domain; do with it what you wish.
  *
  * Equivalent code is available from RSA Data Security, Inc.
  * This code has been tested against that, and is equivalent,
  * except that you don't need to include two pages of legalese
  * with every copy.
@@ skipping 13 matching lines @@
  *
  */
 #ifndef uint32
 #  define uint32 unsigned int
 #endif
 
 struct MD5Context {
   int isInit;
   uint32 buf[4];
   uint32 bits[2];
-  unsigned char in[64];
+  union {
+    unsigned char in[64];
+    uint32 in32[16];
+  } u;
 };
 typedef struct MD5Context MD5Context;
 
 /*
  * Note: this code is harmless on little-endian machines.
  */
 static void byteReverse (unsigned char *buf, unsigned longs){
   uint32 t;
   do {
     t = (uint32)((unsigned)buf[3]<<8 | buf[2]) << 16 |
@@ skipping 128 matching lines @@
   t = ctx->bits[0];
   if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)
     ctx->bits[1]++; /* Carry from low to high */
   ctx->bits[1] += len >> 29;
 
   t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
 
   /* Handle any leading odd-sized chunks */
 
   if ( t ) {
-    unsigned char *p = (unsigned char *)ctx->in + t;
+    unsigned char *p = (unsigned char *)ctx->u.in + t;
 
     t = 64-t;
     if (len < t) {
       memcpy(p, buf, len);
       return;
     }
     memcpy(p, buf, t);
-    byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32 *)ctx->in);
+    byteReverse(ctx->u.in, 16);
+    MD5Transform(ctx->buf, (uint32 *)ctx->u.in);
     buf += t;
     len -= t;
   }
 
   /* Process data in 64-byte chunks */
 
   while (len >= 64) {
-    memcpy(ctx->in, buf, 64);
-    byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32 *)ctx->in);
+    memcpy(ctx->u.in, buf, 64);
+    byteReverse(ctx->u.in, 16);
+    MD5Transform(ctx->buf, (uint32 *)ctx->u.in);
     buf += 64;
     len -= 64;
   }
 
   /* Handle any remaining bytes of data. */
 
-  memcpy(ctx->in, buf, len);
+  memcpy(ctx->u.in, buf, len);
 }
 
 /*
  * Final wrapup - pad to 64-byte boundary with the bit pattern 
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 static void MD5Final(unsigned char digest[16], MD5Context *ctx){
   unsigned count;
   unsigned char *p;
 
   /* Compute number of bytes mod 64 */
   count = (ctx->bits[0] >> 3) & 0x3F;
 
   /* Set the first char of padding to 0x80.  This is safe since there is
      always at least one byte free */
-  p = ctx->in + count;
+  p = ctx->u.in + count;
   *p++ = 0x80;
 
   /* Bytes of padding needed to make 64 bytes */
   count = 64 - 1 - count;
 
   /* Pad out to 56 mod 64 */
   if (count < 8) {
     /* Two lots of padding:  Pad the first block to 64 bytes */
     memset(p, 0, count);
-    byteReverse(ctx->in, 16);
-    MD5Transform(ctx->buf, (uint32 *)ctx->in);
+    byteReverse(ctx->u.in, 16);
+    MD5Transform(ctx->buf, (uint32 *)ctx->u.in);
 
     /* Now fill the next block with 56 bytes */
-    memset(ctx->in, 0, 56);
+    memset(ctx->u.in, 0, 56);
   } else {
     /* Pad block to 56 bytes */
     memset(p, 0, count-8);
   }
-  byteReverse(ctx->in, 14);
+  byteReverse(ctx->u.in, 14);
 
   /* Append length in bits and transform */
-  ((uint32 *)ctx->in)[ 14 ] = ctx->bits[0];
-  ((uint32 *)ctx->in)[ 15 ] = ctx->bits[1];
+  ctx->u.in32[14] = ctx->bits[0];
+  ctx->u.in32[15] = ctx->bits[1];
 
-  MD5Transform(ctx->buf, (uint32 *)ctx->in);
+  MD5Transform(ctx->buf, (uint32 *)ctx->u.in);
   byteReverse((unsigned char *)ctx->buf, 4);
   memcpy(digest, ctx->buf, 16);
-  memset(ctx, 0, sizeof(ctx));    /* In case it is sensitive */
+  memset(ctx, 0, sizeof(*ctx));    /* In case it is sensitive */
 }
 
 /*
 ** Convert a 128-bit MD5 digest into a 32-digit base-16 number.
 */
 static void MD5DigestToBase16(unsigned char *digest, char *zBuf){
   static char const zEncode[] = "0123456789abcdef";
   int i, j;
 
   for(j=i=0; i<16; i++){
@@ skipping 27 matching lines @@
 static void md5finalize(sqlite3_context *context){
   MD5Context *p;
   unsigned char digest[16];
   char zBuf[33];
   p = sqlite3_aggregate_context(context, sizeof(*p));
   MD5Final(digest,p);
   MD5DigestToBase16(digest, zBuf);
   sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
 }
 
-/*************************************************************************
+/*
 ** End of copied md5sum() code.
-*/
+**************************************************************************/
 
 typedef sqlite3_int64 i64;
 
 typedef struct Error Error;
 typedef struct Sqlite Sqlite;
 typedef struct Statement Statement;
 
 typedef struct Threadset Threadset;
 typedef struct Thread Thread;
 
 /* Total number of errors in this process so far. */
 static int nGlobalErr = 0;
 
-/* Set to true to run in "process" instead of "thread" mode. */
-static int bProcessMode = 0;
-
 struct Error {
   int rc;
   int iLine;
   char *zErr;
 };
 
 struct Sqlite {
   sqlite3 *db;                    /* Database handle */
   Statement *pCache;              /* Linked list of cached statements */
   int nText;                      /* Size of array at aText[] */
   char **aText;                   /* Stored text results */
 };
 
 struct Statement {
   sqlite3_stmt *pStmt;            /* Pre-compiled statement handle */
   Statement *pNext;               /* Next statement in linked-list */
 };
 
 struct Thread {
   int iTid;                       /* Thread number within test */
-  int iArg;                       /* Integer argument passed by caller */
+  void* pArg;                     /* Pointer argument passed by caller */
 
   pthread_t tid;                  /* Thread id */
-  char *(*xProc)(int, int);       /* Thread main proc */
+  char *(*xProc)(int, void*);     /* Thread main proc */
   Thread *pNext;                  /* Next in this list of threads */
 };
 
 struct Threadset {
   int iMaxTid;                    /* Largest iTid value allocated so far */
   Thread *pThread;                /* Linked list of threads */
 };
 
 static void free_err(Error *p){
   sqlite3_free(p->zErr);
   p->zErr = 0;
   p->rc = 0;
 }
 
 static void print_err(Error *p){
   if( p->rc!=SQLITE_OK ){
-    printf("Error: (%d) \"%s\" at line %d\n", p->rc, p->zErr, p->iLine);
-    nGlobalErr++;
+    int isWarn = 0;
+    if( p->rc==SQLITE_SCHEMA ) isWarn = 1;
+    if( sqlite3_strglob("* - no such table: *",p->zErr)==0 ) isWarn = 1;
+    printf("%s: (%d) \"%s\" at line %d\n", isWarn ? "Warning" : "Error",
+            p->rc, p->zErr, p->iLine);
+    if( !isWarn ) nGlobalErr++;
+    fflush(stdout);
   }
 }
 
 static void print_and_free_err(Error *p){
   print_err(p);
   free_err(p);
 }
 
 static void system_error(Error *pErr, int iSys){
   pErr->rc = iSys;
@@ skipping 43 matching lines @@
 }
 
 static void opendb_x(
   Error *pErr,                    /* IN/OUT: Error code */
   Sqlite *pDb,                    /* OUT: Database handle */
   const char *zFile,              /* Database file name */
   int bDelete                     /* True to delete db file before opening */
 ){
   if( pErr->rc==SQLITE_OK ){
     int rc;
+    int flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE | SQLITE_OPEN_URI;
     if( bDelete ) unlink(zFile);
-    rc = sqlite3_open(zFile, &pDb->db);
+    rc = sqlite3_open_v2(zFile, &pDb->db, flags, 0);
     if( rc ){
       sqlite_error(pErr, pDb, "open");
       sqlite3_close(pDb->db);
       pDb->db = 0;
     }else{
       sqlite3_create_function(
           pDb->db, "md5sum", -1, SQLITE_UTF8, 0, 0, md5step, md5finalize
       );
       sqlite3_busy_handler(pDb->db, busyhandler, 0);
       sqlite3_exec(pDb->db, "PRAGMA synchronous=OFF", 0, 0, 0);
@@ skipping 28 matching lines @@
 static void sql_script_x(
   Error *pErr,                    /* IN/OUT: Error code */
   Sqlite *pDb,                    /* Database handle */
   const char *zSql                /* SQL script to execute */
 ){
   if( pErr->rc==SQLITE_OK ){
     pErr->rc = sqlite3_exec(pDb->db, zSql, 0, 0, &pErr->zErr);
   }
 }
 
+static void sql_script_printf_x(
+  Error *pErr,                    /* IN/OUT: Error code */
+  Sqlite *pDb,                    /* Database handle */
+  const char *zFormat,            /* SQL printf format string */
+  ...                             /* Printf args */
+){
+  va_list ap;                     /* ... printf arguments */
+  va_start(ap, zFormat);
+  if( pErr->rc==SQLITE_OK ){
+    char *zSql = sqlite3_vmprintf(zFormat, ap);
+    pErr->rc = sqlite3_exec(pDb->db, zSql, 0, 0, &pErr->zErr);
+    sqlite3_free(zSql);
+  }
+  va_end(ap);
+}
+
 static Statement *getSqlStatement(
   Error *pErr,                    /* IN/OUT: Error code */
   Sqlite *pDb,                    /* Database handle */
   const char *zSql                /* SQL statement */
 ){
   Statement *pRet;
   int rc;
 
   for(pRet=pDb->pCache; pRet; pRet=pRet->pNext){
     if( 0==strcmp(sqlite3_sql(pRet->pStmt), zSql) ){
@@ skipping 48 matching lines @@
 
 static i64 execsql_i64_x(
   Error *pErr,                    /* IN/OUT: Error code */
   Sqlite *pDb,                    /* Database handle */
   ...                             /* SQL and pointers to parameter values */
 ){
   i64 iRet = 0;
   if( pErr->rc==SQLITE_OK ){
     sqlite3_stmt *pStmt;          /* SQL statement to execute */
     va_list ap;                   /* ... arguments */
-    int i;                        /* Used to iterate through parameters */
     va_start(ap, pDb);
     pStmt = getAndBindSqlStatement(pErr, pDb, ap);
     if( pStmt ){
-      int rc;
       int first = 1;
       while( SQLITE_ROW==sqlite3_step(pStmt) ){
         if( first && sqlite3_column_count(pStmt)>0 ){
           iRet = sqlite3_column_int64(pStmt, 0);
         }
         first = 0;
       }
       if( SQLITE_OK!=sqlite3_reset(pStmt) ){
         sqlite_error(pErr, pDb, "reset");
       }
@@ skipping 14 matching lines @@
   if( iSlot>=pDb->nText ){
     int nByte = sizeof(char *)*(iSlot+1);
     pDb->aText = (char **)sqlite3_realloc(pDb->aText, nByte);
     memset(&pDb->aText[pDb->nText], 0, sizeof(char*)*(iSlot+1-pDb->nText));
     pDb->nText = iSlot+1;
   }
 
   if( pErr->rc==SQLITE_OK ){
     sqlite3_stmt *pStmt;          /* SQL statement to execute */
     va_list ap;                   /* ... arguments */
-    int i;                        /* Used to iterate through parameters */
     va_start(ap, iSlot);
     pStmt = getAndBindSqlStatement(pErr, pDb, ap);
     if( pStmt ){
-      int rc;
       int first = 1;
       while( SQLITE_ROW==sqlite3_step(pStmt) ){
         if( first && sqlite3_column_count(pStmt)>0 ){
           zRet = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
           sqlite3_free(pDb->aText[iSlot]);
           pDb->aText[iSlot] = zRet;
         }
         first = 0;
       }
       if( SQLITE_OK!=sqlite3_reset(pStmt) ){
         sqlite_error(pErr, pDb, "reset");
       }
     }
     va_end(ap);
   }
 
   return zRet;
 }
 
 static void integrity_check_x(
   Error *pErr,                    /* IN/OUT: Error code */
   Sqlite *pDb                     /* Database handle */
 ){
   if( pErr->rc==SQLITE_OK ){
     Statement *pStatement;        /* Statement to execute */
-    int rc;                       /* Return code */
     char *zErr = 0;               /* Integrity check error */
 
     pStatement = getSqlStatement(pErr, pDb, "PRAGMA integrity_check");
     if( pStatement ){
       sqlite3_stmt *pStmt = pStatement->pStmt;
       while( SQLITE_ROW==sqlite3_step(pStmt) ){
-        const char *z = sqlite3_column_text(pStmt, 0);
+        const char *z = (const char*)sqlite3_column_text(pStmt, 0);
         if( strcmp(z, "ok") ){
           if( zErr==0 ){
             zErr = sqlite3_mprintf("%s", z);
           }else{
             zErr = sqlite3_mprintf("%z\n%s", zErr, z);
           }
         }
       }
       sqlite3_reset(pStmt);
 
       if( zErr ){
         pErr->zErr = zErr;
         pErr->rc = 1;
       }
     }
   }
 }
 
 static void *launch_thread_main(void *pArg){
   Thread *p = (Thread *)pArg;
-  return (void *)p->xProc(p->iTid, p->iArg);
+  return (void *)p->xProc(p->iTid, p->pArg);
 }
 
 static void launch_thread_x(
   Error *pErr,                    /* IN/OUT: Error code */
   Threadset *pThreads,            /* Thread set */
-  char *(*xProc)(int, int),       /* Proc to run */
-  int iArg                        /* Argument passed to thread proc */
+  char *(*xProc)(int, void*),     /* Proc to run */
+  void *pArg                      /* Argument passed to thread proc */
 ){
   if( pErr->rc==SQLITE_OK ){
     int iTid = ++pThreads->iMaxTid;
     Thread *p;
     int rc;
 
     p = (Thread *)sqlite3_malloc(sizeof(Thread));
     memset(p, 0, sizeof(Thread));
     p->iTid = iTid;
-    p->iArg = iArg;
+    p->pArg = pArg;
     p->xProc = xProc;
 
     rc = pthread_create(&p->tid, NULL, launch_thread_main, (void *)p);
     if( rc!=0 ){
       system_error(pErr, rc);
       sqlite3_free(p);
     }else{
       p->pNext = pThreads->pThread;
       pThreads->pThread = p;
     }
   }
 }
 
 static void join_all_threads_x(
   Error *pErr,                    /* IN/OUT: Error code */
   Threadset *pThreads             /* Thread set */
 ){
   Thread *p;
   Thread *pNext;
   for(p=pThreads->pThread; p; p=pNext){
     void *ret;
     pNext = p->pNext;
     int rc;
     rc = pthread_join(p->tid, &ret);
     if( rc!=0 ){
       if( pErr->rc==SQLITE_OK ) system_error(pErr, rc);
     }else{
       printf("Thread %d says: %s\n", p->iTid, (ret==0 ? "..." : (char *)ret));
+      fflush(stdout);
     }
     sqlite3_free(p);
   }
   pThreads->pThread = 0;
 }
 
 static i64 filesize_x(
   Error *pErr,
   const char *zFile
 ){
@@ skipping 57 matching lines @@
       close(fd1);
       close(fd2);
     }
   }
 }
 
 /* 
 ** Used by setstoptime() and timetostop().
 */
 static double timelimit = 0.0;
-static sqlite3_vfs *pTimelimitVfs = 0;
+
+static double currentTime(void){
+  double t;
+  static sqlite3_vfs *pTimelimitVfs = 0;
+  if( pTimelimitVfs==0 ) pTimelimitVfs = sqlite3_vfs_find(0);
+  if( pTimelimitVfs->iVersion>=1 && pTimelimitVfs->xCurrentTimeInt64!=0 ){
+    sqlite3_int64 tm;
+    pTimelimitVfs->xCurrentTimeInt64(pTimelimitVfs, &tm);
+    t = tm/86400000.0;
+  }else{
+    pTimelimitVfs->xCurrentTime(pTimelimitVfs, &t);
+  }
+  return t;
+}
 
 static void setstoptime_x(
   Error *pErr,                    /* IN/OUT: Error code */
   int nMs                         /* Milliseconds until "stop time" */
 ){
   if( pErr->rc==SQLITE_OK ){
-    double t;
-    int rc;
-    pTimelimitVfs = sqlite3_vfs_find(0);
-    rc = pTimelimitVfs->xCurrentTime(pTimelimitVfs, &t);
-    if( rc!=SQLITE_OK ){
-      pErr->rc = rc;
-    }else{
-      timelimit = t + ((double)nMs)/(1000.0*60.0*60.0*24.0);
-    }
+    double t = currentTime();
+    timelimit = t + ((double)nMs)/(1000.0*60.0*60.0*24.0);
   }
 }
 
 static int timetostop_x(
   Error *pErr                     /* IN/OUT: Error code */
 ){
   int ret = 1;
   if( pErr->rc==SQLITE_OK ){
-    double t;
-    int rc;
-    rc = pTimelimitVfs->xCurrentTime(pTimelimitVfs, &t);
-    if( rc!=SQLITE_OK ){
-      pErr->rc = rc;
-    }else{
-      ret = (t >= timelimit);
-    }
+    double t = currentTime();
+    ret = (t >= timelimit);
   }
   return ret;
 }
 
-/* 
-** The "Set Error Line" macro.
-*/
-#define SEL(e) ((e)->iLine = ((e)->rc ? (e)->iLine : __LINE__))
-
 
 /*************************************************************************
 **************************************************************************
 **************************************************************************
 ** End infrastructure. Begin tests.
 */
 
 #define WALTHREAD1_NTHREAD  10
 #define WALTHREAD3_NTHREAD  6
 
-static char *walthread1_thread(int iTid, int iArg){
+static char *walthread1_thread(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
   int nIter = 0;                  /* Iterations so far */
 
   opendb(&err, &db, "test.db", 0);
   while( !timetostop(&err) ){
     const char *azSql[] = {
       "SELECT md5sum(x) FROM t1 WHERE rowid != (SELECT max(rowid) FROM t1)",
       "SELECT x FROM t1 WHERE rowid = (SELECT max(rowid) FROM t1)",
     };
@@ skipping 18 matching lines @@
         "COMMIT;"
     );
     nIter++;
   }
   closedb(&err, &db);
 
   print_and_free_err(&err);
   return sqlite3_mprintf("%d iterations", nIter);
 }
 
-static char *walthread1_ckpt_thread(int iTid, int iArg){
+static char *walthread1_ckpt_thread(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
   int nCkpt = 0;                  /* Checkpoints so far */
 
   opendb(&err, &db, "test.db", 0);
   while( !timetostop(&err) ){
     usleep(500*1000);
     execsql(&err, &db, "PRAGMA wal_checkpoint");
     if( err.rc==SQLITE_OK ) nCkpt++;
     clear_error(&err, SQLITE_BUSY);
@@ skipping 11 matching lines @@
   int i;                          /* Iterator variable */
 
   opendb(&err, &db, "test.db", 1);
   sql_script(&err, &db,
       "PRAGMA journal_mode = WAL;"
       "CREATE TABLE t1(x PRIMARY KEY);"
       "INSERT INTO t1 VALUES(randomblob(100));"
       "INSERT INTO t1 VALUES(randomblob(100));"
       "INSERT INTO t1 SELECT md5sum(x) FROM t1;"
   );
+  closedb(&err, &db);
 
   setstoptime(&err, nMs);
   for(i=0; i<WALTHREAD1_NTHREAD; i++){
     launch_thread(&err, &threads, walthread1_thread, 0);
   }
   launch_thread(&err, &threads, walthread1_ckpt_thread, 0);
   join_all_threads(&err, &threads);
 
   print_and_free_err(&err);
 }
 
-static char *walthread2_thread(int iTid, int iArg){
+static char *walthread2_thread(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
   int anTrans[2] = {0, 0};        /* Number of WAL and Rollback transactions */
+  int iArg = PTR2INT(pArg);
 
   const char *zJournal = "PRAGMA journal_mode = WAL";
   if( iArg ){ zJournal = "PRAGMA journal_mode = DELETE"; }
 
   while( !timetostop(&err) ){
     int journal_exists = 0;
     int wal_exists = 0;
 
     opendb(&err, &db, "test.db", 0);
 
@@ skipping 25 matching lines @@
   Sqlite db = {0};
   Threadset threads = {0};
 
   opendb(&err, &db, "test.db", 1);
   sql_script(&err, &db, "CREATE TABLE t1(x INTEGER PRIMARY KEY, y UNIQUE)");
   closedb(&err, &db);
 
   setstoptime(&err, nMs);
   launch_thread(&err, &threads, walthread2_thread, 0);
   launch_thread(&err, &threads, walthread2_thread, 0);
-  launch_thread(&err, &threads, walthread2_thread, 1);
-  launch_thread(&err, &threads, walthread2_thread, 1);
+  launch_thread(&err, &threads, walthread2_thread, (void*)1);
+  launch_thread(&err, &threads, walthread2_thread, (void*)1);
   join_all_threads(&err, &threads);
 
   print_and_free_err(&err);
 }
 
-static char *walthread3_thread(int iTid, int iArg){
+static char *walthread3_thread(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
   i64 iNextWrite;                 /* Next value this thread will write */
+  int iArg = PTR2INT(pArg);
 
   opendb(&err, &db, "test.db", 0);
   sql_script(&err, &db, "PRAGMA wal_autocheckpoint = 10");
 
   iNextWrite = iArg+1;
   while( 1 ){
     i64 sum1;
     i64 sum2;
     int stop = 0;                 /* True to stop executing (test timed out) */
 
@@ skipping 30 matching lines @@
       "PRAGMA journal_mode = WAL;"
       "CREATE TABLE t1(cnt PRIMARY KEY, sum1, sum2);"
       "CREATE INDEX i1 ON t1(sum1);"
       "CREATE INDEX i2 ON t1(sum2);"
       "INSERT INTO t1 VALUES(0, 0, 0);"
   );
   closedb(&err, &db);
 
   setstoptime(&err, nMs);
   for(i=0; i<WALTHREAD3_NTHREAD; i++){
-    launch_thread(&err, &threads, walthread3_thread, i);
+    launch_thread(&err, &threads, walthread3_thread, INT2PTR(i));
   }
   join_all_threads(&err, &threads);
 
   print_and_free_err(&err);
 }
 
-static char *walthread4_reader_thread(int iTid, int iArg){
+static char *walthread4_reader_thread(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
 
   opendb(&err, &db, "test.db", 0);
   while( !timetostop(&err) ){
     integrity_check(&err, &db);
   }
   closedb(&err, &db);
 
   print_and_free_err(&err);
   return 0;
 }
 
-static char *walthread4_writer_thread(int iTid, int iArg){
+static char *walthread4_writer_thread(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
   i64 iRow = 1;
 
   opendb(&err, &db, "test.db", 0);
   sql_script(&err, &db, "PRAGMA wal_autocheckpoint = 15;");
   while( !timetostop(&err) ){
     execsql_i64(
         &err, &db, "REPLACE INTO t1 VALUES(:iRow, randomblob(300))", &iRow
     );
@@ skipping 19 matching lines @@
   closedb(&err, &db);
 
   setstoptime(&err, nMs);
   launch_thread(&err, &threads, walthread4_reader_thread, 0);
   launch_thread(&err, &threads, walthread4_writer_thread, 0);
   join_all_threads(&err, &threads);
 
   print_and_free_err(&err);
 }
 
-static char *walthread5_thread(int iTid, int iArg){
+static char *walthread5_thread(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
   i64 nRow;
 
   opendb(&err, &db, "test.db", 0);
   nRow = execsql_i64(&err, &db, "SELECT count(*) FROM t1");
   closedb(&err, &db);
 
   if( nRow!=65536 ) test_error(&err, "Bad row count: %d", (int)nRow);
   print_and_free_err(&err);
@@ skipping 111 matching lines @@
 }
 
 /*------------------------------------------------------------------------
 ** Test case "dynamic_triggers"
 **
 **   Two threads executing statements that cause deeply nested triggers
 **   to fire. And one thread busily creating and deleting triggers. This
 **   is an attempt to find a bug reported to us.
 */
 
-static char *dynamic_triggers_1(int iTid, int iArg){
+static char *dynamic_triggers_1(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
   int nDrop = 0;
   int nCreate = 0;
 
   opendb(&err, &db, "test.db", 0);
   while( !timetostop(&err) ){
     int i;
 
     for(i=1; i<9; i++){
@@ skipping 25 matching lines @@
       nDrop++;
     }
 
     for(i=1; i<9; i++){
       char *zSql = sqlite3_mprintf("DROP TRIGGER dtr%d", i);
       execsql(&err, &db, zSql);
       sqlite3_free(zSql);
       nDrop++;
     }
   }
+  closedb(&err, &db);
 
   print_and_free_err(&err);
   return sqlite3_mprintf("%d created, %d dropped", nCreate, nDrop);
 }
 
-static char *dynamic_triggers_2(int iTid, int iArg){
+static char *dynamic_triggers_2(int iTid, void *pArg){
   Error err = {0};                /* Error code and message */
   Sqlite db = {0};                /* SQLite database connection */
   i64 iVal = 0;
   int nInsert = 0;
   int nDelete = 0;
 
   opendb(&err, &db, "test.db", 0);
   while( !timetostop(&err) ){
     do {
       iVal = (iVal+1)%100;
       execsql(&err, &db, "INSERT INTO t1 VALUES(:iX, :iY+1)", &iVal, &iVal);
       nInsert++;
     } while( iVal );
 
     do {
       iVal = (iVal+1)%100;
       execsql(&err, &db, "DELETE FROM t1 WHERE x = :iX", &iVal);
       nDelete++;
     } while( iVal );
   }
+  closedb(&err, &db);
 
   print_and_free_err(&err);
   return sqlite3_mprintf("%d inserts, %d deletes", nInsert, nDelete);
 }
 
 static void dynamic_triggers(int nMs){
   Error err = {0};
   Sqlite db = {0};
   Threadset threads = {0};
 
   opendb(&err, &db, "test.db", 1);
   sql_script(&err, &db, 
       "PRAGMA page_size = 1024;"
       "PRAGMA journal_mode = WAL;"
       "CREATE TABLE t1(x, y);"
       "CREATE TABLE t2(x, y);"
       "CREATE TABLE t3(x, y);"
       "CREATE TABLE t4(x, y);"
       "CREATE TABLE t5(x, y);"
       "CREATE TABLE t6(x, y);"
       "CREATE TABLE t7(x, y);"
       "CREATE TABLE t8(x, y);"
       "CREATE TABLE t9(x, y);"
   );
+  closedb(&err, &db);
 
   setstoptime(&err, nMs);
 
   sqlite3_enable_shared_cache(1);
   launch_thread(&err, &threads, dynamic_triggers_2, 0);
   launch_thread(&err, &threads, dynamic_triggers_2, 0);
-  sqlite3_enable_shared_cache(0);
 
   sleep(2);
+  sqlite3_enable_shared_cache(0);
 
   launch_thread(&err, &threads, dynamic_triggers_2, 0);
   launch_thread(&err, &threads, dynamic_triggers_1, 0);
 
   join_all_threads(&err, &threads);
 
   print_and_free_err(&err);
 }
 
 
 
 #include "tt3_checkpoint.c"
 #include "tt3_index.c"
+#include "tt3_lookaside1.c"
+#include "tt3_vacuum.c"
+#include "tt3_stress.c"
 
 int main(int argc, char **argv){
   struct ThreadTest {
-    void (*xTest)(int);
-    const char *zTest;
-    int nMs;
+    void (*xTest)(int);   /* Routine for running this test */
+    const char *zTest;    /* Name of this test */
+    int nMs;              /* How long to run this test, in milliseconds */
   } aTest[] = {
     { walthread1, "walthread1", 20000 },
     { walthread2, "walthread2", 20000 },
     { walthread3, "walthread3", 20000 },
     { walthread4, "walthread4", 20000 },
     { walthread5, "walthread5",  1000 },
-    { walthread5, "walthread5",  1000 },
     
     { cgt_pager_1,      "cgt_pager_1", 0 },
     { dynamic_triggers, "dynamic_triggers", 20000 },
 
     { checkpoint_starvation_1, "checkpoint_starvation_1", 10000 },
     { checkpoint_starvation_2, "checkpoint_starvation_2", 10000 },
 
     { create_drop_index_1, "create_drop_index_1", 10000 },
+    { lookaside1,          "lookaside1", 10000 },
+    { vacuum1,             "vacuum1", 10000 },
+    { stress1,             "stress1", 10000 },
+    { stress2,             "stress2", 60000 },
   };
+  static char *substArgv[] = { 0, "*", 0 };
+  int i, iArg;
+  int nTestfound = 0;
 
-  int i;
-  char *zTest = 0;
-  int nTest = 0;
-  int bTestfound = 0;
-  int bPrefix = 0;
+  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
+  if( argc<2 ){
+    argc = 2;
+    argv = substArgv;
+  }
 
-  if( argc>2 ) goto usage;
-  if( argc==2 ){
-    zTest = argv[1];
-    nTest = strlen(zTest);
-    if( zTest[nTest-1]=='*' ){
-      nTest--;
-      bPrefix = 1;
+  /* Loop through the command-line arguments to ensure that each argument
+  ** selects at least one test. If not, assume there is a typo on the 
+  ** command-line and bail out with the usage message.  */
+  for(iArg=1; iArg<argc; iArg++){
+    const char *zArg = argv[iArg];
+    if( zArg[0]=='-' ){
+      if( sqlite3_stricmp(zArg, "-multiplexor")==0 ){
+        /* Install the multiplexor VFS as the default */
+        int rc = sqlite3_multiplex_initialize(0, 1);
+        if( rc!=SQLITE_OK ){
+          fprintf(stderr, "Failed to install multiplexor VFS (%d)\n", rc);
+          return 253;
+        }
+      }
+      else {
+        goto usage;
+      }
+
+      continue;
+    }
+
+    for(i=0; i<sizeof(aTest)/sizeof(aTest[0]); i++){
+      if( sqlite3_strglob(zArg, aTest[i].zTest)==0 ) break;
+    }
+    if( i>=sizeof(aTest)/sizeof(aTest[0]) ) goto usage;   
+  }
+
+  for(iArg=1; iArg<argc; iArg++){
+    if( argv[iArg][0]=='-' ) continue;
+    for(i=0; i<sizeof(aTest)/sizeof(aTest[0]); i++){
+      char const *z = aTest[i].zTest;
+      if( sqlite3_strglob(argv[iArg],z)==0 ){
+        printf("Running %s for %d seconds...\n", z, aTest[i].nMs/1000);
+        fflush(stdout);
+        aTest[i].xTest(aTest[i].nMs);
+        nTestfound++;
+      }
     }
   }
+  if( nTestfound==0 ) goto usage;
 
-  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
-
-  for(i=0; i<sizeof(aTest)/sizeof(aTest[0]); i++){
-    char const *z = aTest[i].zTest;
-    int n = strlen(z);
-    if( !zTest || ((bPrefix || n==nTest) && 0==strncmp(zTest, z, nTest)) ){
-      printf("Running %s for %d seconds...\n", z, aTest[i].nMs/1000);
-      aTest[i].xTest(aTest[i].nMs);
-      bTestfound++;
-    }
-  }
-  if( bTestfound==0 ) goto usage;
-
-  printf("Total of %d errors across all tests\n", nGlobalErr);
+  printf("%d errors out of %d tests\n", nGlobalErr, nTestfound);
   return (nGlobalErr>0 ? 255 : 0);
 
  usage:
-  printf("Usage: %s [testname|testprefix*]\n", argv[0]);
+  printf("Usage: %s [-multiplexor] [testname|testprefix*]...\n", argv[0]);
   printf("Available tests are:\n");
   for(i=0; i<sizeof(aTest)/sizeof(aTest[0]); i++){
     printf("   %s\n", aTest[i].zTest);
   }
 
   return 254;
 }
-
-