src/third_party/sqlite/src/test/crash.test - cobalt - Git at Google

 # 2001 September 15
 #
 # 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 file implements regression tests for SQLite library.
 #
 # The focus of this file is testing the ability of the database to
 # uses its rollback journal to recover intact (no database corruption)
 # from a power failure during the middle of a COMMIT.  The OS interface
 # modules are overloaded using the modified I/O routines found in test6.c.
 # These routines allow us to simulate the kind of file damage that
 # occurs after a power failure.
 #
 # $Id: crash.test,v 1.27 2008/01/08 15:18:52 drh Exp $

 set testdir [file dirname $argv0]
 source $testdir/tester.tcl

 ifcapable !crashtest {
   finish_test
   return
 }

 set repeats 100
 #set repeats 10

 # The following procedure computes a "signature" for table "abc".  If
 # abc changes in any way, the signature should change.
 proc signature {} {
   return [db eval {SELECT count(*), md5sum(a), md5sum(b), md5sum(c) FROM abc}]
 }
 proc signature2 {} {
   return [db eval {SELECT count(*), md5sum(a), md5sum(b), md5sum(c) FROM abc2}]
 }

 #--------------------------------------------------------------------------
 # Simple crash test:
 #
 # crash-1.1: Create a database with a table with two rows.
 # crash-1.2: Run a 'DELETE FROM abc WHERE a = 1' that crashes during
 #            the first journal-sync.
 # crash-1.3: Ensure the database is in the same state as after crash-1.1.
 # crash-1.4: Run a 'DELETE FROM abc WHERE a = 1' that crashes during
 #            the first database-sync.
 # crash-1.5: Ensure the database is in the same state as after crash-1.1.
 # crash-1.6: Run a 'DELETE FROM abc WHERE a = 1' that crashes during
 #            the second journal-sync.
 # crash-1.7: Ensure the database is in the same state as after crash-1.1.
 #
 # Tests 1.8 through 1.11 test for crashes on the third journal sync and
 # second database sync.  Neither of these is required in such a small test
 # case, so these tests are just to verify that the test infrastructure
 # operates as expected.
 #
 do_test crash-1.1 {
   execsql {
     CREATE TABLE abc(a, b, c);
     INSERT INTO abc VALUES(1, 2, 3);
     INSERT INTO abc VALUES(4, 5, 6);
   }
   set ::sig [signature]
   expr 0
 } {0}
 for {set i 0} {$i<10} {incr i} {
   set seed [expr {int(abs(rand()*10000))}]
   do_test crash-1.2.$i {
     crashsql -delay 1 -file test.db-journal -seed $seed {
       DELETE FROM abc WHERE a = 1;
     }
   } {1 {child process exited abnormally}}
   do_test crash-1.3.$i {
     signature
   } $::sig
 }
 do_test crash-1.4 {
   crashsql -delay 1 -file test.db {
     DELETE FROM abc WHERE a = 1;
   }
 } {1 {child process exited abnormally}}
 do_test crash-1.5 {
   signature
 } $::sig
 do_test crash-1.6 {
   crashsql -delay 2 -file test.db-journal {
     DELETE FROM abc WHERE a = 1;
   }
 } {1 {child process exited abnormally}}
 do_test crash-1.7 {
   catchsql {
     SELECT * FROM abc;
   }
 } {0 {1 2 3 4 5 6}}

 do_test crash-1.8 {
   crashsql -delay 3 -file test.db-journal {
     DELETE FROM abc WHERE a = 1;
   }
 } {0 {}}
 do_test crash-1.9 {
   catchsql {
     SELECT * FROM abc;
   }
 } {0 {4 5 6}}
 do_test crash-1.10 {
   crashsql -delay 2 -file test.db {
     DELETE FROM abc WHERE a = 4;
   }
 } {0 {}}
 do_test crash-1.11 {
   catchsql {
     SELECT * FROM abc;
   }
 } {0 {}}

 #--------------------------------------------------------------------------
 # The following tests test recovery when both the database file and the the
 # journal file contain corrupt data. This can happen after pages are
 # written to the database file before a transaction is committed due to
 # cache-pressure.
 #
 # crash-2.1: Insert 18 pages of data into the database.
 # crash-2.2: Check the database file size looks ok.
 # crash-2.3: Delete 15 or so pages (with a 10 page page-cache), then crash.
 # crash-2.4: Ensure the database is in the same state as after crash-2.1.
 #
 # Test cases crash-2.5 and crash-2.6 check that the database is OK if the
 # crash occurs during the main database file sync. But this isn't really
 # different from the crash-1.* cases.
 #
 do_test crash-2.1 {
   execsql { BEGIN }
   for {set n 0} {$n < 1000} {incr n} {
     execsql "INSERT INTO abc VALUES($n, [expr 2*$n], [expr 3*$n])"
   }
   execsql { COMMIT }
   set ::sig [signature]
   execsql { SELECT sum(a), sum(b), sum(c) from abc }
 } {499500 999000 1498500}
 do_test crash-2.2 {
   expr ([file size test.db] / 1024)>16
 } {1}
 do_test crash-2.3 {
   crashsql -delay 2 -file test.db-journal {
     DELETE FROM abc WHERE a < 800;
   }
 } {1 {child process exited abnormally}}
 do_test crash-2.4 {
   signature
 } $sig
 do_test crash-2.5 {
   crashsql -delay 1 -file test.db {
     DELETE FROM abc WHERE a<800;
   }
 } {1 {child process exited abnormally}}
 do_test crash-2.6 {
   signature
 } $sig

 #--------------------------------------------------------------------------
 # The crash-3.* test cases are essentially the same test as test case
 # crash-2.*, but with a more complicated data set.
 #
 # The test is repeated a few times with different seeds for the random
 # number generator in the crashing executable. Because there is no way to
 # seed the random number generator directly, some SQL is added to the test
 # case to 'use up' a different quantity random numbers before the test SQL
 # is executed.
 #

 # Make sure the file is much bigger than the pager-cache (10 pages). This
 # ensures that cache-spills happen regularly.
 do_test crash-3.0 {
   execsql {
     INSERT INTO abc SELECT * FROM abc;
     INSERT INTO abc SELECT * FROM abc;
     INSERT INTO abc SELECT * FROM abc;
     INSERT INTO abc SELECT * FROM abc;
     INSERT INTO abc SELECT * FROM abc;
   }
   expr ([file size test.db] / 1024) > 450
 } {1}
 for {set i 1} {$i < $repeats} {incr i} {
   set sig [signature]
   do_test crash-3.$i.1 {
      set seed [expr {int(abs(rand()*10000))}]
      crashsql -delay [expr $i%5 + 1] -file test.db-journal -seed $seed "
        BEGIN;
        SELECT random() FROM abc LIMIT $i;
        INSERT INTO abc VALUES(randstr(10,10), 0, 0);
        DELETE FROM abc WHERE random()%10!=0;
        COMMIT;
      "
   } {1 {child process exited abnormally}}
   do_test crash-3.$i.2 {
     signature
   } $sig
 }

 #--------------------------------------------------------------------------
 # The following test cases - crash-4.* - test the correct recovery of the
 # database when a crash occurs during a multi-file transaction.
 #
 # crash-4.1.*: Test recovery when crash occurs during sync() of the
 #              main database journal file.
 # crash-4.2.*: Test recovery when crash occurs during sync() of an
 #              attached database journal file.
 # crash-4.3.*: Test recovery when crash occurs during sync() of the master
 #              journal file.
 #
 ifcapable attach {
   do_test crash-4.0 {
     file delete -force test2.db
     file delete -force test2.db-journal
     execsql {
       ATTACH 'test2.db' AS aux;
       PRAGMA aux.default_cache_size = 10;
       CREATE TABLE aux.abc2 AS SELECT 2*a as a, 2*b as b, 2*c as c FROM abc;
     }
     expr ([file size test2.db] / 1024) > 450
   } {1}

   set fin 0
   for {set i 1} {$i<$repeats} {incr i} {
     set seed [expr {int(abs(rand()*10000))}]
     set sig [signature]
     set sig2 [signature2]
     do_test crash-4.1.$i.1 {
        set c [crashsql -delay $i -file test.db-journal -seed $::seed "
          ATTACH 'test2.db' AS aux;
          BEGIN;
          SELECT randstr($i,$i) FROM abc LIMIT $i;
          INSERT INTO abc VALUES(randstr(10,10), 0, 0);
          DELETE FROM abc WHERE random()%10!=0;
          INSERT INTO abc2 VALUES(randstr(10,10), 0, 0);
          DELETE FROM abc2 WHERE random()%10!=0;
          COMMIT;
        "]
        if { $c == {0 {}} } {
          set ::fin 1
          set c {1 {child process exited abnormally}}
        }
        set c
     } {1 {child process exited abnormally}}
     if {$::fin} break
     do_test crash-4.1.$i.2 {
       signature
     } $sig
     do_test crash-4.1.$i.3 {
       signature2
     } $sig2
   }
   set i 0
   set fin 0
   while {[incr i]} {
     set seed [expr {int(abs(rand()*10000))}]
     set sig [signature]
     set sig2 [signature2]
     set ::fin 0
     do_test crash-4.2.$i.1 {
        set c [crashsql -delay $i -file test2.db-journal -seed $::seed "
          ATTACH 'test2.db' AS aux;
          BEGIN;
          SELECT randstr($i,$i) FROM abc LIMIT $i;
          INSERT INTO abc VALUES(randstr(10,10), 0, 0);
          DELETE FROM abc WHERE random()%10!=0;
          INSERT INTO abc2 VALUES(randstr(10,10), 0, 0);
          DELETE FROM abc2 WHERE random()%10!=0;
          COMMIT;
        "]
        if { $c == {0 {}} } {
          set ::fin 1
          set c {1 {child process exited abnormally}}
        }
        set c
     } {1 {child process exited abnormally}}
     if { $::fin } break
     do_test crash-4.2.$i.2 {
       signature
     } $sig
     do_test crash-4.2.$i.3 {
       signature2
     } $sig2
   }
   for {set i 1} {$i < 5} {incr i} {
     set sig [signature]
     set sig2 [signature2]
     do_test crash-4.3.$i.1 {
        crashsql -delay 1 -file test.db-mj* "
          ATTACH 'test2.db' AS aux;
          BEGIN;
          SELECT random() FROM abc LIMIT $i;
          INSERT INTO abc VALUES(randstr(10,10), 0, 0);
          DELETE FROM abc WHERE random()%10!=0;
          INSERT INTO abc2 VALUES(randstr(10,10), 0, 0);
          DELETE FROM abc2 WHERE random()%10!=0;
          COMMIT;
        "
     } {1 {child process exited abnormally}}
     do_test crash-4.3.$i.2 {
       signature
     } $sig
     do_test crash-4.3.$i.3 {
       signature2
     } $sig2
   }
 }

 #--------------------------------------------------------------------------
 # The following test cases - crash-5.* - exposes a bug that existed in the
 # sqlite3pager_movepage() API used by auto-vacuum databases.
 # database when a crash occurs during a multi-file transaction. See comments
 # in test crash-5.3 for details.
 #
 db close
 file delete -force test.db
 sqlite3 db test.db
 do_test crash-5.1 {
   execsql {
     CREATE TABLE abc(a, b, c);                          -- Root page 3
     INSERT INTO abc VALUES(randstr(1500,1500), 0, 0);   -- Overflow page 4
     INSERT INTO abc SELECT * FROM abc;
     INSERT INTO abc SELECT * FROM abc;
     INSERT INTO abc SELECT * FROM abc;
   }
 } {}
 do_test crash-5.2 {
   expr [file size test.db] / 1024
 } [expr [string match [execsql {pragma auto_vacuum}] 1] ? 11 : 10]
 set sig [signature]
 do_test crash-5.3 {
 # The SQL below is used to expose a bug that existed in
 # sqlite3pager_movepage() during development of the auto-vacuum feature. It
 # functions as follows:
 #
 # 1: Begin a transaction.
 # 2: Put page 4 on the free-list (was the overflow page for the row deleted).
 # 3: Write data to page 4 (it becomes the overflow page for the row inserted).
 #    The old page 4 data has been written to the journal file, but the
 #    journal file has not been sync()hronized.
 # 4: Create a table, which calls sqlite3pager_movepage() to move page 4
 #    to the end of the database (page 12) to make room for the new root-page.
 # 5: Put pressure on the pager-cache. This results in page 4 being written
 #    to the database file to make space in the cache to load a new page. The
 #    bug was that page 4 was written to the database file before the journal
 #    is sync()hronized.
 # 6: Commit. A crash occurs during the sync of the journal file.
 #
 # End result: Before the bug was fixed, data has been written to page 4 of the
 # database file and the journal file does not contain trustworthy rollback
 # data for this page.
 #
   crashsql -delay 1 -file test.db-journal {
     BEGIN;                                             -- 1
     DELETE FROM abc WHERE oid = 1;                     -- 2
     INSERT INTO abc VALUES(randstr(1500,1500), 0, 0);  -- 3
     CREATE TABLE abc2(a, b, c);                        -- 4
     SELECT * FROM abc;                                 -- 5
     COMMIT;                                            -- 6
   }
 } {1 {child process exited abnormally}}
 integrity_check crash-5.4
 do_test crash-5.5 {
   signature
 } $sig

 #--------------------------------------------------------------------------
 # The following test cases - crash-6.* - test that a DROP TABLE operation
 # is correctly rolled back in the event of a crash while the database file
 # is being written. This is mainly to test that all pages are written to the
 # journal file before truncation in an auto-vacuum database.
 #
 do_test crash-6.1 {
   crashsql -delay 1 -file test.db {
     DROP TABLE abc;
   }
 } {1 {child process exited abnormally}}
 do_test crash-6.2 {
   signature
 } $sig

 #--------------------------------------------------------------------------
 # These test cases test the case where the master journal file name is
 # corrupted slightly so that the corruption has to be detected by the
 # checksum.
 do_test crash-7.1 {
   crashsql -delay 1 -file test.db {
     ATTACH 'test2.db' AS aux;
     BEGIN;
     INSERT INTO abc VALUES(randstr(1500,1500), 0, 0);
     INSERT INTO abc2 VALUES(randstr(1500,1500), 0, 0);
     COMMIT;
   }

   # Change the checksum value for the master journal name.
   set f [open test.db-journal a]
   fconfigure $f -encoding binary
   seek $f [expr [file size test.db-journal] - 12]
   puts -nonewline $f "\00\00\00\00"
   close $f
 } {}
 do_test crash-7.2 {
   signature
 } $sig

 finish_test
	# 2001 September 15
	#
	# 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 file implements regression tests for SQLite library.
	#
	# The focus of this file is testing the ability of the database to
	# uses its rollback journal to recover intact (no database corruption)
	# from a power failure during the middle of a COMMIT. The OS interface
	# modules are overloaded using the modified I/O routines found in test6.c.
	# These routines allow us to simulate the kind of file damage that
	# occurs after a power failure.
	#
	# $Id: crash.test,v 1.27 2008/01/08 15:18:52 drh Exp $

	set testdir [file dirname $argv0]
	source $testdir/tester.tcl

	ifcapable !crashtest {
	finish_test
	return
	}

	set repeats 100
	#set repeats 10

	# The following procedure computes a "signature" for table "abc". If
	# abc changes in any way, the signature should change.
	proc signature {} {
	return [db eval {SELECT count(*), md5sum(a), md5sum(b), md5sum(c) FROM abc}]
	}
	proc signature2 {} {
	return [db eval {SELECT count(*), md5sum(a), md5sum(b), md5sum(c) FROM abc2}]
	}

	#--------------------------------------------------------------------------
	# Simple crash test:
	#
	# crash-1.1: Create a database with a table with two rows.
	# crash-1.2: Run a 'DELETE FROM abc WHERE a = 1' that crashes during
	# the first journal-sync.
	# crash-1.3: Ensure the database is in the same state as after crash-1.1.
	# crash-1.4: Run a 'DELETE FROM abc WHERE a = 1' that crashes during
	# the first database-sync.
	# crash-1.5: Ensure the database is in the same state as after crash-1.1.
	# crash-1.6: Run a 'DELETE FROM abc WHERE a = 1' that crashes during
	# the second journal-sync.
	# crash-1.7: Ensure the database is in the same state as after crash-1.1.
	#
	# Tests 1.8 through 1.11 test for crashes on the third journal sync and
	# second database sync. Neither of these is required in such a small test
	# case, so these tests are just to verify that the test infrastructure
	# operates as expected.
	#
	do_test crash-1.1 {
	execsql {
	CREATE TABLE abc(a, b, c);
	INSERT INTO abc VALUES(1, 2, 3);
	INSERT INTO abc VALUES(4, 5, 6);
	}
	set ::sig [signature]
	expr 0
	} {0}
	for {set i 0} {$i<10} {incr i} {
	set seed [expr {int(abs(rand()*10000))}]
	do_test crash-1.2.$i {
	crashsql -delay 1 -file test.db-journal -seed $seed {
	DELETE FROM abc WHERE a = 1;
	}
	} {1 {child process exited abnormally}}
	do_test crash-1.3.$i {
	signature
	} $::sig
	}
	do_test crash-1.4 {
	crashsql -delay 1 -file test.db {
	DELETE FROM abc WHERE a = 1;
	}
	} {1 {child process exited abnormally}}
	do_test crash-1.5 {
	signature
	} $::sig
	do_test crash-1.6 {
	crashsql -delay 2 -file test.db-journal {
	DELETE FROM abc WHERE a = 1;
	}
	} {1 {child process exited abnormally}}
	do_test crash-1.7 {
	catchsql {
	SELECT * FROM abc;
	}
	} {0 {1 2 3 4 5 6}}

	do_test crash-1.8 {
	crashsql -delay 3 -file test.db-journal {
	DELETE FROM abc WHERE a = 1;
	}
	} {0 {}}
	do_test crash-1.9 {
	catchsql {
	SELECT * FROM abc;
	}
	} {0 {4 5 6}}
	do_test crash-1.10 {
	crashsql -delay 2 -file test.db {
	DELETE FROM abc WHERE a = 4;
	}
	} {0 {}}
	do_test crash-1.11 {
	catchsql {
	SELECT * FROM abc;
	}
	} {0 {}}

	#--------------------------------------------------------------------------
	# The following tests test recovery when both the database file and the the
	# journal file contain corrupt data. This can happen after pages are
	# written to the database file before a transaction is committed due to
	# cache-pressure.
	#
	# crash-2.1: Insert 18 pages of data into the database.
	# crash-2.2: Check the database file size looks ok.
	# crash-2.3: Delete 15 or so pages (with a 10 page page-cache), then crash.
	# crash-2.4: Ensure the database is in the same state as after crash-2.1.
	#
	# Test cases crash-2.5 and crash-2.6 check that the database is OK if the
	# crash occurs during the main database file sync. But this isn't really
	# different from the crash-1.* cases.
	#
	do_test crash-2.1 {
	execsql { BEGIN }
	for {set n 0} {$n < 1000} {incr n} {
	execsql "INSERT INTO abc VALUES($n, [expr 2$n], [expr 3$n])"
	}
	execsql { COMMIT }
	set ::sig [signature]
	execsql { SELECT sum(a), sum(b), sum(c) from abc }
	} {499500 999000 1498500}
	do_test crash-2.2 {
	expr ([file size test.db] / 1024)>16
	} {1}
	do_test crash-2.3 {
	crashsql -delay 2 -file test.db-journal {
	DELETE FROM abc WHERE a < 800;
	}
	} {1 {child process exited abnormally}}
	do_test crash-2.4 {
	signature
	} $sig
	do_test crash-2.5 {
	crashsql -delay 1 -file test.db {
	DELETE FROM abc WHERE a<800;
	}
	} {1 {child process exited abnormally}}
	do_test crash-2.6 {
	signature
	} $sig

	#--------------------------------------------------------------------------
	# The crash-3.* test cases are essentially the same test as test case
	# crash-2.*, but with a more complicated data set.
	#
	# The test is repeated a few times with different seeds for the random
	# number generator in the crashing executable. Because there is no way to
	# seed the random number generator directly, some SQL is added to the test
	# case to 'use up' a different quantity random numbers before the test SQL
	# is executed.
	#

	# Make sure the file is much bigger than the pager-cache (10 pages). This
	# ensures that cache-spills happen regularly.
	do_test crash-3.0 {
	execsql {
	INSERT INTO abc SELECT * FROM abc;
	INSERT INTO abc SELECT * FROM abc;
	INSERT INTO abc SELECT * FROM abc;
	INSERT INTO abc SELECT * FROM abc;
	INSERT INTO abc SELECT * FROM abc;
	}
	expr ([file size test.db] / 1024) > 450
	} {1}
	for {set i 1} {$i < $repeats} {incr i} {
	set sig [signature]
	do_test crash-3.$i.1 {
	set seed [expr {int(abs(rand()*10000))}]
	crashsql -delay [expr $i%5 + 1] -file test.db-journal -seed $seed "
	BEGIN;
	SELECT random() FROM abc LIMIT $i;
	INSERT INTO abc VALUES(randstr(10,10), 0, 0);
	DELETE FROM abc WHERE random()%10!=0;
	COMMIT;
	"
	} {1 {child process exited abnormally}}
	do_test crash-3.$i.2 {
	signature
	} $sig
	}

	#--------------------------------------------------------------------------
	# The following test cases - crash-4.* - test the correct recovery of the
	# database when a crash occurs during a multi-file transaction.
	#
	# crash-4.1.*: Test recovery when crash occurs during sync() of the
	# main database journal file.
	# crash-4.2.*: Test recovery when crash occurs during sync() of an
	# attached database journal file.
	# crash-4.3.*: Test recovery when crash occurs during sync() of the master
	# journal file.
	#
	ifcapable attach {
	do_test crash-4.0 {
	file delete -force test2.db
	file delete -force test2.db-journal
	execsql {
	ATTACH 'test2.db' AS aux;
	PRAGMA aux.default_cache_size = 10;
	CREATE TABLE aux.abc2 AS SELECT 2a as a, 2b as b, 2*c as c FROM abc;
	}
	expr ([file size test2.db] / 1024) > 450
	} {1}

	set fin 0
	for {set i 1} {$i<$repeats} {incr i} {
	set seed [expr {int(abs(rand()*10000))}]
	set sig [signature]
	set sig2 [signature2]
	do_test crash-4.1.$i.1 {
	set c [crashsql -delay $i -file test.db-journal -seed $::seed "
	ATTACH 'test2.db' AS aux;
	BEGIN;
	SELECT randstr($i,$i) FROM abc LIMIT $i;
	INSERT INTO abc VALUES(randstr(10,10), 0, 0);
	DELETE FROM abc WHERE random()%10!=0;
	INSERT INTO abc2 VALUES(randstr(10,10), 0, 0);
	DELETE FROM abc2 WHERE random()%10!=0;
	COMMIT;
	"]
	if { $c == {0 {}} } {
	set ::fin 1
	set c {1 {child process exited abnormally}}
	}
	set c
	} {1 {child process exited abnormally}}
	if {$::fin} break
	do_test crash-4.1.$i.2 {
	signature
	} $sig
	do_test crash-4.1.$i.3 {
	signature2
	} $sig2
	}
	set i 0
	set fin 0
	while {[incr i]} {
	set seed [expr {int(abs(rand()*10000))}]
	set sig [signature]
	set sig2 [signature2]
	set ::fin 0
	do_test crash-4.2.$i.1 {
	set c [crashsql -delay $i -file test2.db-journal -seed $::seed "
	ATTACH 'test2.db' AS aux;
	BEGIN;
	SELECT randstr($i,$i) FROM abc LIMIT $i;
	INSERT INTO abc VALUES(randstr(10,10), 0, 0);
	DELETE FROM abc WHERE random()%10!=0;
	INSERT INTO abc2 VALUES(randstr(10,10), 0, 0);
	DELETE FROM abc2 WHERE random()%10!=0;
	COMMIT;
	"]
	if { $c == {0 {}} } {
	set ::fin 1
	set c {1 {child process exited abnormally}}
	}
	set c
	} {1 {child process exited abnormally}}
	if { $::fin } break
	do_test crash-4.2.$i.2 {
	signature
	} $sig
	do_test crash-4.2.$i.3 {
	signature2
	} $sig2
	}
	for {set i 1} {$i < 5} {incr i} {
	set sig [signature]
	set sig2 [signature2]
	do_test crash-4.3.$i.1 {
	crashsql -delay 1 -file test.db-mj* "
	ATTACH 'test2.db' AS aux;
	BEGIN;
	SELECT random() FROM abc LIMIT $i;
	INSERT INTO abc VALUES(randstr(10,10), 0, 0);
	DELETE FROM abc WHERE random()%10!=0;
	INSERT INTO abc2 VALUES(randstr(10,10), 0, 0);
	DELETE FROM abc2 WHERE random()%10!=0;
	COMMIT;
	"
	} {1 {child process exited abnormally}}
	do_test crash-4.3.$i.2 {
	signature
	} $sig
	do_test crash-4.3.$i.3 {
	signature2
	} $sig2
	}
	}

	#--------------------------------------------------------------------------
	# The following test cases - crash-5.* - exposes a bug that existed in the
	# sqlite3pager_movepage() API used by auto-vacuum databases.
	# database when a crash occurs during a multi-file transaction. See comments
	# in test crash-5.3 for details.
	#
	db close
	file delete -force test.db
	sqlite3 db test.db
	do_test crash-5.1 {
	execsql {
	CREATE TABLE abc(a, b, c); -- Root page 3
	INSERT INTO abc VALUES(randstr(1500,1500), 0, 0); -- Overflow page 4
	INSERT INTO abc SELECT * FROM abc;
	INSERT INTO abc SELECT * FROM abc;
	INSERT INTO abc SELECT * FROM abc;
	}
	} {}
	do_test crash-5.2 {
	expr [file size test.db] / 1024
	} [expr [string match [execsql {pragma auto_vacuum}] 1] ? 11 : 10]
	set sig [signature]
	do_test crash-5.3 {
	# The SQL below is used to expose a bug that existed in
	# sqlite3pager_movepage() during development of the auto-vacuum feature. It
	# functions as follows:
	#
	# 1: Begin a transaction.
	# 2: Put page 4 on the free-list (was the overflow page for the row deleted).
	# 3: Write data to page 4 (it becomes the overflow page for the row inserted).
	# The old page 4 data has been written to the journal file, but the
	# journal file has not been sync()hronized.
	# 4: Create a table, which calls sqlite3pager_movepage() to move page 4
	# to the end of the database (page 12) to make room for the new root-page.
	# 5: Put pressure on the pager-cache. This results in page 4 being written
	# to the database file to make space in the cache to load a new page. The
	# bug was that page 4 was written to the database file before the journal
	# is sync()hronized.
	# 6: Commit. A crash occurs during the sync of the journal file.
	#
	# End result: Before the bug was fixed, data has been written to page 4 of the
	# database file and the journal file does not contain trustworthy rollback
	# data for this page.
	#
	crashsql -delay 1 -file test.db-journal {
	BEGIN; -- 1
	DELETE FROM abc WHERE oid = 1; -- 2
	INSERT INTO abc VALUES(randstr(1500,1500), 0, 0); -- 3
	CREATE TABLE abc2(a, b, c); -- 4
	SELECT * FROM abc; -- 5
	COMMIT; -- 6
	}
	} {1 {child process exited abnormally}}
	integrity_check crash-5.4
	do_test crash-5.5 {
	signature
	} $sig

	#--------------------------------------------------------------------------
	# The following test cases - crash-6.* - test that a DROP TABLE operation
	# is correctly rolled back in the event of a crash while the database file
	# is being written. This is mainly to test that all pages are written to the
	# journal file before truncation in an auto-vacuum database.
	#
	do_test crash-6.1 {
	crashsql -delay 1 -file test.db {
	DROP TABLE abc;
	}
	} {1 {child process exited abnormally}}
	do_test crash-6.2 {
	signature
	} $sig

	#--------------------------------------------------------------------------
	# These test cases test the case where the master journal file name is
	# corrupted slightly so that the corruption has to be detected by the
	# checksum.
	do_test crash-7.1 {
	crashsql -delay 1 -file test.db {
	ATTACH 'test2.db' AS aux;
	BEGIN;
	INSERT INTO abc VALUES(randstr(1500,1500), 0, 0);
	INSERT INTO abc2 VALUES(randstr(1500,1500), 0, 0);
	COMMIT;
	}

	# Change the checksum value for the master journal name.
	set f [open test.db-journal a]
	fconfigure $f -encoding binary
	seek $f [expr [file size test.db-journal] - 12]
	puts -nonewline $f "\00\00\00\00"
	close $f
	} {}
	do_test crash-7.2 {
	signature
	} $sig

	finish_test