[sql] Import SQLite 3.17.0.

third_party/sqlite/src/test/fuzzcheck.c

 /*
 ** 2015-05-25
 **
 ** 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.
 **
@@ skipping 61 matching lines @@
 #include "sqlite3.h"
 #define ISSPACE(X) isspace((unsigned char)(X))
 #define ISDIGIT(X) isdigit((unsigned char)(X))
 
 
 #ifdef __unix__
 # include <signal.h>
 # include <unistd.h>
 #endif
 
+#ifdef SQLITE_OSS_FUZZ
+# include <stddef.h>
+# include <stdint.h>
+#endif
+
 /*
 ** Files in the virtual file system.
 */
 typedef struct VFile VFile;
 struct VFile {
   char *zFilename;        /* Filename.  NULL for delete-on-close. From malloc() */
   int sz;                 /* Size of the file in bytes */
   int nRef;               /* Number of references to this file */
   unsigned char *a;       /* Content of the file.  From malloc() */
 };
@@ skipping 28 matching lines @@
 /*
 ** All global variables are gathered into the "g" singleton.
 */
 static struct GlobalVars {
   const char *zArgv0;              /* Name of program */
   VFile aFile[MX_FILE];            /* The virtual filesystem */
   int nDb;                         /* Number of template databases */
   Blob *pFirstDb;                  /* Content of first template database */
   int nSql;                        /* Number of SQL scripts */
   Blob *pFirstSql;                 /* First SQL script */
+  unsigned int uRandom;            /* Seed for the SQLite PRNG */
   char zTestName[100];             /* Name of current test */
 } g;
 
 /*
 ** Print an error message and quit.
 */
 static void fatalError(const char *zFormat, ...){
   va_list ap;
   if( g.zTestName[0] ){
     fprintf(stderr, "%s (%s): ", g.zArgv0, g.zTestName);
@@ skipping 41 matching lines @@
 static int progressHandler(void *pVdbeLimitFlag){
   if( *(int*)pVdbeLimitFlag ) fatalError("too many VDBE cycles");
   return 1;
 }
 #endif
 
 /*
 ** Reallocate memory.  Show and error and quit if unable.
 */
 static void *safe_realloc(void *pOld, int szNew){
-  void *pNew = realloc(pOld, szNew);
+  void *pNew = realloc(pOld, szNew<=0 ? 1 : szNew);
   if( pNew==0 ) fatalError("unable to realloc for %d bytes", szNew);
   return pNew;
 }
 
 /*
 ** Initialize the virtual file system.
 */
 static void formatVfs(void){
   int i;
   for(i=0; i<MX_FILE; i++){
@@ skipping 46 matching lines @@
 ** Return NULL only if the filesystem is full.
 */
 static VFile *createVFile(const char *zName, int sz, unsigned char *pData){
   VFile *pNew = findVFile(zName);
   int i;
   if( pNew ) return pNew;
   for(i=0; i<MX_FILE && g.aFile[i].sz>=0; i++){}
   if( i>=MX_FILE ) return 0;
   pNew = &g.aFile[i];
   if( zName ){
-    pNew->zFilename = safe_realloc(0, strlen(zName)+1);
-    memcpy(pNew->zFilename, zName, strlen(zName)+1);
+    int nName = (int)strlen(zName)+1;
+    pNew->zFilename = safe_realloc(0, nName);
+    memcpy(pNew->zFilename, zName, nName);
   }else{
     pNew->zFilename = 0;
   }
   pNew->nRef = 0;
   pNew->sz = sz;
   pNew->a = safe_realloc(0, sz);
   if( sz>0 ) memcpy(pNew->a, pData, sz);
   return pNew;
 }
 
@@ skipping 311 matching lines @@
 static int inmemFullPathname(
   sqlite3_vfs *pVfs,
   const char *zFilename,
   int nOut,
   char *zOut
 ){
   sqlite3_snprintf(nOut, zOut, "%s", zFilename);
   return SQLITE_OK;
 }
 
+/* Always use the same random see, for repeatability.
+*/
+static int inmemRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){
+  memset(zBuf, 0, nBuf);
+  memcpy(zBuf, &g.uRandom, nBuf<sizeof(g.uRandom) ? nBuf : sizeof(g.uRandom));
+  return nBuf;
+}
+
 /*
 ** Register the VFS that reads from the g.aFile[] set of files.
 */
-static void inmemVfsRegister(void){
+static void inmemVfsRegister(int makeDefault){
   static sqlite3_vfs inmemVfs;
   sqlite3_vfs *pDefault = sqlite3_vfs_find(0);
   inmemVfs.iVersion = 3;
   inmemVfs.szOsFile = sizeof(VHandle);
   inmemVfs.mxPathname = 200;
   inmemVfs.zName = "inmem";
   inmemVfs.xOpen = inmemOpen;
   inmemVfs.xDelete = inmemDelete;
   inmemVfs.xAccess = inmemAccess;
   inmemVfs.xFullPathname = inmemFullPathname;
-  inmemVfs.xRandomness = pDefault->xRandomness;
+  inmemVfs.xRandomness = inmemRandomness;
   inmemVfs.xSleep = pDefault->xSleep;
   inmemVfs.xCurrentTimeInt64 = pDefault->xCurrentTimeInt64;
-  sqlite3_vfs_register(&inmemVfs, 0);
+  sqlite3_vfs_register(&inmemVfs, makeDefault);
 };
 
 /*
 ** Allowed values for the runFlags parameter to runSql()
 */
 #define SQL_TRACE  0x0001     /* Print each SQL statement as it is prepared */
 #define SQL_OUTPUT 0x0002     /* Show the SQL output */
 
 /*
 ** Run multiple commands of SQL.  Similar to sqlite3_exec(), but does not
@@ skipping 152 matching lines @@
 
 /*
 ** Print sketchy documentation for this utility program
 */
 static void showHelp(void){
   printf("Usage: %s [options] SOURCE-DB ?ARGS...?\n", g.zArgv0);
   printf(
 "Read databases and SQL scripts from SOURCE-DB and execute each script against\n"
 "each database, checking for crashes and memory leaks.\n"
 "Options:\n"
-"  --cell-size-check     Set the PRAGMA cell_size_check=ON\n"
-"  --dbid N              Use only the database where dbid=N\n"
-"  --export-db DIR       Write databases to files(s) in DIR. Works with --dbid\n"
-"  --export-sql DIR      Write SQL to file(s) in DIR. Also works with --sqlid\n"
-"  --help                Show this help text\n"
-"  -q                    Reduced output\n"
-"  --quiet               Reduced output\n"
-"  --limit-mem N         Limit memory used by test SQLite instance to N bytes\n"
-"  --limit-vdbe          Panic if an sync SQL runs for more than 100,000 cycles\n"
-"  --load-sql ARGS...    Load SQL scripts fro files into SOURCE-DB\n"
-"  --load-db ARGS...     Load template databases from files into SOURCE_DB\n"
-"  -m TEXT               Add a description to the database\n"
-"  --native-vfs          Use the native VFS for initially empty database files\n"
-"  --rebuild             Rebuild and vacuum the database file\n"
-"  --result-trace        Show the results of each SQL command\n"
-"  --sqlid N             Use only SQL where sqlid=N\n"
-"  --timeout N           Abort if any single test case needs more than N seconds\n"
-"  -v                    Increased output\n"
-"  --verbose             Increased output\n"
+"  --cell-size-check    Set the PRAGMA cell_size_check=ON\n"
+"  --dbid N             Use only the database where dbid=N\n"
+"  --export-db DIR      Write databases to files(s) in DIR. Works with --dbid\n"
+"  --export-sql DIR     Write SQL to file(s) in DIR. Also works with --sqlid\n"
+"  --help               Show this help text\n"
+"  -q|--quiet           Reduced output\n"
+"  --limit-mem N        Limit memory used by test SQLite instance to N bytes\n"
+"  --limit-vdbe         Panic if any test runs for more than 100,000 cycles\n"
+"  --load-sql ARGS...   Load SQL scripts fro files into SOURCE-DB\n"
+"  --load-db ARGS...    Load template databases from files into SOURCE_DB\n"
+"  -m TEXT              Add a description to the database\n"
+"  --native-vfs         Use the native VFS for initially empty database files\n"
+"  --oss-fuzz           Enable OSS-FUZZ testing\n"
+"  --prng-seed N        Seed value for the PRGN inside of SQLite\n"
+"  --rebuild            Rebuild and vacuum the database file\n"
+"  --result-trace       Show the results of each SQL command\n"
+"  --sqlid N            Use only SQL where sqlid=N\n"
+"  --timeout N          Abort if any single test needs more than N seconds\n"
+"  -v|--verbose         Increased output.  Repeat for more output.\n"
   );
 }
 
 int main(int argc, char **argv){
   sqlite3_int64 iBegin;        /* Start time of this program */
   int quietFlag = 0;           /* True if --quiet or -q */
   int verboseFlag = 0;         /* True if --verbose or -v */
   char *zInsSql = 0;           /* SQL statement for --load-db or --load-sql */
   int iFirstInsArg = 0;        /* First argv[] to use for --load-db or --load-sql */
   sqlite3 *db = 0;             /* The open database connection */
@@ skipping 13 matching lines @@
   int nSrcDb = 0;              /* Number of source databases */
   char **azSrcDb = 0;          /* Array of source database names */
   int iSrcDb;                  /* Loop over all source databases */
   int nTest = 0;               /* Total number of tests performed */
   char *zDbName = "";          /* Appreviated name of a source database */
   const char *zFailCode = 0;   /* Value of the TEST_FAILURE environment variable */
   int cellSzCkFlag = 0;        /* --cell-size-check */
   int sqlFuzz = 0;             /* True for SQL fuzz testing. False for DB fuzz */
   int iTimeout = 120;          /* Default 120-second timeout */
   int nMem = 0;                /* Memory limit */
+  int nMemThisDb = 0;          /* Memory limit set by the CONFIG table */
   char *zExpDb = 0;            /* Write Databases to files in this directory */
   char *zExpSql = 0;           /* Write SQL to files in this directory */
   void *pHeap = 0;             /* Heap for use by SQLite */
+  int ossFuzz = 0;             /* enable OSS-FUZZ testing */
+  int ossFuzzThisDb = 0;       /* ossFuzz value for this particular database */
+  sqlite3_vfs *pDfltVfs;       /* The default VFS */
 
   iBegin = timeOfDay();
 #ifdef __unix__
   signal(SIGALRM, timeoutHandler);
 #endif
   g.zArgv0 = argv[0];
   zFailCode = getenv("TEST_FAILURE");
+  pDfltVfs = sqlite3_vfs_find(0);
+  inmemVfsRegister(1);
   for(i=1; i<argc; i++){
     const char *z = argv[i];
     if( z[0]=='-' ){
       z++;
       if( z[0]=='-' ) z++;
       if( strcmp(z,"cell-size-check")==0 ){
         cellSzCkFlag = 1;
       }else
       if( strcmp(z,"dbid")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
         onlyDbid = integerValue(argv[++i]);
       }else
       if( strcmp(z,"export-db")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
         zExpDb = argv[++i];
       }else
       if( strcmp(z,"export-sql")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
         zExpSql = argv[++i];
       }else
       if( strcmp(z,"help")==0 ){
         showHelp();
         return 0;
       }else
       if( strcmp(z,"limit-mem")==0 ){
+#if !defined(SQLITE_ENABLE_MEMSYS3) && !defined(SQLITE_ENABLE_MEMSYS5)
+        fatalError("the %s option requires -DSQLITE_ENABLE_MEMSYS5 or _MEMSYS3",
+                   argv[i]);
+#else
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
         nMem = integerValue(argv[++i]);
+#endif
       }else
       if( strcmp(z,"limit-vdbe")==0 ){
         vdbeLimitFlag = 1;
       }else
       if( strcmp(z,"load-sql")==0 ){
         zInsSql = "INSERT INTO xsql(sqltext) VALUES(CAST(readfile(?1) AS text))";
         iFirstInsArg = i+1;
         break;
       }else
       if( strcmp(z,"load-db")==0 ){
         zInsSql = "INSERT INTO db(dbcontent) VALUES(readfile(?1))";
         iFirstInsArg = i+1;
         break;
       }else
       if( strcmp(z,"m")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
         zMsg = argv[++i];
       }else
       if( strcmp(z,"native-vfs")==0 ){
         nativeFlag = 1;
       }else
+      if( strcmp(z,"oss-fuzz")==0 ){
+        ossFuzz = 1;
+      }else
+      if( strcmp(z,"prng-seed")==0 ){
+        if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
+        g.uRandom = atoi(argv[++i]);
+      }else
       if( strcmp(z,"quiet")==0 || strcmp(z,"q")==0 ){
         quietFlag = 1;
         verboseFlag = 0;
       }else
       if( strcmp(z,"rebuild")==0 ){
         rebuildFlag = 1;
       }else
       if( strcmp(z,"result-trace")==0 ){
         runFlags |= SQL_OUTPUT;
       }else
       if( strcmp(z,"sqlid")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
         onlySqlid = integerValue(argv[++i]);
       }else
       if( strcmp(z,"timeout")==0 ){
         if( i>=argc-1 ) fatalError("missing arguments on %s", argv[i]);
         iTimeout = integerValue(argv[++i]);
       }else
       if( strcmp(z,"timeout-test")==0 ){
         timeoutTest = 1;
 #ifndef __unix__
         fatalError("timeout is not available on non-unix systems");
 #endif
       }else
       if( strcmp(z,"verbose")==0 || strcmp(z,"v")==0 ){
         quietFlag = 0;
-        verboseFlag = 1;
-        runFlags |= SQL_TRACE;
+        verboseFlag++;
+        if( verboseFlag>1 ) runFlags |= SQL_TRACE;
       }else
       {
         fatalError("unknown option: %s", argv[i]);
       }
     }else{
       nSrcDb++;
       azSrcDb = safe_realloc(azSrcDb, nSrcDb*sizeof(azSrcDb[0]));
       azSrcDb[nSrcDb-1] = argv[i];
     }
   }
   if( nSrcDb==0 ) fatalError("no source database specified");
   if( nSrcDb>1 ){
     if( zMsg ){
       fatalError("cannot change the description of more than one database");
     }
     if( zInsSql ){
       fatalError("cannot import into more than one database");
     }
   }
 
   /* Process each source database separately */
   for(iSrcDb=0; iSrcDb<nSrcDb; iSrcDb++){
-    rc = sqlite3_open(azSrcDb[iSrcDb], &db);
+    rc = sqlite3_open_v2(azSrcDb[iSrcDb], &db,
+                         SQLITE_OPEN_READONLY, pDfltVfs->zName);
     if( rc ){
       fatalError("cannot open source database %s - %s",
       azSrcDb[iSrcDb], sqlite3_errmsg(db));
     }
     rc = sqlite3_exec(db,
        "CREATE TABLE IF NOT EXISTS db(\n"
        "  dbid INTEGER PRIMARY KEY, -- database id\n"
        "  dbcontent BLOB            -- database disk file image\n"
        ");\n"
        "CREATE TABLE IF NOT EXISTS xsql(\n"
        "  sqlid INTEGER PRIMARY KEY,   -- SQL script id\n"
        "  sqltext TEXT                 -- Text of SQL statements to run\n"
        ");"
        "CREATE TABLE IF NOT EXISTS readme(\n"
        "  msg TEXT -- Human-readable description of this file\n"
        ");", 0, 0, 0);
     if( rc ) fatalError("cannot create schema: %s", sqlite3_errmsg(db));
     if( zMsg ){
       char *zSql;
       zSql = sqlite3_mprintf(
                "DELETE FROM readme; INSERT INTO readme(msg) VALUES(%Q)", zMsg);
       rc = sqlite3_exec(db, zSql, 0, 0, 0);
       sqlite3_free(zSql);
       if( rc ) fatalError("cannot change description: %s", sqlite3_errmsg(db));
     }
+    ossFuzzThisDb = ossFuzz;
+
+    /* If the CONFIG(name,value) table exists, read db-specific settings
+    ** from that table */
+    if( sqlite3_table_column_metadata(db,0,"config",0,0,0,0,0,0)==SQLITE_OK ){
+      rc = sqlite3_prepare_v2(db, "SELECT name, value FROM config", -1, &pStmt, 0);
+      if( rc ) fatalError("cannot prepare query of CONFIG table: %s",
+                          sqlite3_errmsg(db));
+      while( SQLITE_ROW==sqlite3_step(pStmt) ){
+        const char *zName = (const char *)sqlite3_column_text(pStmt,0);
+        if( zName==0 ) continue;
+        if( strcmp(zName, "oss-fuzz")==0 ){
+          ossFuzzThisDb = sqlite3_column_int(pStmt,1);
+          if( verboseFlag ) printf("Config: oss-fuzz=%d\n", ossFuzzThisDb);
+        }
+        if( strcmp(zName, "limit-mem")==0 ){
+#if !defined(SQLITE_ENABLE_MEMSYS3) && !defined(SQLITE_ENABLE_MEMSYS5)
+          fatalError("the limit-mem option requires -DSQLITE_ENABLE_MEMSYS5"
+                     " or _MEMSYS3");
+#else
+          nMemThisDb = sqlite3_column_int(pStmt,1);
+          if( verboseFlag ) printf("Config: limit-mem=%d\n", nMemThisDb);
+#endif
+        }
+      }
+      sqlite3_finalize(pStmt);
+    }
+
     if( zInsSql ){
       sqlite3_create_function(db, "readfile", 1, SQLITE_UTF8, 0,
                               readfileFunc, 0, 0);
       rc = sqlite3_prepare_v2(db, zInsSql, -1, &pStmt, 0);
       if( rc ) fatalError("cannot prepare statement [%s]: %s",
                           zInsSql, sqlite3_errmsg(db));
       rc = sqlite3_exec(db, "BEGIN", 0, 0, 0);
       if( rc ) fatalError("cannot start a transaction");
       for(i=iFirstInsArg; i<argc; i++){
         sqlite3_bind_text(pStmt, 1, argv[i], -1, SQLITE_STATIC);
@@ skipping 66 matching lines @@
       memset(g.pFirstDb, 0, sizeof(Blob));
       g.pFirstDb->id = 1;
       g.pFirstDb->seq = 0;
       g.nDb = 1;
       sqlFuzz = 1;
     }
   
     /* Print the description, if there is one */
     if( !quietFlag ){
       zDbName = azSrcDb[iSrcDb];
-      i = strlen(zDbName) - 1;
+      i = (int)strlen(zDbName) - 1;
       while( i>0 && zDbName[i-1]!='/' && zDbName[i-1]!='\\' ){ i--; }
       zDbName += i;
       sqlite3_prepare_v2(db, "SELECT msg FROM readme", -1, &pStmt, 0);
       if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
         printf("%s: %s\n", zDbName, sqlite3_column_text(pStmt,0));
       }
       sqlite3_finalize(pStmt);
     }
 
     /* Rebuild the database, if requested */
     if( rebuildFlag ){
       if( !quietFlag ){
         printf("%s: rebuilding... ", zDbName);
         fflush(stdout);
       }
       rebuild_database(db);
       if( !quietFlag ) printf("done\n");
     }
   
     /* Close the source database.  Verify that no SQLite memory allocations are
     ** outstanding.
     */
     sqlite3_close(db);
     if( sqlite3_memory_used()>0 ){
       fatalError("SQLite has memory in use before the start of testing");
     }
 
     /* Limit available memory, if requested */
-    if( nMem>0 ){
+    if( nMemThisDb>0 ){
       sqlite3_shutdown();
-      pHeap = malloc(nMem);
+      pHeap = realloc(pHeap, nMemThisDb);
       if( pHeap==0 ){
         fatalError("failed to allocate %d bytes of heap memory", nMem);
       }
-      sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nMem, 128);
+      sqlite3_config(SQLITE_CONFIG_HEAP, pHeap, nMemThisDb, 128);
     }
   
-    /* Register the in-memory virtual filesystem
-    */
+    /* Reset the in-memory virtual filesystem */
     formatVfs();
-    inmemVfsRegister();
     
     /* Run a test using each SQL script against each database.
     */
     if( !verboseFlag && !quietFlag ) printf("%s:", zDbName);
     for(pSql=g.pFirstSql; pSql; pSql=pSql->pNext){
       for(pDb=g.pFirstDb; pDb; pDb=pDb->pNext){
         int openFlags;
         const char *zVfs = "inmem";
         sqlite3_snprintf(sizeof(g.zTestName), g.zTestName, "sqlid=%d,dbid=%d",
                          pSql->id, pDb->id);
         if( verboseFlag ){
           printf("%s\n", g.zTestName);
           fflush(stdout);
         }else if( !quietFlag ){
           static int prevAmt = -1;
           int idx = pSql->seq*g.nDb + pDb->id - 1;
           int amt = idx*10/(g.nDb*g.nSql);
           if( amt!=prevAmt ){
             printf(" %d%%", amt*10);
             fflush(stdout);
             prevAmt = amt;
           }
         }
         createVFile("main.db", pDb->sz, pDb->a);
-        openFlags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE;
-        if( nativeFlag && pDb->sz==0 ){
-          openFlags |= SQLITE_OPEN_MEMORY;
-          zVfs = 0;
+        sqlite3_randomness(0,0);
+        if( ossFuzzThisDb ){
+#ifndef SQLITE_OSS_FUZZ
+          fatalError("--oss-fuzz not supported: recompile with -DSQLITE_OSS_FUZZ");
+#else
+          extern int LLVMFuzzerTestOneInput(const uint8_t*, size_t);
+          LLVMFuzzerTestOneInput((const uint8_t*)pSql->a, (size_t)pSql->sz);
+#endif
+        }else{
+          openFlags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE;
+          if( nativeFlag && pDb->sz==0 ){
+            openFlags |= SQLITE_OPEN_MEMORY;
+            zVfs = 0;
+          }
+          rc = sqlite3_open_v2("main.db", &db, openFlags, zVfs);
+          if( rc ) fatalError("cannot open inmem database");
+          sqlite3_limit(db, SQLITE_LIMIT_LENGTH, 100000000);
+          sqlite3_limit(db, SQLITE_LIMIT_LIKE_PATTERN_LENGTH, 50);
+          if( cellSzCkFlag ) runSql(db, "PRAGMA cell_size_check=ON", runFlags);
+          setAlarm(iTimeout);
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+          if( sqlFuzz || vdbeLimitFlag ){
+            sqlite3_progress_handler(db, 100000, progressHandler, &vdbeLimitFlag);
+          }
+#endif
+          do{
+            runSql(db, (char*)pSql->a, runFlags);
+          }while( timeoutTest );
+          setAlarm(0);
+          sqlite3_close(db);
         }
-        rc = sqlite3_open_v2("main.db", &db, openFlags, zVfs);
-        if( rc ) fatalError("cannot open inmem database");
-        if( cellSzCkFlag ) runSql(db, "PRAGMA cell_size_check=ON", runFlags);
-        setAlarm(iTimeout);
-#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
-        if( sqlFuzz || vdbeLimitFlag ){
-          sqlite3_progress_handler(db, 100000, progressHandler, &vdbeLimitFlag);
-        }
-#endif
-        do{
-          runSql(db, (char*)pSql->a, runFlags);
-        }while( timeoutTest );
-        setAlarm(0);
-        sqlite3_close(db);
         if( sqlite3_memory_used()>0 ) fatalError("memory leak");
         reformatVfs();
         nTest++;
         g.zTestName[0] = 0;
 
         /* Simulate an error if the TEST_FAILURE environment variable is "5".
         ** This is used to verify that automated test script really do spot
         ** errors that occur in this test program.
         */
         if( zFailCode ){
@@ skipping 26 matching lines @@
     sqlite3_int64 iElapse = timeOfDay() - iBegin;
     printf("fuzzcheck: 0 errors out of %d tests in %d.%03d seconds\n"
            "SQLite %s %s\n",
            nTest, (int)(iElapse/1000), (int)(iElapse%1000),
            sqlite3_libversion(), sqlite3_sourceid());
   }
   free(azSrcDb);
   free(pHeap);
   return 0;
 }