Index: test/pager1.test
==================================================================
--- test/pager1.test
+++ test/pager1.test
@@ -1220,10 +1220,19 @@
  db one {SELECT md5sum(a, b) FROM ab}
 } [db2 one {SELECT md5sum(a, b) FROM ab}]
 do_test pager1-9.2.4 { execsql { SELECT count(*) FROM ab } } {128}
 db close
 db2 close
+
+proc recursive_select {id table {script {}}} {
+  set cnt 0
+  db eval "SELECT rowid, * FROM $table WHERE rowid = ($id-1)" {
+    recursive_select $rowid $table $script
+    incr cnt
+  }
+  if {$cnt==0} { eval $script }
+}
 
 #-------------------------------------------------------------------------
 # Test that regardless of the value returned by xSectorSize(), the
 # minimum effective sector-size is 512 and the maximum 65536 bytes.
 #
@@ -1235,20 +1244,104 @@
   tv sectorsize $sectorsize
   set eff $sectorsize
   if {$sectorsize < 512}   { set eff 512 }
   if {$sectorsize > 65536} { set eff 65536 }
 
-  do_test pager1-10.$sectorsize {
+  do_test pager1-10.$sectorsize.1 {
     faultsim_delete_and_reopen
+    db func a_string a_string
     execsql {
       PRAGMA journal_mode = PERSIST;
       PRAGMA page_size = 1024;
-      CREATE TABLE t1(a, b);
+      BEGIN;
+        CREATE TABLE t1(a, b);
+        CREATE TABLE t2(a, b);
+        CREATE TABLE t3(a, b);
+      COMMIT;
     }
     file size test.db-journal
   } [expr $sectorsize > 65536 ? 65536 : $sectorsize]
+
+  do_test pager1-10.$sectorsize.2 {
+    execsql { 
+      INSERT INTO t3 VALUES(a_string(300), a_string(300));
+      INSERT INTO t3 SELECT * FROM t3;        /*  2 */
+      INSERT INTO t3 SELECT * FROM t3;        /*  4 */
+      INSERT INTO t3 SELECT * FROM t3;        /*  8 */
+      INSERT INTO t3 SELECT * FROM t3;        /* 16 */
+      INSERT INTO t3 SELECT * FROM t3;        /* 32 */
+    }
+  } {}
+
+  do_test pager1-10.$sectorsize.3 {
+    db close
+    sqlite3 db test.db
+    execsql { 
+      PRAGMA cache_size = 10;
+      BEGIN;
+    }
+    recursive_select 32 t3 {db eval "INSERT INTO t2 VALUES(1, 2)"}
+    execsql {
+      COMMIT;
+      SELECT * FROM t2;
+    }
+  } {1 2}
+
+  do_test pager1-10.$sectorsize.4 {
+    execsql {
+      CREATE TABLE t6(a, b);
+      CREATE TABLE t7(a, b);
+      CREATE TABLE t5(a, b);
+      DROP TABLE t6;
+      DROP TABLE t7;
+    }
+    if {$eff==65536} breakpoint
+    execsql {
+      BEGIN;
+        CREATE TABLE t6(a, b);
+    }
+    recursive_select 32 t3 {db eval "INSERT INTO t5 VALUES(1, 2)"}
+    execsql {
+      COMMIT;
+      SELECT * FROM t5;
+    }
+  } {1 2}
+  
 }
+db close
+
+tv sectorsize 4096
+do_test pager1.10.x.1 {
+  faultsim_delete_and_reopen
+  execsql {
+    PRAGMA page_size = 1024;
+    CREATE TABLE t1(x);
+  }
+  for {set i 0} {$i<30} {incr i} {
+    execsql { INSERT INTO t1 VALUES(zeroblob(900)) }
+  }
+  file size test.db
+} {32768}
+do_test pager1.10.x.2 {
+  execsql {
+    CREATE TABLE t2(x);
+    DROP TABLE t2;
+  }
+  file size test.db
+} {33792}
+do_test pager1.10.x.3 {
+  execsql {
+    BEGIN;
+    CREATE TABLE t2(x);
+  }
+  recursive_select 30 t1
+  execsql {
+    CREATE TABLE t3(x);
+    COMMIT;
+  }
+} {}
+
 db close
 tv delete
 
 testvfs tv -default 1
 faultsim_delete_and_reopen
@@ -1798,11 +1891,10 @@
   catchsql { SELECT * FROM ko } db2
 } {1 {unable to open database file}}
 db2 close
 tv delete
 do_test pager1-21.2 {
-breakpoint
   testvfs tv -iversion 1
   sqlite3 db2 test.db -vfs tv
   catchsql { SELECT * FROM ko } db2
 } {1 {unable to open database file}}
 db2 close
