Adding upstream version 3.40.1.upstream/3.40.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1470 insertions, 0 deletions

diff --git a/mptest/mptest.c b/mptest/mptest.c
new file mode 100644
index 0000000..5022b00
--- /dev/null
+++ b/mptest/mptest.c
@@ -0,0 +1,1470 @@
+/*
+** 2013-04-05
+**
+** 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.
+**
+*************************************************************************
+** 
+** This is a program used for testing SQLite, and specifically for testing
+** the ability of independent processes to access the same SQLite database
+** concurrently.
+**
+** Compile this program as follows:
+**
+**    gcc -g -c -Wall sqlite3.c $(OPTS)
+**    gcc -g -o mptest mptest.c sqlite3.o $(LIBS)
+**
+** Recommended options:
+**
+**    -DHAVE_USLEEP
+**    -DSQLITE_NO_SYNC
+**    -DSQLITE_THREADSAFE=0
+**    -DSQLITE_OMIT_LOAD_EXTENSION
+**
+** Run like this:
+**
+**     ./mptest $database $script
+**
+** where $database is the database to use for testing and $script is a
+** test script.
+*/
+#include "sqlite3.h"
+#include <stdio.h>
+#if defined(_WIN32)
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+#else
+# include <unistd.h>
+#endif
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+
+#define ISSPACE(X) isspace((unsigned char)(X))
+#define ISDIGIT(X) isdigit((unsigned char)(X))
+
+/* The suffix to append to the child command lines, if any */
+#if defined(_WIN32)
+# define GETPID (int)GetCurrentProcessId
+#else
+# define GETPID getpid
+#endif
+
+/* The directory separator character(s) */
+#if defined(_WIN32)
+# define isDirSep(c) (((c) == '/') || ((c) == '\\'))
+#else
+# define isDirSep(c) ((c) == '/')
+#endif
+
+/* Mark a parameter as unused to suppress compiler warnings */
+#define UNUSED_PARAMETER(x)  (void)x
+
+/* Global data
+*/
+static struct Global {
+  char *argv0;           /* Name of the executable */
+  const char *zVfs;      /* Name of VFS to use. Often NULL meaning "default" */
+  char *zDbFile;         /* Name of the database */
+  sqlite3 *db;           /* Open connection to database */
+  char *zErrLog;         /* Filename for error log */
+  FILE *pErrLog;         /* Where to write errors */
+  char *zLog;            /* Name of output log file */
+  FILE *pLog;            /* Where to write log messages */
+  char zName[32];        /* Symbolic name of this process */
+  int taskId;            /* Task ID.  0 means supervisor. */
+  int iTrace;            /* Tracing level */
+  int bSqlTrace;         /* True to trace SQL commands */
+  int bIgnoreSqlErrors;  /* Ignore errors in SQL statements */
+  int nError;            /* Number of errors */
+  int nTest;             /* Number of --match operators */
+  int iTimeout;          /* Milliseconds until a busy timeout */
+  int bSync;             /* Call fsync() */
+} g;
+
+/* Default timeout */
+#define DEFAULT_TIMEOUT 10000
+
+/*
+** Print a message adding zPrefix[] to the beginning of every line.
+*/
+static void printWithPrefix(FILE *pOut, const char *zPrefix, const char *zMsg){
+  while( zMsg && zMsg[0] ){
+    int i;
+    for(i=0; zMsg[i] && zMsg[i]!='\n' && zMsg[i]!='\r'; i++){}
+    fprintf(pOut, "%s%.*s\n", zPrefix, i, zMsg);
+    zMsg += i;
+    while( zMsg[0]=='\n' || zMsg[0]=='\r' ) zMsg++;
+  }
+}
+
+/*
+** Compare two pointers to strings, where the pointers might be NULL.
+*/
+static int safe_strcmp(const char *a, const char *b){
+  if( a==b ) return 0;
+  if( a==0 ) return -1;
+  if( b==0 ) return 1;
+  return strcmp(a,b);
+}
+
+/*
+** Return TRUE if string z[] matches glob pattern zGlob[].
+** Return FALSE if the pattern does not match.
+**
+** Globbing rules:
+**
+**      '*'       Matches any sequence of zero or more characters.
+**
+**      '?'       Matches exactly one character.
+**
+**     [...]      Matches one character from the enclosed list of
+**                characters.
+**
+**     [^...]     Matches one character not in the enclosed list.
+**
+**      '#'       Matches any sequence of one or more digits with an
+**                optional + or - sign in front
+*/
+int strglob(const char *zGlob, const char *z){
+  int c, c2;
+  int invert;
+  int seen;
+
+  while( (c = (*(zGlob++)))!=0 ){
+    if( c=='*' ){
+      while( (c=(*(zGlob++))) == '*' || c=='?' ){
+        if( c=='?' && (*(z++))==0 ) return 0;
+      }
+      if( c==0 ){
+        return 1;
+      }else if( c=='[' ){
+        while( *z && strglob(zGlob-1,z) ){
+          z++;
+        }
+        return (*z)!=0;
+      }
+      while( (c2 = (*(z++)))!=0 ){
+        while( c2!=c ){
+          c2 = *(z++);
+          if( c2==0 ) return 0;
+        }
+        if( strglob(zGlob,z) ) return 1;
+      }
+      return 0;
+    }else if( c=='?' ){
+      if( (*(z++))==0 ) return 0;
+    }else if( c=='[' ){
+      int prior_c = 0;
+      seen = 0;
+      invert = 0;
+      c = *(z++);
+      if( c==0 ) return 0;
+      c2 = *(zGlob++);
+      if( c2=='^' ){
+        invert = 1;
+        c2 = *(zGlob++);
+      }
+      if( c2==']' ){
+        if( c==']' ) seen = 1;
+        c2 = *(zGlob++);
+      }
+      while( c2 && c2!=']' ){
+        if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
+          c2 = *(zGlob++);
+          if( c>=prior_c && c<=c2 ) seen = 1;
+          prior_c = 0;
+        }else{
+          if( c==c2 ){
+            seen = 1;
+          }
+          prior_c = c2;
+        }
+        c2 = *(zGlob++);
+      }
+      if( c2==0 || (seen ^ invert)==0 ) return 0;
+    }else if( c=='#' ){
+      if( (z[0]=='-' || z[0]=='+') && ISDIGIT(z[1]) ) z++;
+      if( !ISDIGIT(z[0]) ) return 0;
+      z++;
+      while( ISDIGIT(z[0]) ){ z++; }
+    }else{
+      if( c!=(*(z++)) ) return 0;
+    }
+  }
+  return *z==0;
+}
+
+/*
+** Close output stream pOut if it is not stdout or stderr
+*/
+static void maybeClose(FILE *pOut){
+  if( pOut!=stdout && pOut!=stderr ) fclose(pOut);
+}
+
+/*
+** Print an error message
+*/
+static void errorMessage(const char *zFormat, ...){
+  va_list ap;
+  char *zMsg;
+  char zPrefix[30];
+  va_start(ap, zFormat);
+  zMsg = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:ERROR: ", g.zName);
+  if( g.pLog ){
+    printWithPrefix(g.pLog, zPrefix, zMsg);
+    fflush(g.pLog);
+  }
+  if( g.pErrLog && safe_strcmp(g.zErrLog,g.zLog) ){
+    printWithPrefix(g.pErrLog, zPrefix, zMsg);
+    fflush(g.pErrLog);
+  }
+  sqlite3_free(zMsg);
+  g.nError++;
+}
+
+/* Forward declaration */
+static int trySql(const char*, ...);
+
+/*
+** Print an error message and then quit.
+*/
+static void fatalError(const char *zFormat, ...){
+  va_list ap;
+  char *zMsg;
+  char zPrefix[30];
+  va_start(ap, zFormat);
+  zMsg = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s:FATAL: ", g.zName);
+  if( g.pLog ){
+    printWithPrefix(g.pLog, zPrefix, zMsg);
+    fflush(g.pLog);
+    maybeClose(g.pLog);
+  }
+  if( g.pErrLog && safe_strcmp(g.zErrLog,g.zLog) ){
+    printWithPrefix(g.pErrLog, zPrefix, zMsg);
+    fflush(g.pErrLog);
+    maybeClose(g.pErrLog);
+  }
+  sqlite3_free(zMsg);
+  if( g.db ){
+    int nTry = 0;
+    g.iTimeout = 0;
+    while( trySql("UPDATE client SET wantHalt=1;")==SQLITE_BUSY
+           && (nTry++)<100 ){
+      sqlite3_sleep(10);
+    }
+  }
+  sqlite3_close(g.db);
+  exit(1);  
+}
+
+
+/*
+** Print a log message
+*/
+static void logMessage(const char *zFormat, ...){
+  va_list ap;
+  char *zMsg;
+  char zPrefix[30];
+  va_start(ap, zFormat);
+  zMsg = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  sqlite3_snprintf(sizeof(zPrefix), zPrefix, "%s: ", g.zName);
+  if( g.pLog ){
+    printWithPrefix(g.pLog, zPrefix, zMsg);
+    fflush(g.pLog);
+  }
+  sqlite3_free(zMsg);
+}
+
+/*
+** Return the length of a string omitting trailing whitespace
+*/
+static int clipLength(const char *z){
+  int n = (int)strlen(z);
+  while( n>0 && ISSPACE(z[n-1]) ){ n--; }
+  return n;
+}
+
+/*
+** Auxiliary SQL function to return the name of the VFS
+*/
+static void vfsNameFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_context_db_handle(context);
+  char *zVfs = 0;
+  UNUSED_PARAMETER(argc);
+  UNUSED_PARAMETER(argv);
+  sqlite3_file_control(db, "main", SQLITE_FCNTL_VFSNAME, &zVfs);
+  if( zVfs ){
+    sqlite3_result_text(context, zVfs, -1, sqlite3_free);
+  }
+}
+
+/*
+** Busy handler with a g.iTimeout-millisecond timeout
+*/
+static int busyHandler(void *pCD, int count){
+  UNUSED_PARAMETER(pCD);
+  if( count*10>g.iTimeout ){
+    if( g.iTimeout>0 ) errorMessage("timeout after %dms", g.iTimeout);
+    return 0;
+  }
+  sqlite3_sleep(10);
+  return 1;
+}
+
+/*
+** SQL Trace callback
+*/
+static void sqlTraceCallback(void *NotUsed1, const char *zSql){
+  UNUSED_PARAMETER(NotUsed1);
+  logMessage("[%.*s]", clipLength(zSql), zSql);
+}
+
+/*
+** SQL error log callback
+*/
+static void sqlErrorCallback(void *pArg, int iErrCode, const char *zMsg){
+  UNUSED_PARAMETER(pArg);
+  if( iErrCode==SQLITE_ERROR && g.bIgnoreSqlErrors ) return;
+  if( (iErrCode&0xff)==SQLITE_SCHEMA && g.iTrace<3 ) return;
+  if( g.iTimeout==0 && (iErrCode&0xff)==SQLITE_BUSY && g.iTrace<3 ) return;
+  if( (iErrCode&0xff)==SQLITE_NOTICE ){
+    logMessage("(info) %s", zMsg);
+  }else{
+    errorMessage("(errcode=%d) %s", iErrCode, zMsg);
+  }
+}
+
+/*
+** Prepare an SQL statement.  Issue a fatal error if unable.
+*/
+static sqlite3_stmt *prepareSql(const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc;
+  sqlite3_stmt *pStmt = 0;
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  rc = sqlite3_prepare_v2(g.db, zSql, -1, &pStmt, 0);
+  if( rc!=SQLITE_OK ){
+    sqlite3_finalize(pStmt);
+    fatalError("%s\n%s\n", sqlite3_errmsg(g.db), zSql);
+  }
+  sqlite3_free(zSql);
+  return pStmt;
+}
+
+/*
+** Run arbitrary SQL.  Issue a fatal error on failure.
+*/
+static void runSql(const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc;
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  rc = sqlite3_exec(g.db, zSql, 0, 0, 0);
+  if( rc!=SQLITE_OK ){
+    fatalError("%s\n%s\n", sqlite3_errmsg(g.db), zSql);
+  }
+  sqlite3_free(zSql);
+}
+
+/*
+** Try to run arbitrary SQL.  Return success code.
+*/
+static int trySql(const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc;
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  rc = sqlite3_exec(g.db, zSql, 0, 0, 0);
+  sqlite3_free(zSql);
+  return rc;
+}
+
+/* Structure for holding an arbitrary length string
+*/
+typedef struct String String;
+struct String {
+  char *z;         /* the string */
+  int n;           /* Slots of z[] used */
+  int nAlloc;      /* Slots of z[] allocated */
+};
+
+/* Free a string */
+static void stringFree(String *p){
+  if( p->z ) sqlite3_free(p->z);
+  memset(p, 0, sizeof(*p));
+}
+
+/* Append n bytes of text to a string.  If n<0 append the entire string. */
+static void stringAppend(String *p, const char *z, int n){
+  if( n<0 ) n = (int)strlen(z);
+  if( p->n+n>=p->nAlloc ){
+    int nAlloc = p->nAlloc*2 + n + 100;
+    char *zNew = sqlite3_realloc(p->z, nAlloc);
+    if( zNew==0 ) fatalError("out of memory");
+    p->z = zNew;
+    p->nAlloc = nAlloc;
+  }
+  memcpy(p->z+p->n, z, n);
+  p->n += n;
+  p->z[p->n] = 0;
+}
+
+/* Reset a string to an empty string */
+static void stringReset(String *p){
+  if( p->z==0 ) stringAppend(p, " ", 1);
+  p->n = 0;
+  p->z[0] = 0;
+}
+
+/* Append a new token onto the end of the string */
+static void stringAppendTerm(String *p, const char *z){
+  int i;
+  if( p->n ) stringAppend(p, " ", 1);
+  if( z==0 ){
+    stringAppend(p, "nil", 3);
+    return;
+  }
+  for(i=0; z[i] && !ISSPACE(z[i]); i++){}
+  if( i>0 && z[i]==0 ){
+    stringAppend(p, z, i);
+    return;
+  }
+  stringAppend(p, "'", 1);
+  while( z[0] ){
+    for(i=0; z[i] && z[i]!='\''; i++){}
+    if( z[i] ){
+      stringAppend(p, z, i+1);
+      stringAppend(p, "'", 1);
+      z += i+1;
+    }else{
+      stringAppend(p, z, i);
+      break;
+    }
+  }
+  stringAppend(p, "'", 1);
+}
+
+/*
+** Callback function for evalSql()
+*/
+static int evalCallback(void *pCData, int argc, char **argv, char **azCol){
+  String *p = (String*)pCData;
+  int i;
+  UNUSED_PARAMETER(azCol);
+  for(i=0; i<argc; i++) stringAppendTerm(p, argv[i]);
+  return 0;
+}
+
+/*
+** Run arbitrary SQL and record the results in an output string
+** given by the first parameter.
+*/
+static int evalSql(String *p, const char *zFormat, ...){
+  va_list ap;
+  char *zSql;
+  int rc;
+  char *zErrMsg = 0;
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  assert( g.iTimeout>0 );
+  rc = sqlite3_exec(g.db, zSql, evalCallback, p, &zErrMsg);
+  sqlite3_free(zSql);
+  if( rc ){
+    char zErr[30];
+    sqlite3_snprintf(sizeof(zErr), zErr, "error(%d)", rc);
+    stringAppendTerm(p, zErr);
+    if( zErrMsg ){
+      stringAppendTerm(p, zErrMsg);
+      sqlite3_free(zErrMsg);
+    }
+  }
+  return rc;
+}
+
+/*
+** Auxiliary SQL function to recursively evaluate SQL.
+*/
+static void evalFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  sqlite3 *db = sqlite3_context_db_handle(context);
+  const char *zSql = (const char*)sqlite3_value_text(argv[0]);
+  String res;
+  char *zErrMsg = 0;
+  int rc;
+  UNUSED_PARAMETER(argc);
+  memset(&res, 0, sizeof(res));
+  rc = sqlite3_exec(db, zSql, evalCallback, &res, &zErrMsg);
+  if( zErrMsg ){
+    sqlite3_result_error(context, zErrMsg, -1);
+    sqlite3_free(zErrMsg);
+  }else if( rc ){
+    sqlite3_result_error_code(context, rc);
+  }else{
+    sqlite3_result_text(context, res.z, -1, SQLITE_TRANSIENT);
+  }
+  stringFree(&res);
+}
+
+/*
+** Look up the next task for client iClient in the database.
+** Return the task script and the task number and mark that
+** task as being under way.
+*/
+static int startScript(
+  int iClient,              /* The client number */
+  char **pzScript,          /* Write task script here */
+  int *pTaskId,             /* Write task number here */
+  char **pzTaskName         /* Name of the task */
+){
+  sqlite3_stmt *pStmt = 0;
+  int taskId;
+  int rc;
+  int totalTime = 0;
+
+  *pzScript = 0;
+  g.iTimeout = 0;
+  while(1){
+    rc = trySql("BEGIN IMMEDIATE");
+    if( rc==SQLITE_BUSY ){
+      sqlite3_sleep(10);
+      totalTime += 10;
+      continue;
+    }
+    if( rc!=SQLITE_OK ){
+      fatalError("in startScript: %s", sqlite3_errmsg(g.db));
+    }
+    if( g.nError || g.nTest ){
+      runSql("UPDATE counters SET nError=nError+%d, nTest=nTest+%d",
+             g.nError, g.nTest);
+      g.nError = 0;
+      g.nTest = 0;
+    }
+    pStmt = prepareSql("SELECT 1 FROM client WHERE id=%d AND wantHalt",iClient);
+    rc = sqlite3_step(pStmt);
+    sqlite3_finalize(pStmt);
+    if( rc==SQLITE_ROW ){
+      runSql("DELETE FROM client WHERE id=%d", iClient);
+      g.iTimeout = DEFAULT_TIMEOUT;
+      runSql("COMMIT TRANSACTION;");
+      return SQLITE_DONE;
+    }
+    pStmt = prepareSql(
+              "SELECT script, id, name FROM task"
+              " WHERE client=%d AND starttime IS NULL"
+              " ORDER BY id LIMIT 1", iClient);
+    rc = sqlite3_step(pStmt);
+    if( rc==SQLITE_ROW ){
+      int n = sqlite3_column_bytes(pStmt, 0);
+      *pzScript = sqlite3_malloc(n+1);
+      strcpy(*pzScript, (const char*)sqlite3_column_text(pStmt, 0));
+      *pTaskId = taskId = sqlite3_column_int(pStmt, 1);
+      *pzTaskName = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 2));
+      sqlite3_finalize(pStmt);
+      runSql("UPDATE task"
+             "   SET starttime=strftime('%%Y-%%m-%%d %%H:%%M:%%f','now')"
+             " WHERE id=%d;", taskId);
+      g.iTimeout = DEFAULT_TIMEOUT;
+      runSql("COMMIT TRANSACTION;");
+      return SQLITE_OK;
+    }
+    sqlite3_finalize(pStmt);
+    if( rc==SQLITE_DONE ){
+      if( totalTime>30000 ){
+        errorMessage("Waited over 30 seconds with no work.  Giving up.");
+        runSql("DELETE FROM client WHERE id=%d; COMMIT;", iClient);
+        sqlite3_close(g.db);
+        exit(1);
+      }
+      while( trySql("COMMIT")==SQLITE_BUSY ){
+        sqlite3_sleep(10);
+        totalTime += 10;
+      }
+      sqlite3_sleep(100);
+      totalTime += 100;
+      continue;
+    }
+    fatalError("%s", sqlite3_errmsg(g.db));
+  }
+  g.iTimeout = DEFAULT_TIMEOUT;
+}
+
+/*
+** Mark a script as having finished.   Remove the CLIENT table entry
+** if bShutdown is true.
+*/
+static int finishScript(int iClient, int taskId, int bShutdown){
+  runSql("UPDATE task"
+         "   SET endtime=strftime('%%Y-%%m-%%d %%H:%%M:%%f','now')"
+         " WHERE id=%d;", taskId);
+  if( bShutdown ){
+    runSql("DELETE FROM client WHERE id=%d", iClient);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** Start up a client process for iClient, if it is not already
+** running.  If the client is already running, then this routine
+** is a no-op.
+*/
+static void startClient(int iClient){
+  runSql("INSERT OR IGNORE INTO client VALUES(%d,0)", iClient);
+  if( sqlite3_changes(g.db) ){
+    char *zSys;
+    int rc;
+    zSys = sqlite3_mprintf("%s \"%s\" --client %d --trace %d",
+                 g.argv0, g.zDbFile, iClient, g.iTrace);
+    if( g.bSqlTrace ){
+      zSys = sqlite3_mprintf("%z --sqltrace", zSys);
+    }
+    if( g.bSync ){
+      zSys = sqlite3_mprintf("%z --sync", zSys);
+    }
+    if( g.zVfs ){
+      zSys = sqlite3_mprintf("%z --vfs \"%s\"", zSys, g.zVfs);
+    }
+    if( g.iTrace>=2 ) logMessage("system('%q')", zSys);
+#if !defined(_WIN32)
+    zSys = sqlite3_mprintf("%z &", zSys);
+    rc = system(zSys);
+    if( rc ) errorMessage("system() fails with error code %d", rc);
+#else
+    {
+      STARTUPINFOA startupInfo;
+      PROCESS_INFORMATION processInfo;
+      memset(&startupInfo, 0, sizeof(startupInfo));
+      startupInfo.cb = sizeof(startupInfo);
+      memset(&processInfo, 0, sizeof(processInfo));
+      rc = CreateProcessA(NULL, zSys, NULL, NULL, FALSE, 0, NULL, NULL,
+                        &startupInfo, &processInfo);
+      if( rc ){
+        CloseHandle(processInfo.hThread);
+        CloseHandle(processInfo.hProcess);
+      }else{
+        errorMessage("CreateProcessA() fails with error code %lu",
+                     GetLastError());
+      }
+    }
+#endif
+    sqlite3_free(zSys);
+  }
+}
+
+/*
+** Read the entire content of a file into memory
+*/
+static char *readFile(const char *zFilename){
+  FILE *in = fopen(zFilename, "rb");
+  long sz;
+  char *z;
+  if( in==0 ){
+    fatalError("cannot open \"%s\" for reading", zFilename);
+  }
+  fseek(in, 0, SEEK_END);
+  sz = ftell(in);
+  rewind(in);
+  z = sqlite3_malloc( sz+1 );
+  sz = (long)fread(z, 1, sz, in);
+  z[sz] = 0;
+  fclose(in);
+  return z;
+}
+
+/*
+** Return the length of the next token.
+*/
+static int tokenLength(const char *z, int *pnLine){
+  int n = 0;
+  if( ISSPACE(z[0]) || (z[0]=='/' && z[1]=='*') ){
+    int inC = 0;
+    int c;
+    if( z[0]=='/' ){
+      inC = 1;
+      n = 2;
+    }
+    while( (c = z[n++])!=0 ){
+      if( c=='\n' ) (*pnLine)++;
+      if( ISSPACE(c) ) continue;
+      if( inC && c=='*' && z[n]=='/' ){
+        n++;
+        inC = 0;
+      }else if( !inC && c=='/' && z[n]=='*' ){
+        n++;
+        inC = 1;
+      }else if( !inC ){
+        break;
+      }
+    }
+    n--;
+  }else if( z[0]=='-' && z[1]=='-' ){
+    for(n=2; z[n] && z[n]!='\n'; n++){}
+    if( z[n] ){ (*pnLine)++; n++; }
+  }else if( z[0]=='"' || z[0]=='\'' ){
+    int delim = z[0];
+    for(n=1; z[n]; n++){
+      if( z[n]=='\n' ) (*pnLine)++;
+      if( z[n]==delim ){
+        n++;
+        if( z[n+1]!=delim ) break;
+      }
+    }
+  }else{
+    int c;
+    for(n=1; (c = z[n])!=0 && !ISSPACE(c) && c!='"' && c!='\'' && c!=';'; n++){}
+  }
+  return n;
+}
+
+/*
+** Copy a single token into a string buffer.
+*/
+static int extractToken(const char *zIn, int nIn, char *zOut, int nOut){
+  int i;
+  if( nIn<=0 ){
+    zOut[0] = 0;
+    return 0;
+  }
+  for(i=0; i<nIn && i<nOut-1 && !ISSPACE(zIn[i]); i++){ zOut[i] = zIn[i]; }
+  zOut[i] = 0;
+  return i;
+}
+
+/*
+** Find the number of characters up to the start of the next "--end" token.
+*/
+static int findEnd(const char *z, int *pnLine){
+  int n = 0;
+  while( z[n] && (strncmp(z+n,"--end",5) || !ISSPACE(z[n+5])) ){
+    n += tokenLength(z+n, pnLine);
+  }
+  return n;
+}
+
+/*
+** Find the number of characters up to the first character past the
+** of the next "--endif"  or "--else" token. Nested --if commands are
+** also skipped.
+*/
+static int findEndif(const char *z, int stopAtElse, int *pnLine){
+  int n = 0;
+  while( z[n] ){
+    int len = tokenLength(z+n, pnLine);
+    if( (strncmp(z+n,"--endif",7)==0 && ISSPACE(z[n+7]))
+     || (stopAtElse && strncmp(z+n,"--else",6)==0 && ISSPACE(z[n+6]))
+    ){
+      return n+len;
+    }
+    if( strncmp(z+n,"--if",4)==0 && ISSPACE(z[n+4]) ){
+      int skip = findEndif(z+n+len, 0, pnLine);
+      n += skip + len;
+    }else{
+      n += len;
+    }
+  }
+  return n;
+}
+
+/*
+** Wait for a client process to complete all its tasks
+*/
+static void waitForClient(int iClient, int iTimeout, char *zErrPrefix){
+  sqlite3_stmt *pStmt;
+  int rc;
+  if( iClient>0 ){
+    pStmt = prepareSql(
+               "SELECT 1 FROM task"
+               " WHERE client=%d"
+               "   AND client IN (SELECT id FROM client)"
+               "  AND endtime IS NULL",
+               iClient);
+  }else{
+    pStmt = prepareSql(
+               "SELECT 1 FROM task"
+               " WHERE client IN (SELECT id FROM client)"
+               "   AND endtime IS NULL");
+  }
+  g.iTimeout = 0;
+  while( ((rc = sqlite3_step(pStmt))==SQLITE_BUSY || rc==SQLITE_ROW)
+    && iTimeout>0
+  ){
+    sqlite3_reset(pStmt);
+    sqlite3_sleep(50);
+    iTimeout -= 50;
+  }
+  sqlite3_finalize(pStmt);
+  g.iTimeout = DEFAULT_TIMEOUT;
+  if( rc!=SQLITE_DONE ){
+    if( zErrPrefix==0 ) zErrPrefix = "";
+    if( iClient>0 ){
+      errorMessage("%stimeout waiting for client %d", zErrPrefix, iClient);
+    }else{
+      errorMessage("%stimeout waiting for all clients", zErrPrefix);
+    }
+  }
+}
+
+/* Return a pointer to the tail of a filename
+*/
+static char *filenameTail(char *z){
+  int i, j;
+  for(i=j=0; z[i]; i++) if( isDirSep(z[i]) ) j = i+1;
+  return z+j;
+}
+
+/*
+** Interpret zArg as a boolean value.  Return either 0 or 1.
+*/
+static int booleanValue(char *zArg){
+  int i;
+  if( zArg==0 ) return 0;
+  for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
+  if( i>0 && zArg[i]==0 ) return atoi(zArg);
+  if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
+    return 1;
+  }
+  if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
+    return 0;
+  }
+  errorMessage("unknown boolean: [%s]", zArg);
+  return 0;
+}
+
+
+/* This routine exists as a convenient place to set a debugger
+** breakpoint.
+*/
+static void test_breakpoint(void){ static volatile int cnt = 0; cnt++; }
+
+/* Maximum number of arguments to a --command */
+#define MX_ARG 2
+
+/*
+** Run a script.
+*/
+static void runScript(
+  int iClient,       /* The client number, or 0 for the master */
+  int taskId,        /* The task ID for clients.  0 for master */
+  char *zScript,     /* Text of the script */
+  char *zFilename    /* File from which script was read. */
+){
+  int lineno = 1;
+  int prevLine = 1;
+  int ii = 0;
+  int iBegin = 0;
+  int n, c, j;
+  int len;
+  int nArg;
+  String sResult;
+  char zCmd[30];
+  char zError[1000];
+  char azArg[MX_ARG][100];
+
+  memset(&sResult, 0, sizeof(sResult));
+  stringReset(&sResult);
+  while( (c = zScript[ii])!=0 ){
+    prevLine = lineno;
+    len = tokenLength(zScript+ii, &lineno);
+    if( ISSPACE(c) || (c=='/' && zScript[ii+1]=='*') ){
+      ii += len;
+      continue;
+    }
+    if( c!='-' || zScript[ii+1]!='-' || !isalpha(zScript[ii+2]) ){
+      ii += len;
+      continue;
+    }
+
+    /* Run any prior SQL before processing the new --command */
+    if( ii>iBegin ){
+      char *zSql = sqlite3_mprintf("%.*s", ii-iBegin, zScript+iBegin);
+      evalSql(&sResult, zSql);
+      sqlite3_free(zSql);
+      iBegin = ii + len;
+    }
+
+    /* Parse the --command */
+    if( g.iTrace>=2 ) logMessage("%.*s", len, zScript+ii);
+    n = extractToken(zScript+ii+2, len-2, zCmd, sizeof(zCmd));
+    for(nArg=0; n<len-2 && nArg<MX_ARG; nArg++){
+      while( n<len-2 && ISSPACE(zScript[ii+2+n]) ){ n++; }
+      if( n>=len-2 ) break;
+      n += extractToken(zScript+ii+2+n, len-2-n,
+                        azArg[nArg], sizeof(azArg[nArg]));
+    }
+    for(j=nArg; j<MX_ARG; j++) azArg[j++][0] = 0;
+
+    /*
+    **  --sleep N
+    **
+    ** Pause for N milliseconds
+    */
+    if( strcmp(zCmd, "sleep")==0 ){
+      sqlite3_sleep(atoi(azArg[0]));
+    }else 
+
+    /*
+    **   --exit N
+    **
+    ** Exit this process.  If N>0 then exit without shutting down
+    ** SQLite.  (In other words, simulate a crash.)
+    */
+    if( strcmp(zCmd, "exit")==0 ){
+      int rc = atoi(azArg[0]);
+      finishScript(iClient, taskId, 1);
+      if( rc==0 ) sqlite3_close(g.db);
+      exit(rc);
+    }else
+
+    /*
+    **   --testcase NAME
+    **
+    ** Begin a new test case.  Announce in the log that the test case
+    ** has begun.
+    */
+    if( strcmp(zCmd, "testcase")==0 ){
+      if( g.iTrace==1 ) logMessage("%.*s", len - 1, zScript+ii);
+      stringReset(&sResult);
+    }else
+
+    /*
+    **   --finish
+    **
+    ** Mark the current task as having finished, even if it is not.
+    ** This can be used in conjunction with --exit to simulate a crash.
+    */
+    if( strcmp(zCmd, "finish")==0 && iClient>0 ){
+      finishScript(iClient, taskId, 1);
+    }else
+
+    /*
+    **  --reset
+    **
+    ** Reset accumulated results back to an empty string
+    */
+    if( strcmp(zCmd, "reset")==0 ){
+      stringReset(&sResult);
+    }else
+
+    /*
+    **  --match ANSWER...
+    **
+    ** Check to see if output matches ANSWER.  Report an error if not.
+    */
+    if( strcmp(zCmd, "match")==0 ){
+      int jj;
+      char *zAns = zScript+ii;
+      for(jj=7; jj<len-1 && ISSPACE(zAns[jj]); jj++){}
+      zAns += jj;
+      if( len-jj-1!=sResult.n || strncmp(sResult.z, zAns, len-jj-1) ){
+        errorMessage("line %d of %s:\nExpected [%.*s]\n     Got [%s]",
+          prevLine, zFilename, len-jj-1, zAns, sResult.z);
+      }
+      g.nTest++;
+      stringReset(&sResult);
+    }else
+
+    /*
+    **  --glob ANSWER...
+    **  --notglob ANSWER....
+    **
+    ** Check to see if output does or does not match the glob pattern
+    ** ANSWER.
+    */
+    if( strcmp(zCmd, "glob")==0 || strcmp(zCmd, "notglob")==0 ){
+      int jj;
+      char *zAns = zScript+ii;
+      char *zCopy;
+      int isGlob = (zCmd[0]=='g');
+      for(jj=9-3*isGlob; jj<len-1 && ISSPACE(zAns[jj]); jj++){}
+      zAns += jj;
+      zCopy = sqlite3_mprintf("%.*s", len-jj-1, zAns);
+      if( (sqlite3_strglob(zCopy, sResult.z)==0)^isGlob ){
+        errorMessage("line %d of %s:\nExpected [%s]\n     Got [%s]",
+          prevLine, zFilename, zCopy, sResult.z);
+      }
+      sqlite3_free(zCopy);
+      g.nTest++;
+      stringReset(&sResult);
+    }else
+
+    /*
+    **  --output
+    **
+    ** Output the result of the previous SQL.
+    */
+    if( strcmp(zCmd, "output")==0 ){
+      logMessage("%s", sResult.z);
+    }else
+
+    /*
+    **  --source FILENAME
+    **
+    ** Run a subscript from a separate file.
+    */
+    if( strcmp(zCmd, "source")==0 ){
+      char *zNewFile, *zNewScript;
+      char *zToDel = 0;
+      zNewFile = azArg[0];
+      if( !isDirSep(zNewFile[0]) ){
+        int k;
+        for(k=(int)strlen(zFilename)-1; k>=0 && !isDirSep(zFilename[k]); k--){}
+        if( k>0 ){
+          zNewFile = zToDel = sqlite3_mprintf("%.*s/%s", k,zFilename,zNewFile);
+        }
+      }
+      zNewScript = readFile(zNewFile);
+      if( g.iTrace ) logMessage("begin script [%s]\n", zNewFile);
+      runScript(0, 0, zNewScript, zNewFile);
+      sqlite3_free(zNewScript);
+      if( g.iTrace ) logMessage("end script [%s]\n", zNewFile);
+      sqlite3_free(zToDel);
+    }else
+
+    /*
+    **  --print MESSAGE....
+    **
+    ** Output the remainder of the line to the log file
+    */
+    if( strcmp(zCmd, "print")==0 ){
+      int jj;
+      for(jj=7; jj<len && ISSPACE(zScript[ii+jj]); jj++){}
+      logMessage("%.*s", len-jj, zScript+ii+jj);
+    }else
+
+    /*
+    **  --if EXPR
+    **
+    ** Skip forward to the next matching --endif or --else if EXPR is false.
+    */
+    if( strcmp(zCmd, "if")==0 ){
+      int jj, rc;
+      sqlite3_stmt *pStmt;
+      for(jj=4; jj<len && ISSPACE(zScript[ii+jj]); jj++){}
+      pStmt = prepareSql("SELECT %.*s", len-jj, zScript+ii+jj);
+      rc = sqlite3_step(pStmt);
+      if( rc!=SQLITE_ROW || sqlite3_column_int(pStmt, 0)==0 ){
+        ii += findEndif(zScript+ii+len, 1, &lineno);
+      }
+      sqlite3_finalize(pStmt);
+    }else
+
+    /*
+    **  --else
+    **
+    ** This command can only be encountered if currently inside an --if that
+    ** is true.  Skip forward to the next matching --endif.
+    */
+    if( strcmp(zCmd, "else")==0 ){
+      ii += findEndif(zScript+ii+len, 0, &lineno);
+    }else
+
+    /*
+    **  --endif
+    **
+    ** This command can only be encountered if currently inside an --if that
+    ** is true or an --else of a false if.  This is a no-op.
+    */
+    if( strcmp(zCmd, "endif")==0 ){
+      /* no-op */
+    }else
+
+    /*
+    **  --start CLIENT
+    **
+    ** Start up the given client.
+    */
+    if( strcmp(zCmd, "start")==0 && iClient==0 ){
+      int iNewClient = atoi(azArg[0]);
+      if( iNewClient>0 ){
+        startClient(iNewClient);
+      }
+    }else
+
+    /*
+    **  --wait CLIENT TIMEOUT
+    **
+    ** Wait until all tasks complete for the given client.  If CLIENT is
+    ** "all" then wait for all clients to complete.  Wait no longer than
+    ** TIMEOUT milliseconds (default 10,000)
+    */
+    if( strcmp(zCmd, "wait")==0 && iClient==0 ){
+      int iTimeout = nArg>=2 ? atoi(azArg[1]) : 10000;
+      sqlite3_snprintf(sizeof(zError),zError,"line %d of %s\n",
+                       prevLine, zFilename);
+      waitForClient(atoi(azArg[0]), iTimeout, zError);
+    }else
+
+    /*
+    **  --task CLIENT
+    **     <task-content-here>
+    **  --end
+    **
+    ** Assign work to a client.  Start the client if it is not running
+    ** already.
+    */
+    if( strcmp(zCmd, "task")==0 && iClient==0 ){
+      int iTarget = atoi(azArg[0]);
+      int iEnd;
+      char *zTask;
+      char *zTName;
+      iEnd = findEnd(zScript+ii+len, &lineno);
+      if( iTarget<0 ){
+        errorMessage("line %d of %s: bad client number: %d",
+                     prevLine, zFilename, iTarget);
+      }else{
+        zTask = sqlite3_mprintf("%.*s", iEnd, zScript+ii+len);
+        if( nArg>1 ){
+          zTName = sqlite3_mprintf("%s", azArg[1]);
+        }else{
+          zTName = sqlite3_mprintf("%s:%d", filenameTail(zFilename), prevLine);
+        }
+        startClient(iTarget);
+        runSql("INSERT INTO task(client,script,name)"
+               " VALUES(%d,'%q',%Q)", iTarget, zTask, zTName);
+        sqlite3_free(zTask);
+        sqlite3_free(zTName);
+      }
+      iEnd += tokenLength(zScript+ii+len+iEnd, &lineno);
+      len += iEnd;
+      iBegin = ii+len;
+    }else
+
+    /*
+    **  --breakpoint
+    **
+    ** This command calls "test_breakpoint()" which is a routine provided
+    ** as a convenient place to set a debugger breakpoint.
+    */
+    if( strcmp(zCmd, "breakpoint")==0 ){
+      test_breakpoint();
+    }else
+
+    /*
+    **  --show-sql-errors BOOLEAN
+    **
+    ** Turn display of SQL errors on and off.
+    */
+    if( strcmp(zCmd, "show-sql-errors")==0 ){
+      g.bIgnoreSqlErrors = nArg>=1 ? !booleanValue(azArg[0]) : 1;
+    }else
+
+
+    /* error */{
+      errorMessage("line %d of %s: unknown command --%s",
+                   prevLine, zFilename, zCmd);
+    }
+    ii += len;
+  }
+  if( iBegin<ii ){
+    char *zSql = sqlite3_mprintf("%.*s", ii-iBegin, zScript+iBegin);
+    runSql(zSql);
+    sqlite3_free(zSql);
+  }
+  stringFree(&sResult);
+}
+
+/*
+** Look for a command-line option.  If present, return a pointer.
+** Return NULL if missing.
+**
+** hasArg==0 means the option is a flag.  It is either present or not.
+** hasArg==1 means the option has an argument.  Return a pointer to the
+** argument.
+*/
+static char *findOption(
+  char **azArg,
+  int *pnArg,
+  const char *zOption,
+  int hasArg
+){
+  int i, j;
+  char *zReturn = 0;
+  int nArg = *pnArg;
+
+  assert( hasArg==0 || hasArg==1 );
+  for(i=0; i<nArg; i++){
+    const char *z;
+    if( i+hasArg >= nArg ) break;
+    z = azArg[i];
+    if( z[0]!='-' ) continue;
+    z++;
+    if( z[0]=='-' ){
+      if( z[1]==0 ) break;
+      z++;
+    }
+    if( strcmp(z,zOption)==0 ){
+      if( hasArg && i==nArg-1 ){
+        fatalError("command-line option \"--%s\" requires an argument", z);
+      }
+      if( hasArg ){
+        zReturn = azArg[i+1];
+      }else{
+        zReturn = azArg[i];
+      }
+      j = i+1+(hasArg!=0);
+      while( j<nArg ) azArg[i++] = azArg[j++];
+      *pnArg = i;
+      return zReturn;
+    }
+  }
+  return zReturn;
+}
+
+/* Print a usage message for the program and exit */
+static void usage(const char *argv0){
+  int i;
+  const char *zTail = argv0;
+  for(i=0; argv0[i]; i++){
+    if( isDirSep(argv0[i]) ) zTail = argv0+i+1;
+  }
+  fprintf(stderr,"Usage: %s DATABASE ?OPTIONS? ?SCRIPT?\n", zTail);
+  fprintf(stderr,
+    "Options:\n"
+    "   --errlog FILENAME           Write errors to FILENAME\n"
+    "   --journalmode MODE          Use MODE as the journal_mode\n"
+    "   --log FILENAME              Log messages to FILENAME\n"
+    "   --quiet                     Suppress unnecessary output\n"
+    "   --vfs NAME                  Use NAME as the VFS\n"
+    "   --repeat N                  Repeat the test N times\n"
+    "   --sqltrace                  Enable SQL tracing\n"
+    "   --sync                      Enable synchronous disk writes\n"
+    "   --timeout MILLISEC          Busy timeout is MILLISEC\n"
+    "   --trace BOOLEAN             Enable or disable tracing\n"
+  );
+  exit(1);
+}
+
+/* Report on unrecognized arguments */
+static void unrecognizedArguments(
+  const char *argv0,
+  int nArg,
+  char **azArg
+){
+  int i;
+  fprintf(stderr,"%s: unrecognized arguments:", argv0);
+  for(i=0; i<nArg; i++){
+    fprintf(stderr," %s", azArg[i]);
+  }
+  fprintf(stderr,"\n");
+  exit(1);
+}
+
+int SQLITE_CDECL main(int argc, char **argv){
+  const char *zClient;
+  int iClient;
+  int n, i;
+  int openFlags = SQLITE_OPEN_READWRITE;
+  int rc;
+  char *zScript;
+  int taskId;
+  const char *zTrace;
+  const char *zCOption;
+  const char *zJMode;
+  const char *zNRep;
+  int nRep = 1, iRep;
+  int iTmout = 0;              /* Default: no timeout */
+  const char *zTmout;
+
+  g.argv0 = argv[0];
+  g.iTrace = 1;
+  if( argc<2 ) usage(argv[0]);
+  g.zDbFile = argv[1];
+  if( strglob("*.test", g.zDbFile) ) usage(argv[0]);
+  if( strcmp(sqlite3_sourceid(), SQLITE_SOURCE_ID)!=0 ){
+    fprintf(stderr, "SQLite library and header mismatch\n"
+                    "Library: %s\n"
+                    "Header:  %s\n",
+                    sqlite3_sourceid(), SQLITE_SOURCE_ID);
+    exit(1);
+  }
+  n = argc-2;
+  sqlite3_snprintf(sizeof(g.zName), g.zName, "%05d.mptest", GETPID());
+  zJMode = findOption(argv+2, &n, "journalmode", 1);
+  zNRep = findOption(argv+2, &n, "repeat", 1);
+  if( zNRep ) nRep = atoi(zNRep);
+  if( nRep<1 ) nRep = 1;
+  g.zVfs = findOption(argv+2, &n, "vfs", 1);
+  zClient = findOption(argv+2, &n, "client", 1);
+  g.zErrLog = findOption(argv+2, &n, "errlog", 1);
+  g.zLog = findOption(argv+2, &n, "log", 1);
+  zTrace = findOption(argv+2, &n, "trace", 1);
+  if( zTrace ) g.iTrace = atoi(zTrace);
+  if( findOption(argv+2, &n, "quiet", 0)!=0 ) g.iTrace = 0;
+  zTmout = findOption(argv+2, &n, "timeout", 1);
+  if( zTmout ) iTmout = atoi(zTmout);
+  g.bSqlTrace = findOption(argv+2, &n, "sqltrace", 0)!=0;
+  g.bSync = findOption(argv+2, &n, "sync", 0)!=0;
+  if( g.zErrLog ){
+    g.pErrLog = fopen(g.zErrLog, "a");
+  }else{
+    g.pErrLog = stderr;
+  }
+  if( g.zLog ){
+    g.pLog = fopen(g.zLog, "a");
+  }else{
+    g.pLog = stdout;
+  }
+  
+  sqlite3_config(SQLITE_CONFIG_LOG, sqlErrorCallback, 0);
+  if( zClient ){
+    iClient = atoi(zClient);
+    if( iClient<1 ) fatalError("illegal client number: %d\n", iClient);
+    sqlite3_snprintf(sizeof(g.zName), g.zName, "%05d.client%02d",
+                     GETPID(), iClient);
+  }else{
+    int nTry = 0;
+    if( g.iTrace>0 ){
+      printf("BEGIN: %s", argv[0]);
+      for(i=1; i<argc; i++) printf(" %s", argv[i]);
+      printf("\n");
+      printf("With SQLite " SQLITE_VERSION " " SQLITE_SOURCE_ID "\n" );
+      for(i=0; (zCOption = sqlite3_compileoption_get(i))!=0; i++){
+        printf("-DSQLITE_%s\n", zCOption);
+      }
+      fflush(stdout);
+    }
+    iClient =  0;
+    do{
+      if( (nTry%5)==4 ) printf("... %strying to unlink '%s'\n",
+                               nTry>5 ? "still " : "", g.zDbFile);
+      rc = unlink(g.zDbFile);
+      if( rc && errno==ENOENT ) rc = 0;
+    }while( rc!=0 && (++nTry)<60 && sqlite3_sleep(1000)>0 );
+    if( rc!=0 ){
+      fatalError("unable to unlink '%s' after %d attempts\n",
+                 g.zDbFile, nTry);
+    }
+    openFlags |= SQLITE_OPEN_CREATE;
+  }
+  rc = sqlite3_open_v2(g.zDbFile, &g.db, openFlags, g.zVfs);
+  if( rc ) fatalError("cannot open [%s]", g.zDbFile);
+  if( iTmout>0 ) sqlite3_busy_timeout(g.db, iTmout);
+  
+  if( zJMode ){
+#if defined(_WIN32)
+    if( sqlite3_stricmp(zJMode,"persist")==0
+     || sqlite3_stricmp(zJMode,"truncate")==0
+    ){
+      printf("Changing journal mode to DELETE from %s", zJMode);
+      zJMode = "DELETE";
+    }
+#endif
+    runSql("PRAGMA journal_mode=%Q;", zJMode);
+  }
+  if( !g.bSync ) trySql("PRAGMA synchronous=OFF");
+  sqlite3_enable_load_extension(g.db, 1);
+  sqlite3_busy_handler(g.db, busyHandler, 0);
+  sqlite3_create_function(g.db, "vfsname", 0, SQLITE_UTF8, 0,
+                          vfsNameFunc, 0, 0);
+  sqlite3_create_function(g.db, "eval", 1, SQLITE_UTF8, 0,
+                          evalFunc, 0, 0);
+  g.iTimeout = DEFAULT_TIMEOUT;
+  if( g.bSqlTrace ) sqlite3_trace(g.db, sqlTraceCallback, 0);
+  if( iClient>0 ){
+    if( n>0 ) unrecognizedArguments(argv[0], n, argv+2);
+    if( g.iTrace ) logMessage("start-client");
+    while(1){
+      char *zTaskName = 0;
+      rc = startScript(iClient, &zScript, &taskId, &zTaskName);
+      if( rc==SQLITE_DONE ) break;
+      if( g.iTrace ) logMessage("begin %s (%d)", zTaskName, taskId);
+      runScript(iClient, taskId, zScript, zTaskName);
+      if( g.iTrace ) logMessage("end %s (%d)", zTaskName, taskId);
+      finishScript(iClient, taskId, 0);
+      sqlite3_free(zTaskName);
+      sqlite3_sleep(10);
+    }
+    if( g.iTrace ) logMessage("end-client");
+  }else{
+    sqlite3_stmt *pStmt;
+    int iTimeout;
+    if( n==0 ){
+      fatalError("missing script filename");
+    }
+    if( n>1 ) unrecognizedArguments(argv[0], n, argv+2);
+    runSql(
+      "DROP TABLE IF EXISTS task;\n"
+      "DROP TABLE IF EXISTS counters;\n"
+      "DROP TABLE IF EXISTS client;\n"
+      "CREATE TABLE task(\n"
+      "  id INTEGER PRIMARY KEY,\n"
+      "  name TEXT,\n"
+      "  client INTEGER,\n"
+      "  starttime DATE,\n"
+      "  endtime DATE,\n"
+      "  script TEXT\n"
+      ");"
+      "CREATE INDEX task_i1 ON task(client, starttime);\n"
+      "CREATE INDEX task_i2 ON task(client, endtime);\n"
+      "CREATE TABLE counters(nError,nTest);\n"
+      "INSERT INTO counters VALUES(0,0);\n"
+      "CREATE TABLE client(id INTEGER PRIMARY KEY, wantHalt);\n"
+    );
+    zScript = readFile(argv[2]);
+    for(iRep=1; iRep<=nRep; iRep++){
+      if( g.iTrace ) logMessage("begin script [%s] cycle %d\n", argv[2], iRep);
+      runScript(0, 0, zScript, argv[2]);
+      if( g.iTrace ) logMessage("end script [%s] cycle %d\n", argv[2], iRep);
+    }
+    sqlite3_free(zScript);
+    waitForClient(0, 2000, "during shutdown...\n");
+    trySql("UPDATE client SET wantHalt=1");
+    sqlite3_sleep(10);
+    g.iTimeout = 0;
+    iTimeout = 1000;
+    while( ((rc = trySql("SELECT 1 FROM client"))==SQLITE_BUSY
+        || rc==SQLITE_ROW) && iTimeout>0 ){
+      sqlite3_sleep(10);
+      iTimeout -= 10;
+    }
+    sqlite3_sleep(100);
+    pStmt = prepareSql("SELECT nError, nTest FROM counters");
+    iTimeout = 1000;
+    while( (rc = sqlite3_step(pStmt))==SQLITE_BUSY && iTimeout>0 ){
+      sqlite3_sleep(10);
+      iTimeout -= 10;
+    }
+    if( rc==SQLITE_ROW ){
+      g.nError += sqlite3_column_int(pStmt, 0);
+      g.nTest += sqlite3_column_int(pStmt, 1);
+    }
+    sqlite3_finalize(pStmt);
+  }
+  sqlite3_close(g.db);
+  maybeClose(g.pLog);
+  maybeClose(g.pErrLog);
+  if( iClient==0 ){
+    printf("Summary: %d errors out of %d tests\n", g.nError, g.nTest);
+    printf("END: %s", argv[0]);
+    for(i=1; i<argc; i++) printf(" %s", argv[i]);
+    printf("\n");
+  }
+  return g.nError>0;
+}