@@ -1854,10 +1946,14 @@
 #
 #   pager1-23.4.*: And, for fun, while holding an exclusive lock.
 #
 #   pager1-23.5.*: Try to set various different journal modes with an
 #                  in-memory database (only MEMORY and OFF should work).
+#
+#   pager1-23.6.*: Try to set locking_mode=normal on an in-memory database
+#                  (doesn't work - in-memory databases always use
+#                  locking_mode=exclusive).
 #
 do_test pager1-23.1.1 {
   faultsim_delete_and_reopen
   execsql {
     PRAGMA journal_mode = PERSIST;
@@ -1935,21 +2031,112 @@
   do_test pager1-23.5.$tn.2 {
     execsql "PRAGMA journal_mode = memory"
     execsql "PRAGMA journal_mode = $mode"
   } [if $possible {list $mode} {list memory}]
 }
-do_test pager1-23.8.1 {
+do_test pager1-23.6.1 {
   execsql {PRAGMA locking_mode = normal}
 } {exclusive}
-do_test pager1-23.8.2 {
+do_test pager1-23.6.2 {
   execsql {PRAGMA locking_mode = exclusive}
 } {exclusive}
-do_test pager1-23.8.3 {
+do_test pager1-23.6.3 {
   execsql {PRAGMA locking_mode}
 } {exclusive}
-do_test pager1-23.8.4 {
+do_test pager1-23.6.4 {
   execsql {PRAGMA main.locking_mode}
 } {exclusive}
 
+#-------------------------------------------------------------------------
+#
+do_test pager1-24.1.1 {
+  faultsim_delete_and_reopen
+  db func a_string a_string
+  execsql {
+    PRAGMA cache_size = 10;
+    PRAGMA auto_vacuum = FULL;
+    CREATE TABLE x1(x, y, z, PRIMARY KEY(y, z));
+    CREATE TABLE x2(x, y, z, PRIMARY KEY(y, z));
+    INSERT INTO x2 VALUES(a_string(400), a_string(500), a_string(600));
+    INSERT INTO x2 SELECT a_string(600), a_string(400), a_string(500) FROM x2;
+    INSERT INTO x2 SELECT a_string(500), a_string(600), a_string(400) FROM x2;
+    INSERT INTO x2 SELECT a_string(400), a_string(500), a_string(600) FROM x2;
+    INSERT INTO x2 SELECT a_string(600), a_string(400), a_string(500) FROM x2;
+    INSERT INTO x2 SELECT a_string(500), a_string(600), a_string(400) FROM x2;
+    INSERT INTO x2 SELECT a_string(400), a_string(500), a_string(600) FROM x2;
+    INSERT INTO x1 SELECT * FROM x2;
+  }
+} {}
+proc recursive_select {id {script {}}} {
+  set cnt 0
+  db eval {SELECT rowid, x,y,z FROM x2 WHERE rowid = ($id-1)} {
+    recursive_select $rowid $script
+    incr cnt
+  }
+  if {$cnt==0} { eval $script }
+}
+do_test pager1-24.1.2 {
+  execsql {
+    BEGIN;
+      DELETE FROM x1 WHERE rowid<32;
+  }
+  recursive_select 64
+} {}
+do_test pager1-24.1.3 {
+  execsql { 
+      UPDATE x1 SET z = a_string(300) WHERE rowid>40;
+    COMMIT;
+    PRAGMA integrity_check;
+    SELECT count(*) FROM x1;
+  }
+} {ok 33}
+
+do_test pager1-24.1.4 {
+  execsql {
+    DELETE FROM x1;
+    INSERT INTO x1 SELECT * FROM x2;
+    BEGIN;
+      DELETE FROM x1 WHERE rowid<32;
+      UPDATE x1 SET z = a_string(299) WHERE rowid>40;
+  }
+  recursive_select 64 {db eval COMMIT}
+  execsql {
+    PRAGMA integrity_check;
+    SELECT count(*) FROM x1;
+  }
+} {ok 33}
+
+do_test pager1-24.1.5 {
+  execsql {
+    DELETE FROM x1;
+    INSERT INTO x1 SELECT * FROM x2;
+  }
+  recursive_select 64 { db eval {CREATE TABLE x3(x, y, z)} }
+  execsql { SELECT * FROM x3 }
+} {}
+
+#-------------------------------------------------------------------------
+#
+do_test pager1-25-1 {
+  faultsim_delete_and_reopen
+  execsql {
+    BEGIN;
+      SAVEPOINT abc;
+        CREATE TABLE t1(a, b);
+      ROLLBACK TO abc;
+    COMMIT;
+  }
+  db close
+} {}
+breakpoint
+do_test pager1-25-2 {
+  faultsim_delete_and_reopen
+  execsql {
+    SAVEPOINT abc;
+      CREATE TABLE t1(a, b);
+    ROLLBACK TO abc;
+    COMMIT;
+  }
+  db close
+} {}
 
 finish_test
-

Index: test/pagerfault.test
==================================================================
--- test/pagerfault.test
+++ test/pagerfault.test
@@ -612,11 +612,10 @@
   execsql { CREATE TABLE xx(a, b) }
 } -test {
   faultsim_test_result {0 {}}
 }
 
-
 #---------------------------------------------------------------------------
 # Test fault injection into a small backup operation.
 #
 do_test pagerfault-14-pre1 {
   faultsim_delete_and_reopen
@@ -643,10 +642,28 @@
 }
 do_faultsim_test pagerfault-14b -prep {
   faultsim_restore_and_reopen
   sqlite3 db2 ""
   db2 eval { PRAGMA page_size = 4096; CREATE TABLE xx(a) }
+} -body {
+  sqlite3_backup B db2 main db main
+  B step 200
+  set rc [B finish]
+  if {[string match SQLITE_IOERR_* $rc]} {set rc SQLITE_IOERR}
+  if {$rc != "SQLITE_OK"} { error [sqlite3_test_errstr $rc] }
+  set {} {}
+} -test {
+  faultsim_test_result {0 {}}
+}
+do_faultsim_test pagerfault-14c -prep {
+  faultsim_restore_and_reopen
+  sqlite3 db2 test.db2
+  db2 eval { 
+    PRAGMA synchronous = off; 
+    PRAGMA page_size = 4096; 
+    CREATE TABLE xx(a);
+  }
 } -body {
   sqlite3_backup B db2 main db main
   B step 200
   set rc [B finish]
   if {[string match SQLITE_IOERR_* $rc]} {set rc SQLITE_IOERR}
@@ -817,12 +834,10 @@
 } -test {
   faultsim_test_result {0 delete}
   faultsim_integrity_check
 }
 
-}
-
 do_faultsim_test pagerfault-19a -prep {
   sqlite3 db :memory:
   db func a_string a_string
   execsql {
     PRAGMA auto_vacuum = FULL;
@@ -873,38 +888,55 @@
   }
 } -test {
   faultsim_test_result {0 {3 5 7}}
 }
 
+#-------------------------------------------------------------------------
+# This tests fault-injection in a special case in the auto-vacuum code.
+#
 do_test pagerfault-20-pre1 {
   faultsim_delete_and_reopen
-  db func a_string a_string
   execsql {
-    CREATE TABLE x1(x, y, z, PRIMARY KEY(y, z));
-    INSERT INTO x1 VALUES(a_string(400), a_string(500), a_string(600));
-    INSERT INTO x1 SELECT a_string(600), a_string(400), a_string(500) FROM x1;
-    INSERT INTO x1 SELECT a_string(500), a_string(600), a_string(400) FROM x1;
-    INSERT INTO x1 SELECT a_string(400), a_string(500), a_string(600) FROM x1;
-    INSERT INTO x1 SELECT a_string(600), a_string(400), a_string(500) FROM x1;
-    INSERT INTO x1 SELECT a_string(500), a_string(600), a_string(400) FROM x1;
-    INSERT INTO x1 SELECT a_string(400), a_string(500), a_string(600) FROM x1;
+    PRAGMA cache_size = 10;
+    PRAGMA auto_vacuum = FULL;
+    CREATE TABLE t0(a, b);
   }
   faultsim_save_and_close
 } {}
 do_faultsim_test pagerfault-20 -prep {
   faultsim_restore_and_reopen
-  db func a_string a_string
 } -body {
   execsql { 
     BEGIN;
-    UPDATE x1 SET z = a_string(300);
-    DELETE FROM x1 WHERE rowid<32;
+      CREATE TABLE t1(a, b);
+      CREATE TABLE t2(a, b);
+      DROP TABLE t1;
     COMMIT;
   }
 } -test {
   faultsim_test_result {0 {}}
-  faultsim_integrity_check
-  set nRow [db one {SELECT count(*) FROM x1}]
-  if {$nRow!=33 && $nRow!=64} {error "Wrong number of rows $nRow"}
+}
+
+do_test pagerfault-21-pre1 {
+  faultsim_delete_and_reopen
+  execsql {
+    PRAGMA cache_size = 10;
+    CREATE TABLE t0(a PRIMARY KEY, b);
+    INSERT INTO t0 VALUES(1, 2);
+  }
+  faultsim_save_and_close
+} {}
+do_faultsim_test pagerfault-21 -prep {
+  faultsim_restore_and_reopen
+} -body {
+  db eval { SELECT * FROM t0 LIMIT 1 } {
+    db eval { INSERT INTO t0 SELECT a+1, b FROM t0 }
+    db eval { INSERT INTO t0 SELECT a+2, b FROM t0 }
+  }
+} -test {
+  faultsim_test_result {0 {}}
+}
+
 }
+
 
 finish_test